Good meeting this morning. Steve had just come off of a multi hour demo yesterday afternoon. He was reporting in and going over things that he had learned. Both Sean and I were listening as Steve was explaining and teaching us. Good stuff.

We talked a lot about solving pain points and how that helps make our product a viable solution. Steve got into some financial training and where things come and go (ways that monies move or track) and how that creates a cause and effect type relationship. As he was talking, I was plugging in numbers on the financial flow calculator to illustrate the flow of the monies. Steve had me build that page to help with just such trainings. The real goal is capturing and recording the story. The numbers then play into and through the story vs just being a standalone number (plugged or adjusted value). That is super important.

As a part of the financial flow, Steve was talking about being able to mix and bled while in the same system. If you run your operations on one platform and then try to do your accounting on another, you will always have disconnects. If you run things as they happen and then report back (roll call) then you can capture the story and thus get the financials or accounting (what really happened). That is where we are heading.

They were talking about software and different releases. With what we do, we release new things and features all of the time. Constant releases and constant refinement. That lead to a discussion on what are called "mash-ups" or "mashups". This is where a software company takes a number of different tools and applications and basically mashes them together to get a whole. There are pros and cons to that, but that type of business is also prone to major disconnects and paid points. We are striving to make a fully integrated system that lives and breathes on its own.

As the guys were talking, Steve was telling Sean how Kelly (adilas rep) was doing the demo. He brought up how well Kelly will say something like "We will help you and here is what that will cost." Both assurance, help, and tying it to cost, in the same sentence. Sadly, I'm not very good at that. It usually comes out something like, "Yes, we can help you do X and Y. And, oh, by the way, we should probably give you a quote." Or something like, "Great idea, I'll build that in and/or make a note of that (assuming all costs or taking it on internally)." Anyways, I'm not very good at the monetizing thing. Light discussions about styles and goals.

The discussion extended into talks about promises, expectations, and what those things really cost. We also talked about how much prep work and knowledge is needed to do certain things, tasks, or jobs. Sometimes those things are a barrier to entry. One of the things that we have found, mini gold mines, is getting first-hand knowledge by helping customers solve their problems. If you can afford it, those clients help by transferring real-life knowledge of what it takes and what is needed to get the jobs done. Invaluable, hard to put a price tag on those things. We love doing that when we can. It ends up in a net benefit. We tend to do what we call piggybacking. We build something for one client and get to pass that on for free or as part of the system to the next client. Then that client will help push something else forward that the other clients get to benefit from. It becomes a form of piggybacking. Kinda fun!

Custom work! That is one of the things that sets us apart from the rest of the software solutions out there. We love and are willing to do custom work. That may not sound that big, but it's huge. As we were talking, we were reminded of our elevator pitch (condensed sales pitch). It talks about us offering a standard package and then being willing to customize on top of that. That's pretty cool. Here's a link to our mini elevator pitch (also one to Sean's expanded elevator pitch). We really do offer a lot of options.

We will just keep working on sharing what we have and how it can help people solve their business problems and needs. As a small side note, Steve was talking about ecommerce and how that little solution is actually becoming a way to sell and interact with clients without even using the main internal tools. It's so simple and connects everything together, we actually have some companies that help people use the ecommerce options and solutions vs using our internal shopping cart tools. It keeps it simple yet limited in options. I just find it interesting that some companies are using that tool vs the internal tools. I don't think that I could have anticipated that. Interesting.

Recording notes from this morning and yesterday. Each day we are either learning new things and/or being reminded of tons of lessons learned or other great ideas. Adilas is virtually a producing idea farm. Sometimes it feels like a slow journey, but it feels like we are headed in the right direction.

Bryan and I met up and we pushed up some new code for the time homepage, grouped output view. The new changes show total hours for elements of time. That will help us watch and quickly get hours and counts.

We then spent the rest of the time talking about new online client facing scheduling stuff for special events. This is going to be called round 2 of the client facing scheduling settings. We recorded a good part of our meeting. See attached. We were mostly going over ideas and concepts and just in time project management.

After the meeting, I rendered the videos, uploaded them and documented things. Light clean-up.

Recording notes from the day and working on a small bug that got reported. It was a date field that was formatting data as a time value vs a date picker. Small tweak and pushed up the new file.

Working on a special custom data extract project. I've got most of the main data done, just getting into the extras or sub data fields. Looking around and seeing the size of data for the client. I was shocked to see 130,000+ customer records, over 570,000+ customer logs, over 14,000+ additional contacts, 94,000+ flex grid tie-ins, and over 420,000+ media/content files - all for this one company. I didn't realize that they were using the CRM (customer relationship management) portion of adilas so heavily. Those are some big numbers. Today alone, they did over 500+ new customer log notes and over 400+ new media/content files that got uploaded. I grabbed a quick screenshot of their data counts for just today.

I sent an email update to let them know where I was with the export project. It's a pretty deep export project.

Recording notes, checking on data stats for a client, and talking with Shari O. about USAePay account transitions and asking her questions about certain data for a client. Fairly quiet meeting.

Cory and I going over projects. Talking about a custom data export and the amount of data that will be exported. We talked about reaching out to our clients and trying to help them with their needs and possible pain points. As we kept going, one of the projects that we talked about was a request for documentation for the adilas API sockets (public access). I sent Cory three links that have some good info on the adilas API sockets. I'll list them below. The last topic was dealing with different parties and companies trying to control certain space or certain aspects of a business. Talked about some pros and cons there.

Here are the API socket documentation links:
- adilas API socket homepage and visual testing tool
- adilas API socket samples and documentation
- adilas API socket help file

Today's server meeting started out pretty normal and ended up in a small work session and trying to figure out how to modify some code for sub inventory. We started out and John reported on his yearend tax forms (W-2's and 1099's). We got a small report on the changes to the email server that Wayne is working on. We are excited to see if we can gain some more control and/or options there. We then switched over to the bug in the sub inventory stuff. This doesn't happen all of the time, but when it does, it throws an error.

Anyways, we spent the next hour or so going over different levels of pre-validation, in-line validation, and post-validation. Sometimes the problems can be stopped before they ever get going, some can be stopped once an error or 0 record count is hit, and some need to be soft or conditional errors that don't do something but allow for other things to still take place. For example, the soft errors may need to happen in a complex loop or nested loop. You may not want to just stop on a dime. You may want the loop to finish and then show problems or gracefully roll past any problems or issues.

Anyways, it got pretty deep. We will end up going in and looking at each page and decide what the best option will be. There is no quick solution for this issue. We may have to check and change code in hundreds of pages. Each one has a different task or function or flow. The quick answer is to just change it at the method level, but this same method is used in tons of places and in different ways. We will just have to chip away at it and/or watch the logs and only fix the pages that show up on the error logs. Once again, it only happens every once in a while and not all pages that use this method have problems. We have to track this one down using manual processes and time reading over the code before the method calls, during the call, and after the call.

To sum it up, it all deals with general error handling and making it more consistent. We are in a state of constant refinement. We will just keep working to make it better and better and smoother and smoother. I will note that we never would have found this error if it weren't for Wayne's monitoring and error logs. Basically, it allows us to look under the covers and catch things that a normal user would never report to us.

After everybody else left, Cory was talking about testing and making sure that we are only pushing up good code. Wayne told her that we push up code everyday, multiple times a day. That is totally true. She only knows about it if it goes bad or has an error or bug in it. Anyways, we'll have to keep pushing on things and we'll find some good balance points between testing, pushing, and progression. Making headway... yee haw!

A couple of different phone calls with Eric to go over cart logic and new updates for his gift card project. As a side note, we sure would love to redesign the shopping cart and turn it all into smaller micro services vs a linear page flow with nested logic. Some of the original cart logic goes back almost 20 years. It's amazing how much things change over time. At the time, it was very well done. By today's standards, we would love to keep tweaking it and making it into much smaller more mobile pieces. I can't even imagine what some software companies are dealing with that started 40 years ago (in the 1980's or 90's). We started in the early 2000's. It very interesting how it keeps changing.

