A look back to the year I was amazed about VueJS and got a working example running based on an ExpressJS server. In the second half the Rust language got my attention again, but put aside by working on a basic bash script library for operation tasks. I also made the change to GitLab and at the end the MkDocs tool. All in all I learned a lot, made good practical solutions and think I'm also on the right way into the future.
MkDocs: As conclusion to the problems and discontinuing of free
gitbook use I decided to switch to MkDocs which also is markdown based with a python static and extendable site builder. Also with this step a complete restructuring was done. See more at MkDocs
Async Control in Bash: I made an extension to my bash libraries which allows to run a collection of processes combined parallel and in series with the ability to continue on the not finished task on a restart after abort.
SSH Control: A port of a previous multi-ssh tool (closed source) to the new bash lib. This is used for server management and deployment.
Admin-Utils: Also build upon the bash library specific commands to help fixing some gaps (closed source).
Bash Library: Creation of a bash library with coloring, logging with file rotation, locking to serialize multiple processes and system analyzation methods.
GitLab + Mattermost: Self hosting and administration of this systems.
Database Testing: Tryout of ORM and direct accessing PostgreSQL databases in Rust.
Rust by Example: With the knowledge of the Rust book I could create my web server and run it. But I am missing the experience and routine and so the code feels a bit uncontrollable to me. So I decided to step back and do some more simpler examples with different language parts, first.
GitLab: Installation and use of self hosted GitLab with Mattermost.
Objectix: My first project using Rust is a web server. The Goal should be to use it to gather object information like data, correctness checks and hints. Depending on the client the REST calls should return well formatted HTML or JSON. But first I have to get the Rust base under control ;-)
Rust: After I did a tryout and some tests while ago, I now want to really use Rust. Therefore my first steps are to dive into the language by first reading about the concepts again, making some simple examples and planing the first project.
Authorization: Now it is also respected on the client side. The information comes out of the already existing authenticated user setting. Both user and roles may be also disabled.
Server stability: By extending the logging into before and after logs with data the process can be better shown and a problem in the default populate hook was found and fixed by own populate handler.
Documentation Project: Updated this document which combines the external GitBook document with the GitHub page contents.
Moving to GitLab: After checking out the free cloud based and standalone GitLab service I decided to migrate my active projects and documentation and go on with it.
Authorization: Dialogs to define the abilities within the Portal and to later establish full server and client authorization.
Basic chat: To try the realtime channel connection between clients and server I added a test which basically works but lacks on some styling issues. Multiple users are able to chat between each other in one common chat room.
Internationalization: added for the complete Portal Client.
Repair: A new CLI application with interactive dialogs should help me analyze problem in data structures. In contrast to the WebObjects program I now make a script for each object containing search, data, references and checks.
User administration: The management of user accounts in the Portal Client was completed including create, update and remove of accounts.
Authentication: Finalize the authentication from client over the server against the mongo db users.
Homepage: To further test Vue2 within the quasar framework I decided to make my personal web site (only some static information) using also the same technology stack.
VS Code: Try out the alternative to Atom editor. I had some performance problems using Atom on my notebook. So I checked out the similar tool which is also build on electron & Co but at the moment better as IDE.
Client-Server-Connection: To make a stable and easy to use connection between the client and server part I had to try out different ways to integrate the Feathers client into Vue2. The result got me a module allowing direct service calls or using an VueEx store as state management system.
REST Server: The initial server is build with feathers and express supporting HTTP and
socket.io connections. For the first working version I made a message service, JWT based authentication and simple validation working. That was the start of Alinex Portal.
Server Planing: For the new client application I need a REST server with authentication. This should be done using NodeJs, too. So I had to look for the right technologies and decided to use: ExpressJS as web server, Feathers for REST and realtime API and its integrated Authentication.
Quasar Framework: After some days of searching I decided based on my previous testings in some of the available web frameworks to give the newer Quasar Framework a chance and see how far I can go with it. First I had to read through the following documentations in about 2 days and tryout what I found there: Vue.js, vue-router, Quasar Framework, Vuelidate, Axios, JWT, Stylus.
Framework Idea: I made a decision to make a modern administration panel usable in Browser, App and maybe as a Desktop Application, too. A REST service should later feed the panel.
KDE Neon: After I work since more than a year at home successfully with KDE I now decided to do the same on my companies notebook. But not all distributions worked fine. I got lucky with KDE Neon.