The Future of DiCMS

a "complete" project

Posted by German Kalinec on 10/30/2024 10:16 PM

Second Post and already talking about the future. I really like what this project has ended up being. As it is right now, it's about 85% of what I need. There are some things that I would like to change, and some features (both big and small) that I would like to add to it, but I really think that the project is almost complete. Today I was thinking about a wiki plugin and perhaps a manual plugin or something along those lines, but that's when I decided that I would really like for this project, and maybe Blogger too, should end so I can concentrate on FABLMS or (more than likely) other plugins.

This doesn't mean I'm done. Not yet, at least, but since I'm at a point where most of my needs are being met by what I have, I was thinking about what that last 15% looks like.  This also struck me, when I noticed that every release so far has been big enough to warrant a minor update and I was running out of number before getting to 1.0!  I also decided that I wanted to dedicate the last few revisions as a “final push” set of revisions, where I can concentrate on last minute QOL (quality of life) things that I might find. This didn't leave much left, and I was already using my sub revisions to track bugs, which would make it more unsustainable. I did change my bug issues to be minor MINOR revisions.

But that led me to think, what should be the last “feature” that I add. I would like to move everything to plugins, so in order to do that it's better to have a finished product that is stable so that plugins can be written for. Looking at my “Roadmap to 1.0” I see a big promise to actually write detailed milestones for 1.0, along with a list that is heavily crossed out, while being vague as hell at the same time. Thus, I decided to write a post to at least get my thoughts together and come up a fully detailed list of what I would like the project to be when it reaches v1.0

This will primarily deal with DiCMS, Blogger will be done at a different blog post.

Editors

The last update had a lot of new features, but at this point I'm pretty much done with most of the ones that I want to include in the base project, while allowing me the option to create plugins to add more functionality.  One of the features of the last update was the ability for plugins to provide config files for GrapesJS, which are bundled into a GrapesJS Plugin that is then instantiated in the instance blade file. I really liked this because it gave now plugins the ability to be built just to add content to GrapesJS. So my next question was, what other blocks do I really want to finish in the base system? Because more of them can be created at a later time as plugins. Honestly, tables are the only major one that stands out to me. I would really like to create a mobile menu, but it's hard without a lot of JavaScript, which should then be left up to the user.  I tried making a collapsible menu and wasn't too successful, but maybe it was because I really didn't want to write custom JS.  So that can be done in a plugin.

As such, adding and manipulating tables (which I might be able to do through an existing plugin) and cleaning up the editor's control page is what I would like to call it done for the integration of GrapesJS into the system. The layout will be done in a separate blade file so it can be updated and changed in settings. This will be one major milestone, which we can define as such:

MilestoneComplete GrapesJS Integration
Requirements
  • Add the blocks needed to create HTML tables
  • Centralize the design of GrapesJS into a single blade file.
  • Create a more appealing layout for GrapesJS
  • Allow users to change the layout view by specifying it in the config file.
  • Move editor creation to a single Blade Component that takes in a standard set of components so they can be easily included in plugins.

We also need to do something similar to the main text editor. It's good enough, but I would like the ability to add more functionality or, frankly, replace it with something better. To that end, the next feature would be to have a similar treatment done for the text editor.  

MilestoneComplete Text Editor integration
Requirements
  • Change the text editor config to include the complete config. Instantiation should be a single line
  • Models that are text-editable should be inherited from a single class.
  • Allow plugins to change the config file, add to the config file, and change the instance file completely.
  • Move the editor creation to a single Blade Component that works the same as GrapesJS

 

New Features

There is one major new feature that I would like have in this system: widgets. Widgets are special content that is drawn from a plugin, but that can be included into a regular CMS page. For example, a widget would be a small div that lists out the last 5 blog posts from a blog, or author, or tagged as something, etc. You could then design a sidebar in your page, and include this widget as a relevant information.  Since I will need to write at least one widget to test, so I can include others through a plugin, I will be writing a simple widget that will do a very simple visitor counter. This widget will be the template for all widgets that can be included through plugins.

MilestoneAdd Widgets to the System
Requirements
  • Add a “visitor counter” widget that can be placed on a page displays a visitor counter specific to that page
  • Make the counter editable only through GrapesJS
  • Encapsulate the widget so that it can then be integrated by plugins so they can provide their own widgets
  • ALL styling needs to be done by the user.  There should be minimal structure as well.

REST API'S

I like REST API's. It lets people build their own damn interfaces and I only need to deal with security and access.  There is always a huge component to how to authenticate requests which can be annoying to set up and run. As of the writing, the new sweetness in Laravel is Sanctum, which I have used and liked quite a bit.  But the goal is to make this as agnostic as possible. It will be optional to turn on API access, all API authentication should be done by the host app and all authorization will be done through policies.  The goal will also be to allow plugins to provide their own API's to be accessible through the base system.

MilestoneAdd REST API's
Requirements
  • Make the system authentication-agnostic
  • Make the authorization happen through apps.
  • Enable API's by enabling routes.
  • Every model needs to have API access.
  • Include API routes from plugins so they can write their own APIs

Asset Manager

I liked what it looks like and how it works. There is only one issue that I keep having with it and that is the I need to be able to put things into folders. Either virtual or … well virtual but stored in a database. I would also like to make the option to not include it in the layout when not needed.

MilestoneFinish the Asset Manager
Requirements
  • Add folder structure to the asset manager
  • Remove it from the layout in certain pages
  • Add the ability to add and delete folders

Quality of Life Improvements

The following milestones are what I would consider QOL stuff that I would like to see it done before I consider this finished.

MilestoneTest Interface in Mobile
RequirementsThe whole admin interface need to be made to look easy to use in mobile. It needs to be tested on a 5'' phone.
MilestoneEnhance Backups
Requirements
  • Include the ability to download all assets (including thumbnails)
  • Zip the JSON datafile and add the date it was downloaded to the file name
MilestoneDocumentation
Requirements
  • Add function doc signatures and relevant comments
  • Finish writing the README
  • Make a blog post with pictures about creating a web site from a template
  • Make the resulting website available through a backup file.

Testing

The bane of coders.  If i was planning on including all testing before I released, it would never be done. So my milestone will be a little bit vaguer (if possible) than the last ones.

MilestoneWrite Tests
Requirements
  • Write a feature test for every model

Road Map to 1.0

Going by the new version numbering system, I will use the 3rd place to specify bug fixes. 2nd place will be used whenever I have a new milestone that I have achieved, the minor revision will follow this roadmap:

  • Version 0.6

    • Introduce and complete widgets 

    • Finish all plugin interfaces so that the structure doesn't change anymore.

    • All Editor improvements are done.

    • REST API's need to be started by now, so that they can be included in the plugin interface

  • Version 0.7

    • New Features are to be completed

    • REST APIs need to be completed

    • All models are complete now

  • Version 0.8

    • Asset manager is completed

    • Quality of life milestones are done.

  • Version 0.9

    • All features and milestones are done except testing.

    • Internationalization will need to be completed

    • I will attempt to use AI to get another language done.

    • Last minute testing and graphical UI issues are to be resolved.