Spent some good time working on a custom data extract or export project for a client. The main subject is customer data records. Most of my time today was dealing with some of the sub data that is associated with customers. Going over code for sub customer additional contacts, customer log notes, customer flex grid tie-ins (custom data per customer), and media/content or uploaded files per customer.

Finished up the first round and built a small sample file to send to the client. Also sent an email update with the sample file, ideas on where we are headed next, and a small proposal going forward.

Quiet morning meeting. Just me. Working on emails and research on validation routines for our internal form and URL (web address) validation. Looking at new code that got merged into the master code branch. Just trying to stay up with changes. Recording notes and updating a couple of internal help files. Small to do list stuff.

Work session with Bryan on the unique event settings for online client facing scheduling. We went over progress, change requests, and ideas for special event images. At one point, we were building sample code on how to relate elements of time to parts and items in the system. We were taking notes, fixing things, and planning the next steps. Good work session.

Work session between Brandon, Shari O., and Bryan. The goal was to do some training on the settings for online client facing scheduling and the new ecommerce settings that Bryan has been working on. We recorded a good part of the meeting. Shari O. has the video recording. If I were sum it up, I would say, it all comes down to the setup (planning and then executing that plan). See attached for a small Word document that we were working on to help us with reminders. If I can get the video from Shari O., I'll add it here.

Recording notes and updating both the shop calendar and the sub elements and projects inside of the adilas corporation. Light clean-up from the day.

Small bug fixes and emails to Wayne, Cory, and Kelly.

Training session between Russell and Brandon. We met over a Zoom meeting and talked about all kinds of project management styles and techniques. Russell was showing me stuff on his Notion app, how he organizes things, and all of the cool drag and drop type styles for his to do lists and project boards. Lots of linking back and forth and dynamics. We talked about IT structures and how to best manage teams. We talked about scrum, agile, sprint (if you know what to do) and kanban (one project at a time from start to finish).

It comes down to what are your resources, timelines, and talent pool. Do you know what you want to get done or is it more open? The dev team does the story points. Not everybody can do virtual (meaning the work environment). Some people really need some handholding and someone to watch over them. Those are harder to manage virtually. The virtual guys/gals need to be somewhat self-driven and self-motivated. Are the developers full stack (able to do the whole thing - start to finish) or are they limited and/or specialized (just a few of the tasks are suitable for them)? Lots of questions and different styles.

One thing that I was shocked with was how many different tools Russell has to use to keep all of his things going and flowing. Tons of different software and web apps like: Jira, notion, Git, Toggle, Google Drive, all of their internals, and tons of others. We do some of that as well, but Russell had a bunch more. Just me speaking, but no thank you. I've got plenty plus a few.

We flipped back to talking about sprints and getting into a grove. Other topics included owning a task and that is just the starting point, a task is never the end all be all. Helping to share understanding. Also getting help and helping to complete certain tasks. Somewhat of a shared workload vs just owning a certain task and being done with it.

People see things differently. Kinda like the telephone game, what you hear and pass on may not be the actual thing that you are trying to do and/or achieve. It is more of a process of growing and becoming vs just being or having (all at once).

Russell was sharing some of the stuff that he goes over with his guys in the interview process. His interviews are like 3.5 hours long and pretty brutal, testing all kinds of different levels and personality type stuff. We talked about documentation. Other things like dependency injection and how testable are things with dynamics vs hardcoded or static values. We got into testing, mocking data, logic test, integration test, etc. It got pretty deep. Russell is trying to mix all kinds of data and tools to get the testing coverage that he wants. He was even getting numbers and test results (scores) back on some of his processes. He was then using those scores to keep refining until he had less crappy code and in theory, better results.

Spent some time talking about breaking things up into smaller pieces. Using flow charts, wireframes, and other schematic type design tools to show the overview of what the functions and/or processes do or could do. I liked that. He had some new big words for me - I didn't fully understand them. Just being silly, but one of the things he was talking about was "Cyclomatic Complexity" and other things. I thought that it was kinda funny and it made me laugh. I kept thinking, if I don't know that... how am I supposed to teach that or expect it from my guys. Just having fun. I did grab a few screenshots with some of his memes and graphics. See attached. Nothing too special.

Hours of emails, tech support, and other stuff. Emails to Wayne, Cory, Kelly, etc. Going over validation stuff, routines, logic, fixing small bugs, and looking into sub inventory data and attribute mappings. On a Zoom session with Kelly, Wayne, Dustin, and I. Looking over code and testing things. Kelly even pulled a client onto the meeting to get some approvals and have her do some live testing. Pretty deep session.

As a side note, if all is going well, the value of the systems admin person doesn't seem that important but when all things go crazy and he/she helps to get it back in check, the value of that person is huge. They are often overlooked when seas are calm and the wind is not blowing (which means that they are doing a good job). Lots of unseen efforts. Thanks Wayne!

Rolling back server times to help with daylight savings. Hit all servers and rolled things back. This is the smoothest that it has ever gone. Good stuff.

Touching base with Steve and Sean. Planning and scheduling demos. Talking about getting my dad (Wayne Moore) involved in some adilas sales. He is really good at talking with people, organizing things, and taking things to the next level.

Cory and Dustin joined the meeting and we switched gears and started talking about a possible error or errors. This took quite a while. We talked about possible date picker problems and using our new date picker. Everything keeps moving. The ground we stand on is in constant motion. That seems to be our reality.

We then switched over to other projects. Cory had a list and we went through that along with multiple things from emails. We got into a discussion on the hierarchy of different settings and which ones take precedence over other things. That can get tricky. It gets even trickier when you get layers of logic involved. Anyways, making progress there.

John and Cory were going over year end forms and documents. They then switched to talking about the discount engine and back merging in master to that branch. It's only a couple of months old and it already over 150 commits behind the master branch. Everything keeps rolling forward as a crazy fast pace. I would almost call it a neck breaking pace.

Zoom meeting with Bryan. We were working on his upload section for new display images out in ecommerce. We did a small work session and got his form submitting things correctly. Images can be tricky to upload, validate, resize, and rename. It gets kinda tricky. We got him going in a good direction. Small work session.

Zoom meeting with Steve and Kelly and tracking down settings. We were looking at cause and effect relationships and turning things on/off in different places and whether or not those same values cascaded to the other settings (show/hide and active/inactive). It can get pretty deep.

The last topic for our meeting was a switch from developing to marketing through training and education. I thought that was a fun idea and topic.

On the morning meeting. It was just John and I for the most part. We were going over year end forms and what not. John is making great progress in that area. For the record, the 1099 interest paid form is quite different than the other 1099 forms (misc or nec - non-employee compensation forms). We talked about options there.

Steve sent me a text message and he and Sean were on the phone talking about stuff. Steve was having some Internet issues.

After John and I finished up with the year end form stuff, we switched over to frontend layouts, style guide stuff, and the power of different Adobe products. John showed me some work that he was doing in Adobe XD (layout and mock-up stuff). We also talked about the power of Adobe ColdFusion and how it really helps us develop cool things quickly. We talked about cool tags like cfinclude (pulling in separate pages) and cflocation (auto redirecting users). There are many other cool and useful tags and functions as well.

Photos for the rafting demo site. Looking up things online and creating a number of product category images. Prep work for the upcoming demo site.

Cory has a list of questions and projects to go over as part of our server meeting. We talked about the email server changes, cascading effects (settings and attributes), and how deep some of the settings and data mapping values go. It really becomes a system. You can't change one thing without it having cause and effect or trickle down effects. That is both good and bad and has pros and cons.

