Added a database library just to connect and manage database tasks (for SQLite3) and created a .sql script to create the empty database on installation/update.

About 1'5h expent into this, closing the deadline!

Last weekend, I started a project about a continous integracion (CI) server that you can run on a Raspberry Pi, actually my Raspberry Pi 2 B. I installed a Gitea on it and started to code.

Working on it everyday. It has a task runner script (like Make/Rake, but with YAML files and written on Python) and its own web interface to configure and connect using webhooks to Gitea.

My goal is to write code at least 1 hour per day, and deadline is next sunday (3 days to finish!)

Almost finished removing all the mocked data calls by real database data with the main logic of the system.

Today I replaced more mocked data with information about the current user organization.
Touched a bit my helpers because of the lapis request context.

Added portuguese districts in the database.
Replaced multiple data mocks with real database data.
Implemented logic to fetch and create the main database models.
Fixed problem where I was loading multiple forms in the lapis initialization, instead of loading it in the request, which would make database calls and slow down every request.

Changed the register_organization controller to register a organization instead of a user and then write the session of the organization owner.
Added data correction if the organization fails to create after the organization user is already generated.
Updated the data constrains in the organization database table.
Added data to the database using the migration system.
Added new helper function for map.

Added all the needed fields for the job_offer creation in the model.
Created roles checking decorator.
Applied the role checking in the needed endpoints.

Fixed the calls to create the current user session after login and registration.
Changed the redirection when the user is not authenticated to go to the 404 page.
Added check of the current user role in the job offers creation.

Implemented checking if the user is logged and display a 404 page if he doesn't has access, using decorators in the wanted endpoints.
Added roles constants.
Implemented controller to create job offers.

Today I built a simple UI to use with my reminder tool.
So I can easily search, insert entries and merge files from other pcs.
Used the iUP widgets from PUC-Rio with lua. Its really nice and simple.

Fixed sessions last details, now sessions are working as expected.
Implemented logout endpoint , logic and triggered the logout by clicking the leave option in the ui menu.
Limited display of the round user icon if the user is not logged.
Created models for the category and skill database tables.

So today I were working on a python + django platform.
I made some bigger architectural changes some months ago and then stopped working in the platform until last week, so right now I don't really remember what was already changed or what was still broken.
So today I passed my coding time implementing unit tests for the multiple application endpoints and fixing some non working code.

So yesterday I implemented a salt for my users, but I was using bcrypt algorithm which already has an internal salt, so it was not needed =D . So today I removed the salt.
Created a lua lib to strip the non-ascii characters from strings - github and luarocks.
Implemented sessions in the platform im building. Now im finishing the user login.

Read data from /dev/urandom and made logic to get only the printable characters.
Implemented salting of the users password when they are created.

I was thinking the need of a salt, and how to implement it in order to protect the users password in the case of a leak. A friend sent me this link - Salt Implementation

It was a very nice read, tomorrow I will try to start it's implementation in my lapis user model.

Added listing of own answers,
Implemented voting in the people answers.
Deploy to the world :)

Implemented some backend logic for a forum. From menus selection, filtering, regular CRUD operations in models.

• Added logic for roles and newsletter registering in the User model.
• Added creation of common users.
• Added extra validations with default values in the user.
• Added user creation when starting the creation of a organization.

I read about the haskell language having tons of really cool features, so I decided to take a bit and look at them. So the end of my day were checking haskell tutorials and testing the language base concepts.
Haskell tutorial I followed

It's really nice, some concepts really unlike the stuff I usually use. In the future I may try to implement something with it to check how the program behaves.
Would like to also try Rust programming, looks fun too. :D

Added validator to the forms to allow the comparison of 2 fields when in validation.
Implemented user creation with encripted password.
Started the creation of organizations.

Today I made just little changes, I added logging to errors detected by the validation in my forms, which uses the lapis validation.
Since lapis already gives me all the feedback about the invalid fields, it was really simple to make :) . Lapis is very nice.

Today I worked in the web platforms.
Read documentation given by clients and prepared requirements, tasks and all of that to the next work days.

In the Lapis application, made my forms use the table information to make automatic validation in the backend when the form post is received.

After the yesterday thoughts, today I added events to my ECS architecture:

• Added event listeners registration and events triggering of logic to the world and to the systems.
• Implemented system to check when the game ends, by listening to the action of a mine being pressed.

Done Today:

• Added input component.

• Added delay for multiple clicks in the same input.

• Added initialization of the mines across the map.

• Research solution for communication between systems, and triggering of actions like checking some condition to validate the end of the game when a block mine is clicked.

  • After looking at other ecs frameworks I found an event system which allows the systems to listen for events and also to fire new events. Implementing one system like this should resolve the problem.

Today I created systems to render the minesweeper map blocks and detect the clicking in them.
I created the main components Block, Rect and Point.
Generated an entity called map_block to hold the 3 components.

This allows me already to have all the map rendering and triggering of the input state changes for each of the blocks.

The ECS is being a nice experiment, I can apply the logic in a more focused way to the components, which allows me to have an easier time when splitting responsibilities in the code.

I'm still checking out how to make interaction between multiple entities, lets see how it goes tomorrow.