On some of the critical places where users can alter or change things, we may need to catch and hold history records of what was done. This is the when, who, and what type of stuff for some of the settings. We already have it in multiple places, both seen and unseen. We are seeing that we may need to continue to keep adding more historical records. This is especially true in those places that have cause and effect relationships both upstream and downstream.

We talked about some of the upcoming server upgrades and maintenance stuff. That is an ongoing process. We are trying to keep our clients informed but not overwhelmed or worried. It's like a car, you have to keep putting gas in it, do oil changes, and even change out the wiper blades. It's the same with code and servers.

Working with Danny and Shari O. over a Zoom session. We were looking into more new settings and getting the rafting company demo site up and going. We made some plans, showed a few updates, and even had some fun marketing and sales type ideas. See attached for an updated MS Word document. Shari O. recorded the meeting. Once again, mostly a work session, but she recorded it anyways.

After the meeting was over, Shari O. and I stayed on and chatted about business ownership, percentages, goals, and feelings about how things are playing out (pros and cons). It was good for both of us, and we both needed a listening ear. Bouncing some thoughts and ideas off of each other. Good stuff. Crazy how busy life is and gets sometimes.

Emails and recording notes from the day. Light clean-up.

No one joined the morning meeting so I just did emails. I also did some thinking about different ideas, progress being made, and options and plans going forward.

The meeting started out and it was just Eric and I. Part way through Wayne joined and then Cory joined after that. The goal of the meeting was to talk about and discuss the sales tax aggregate project and do some light debugging. Eric and I were going over project life cycles and talking about options for dev or development/testing servers. If we were to do that, we would like to give the developers full access to the underlying database as full database admin levels (grants and permissions).

We talked about the process of refactoring code and getting rid of some things and adding other things. It takes time but we are making progress. One of the recent things that Eric was working on was refactoring the submit cart page. We removed all of the hard stops and refactored the code to handle any number of errors without halting progress on other functions or method calls. That will help with automated testing (later on).

While it was just Eric and I on the meeting, we were also talking about the need to be able to see the full database as an admin user, not just a read only SQL prompt (simple look-ups). We need the full access to the backend database. That would really help with debugging and making sure that things are good to go for production.

Wayne joined the meeting and brought up the live database. Eric and Wayne were doing test queries and looking at stored procedures and other SQL stuff. As a side note, we were looking at tons of dates inside the system. They are very important but play at different levels. We were looking at created dates (when it was created), actual dates (when it shows up on reports and such), and last modified dates (if and when it was changed or altered). Each date plays a different role, but they are all important in the grand scheme of things. Along with that, we were going over processes and which ones run first, second, conditional, etc. Lots of backend logic.

It was fun to watch and chime in here and there as Wayne and Eric were getting pretty deep into the processes and procedures. Cory joined us and we ended up having her use the frontend web app (user interface) and Wayne and Eric checking code and actual data on the backend. It was pretty cool to see and watch them all work.

One thing of note was a redo or re-flush type option. Basically, Eric had coded in a special value that if passed in would reset the whole process and/or procedure. The end goal is not a good number (whatever that is). The real goal is a solid process and good error handling (repeatable and solid logic). That produces good numbers.

Two different sessions with Bryan. We were working on the BioTrack API changes. We met at 1 pm for about 1/2 an hour and then he was going to rework some of the code. We re-met at 2 pm and worked until about 3 pm. More BioTrack stuff and we reworked some functions and merged in some new code.

Emails, merging in a pull request for Eric, and light tech support. Worked about an hour on some tweaks for the custom data extract for a client. They wanted the export by customer type and also wanted to limit the amount of customer log notes that got returned. Updated the code, pushed up a new sample file in the JSON file format and sent the client an email with some questions and updates.

Worked on some adilas ownership documents for some of our new sales reps. We are offering them a percentage of ownership in the Adilas, LLC company. That is part of our model for new team members. Ended the session doing some note recording and daily clean-up stuff.

Good meeting this morning. Lots of talk about trends, needs, and client wants. Steve, Sean, John, and I were on the meeting. We were talking about software needs, trends, expectations and how those things keep changing. Steve was pitching the idea of a full white label type approach. This would be something like where we would license our software to a company, help them setup a standalone server(s), give them raw code and let them build and deploy whatever they want to do. This would be similar to open source in that we would give them a full copy, provide them updates, and let them tweak and use whatever they want to. Basically, let independent companies build out their own software solution based on our base code. In reality, that is still quite a ways out, but fun conversations.

Everything keeps changing, daily. Maybe let them (our clients) have it and do their own upkeep for their own systems. We could keep evolving the master branch and allow our clients to pull in new code, if they want it. It just needs to keep perpetually evolving. As a direct quote from John - "Our clients eat with their eyes." We need to keep working on a better look and feel. Also, this look and feel needs to keep changing every few years to keep it up to speed and up to snuff. If you want it to look modern, you need to have an update plan in place to keep it up.

Lots of talk about our competition and what level they are playing with. Because the whole world uses stuff like Amazon, eBay, and other giants, we are virtually competing with those entities and the expectations are similar because we play in the giant web world. Every has a smart phone and get to use mobile apps, nice interfaces, and other cool things every day. That is the expectation. That is really hard to keep up with and/or even play the game. Our users are expecting eye candy, graphs, charts, quick aggregates, slide in/out drawers, show/hide options, drop-down, slide-up, modal pop-ups, and cool one-pager type apps.

We just need to keep going. Eventually, even if it looks pretty, people really need functionality. However, if they can choose pretty and easy, they always will until it bites them due to lack of functionality. The old adage of form and function - which one do you or do our client value? It keeps changing as well.

Steve was talking with John about some future projects dealing with the look and feel. John is going to be taking over the adilas docs now that Chuck had to take another job. We talked about the use of a global style guide and keeping that up. Once again, every couple (2-4) years, we will need to keep upgrading the look and feel. It is part of the game.

As a side note, some of these things are good info for our future project of moving over to a project called fracture. Along those same lines, fracture may end up being a morphing process (using the old and making it become something new) vs a full re-build from the ground up. Both ways take a lot of work and there are pros and cons to both. Until we get more funding, our current goal is to capture the info, ideas, and data. We will then keep chipping away at the current infrastructure and virtually morph into the fracture model vs a full re-build. We would like to re-build, but that may not be practical. It all depends on needs, funds, timing, and goals.

Recording all kinds of notes from the past few days. Lots and lots going on. Even recorded some notes from a training session that I had with Russell over the weekend (last weekend). Busy times.

Cory was working on a news and update for online scheduling. As part of that, she asked me to help with some verbage and copy for the flex grid tie-in part of that feature. Writing content on a shared google doc for Cory.

Bryan got with me and showed me a small demo of what he has going on for the new time and online scheduling stuff for unique events. We already finished the reoccurring events. This new set of settings is for the unique or single events. After the demo we talked about changes that we still want to make. Bryan is going to circle back around later today and show me his progress.

Working on the 3rd party error logs and using them to record advanced history records for master time templates and cultivation settings. The 3rd party error logs used to be for just that, 3rd party error logs. It is somewhat being converted into an admin history and logging tool. Interesting development.

Bryan and I met back up and looked over progress on the new unique events scheduling settings. He is making progress. We were going through a small to do list. When we finished, we helped him make the next little to do list. We keep chipping away at it. I'll bet that by end of the week, next week, it will be ready. Good stuff.

Two different sessions. One from 4:45 pm to 5:45 pm and the other from 7:45 pm to 8:45 pm. Both were dealing with the same thing.

More work on the 3rd party error logs. Working on the add/edit sub inventory template section. The add new sub inventory template was pretty easy. The update method got a little bit harder as we needed to monitor what changes. This particular thing (piece of data) gets submitted in bulk and we only wanted to record changes if something really changed. We had to do some comparing between old and new and then flagging what had changed. Finished up this round and pushed up files into the master branch.

All kinds of stuff today. Tons of emails. I had 30+ new ones just this morning plus another 10-15 while I was working. Spent some time looking into the help file for the 3rd party error logs. Decided to change some things around and made the page into a special history and custom message/log page instead of the 3rd party error logs. Cascaded changes to all servers with new help files, new web page id numbers, and new permissions. Paid bills and recorded notes from today and yesterday. More than I wanted to do on my day off, but that is how it goes.

Steve and Sean were on going over new custom label settings that Steve was working on. He is doing tons on the labels and tying in everything to dynamic page settings. He had a few questions about version control (Git stuff). We got him all squared away and headed in a good direction. Next, we chatted about upcoming online scheduling settings and where to go next with those pieces. Bryan and I are making some good progress. I was doing some drawings and showing the guys where we are headed and what some of Bryan's new setting will do for unique calendar events and being able to book those from online or ecommerce.

Steve was talking with a lady and virtually gave her a small demo just by talking to her over the dinner table (concepts and principles). The lady loved the concepts of what we are trying to do and how it could help make things better and smoother. Basically, I think that people do like what we are doing, they just expect it to be done and ready to pull off the shelf (walmart style) where it looks nice, has a set price, and you can just pick it up. We will keep heading in that direction, but the reality is, it takes time and money, tons of settings, permissions, and even custom pieces. We are really going in a great direction. Keep going!

Shari O. and Danny joined the meeting. We did some light sub inventory training with them. Sean was chiming in as well. We've got some great team members. That is awesome. Hopefully we can all keep learning together along the way.

Project management stuff. Cory and Steve were going over projects, custom labels, and progress in those areas. We jumped into talking about server issues, email issues, and where are we heading. That lead to a conversation about the lack of education and training. Things keep changing so fast, it makes it hard to keep on education and training aspects of the system.

All three of us started talking about permissions and new permissions. We have a need to help secure up or tighten up who has access to certain settings. We decided that we needed a new master page level setting to help control those page settings. As we talked, we decided that eventually, we may need other settings or be able to assign sub permissions to a user based on their higher up settings. Similar to what we do with the manager's time clock settings. It has to be turned on and then we have a whole other page where an administrator turns on certain departments for the manager. We can see the need for similar type things in a settings admin or master settings mode. Basically, a person gets a main permission (part of the permission list) and then we/they configure what underlying access the users get. This becomes somewhat nested, but really opens up options and granular control of who has access to what and who can do certain things but not do other things. More ways the system is breaking or fracturing into subs or smaller and smaller controllable pieces.

We are getting really close on the gift card stuff for the system. Making plans and trying to see if we can push that new feature out before Thanksgiving. We have wanted this for years and years now. It's kinda fun that it is almost there and within a couple of days of being fully launched.

Client Zoom meeting with one of our clients and an outside 3rd party solution. The whole thing was dealing with API sockets and socket connections to push and pull customer data back and forth. The client is looking for a number of special use cases and seeing what already exists. They don't want to do any custom development, if possible.

As a side note for me, we really need to get into out API socket documentation and samples and make sure that everything is updated and good to go. We got into some of that today and it really could use some good time and loving. Not hard, just takes a lot of time. Light research into what else we need to do and expose on the public API socket level.

Recording notes and ideas from earlier today.

All kinds of random stuff. I logged into our Kabbage account (business funding) and flipped everything over to American Express accounts. They changed hands. Pulled down Eric's gift card branch and spent over an hour going through things and making small tweaks to his code. Light code review. I then got on a phone call with Steve. We were on the phone for well over an hour. We covered a ton of different topics. Most of it was geared towards updates, check-ins on different people and projects, and making plans. Trying to keep things going. It takes time and effort to make the ball go around. Trying to help it along. Good conversation.

Spent some time working on some custom black box code that we did for the bike shuttle company and trying to make it more global (for everybody inside of adilas) vs just custom for a couple of companies. Finished up the black box removal process and launched some new code with the standard pages looking at a series of settings and then exposing the bulk flex grid tools based off of settings vs custom page includes (custom code just for a single company). Pushed up the new pages and physically went in and removed the older custom black box pages. It feels good to get rid of some of those older custom code files and make the features generally available to all adilas users. Good stuff.

Looking over code for gift cards. Checking emails. Ended up pushing up some code and ran into a problem (crossing two code branches). Eric joined, Wayne joined, and we ended up rolling things backwards (back to the master branch). We talked about the need for unit testing as well as integration testing. Eric and Wayne were talking about software lifecycles and us maturing as a company. We are getting better and better but still need some improvements.

We could use some internal training on writing tests and how best to make sure that we have good coverage. We have so many different levels of coding skills (junior devs, senior devs, full stack devs, designers, etc.). We got into a big conversation about where certain logic needs to go and how best to handle errors and logic for checking for record counts.

That lead into a conversation about MVC (model, view, controllers) and how we are currently doing some of that but we are also mixing things. For example: We have some of the view and the controller in-line or on the same page. Some of our logic is intermixed with the display vs the business logic. Some of the code is older and some of it is newer. We need to make some plans and then go and head in that direction. Currently, we tend to go in a number of different directions. It gets done, but it looks more like patchwork vs tight, smooth, standardized code. Getting a plan and being united in that rollout, even if we have to do a little bit at a time, would be awesome for our fracture project and plans.

Working with Danny, Sean, and Shari O. on the rafting site (demo site). They, especially Danny, were requesting and wanting some kind of SOP's (standard operating procedures) or some kind of a quick start guide. See attached for our notes. New notes are at the bottom. Mostly the session was just checking in and some light communications for today.

One of my observations is we have things all over the place. We have things inside elements of time, in physical notebooks, in emails, on adilas university, on YouTube, in help files, on different google drives, and the list goes on. We have a ton of resources, but they are not yet linked, cataloged, and organized for use. It's too spread out. That would be an awesome project to get all of that together and available to the public. That could be a future fracture type project. Training and education are huge spokes that we need in our wheel. There is a whole other side to this thing and it's on the education and training level.

Totally random, but a fun side note or thought - Think how cool it would be to go through the different system players (all 12), all of the different system business functions (12 of those as well), and the underlying core concepts. That would be awesome. Beginner, intermediate, advanced, and deep dive or backend levels. Show how things act, cause and effect relationships, where they show up for roll call, how things happened historically, how they effectually show up for roll call, and even how they financially affect inventories, banks, P&L's, balance sheets, and other financial relationships. That would be sooooo cool! I would love to work on that project.

I would love to get into the how, why, and what we are doing. The how and why really seem like fun topics. The "what" is pretty normal but allow us to do the other parts of the puzzle or passing the data along the virtual data assembly line. Getting into 3D world building and all kinds of cool stuff. So many things that we want to do and build. We just need help getting to that next level.

Adding u of m to global parent core updates. Also categories down the way.

While we were waiting for Wayne, Cory and John were going over payroll and yearend forms and updates. We then started to talk about email servers, changes, web servers, and general web API documents, samples, and general documentation. Wayne joined and we touched on some of those same subjects again briefly. Cory then had a list and we started to go through it. One of the crazy things that she is doing is helping to schedule and coordinate releases and updates. We've never had that problem before.

Cory is planning a rolling blast of server updates spread across different days and for different servers. We then rolled into a small discussion about a bug bounty program and possibly offering compensation for individuals who help us find bugs, vulnerabilities, or ways to fix and enhance the system.

Helping Cory with some tech support questions and answers. Wayne then took us into a deeper realm of DNS (domain name server) records, SPF records, DKIM, and DMARC records and errors. All kinds of deep email server stuff. He was going over public and private keys and how they all interact and work together. It got a little bit technical but good to know (or at least be aware of).

Good phone call with Steve. We were going over some new options and just talking about plans going forward. Steve was saying that we need these basic departments, inside of adilas: sales, training, support, development, admin, and deployment. He was also talking about how to help extend ourselves by selling some our adilas percentages or shares. We talked about how we need a virtual bridge between the current adilas leadership and the next generation of that leadership. It (a virtual bridge) could be either through our SBA loan (debt and equity) or shares/percentages (revenue and equity). Steve had tons of good ideas. Just bouncing things off of one another. It was a fun and interesting call.

Meeting with Cory and going over transition invoices and some of the logic behind the scenes. I was showing her the old way that we used to update transition invoices by adding line items after the fact. We looked into some code and tried to fix a small bug. We opted to send it over to Alan and let him take a look.

As I joined the meeting, Cory was already on there. She invited Alan and we had a good discussion about transitional invoices (QTI stuff - between a quote (Q) and an invoice (I) - thus QTI - quote, transition, invoice).

Cory showed us the problem and then I showed Alan, in code, and we ran a number of simple queries on the live server to look at data. I did lots of drawing to help illustrate what is going on. We talked about things and Alan is going to look at the code and make some changes. Good session.

Right at the end of the meeting, both Wayne and Eric joined the meeting. They are working together on the new gift card stuff. They are both very smart and I'm glad that they can work together. More good progress. Cory and I had to jump off to get on another client meeting. We left them in charge and on the GoToMeeting session.

On a Zoom meeting with a client. They wanted us to go over a custom data extract with some other tech guys who may be helping them with some of their data needs. Adilas has a ton of things built-in that may be hard to replicate. Anyways, there were six of us on the call. I ended up showing my screen and we virtually dissected the JSON data and looked at a basic visual dump of the data and what it means and does. I was drawing and trying to explain things as we were going. I was having fun. Hopefully they were enjoying it and getting the info that they needed.

Towards the end, the client was using adilas to show the new tech guys how it works and flows inside of adilas. I think that the other tech guys were impressed as well. Interesting conversation.

This may be overstating things, but I kinda feel like Adilas is a mix between Salesforce, QuickBooks, woocommerce, and high-level Oracle of SAP type level software packages, all in one. There is some real value there.

Recording notes, emails, follow-ups, etc.

Recording notes from the past couple of days. There has been some fun brainstorming on education and training plans. Here is a summary of the last few days.

On a phone call with a business investment company out of Canada. Talking about options and possible growth stuff.

Finishing up with notes and transferring meeting notes from post-it notes to digital records for the developer's notebook.

Added a new permission for some of the page level settings. We called it "Admin Level - Page Settings" permission. Cascaded the new permission to all servers and updated a number of files to watch for the new permission. The new permission id number is 176.

Side note for me - while syncing up all of the servers, I had to pull data from the data 0 box for multiple tables. Currently, the data sync grabs the entire table and its contents and syncs that data (inserts or updates). We really need to add a last modified date to those tables. Instead of pulling thousands and thousands of records, we would be pulling super small record sets. That would really help speed things up. Along with that, we could keep a history to help us know when the last pulls were made so that we could efficiently request and pull (sync up) the data.

The other thing that I was thinking about, while waiting for full tables to sync up, was daydreaming about using the web/API sockets to build the next generation of our software. I'm not sure if this is the fracture project or the next one beyond that. I think it would be really cool if we use our own API sockets and build some super cool pieces. They wouldn't have to follow any of the existing rules, look and feel, or whatever. We could build the whole app using the web/API sockets and host it on any server that we want. Just some thoughts. I think it would be really cool to do that. Even for the fracture project.

Along those same lines, if we build out the web/API socket interface, we could teach and train others to use the same thing (web interface or API level interface) to build all kinds of cool things. You could make it a way to teach other people and virtually invite other developers to build out cool add-on's, custom apps, or skinned down apps of what we currently have. Just some

Small demo for my day (Wayne Moore) and Harry (my dad's friend). They were pitching that we need some training courses. They want to go pitch adilas, but don't feel that they know what it can do. We talked a bunch about LinkedIn training courses. See attached for some of my notes. The first part was for the demo and then we started talking about all kinds of education type options.

- Wayne - training courses - in LinkedIn - people need to see it

- Adilas course that could be as deep as we would like... overview, beginner, intermediate, advanced, deep-dive

- Helping people know what is possible

- Get people where they need to go and then come out with a skill

- YouTube is another option

- We could get a lot of traction if we help train the public on what we have

- Putting the pieces together - where do you start and where can it go (easily) and with some work (more in-depth).

- The crazy things that we are doing - everybody needs.

- Global communities

- Tapping into other resources - including going into LinkedIn - allowing them to get all of the resources (course materials) so that they could do it on their own

- Helping show the adilas world - we have to show what we have

- Just in time learning and training - being able to move from step to step (building out the whole)

- We already have pieces - we need to string it all together - at the professional level - having our own plan of how to navigate the elephant

- Wayne was really pitching the training aspect of what we have and do

- Harry - you get what you pay for - If they pay for it, they become invested and involved - time, money, etc.

- Time - that is the tricky piece - sometimes we feel like we are so busy

- The digital world of learning - certificates, learning, etc.

- Adilas keeps changing... that is part of the game

- Steve was commenting on how we used to do videos - way back - we couldn’t even get things edited before they changed

- Wayne and Steve were talking about setting up new courses on LinkedIn - Wayne will see what it takes to add in new courses

- Steve was showing them some of Danny’s adilas quick tip videos

- Funding - getting enough to get that part of the puzzle going

- Talking about invoice reminders, online payments, etc.

- Steve was showing them the warranty registration stuff - video from Chuck

- Steve was explaining how our model has changed. We used to use outside reps and consultants. Now everything is done internally, using adilas trainers

- Steve was pitching ongoing training courses for our clients.

- Wayne has a degree in curriculum and training

- Steve was showing his older YouTube player - older stuff - but still valid - we need to update it and keep it fresh

- Speed and cadence of what we are going over - full outline and layout

- Just in time online courses

- People are pretty picky - we have to capture their attention pretty quick or maybe even faster

- Keeping up with the constant changes

- From Wayne - make the world our audience! Getting the information in front of the decision makers

- We can schedule more meetings, or we are on every morning at 9:00 am on the GoToMeeting channel

- From Steve - how do we make this go forward? Plans, compensation, ideas (even out of the box).

/////////////////////////

After the meeting, my head was swimming. I came up with a couple of other ideas, just for fun.

- What if for training we gave a new user 3 accounts vs just one account. Here is my thinking - One could be for the start of the lesson (work area), one could be for the finish of the lesson (what is expected or a finished product), and one could be for fun (we keep whatever, their own playground). All of the other systems could be reset to any stage by rolling back a database. Assuming that the training was planned out enough to roll things backwards and forwards as needed. This could all be scripted and rolled around as needed. It would really help with training and keeping things standard.

- What about making things plane Jane type interface or only as much as is needed. Keep it simple. Just a thought.

- Being able to reset the database at any time could be really cool.

- We aren't ready for this yet, but for fracture, it sure would be cool if we could have certain settings and defaults on speed dial. Basically, if someone wants a certain setup or package, the database (aka the backend scripts) could help us flip flop things in a hurry. Currently, we have to setup all of the pieces, settings, permissions, naming conventions, show/hide, sort order, and other aliases in a manual format or fashion. That takes quite a bit of knowledge. If we could get our settings and options dialed in, that would really help and speed things up. We could configure and virtually show/hide certain things in a click of the button vs hours of individual configuration. Lots of options here. It could be size wise (tiny, small, medium, large, extra large, huge) or it could be industry specific (this for that, and this other stuff for some other industry - tons of options). Preconfigure whatever we can. If they want to still tweak things out, it all exists, it just gives them a quicker starting point.

- Not sure where to take this... but I was thinking about books and choose your own adventure type style books. If you want to do this, go to page x or y. If you want to do this other thing go to page z. What if we helped setup our training in the same manner? If you want to put this on account, do this. If you want to pay for this, do this. You get the idea.

- Train the world

- Super easy setup and configuration, you could then tweak it if needed to get super custom

John and I going over yearend payroll, forms, and tax table copier code. We also spent some time talking about the next projects.

Reviewing code with Bryan. Looking at his new settings and flow for unique events. Going over some scenarios and checking on bugs. Also did a quick fix for Danny for online scheduling, small bug fix.

Spent 15 minutes on a phone call with Eric, going over logic and flow for submit cart and gift cards. Emails, checking on bugs, and general stuff.

Working on some code updates from Bryan on the unique event and online booking settings. Light code review session. I also gave him two new post-it note fixes (small bugs or to do list stuff) from my never-ending post-it note collection.

Danny, Sean, Steve, and I on a meeting. Who is our competition? What if we took our sales angle and tried shooting for bigger targets. We can get small accounts, but that takes a lot of work to get them setup. Really big ones have a bunch of red tape and lots of levels of management to get through. It gets tough.

Talking about associations, relationships, and social networking. On the training side of things, we talked about getting the word out and helping people know what we do. Currently, nobody knows all of the pieces of adilas. That is crazy. Just for fun, I rolled back and was looking at an older entry that was talking about what we have and what we offer. See element of time # 5484 for more info.

We then got into talking about private research and transferring knowledge and information. We need to keep working on good documentation and what we really have.

Code review with Bryan on his unique event stuff and online scheduling. We were also looking at a few post-it note bugs and changes that Bryan is making. One of them (small fixes) was dealing with updating vendor/payees with an inventory flag. The other one (small fixes) was dealing with show/hide settings for part categories and the show/hide on the web setting.

Looking over unique web events and online bookings. More code review and did some merge conflict stuff.

Working with Bryan. We were fixing bugs, cleaning up pages, and I was pointing him in the next direction for time settings. See element of time # 8004 in the shop for a list of things we want to do with time (new time template settings).

Going over the time ecommerce page settings and making a few changes. Light clean-up process and code review.

Steve and Sean going over more custom labels. Talking about using a calling company to help with leads and demos. I was doing emails behind the scenes.

We started out talking about some yummy food (before Thanksgiving). That was kinda fun. We then switched to API's and trying to fix a small bug. We ended up having some session stuff in the CFC's. We got that removed. I will work with the developer to help them not do that again. It worked fine for internal exchanges but it would fail if we used external exchanges (API sockets).

John checked in and we talked about payroll and state withholdings. He is going to focus on Texas, Wyoming, Oklahoma, Colorado, etc. We'll go from there.

Meeting with Wayne and Eric. Talking about internal shopping carts and refactoring the internal cart engine. Not the user interface but the backend logic and brain. They were talking a new cart model and making things consistent.

Just for fun, we were talking about what adilas might look like if it was a building (a core with multiple add-on's). Kind of this conglomeration and stacking of structures on top of structures. Kinda interesting.

We talked about taking the logic and look-ups out of the pages and into functions and models. Trying to standardize things. We talked about overloading variables and using a single thing to hold multiple things. For example: We have a form field that is called store_id. However, behind the scenes, that field has the store id, the store initials, and the whole store name. Basically, we pass a list of data to prevent a later look-up, but it basically overloads a form variable.

Anyways, just trying to be more consistent and having  a known starting point. We also got into duplicating things to cart, invoices to carts, quotes to carts, restore to cart, buttons to carts, barcodes to carts, simple searches to carts, starting from a customer vs an item, etc. We are trying to make all of those pieces work in tandem and flow smoothly between the different sections. Basically, creating models, controlling inheritance, and the flow of data and logic.

Eric was talking about the time it takes to push things live. If the model is not consistent, it takes twice to triple the amount of time. 

Small work session with Bryan out in ecommerce land. We pulled some session variables out of the functions and put them in-line in the page logic.

Looking into a merge request from Eric. I wrote him back after making some changes. On the phone with my dad talking about being a teacher to teach adilas courses for LinkedIn. We really need to get into the training end of stuff.

Emails, small code merge for Eric, and reading and doing some research on why we do what we do. We are making conscious decisions. See element of time # 5484 for some older ideas and session notes about the why and why we do what we do.

Talking with Sean about a cart redo "the guts" and how we are going to refactor things. Going over gift cards and where that project is at. Getting closer, just waiting on the cart logic refactor. Just for fun, Sean and I were talking about the classic look and feel vs the newer snow owl theme and look and feel. The classic is fully done but older. The snow owl theme look and feel is newer but is only partially finished (full page rewrites). Still updating pages and sections. It has more functionality and provides our users with a better overall experience.

Along with those look and feel discussions, we were talking about some what if's... what if we used a super generic (almost black and white) type interface for training (just the basics) and then showed how you could skin it (adding on the look and feel once you know what you are doing). As we were talking about this, Sean said that he has a email that had some client requests on it. I asked him to send it over for review. I would really like to see what the client wish list is.

As a side note, one thing that some of the clients were asking for, which we do, is no transaction fees, they just wanted a flat rate or a flat fee. I thought that was interesting. Basically, don't punish me for doing more transactions. Steve and Sean asked for a demo on the new unique event online scheduling. We ran into a small bug and the demo didn't go very well. It's close, it just needs a little tweaking.

I switched and did a small bug fix out in ecommerce and pushed up some new code.

Bryan and I going over some new time template settings for make private and admin only settings.

Emails, working with Bryan on time template settings, merging in some new code, and running some tests. Also spent some time looking into tweaks that were needed for ecommerce and unique events. Bryan asked for some more post-it note fixes (small mini project that hit our to do list). I did some look-up and research and got some code samples for the new date picker stuff.

Emails and small to do list stuff.

Emails and recording notes from a couple of weeks ago. We had some fun brainstorming sessions on education and training.

I was recording notes while the other guys were talking about sales and strategies. Steve, Danny, and Sean were talking about small promo items, selling and pitching our services, and even getting a small account for our guys in the field to really figure things out (a live mini test bed). The more that they get into the whole process, the more they get it what it can do and can't do. That is huge. Lots of talks about that and ideas that were related to that on-the-job training (hand on) approach. Steve was even saying, it may be worth it for us to pay them (the sales reps) to get an account and we cover the setup fees, training costs, and what not to get them up and going. Just an idea.

We are wanting and needing to get ourselves out there more. Nobody knows what we do and what we provide. We need to get the word out there. It would be nice to have a really small starting point. Getting people engaged right away. Some of our guys need some more accountability (daily meetings and/or small touches).

Cory came on and they, she and Sean, were talking about the pros and cons of selling and pitching 3rd party solutions. After that, Cory and I went over a number of current projects. We talked about a company that wants to use iframes out in ecommerce or use our ecommerce package inside of an iframe (window within a window). We discussed a client and their custom data export needs and how we can help them out. We wrapped up by dealing with other projects and plans that are floating around.

Recording notes from last week. Short week, due to Thanksgiving. Busy times.

Alan and I met up over the GoToMeeting session. Eric was supposed to join but forgot. He joined right at the end after Alan and I were finished. He just got busy. Anyways, Alan and I were talking about the process and what it would take for enterprise level parts or items catalog. We talked about things at a high level and then actually moved into existing code. We reviewed the current add/edit parts page and talked about different possible cause and effect type scenarios. Our plan is to make a simple copy at first and then lock it down so that the transactional corps can't change it. At some point, we will have to make some decisions on how deep to go and what to lock down and what to leave open or more flexible. Good discussion.

Towards the end of the meeting, both Alan and I were talking about how we'd love to get the developers together and get some standard training to help us all get on the same page. I'm not sure when this could happen, but I'd like to see it start heading in that direction (either virtually or in person - either way).

Unique event settings with Bryan. Small demo of where things are at. Looking good. We then spent some time going through different scenarios and flow processes (URL vs Form controlled searches). You also have to mix in different settings along the way as well. It starts getting more complex. Bryan is going to work on a few more things and we'll get together after that to look at things. Making progress.

Spent the last few minutes, after Bryan left, looking around the adilas site and clicking through a number of small reports, bank statements, and payables.

I was going to meet with John to discuss the state percentage withholding tables, but he got tied up at school. Instead, I spent the time recording notes and doing some research. I also tried to tick away at my to do list.

Met with Bryan and he was reporting on his changes to the unique event settings. We were going over the order to operations within the scheduling part of the system. We spent some time walking through the different settings and how they played through the mix. We fixed a few little things and Bryan is going to work on a few more little tweaks. We are getting close. Just a couple more things to tweak and get polished up.

Steve texted me and we jumped on the GoToMeeting session. He was working on his custom label settings. We got deep into looking at dependencies for payee and corp-wide settings for custom colors. Basically, the page that he was coding had an if statement up higher that would split the page based on payee (user) level settings. We verified that the pages were the same, it was just the settings that were different. Anyways, we ended up looking at pages that ran correctly vs pages that did not run correctly. We were comparing things and looking deep into the dependencies. It turned into a virtual witch hunt and trying to find what the different settings did and which ones controlled the pages in different ways. We ran out of time, but at least we know where to look now.

Somehow the page was adding in two top portions of the HTML file and skipping some key CSS code. We found this by looking at the custom PO labels settings on servers and corporations that had different settings. Basically, the page would work if a person has a certain setting but it would fail if that setting was not in place.

As a side note, we had to compare the final browser output (page source code) vs the underlying code (actual code). Sometimes you can find the bug directly in the code. That's the normal way. Other times, you have to let the code generate and then look under the covers from what gets pushed back to the browser (html source code - what gets returned). Almost finding things after the fact vs up front. Anyways, that is how we found this error. We went backwards on it.

Great meeting with the sales crew. There were 8 of us on the call. See attached for the meeting notes.

Stephen Berkenkotter	10:26 AM (0 minutes ago)
to Sean, Shari, Hope, Michael, Rueben, Danny

So ......... great meeting.

Everyone on the call is a co-owner of adilas.

Each person has full on authority to complete the sales process and deploy.

Just touch base on pricing until you have this dialed in.

Goal is

Help 1 business succeed. 

Focus on just 1.

Tools are

Free Deployment/Training

Competitive Monthly / Activation Pricing

No Contract

Benefits are

Increased hours 

10% of the monthly

This is for all salespeople

Danny

Sean

Hope

Michael

Rueben

Open this link on your phone and save to the homescreen.

Sales Presentation Gallery

Sales meeting. We had 8 of the adilas salespeople on the call/GoToMeeting session. Steve was leading it out. We heard reports from the field, ideas, and then some great ideas on "Pivoting" to fit our needs. See attached for the notes. Great little meeting.

Here are just a couple of things. See the note for more details:

- Steve empowered the guys/gals to make their own calls on pricing, setup, and activation. If the client can handle it, we charge for it. If not, we make that call and just do it to help them out.

- The concept of "Pivot" or being able to pivot as needed.

- Our new pivot is going to be free training and setup for the next month or so (till the end of the year).

- Respect, like, and trust - we are seeking to have our clients feel this way about us.

- Use your resources

- Tons of other good stuff (see notes)

Cory had a list of things to go over with Wayne in our sever meeting. We had Wayne, Cory, John, and I on the meeting. Steve and a couple of others were also on but not participating. Cory pretty much led the discussion and the meeting. Here are some of the topics that we covered. New backend cart process and refactoring code, new tests for the add to cart page and view cart page, automated tests, email servers, security updates, and scheduled maintenance.

John gave us a report on where he is at with yearend payroll and tax withholding stuff. He is also working on new documentation for payroll and yearend forms and processes. We talked about the adilas docs (our internal documentation and style guide stuff). Possible new options for automating database updates and pros and cons of using outside plug-ins - like date/time pickers, data tables, and what not.

Steve, Wayne, Harry, John, and I were all on a meeting. Steve was talking with my dad (Wayne Moore) about all kinds of ideas and direction stuff. It was pretty heavy on the education and training side. Partway through the meeting, Steve had to jump on another call/meeting. I stayed on and talked with them about all kinds of stuff. See attached for some notes.

2/15/23 Edit pages:

- top_secret/secure/statement_home.cfm

- top_secret/secure/add_edit_statement.cfm - step 2 - select statement date range (2 of them)

- top_secret/secure/add_edit_statement.cfm - step 3 - set the dates (4 of them)

- top_secret/secure/bulk_receipt_verify.cfm - top form and looping over the results

- top_secret/secure/bulk_deposit_verify.cfm - top form and looping over the results

1/26 check and pushed final pages with Brandon.  Basic project complete.

1/23/23 checked and pushed 600 pages with Brandon.

1/18/23 checked and pushed 300 pages with Brandon.

1/13/23 updated more datepicker code on pages.

12/21/22 updated more datepicker code on pages (see below). Will connect with Dustin on testing:

12/6/22 Consolidated the Time code that Brandon and Charles did, and met with Brandon to check the code.  Two news and update pages have already been created for this project "Elements of Time Homepage Will Have a New Look" and  "New Look for Working With Time". Next we plan to have Wayne point the data 5 server to the branch (project-2260combine) so that the code can be tested on data 5. 12/5/22 met with Brandon on what we wanted to do with time:

    Date picker:

1. We want:
2. 1. put in 1/1/2 (characters)
3. 2. get 1999 when we put in 99 (not 2099)
4. 3. truncate correctly: 1999 goes to 1999 not 19
5. 4. if I supply a date in the past on the first click I want to go to that first (not how it is currently functioning going to todays date).
6. 5. create documentation in help file and in Adilas docs (update).
7. 6. update to all datetime instances. Check for date validation and go backwards (if I am validating a date I am putting a date in). (search for 'datepicker', '_date', 'date_', '
8. from_date', 'to_date', -form fields are what we are mostly looking for)
9. 7. on the times be able to put in a one digit (1 PM not 1:00 PM)
10. 8. put the datepicker on the content server.
11. 9. roll it out in small batches (10 or so pages instead of all at once)
12. 10. leave Bear100 code alone.
13. 11. communicate with Cory and John.

12/2/22 Spoke with Cory and John about the project.  John said there is a bug with the new picker that needs to be resolved. He said there is some information in the Adilas Docs that may be helpful (Adilas Docs>hamburger link>Adilas Core>components (top links)>date picker (left side dropdown, 'here' link - If you need more information on flatpickr for some reason you can find the documention for the plug-in here ).

Next, all of the datepickers in the system need to be updated to the new datepicker.  Brandon sent an email regarding what needs to be done to update all of the datepickers as follows:

 I found a page that shows some simple date picker stuff. Here is the page: top_secret/secure/add_bulk_flex_grid.cfm – if you search for “picker” it will take you to the different options that are needed. Here is a quick rundown.

• 1^st include is set right before the include for basic_css.cfm it looks like this:

 

 

• Then any new date field will need the date-picker class. For example:

 

--- the key is the class=”date-picker” part or css class stuff

 

• The last include is set right before the ending body tag. It looks like this:

 

Anyways, there are 3 basic parts… the top include, the new class on form fields, and the bottom include. This is true for any page that is a full page (no black box options). If it does have black box options, it is slightly different. Anyways, just wanted to get you some information. I don’t have a list of files right now, but we want to spread it (the new date picker) across the whole site. If you want, we can meet and build a list or if you want to poke around and fix things, that would be great as well.

The only page that I know we don’t want the new date pickers on is some of the bear 100 custom files. They get dates entered in via special formats and the date picker screws things up. Everything else needs to be updated (to my knowledge).

Going through ecommerce level time settings for unique events and what not. We have done multiple rounds on these new settings. It gets complicated on the display level - show/hide normal items, show/hide reoccurring events, show/hide unique events, show big tables, icon boxes, description tables, bulk tables, etc. Anyways, working the different scenarios and possible display options. Lots of moving pieces.

Bryan was showing me some new setup and validation to help get the proper settings based on the display decisions. We got deep into the technical to do list stuff. We ended up looking at the different ways to do searches and drill-downs. We have a number of them fully mapped and built out. We just need to keep testing the other possible search and display options. That's where it gets a little bit wild, just so many options. Making plans and looking at the next few steps. We are getting close.

GoToMeeting work session with John. Clarifying payroll code and state figures to calculate taxes owed. Looking into Colorado state tax withholdings as well as Oklahoma state tax withholdings. Getting in deep and actually doing mock calculations and dumping the variables to check the math. We ended up looking at old code, new code, tax guides, and special external calculators. Just checking our stuff. Good little work session. We had some good breakthroughs, even just getting more comfortable inside of the payroll system. Thousands of lines of code and tons of math and special look-ups. It gets deep.

Recording notes from yesterday and meetings that I was on earlier this morning. Also met with Bryan for a few minutes to see some of his progress on the to do list for the unique event ecommerce settings. More end of the day clean-up stuff.

Danny and Sean popped into the meeting. Nothing major going on but just talking about sales, demos, and how to put our best foot forward. We talked about getting small quick screenshots and samples to help go along with our demos. Currently, we bounce inside of a demo site, show someone around and then bounce somewhere else. I use the word bounce, and we are fine with that, but to a new user, that seems like you have to know a lot, in order to jump or bounce around. They want to know that we have certain things and want to get their hands held for the first little bit.

Because we are so flexible, it sometimes intimidates people and new users. That might be a good thing to remember for fracture (future project). Maybe setup a super simple step 1, 2, 3 process that always work (for example, the normal front door entance) and then show them how they can change that if they want to (side doors, back doors, basement doors, garage doors, etc.). Dustin was calling it handrails. I might be nice to have different training modes or education modes. If you turn it on, meaning education mode, it virtually tells you what to do. If you turn it off, you can bounce wherever you want (like normal). Almost an analogy of training wheels vs freeride or normal bike riding (without training wheels).

As a small side note, my dad (Wayne Moore) was saying the same things yesterday. We were looking at the main adilas.biz website and he was saying, I like the verbage but I want to see it (super tiny clips or screenshots). For example: It says "real time visibility and control with inventory management". Ok, what does that mean and can you quickly show me (a picture is worth a 1,000 words type mentality)? Just some quick screen shots.

As a note, there may be different levels. We may need a quick overview, a quick this is that (demo style), and then a deeper how to or let's really learn and master this. I can totally see a need for different levels of screenshots, examples, tutorials, and step-by-step walk throughs. Good stuff.

Wayne and I jumped in and did an hour and a half long meeting talking about the internal shopping cart. Wayne was showing me how he has to change things in order to run tests on certain pages. He is using an interesting combo of saving content and running included files inside of the saved content. Then it becomes a memory variable (big but still in memory) and he can test certain parts of the page that way. Interesting.

We went over some of his tests and how he has to virtually fake it, mock it up, and simulate certain flow and/or actions. He is working on removing an older code set that used a cfinvoke tag into more of an object model. We went over mocking the data, throwing errors, and catching the errors and exceptions. The discussion on testing got us into topics like: limiting the scope, only testing one page at a time (not the dependencies), testing without touching the database, keeping your data clean, simulating page redirects, as well as hard aborts or stops.

Part of the test is separating the data from the logic. The logic doesn't know if the data is real or not. It just knows what to do with certain types and kinds of data. By splitting things up, you could test the code logic without having full access to the actual data (live data) or being able to fake or mock the data (hardcoded or simulated data). The goal is to test the logical flow of the data through its process and/or routine. Ideally, the end goal is to make the processes more refined, bullet proof, while keeping the data nice and clean, and organizing the code to be reused and maintained by others (where does each process live and how is it organized). We briefly talked about putting supporting code closer to the usage of that code vs a more disjointed style.

After going over some of the testing, we switched over and started looking at the actual cart code and how it works. We did some demos, looked at code, and did some drawings. Some of the discussion was dealing with other developers and what assumptions that they are making. If the process is super complicated, the other guys who don't know, guess at where to make changes and where to start. That has bitten us in the butt a few times. Often, we play this crazy game of "add on". If the other person/developer doesn't know where it starts, they simply add on where they can and then go from there. Sometimes that is fine but as it gets more complex, it actually causes pain to the other developers.

To be honest, sometimes we don't know where things are going when they get built out (first time around or phase one). It just keeps organically growing through that add on game. Eventually things slow down and we can determine what is needed and wanted but we may make a mess getting there. That is totally normal. You just have to be willing and able to go back and do some maintenance and clean-up. That's the part that we have been missing. Currently, we just keep pushing forward without taking time to circle back around. That process of circling back around takes major work sometimes. Part of our fracture project (future project) will be going back and defining what we want (overarching scope and requirements) and what we need and then building accordingly. The bigger the picture that we can see (speaking hypothetically) the more we know what needs to be included and fully integrated - once you know the bigger picture, the path becomes clearer and you can plan accordingly.

Things get really crazy when there is a difference between testing and production environments. That could be settings, permissions, versions, data, usage, processes, scale, etc. It can get quite in-depth. The more ways to do things, the more things that need to be checked and maintained.

Wayne was saying, none of our customers have ever left our system because we don't do custom. They love that. Some of them really hate that as well as they have been burned and feel like testers vs clients. Most clients don't have a problem with what we charge, for what they get, we are way under the normal market prices. The biggest reason that some of our biggest clients leave is either the look and feel or consistency and scaling issues (they get too big for our product). The next step up is a big one (cost of other custom software solutions). Wayne and I were talking about helping our code not be fragile and be more bomber and scalable. That is a task, in and of itself. One of our biggest weaknesses is code reliability. Getting that dialed in and on speed dial, that's the goal.

Having said that, we have a viable working prototype (the adilas system or adilas platform). Not only are we constantly refining it, we have had paying customers who have paid hundreds of thousands of dollars per corporation to use our system, as is. That's millions and millions of dollars that we have generated on a working prototype of sorts. That is awesome. I'm excited to see where it goes.

Finished off our meeting and conversation about talking about how even automated testing still needs some hands on testing and virtually kicking the tires. Wayne and I also talked briefly about percentage ownerships stuff inside of the adilas company. We would like to invite Wayne to be a co-owner in the Adilas, LLC - multi member LLC company.

Do not allow a dup to be created on the compare inventory. Will create a table to track how this is happening, who is doing it, and timing etc. But won’t let it create the dup. 

Zoom meeting with Cory, myself, and an adilas client. Small meeting to get some further clarification on what they are wanting. We are building out a custom data export for some of their data. They are trying to work with Salesforce to get a big integrated communication system. Sounds like a big build out of sorts. Anyways, we chatted with the client and got some good information about costs, timelines, etc.

Research on priorities, emails, and checking things out on adilas. Looking at deposits, banks, payables, etc. Recording notes from earlier today. We had a few good sessions.

Working with Aspen and going over her training website project. She finished it up and we went through each page and looked around. Light critique, some small suggestions, and fun looking around and getting a flavor of her subject. Good stuff. I would say it was a good session. Then after that, we flipped over to her next task of doing some research on world building. We are looking for a virtual funnel and pulling things together and gathering up all of the research. She was talking about summaries, timelines, etc. It should be fun.