conversion of markdown files to html works fine, but the coresponding
css, js and image assets were not being moved, so the class responsible
for moving them was edited so theme assets are moved to their
appropriate directories when the site is published.
also made some css and image edits, and removed a legacy css files that
were no longer in use
the default theme included with fipamo was a bit janky, so that's been
cleaned to bring it more inline with current accessiblility standards,
an updated mobile friendly menu, updated the logo and plugged in the
fresh colors.
the layout is still a bit boring but the main purpose of the default is
to show how templating works, so it needs to be kept as simple as
possible
but it still has some room for making it pop a bit more.
rather than make a massive downloadable archive file for ever image on
the site (which still may happen), a method has been added to make
copies of imags from an external site and store them on the fresh
install based on the image list saved in the created back up file
it's clean but some additional error checking is needed so the process
does not crash out when a file can't be located and upon completion the
user can be notified of what images did not make it over in the process
ported over the backup functionality from the old build to the new while
making few tweaks
instead of packaging up all files in the site to create massive zip
files, now a list of files is created for the user and blog directories
that the system will use to download and put them in the appropriate
directories, resulting in a such slimmer backup file.
archiving images my be added at a later date, but will be kept seperate
from the current back up process
decided to keep the sorting service class as is and remix how it works to
return data objects rather than just settings information to render
pages.
the overall size of the class is still large but now there are
some opportunites to move around some methodolgy to reduce it.
also made the necessary changes in the render service class and the
theme controller to use the new methodology
the last ui page that needed to be added was managing the main
navigation menu for rendered pages, so that's been turned on. menu
items can be added by pinning pages to the menu when editing them and
can be removed by unpinning them or deleting them from the navigation
edit ui
it touched quite a few systems so all of those classes needed to be
edited as well tweaking the front end script to work with the new
modular script format
turned on the abiity to save settings to config file via the settings
page
the current member session needs to updated by the data coming in but
that will be handled by a specific member service that hasn't been built
yet, so just commenting it out for now
also fixed a minor bug that was stopping the save on render toggle from
working correctly, so now it's saving and updating the status properly
now
with the setting page set up, now the the settings api can be added,
beginning with the ability to render all files from settings.
the base settings api class is set up, so now the rest of the methods
can be added
it's time to get the setting api running so site options can be editied
so the first step is to get the settings page up and running.
the sorting class is getting a bit heavy, but it will hold the method
for gathering settings page info for now.
added a controller class to handle what is being served when the browser
hits the root directory.
very basic to start as it is just a placeholder until it's filled out
page rendering for tags, archives and markdown pages is now up and
running and being exported to html when requested.
currently it only works when saving a page, so now the settings page
needs to be plugged in so those features can be activated and toggled
through that UI
error checking will probably be added in the near future just in case
something unforeseen happens in the render process, resulting in the
site erroring out.
theme controller was getting top heavy, so an asset service class was
plugged in to handle moving assets around for theme testing and
eventually to production when HTML rendering is set up
with the archive template up and running a bug with page creation and
editing was revealed which was certain options were not being set
correctly due to property not being set correctly when an markdown page
was being edited.
also added a null state check for page submissions that do not have a
layout set, so it defaults to 'page'
also patched theme service class to look for blade templates instead of
twig, which it was still doing
the remaining base template pages have beeen converted to blade as well
as filling out the data they need to render being added to the sorting
service class
theming controller and and sorting service still need to be optimized
but they work so now they can be refined
once they have been cleaned up, the render service is class is ready to
be finished
to complete page rendering, the default theme needed to be converted to
use blade templating. rather than update the theme kit as a seperate
progress, it will be integrated into this codebase so themes can be
developed and tested in app.
the basics for the theme kit are in place, so now conversion of the
defualt theme can be completed.
once the that is done, it can then be used to complete the rendering
engine to export HTML files
editing page works but making new pages was still wonky, so that was
fixed and now page creation works fine
made some minor tweaks to prettier config for css formatting
ported over the new file uploader from the old build and made it a
service make for from some additonal file processing
i.e. image optimization or video converstion before it is saved to the system
the first part of the page editing API is working again after porting it over
form the old fipamo build. a few changes where made to make the code a
big more managable, but the end to end process works for updating pages.
the remaining page editing methods will be activated after the rendering
engine is in place because that's going to be a pretty siginficant
effort.
but this is a big step.
start building out the new version of the page editing api while making
some changes to the original scripts for added flexibility and using the
full range of HTTP methods that weren't being used before.
currenlty, it's just an end to end test to make sure the plumbing works
as it should data is being passed and can be processed.
now that it all works, the guts of page editing can be completed
update sortablejs to the latest since it's been awhile and got rid of
the old version
so there was an error when trying to use services for API controllers
that was happening because the api middleware didn't pass the same info
as web middleware, resulting in session info not being passed to
controllers used in the api
after a bit of reading discovered necessary middleware could be added to
api routing so session data is available in in api routing
whew
Got the first part of the API working, which checks to see if there is a
valid session active to set up requests
also some small changes to get the favicon working, yeah, yeah, but it's
cool looking...
seperated dash controllers for api controllers in the controller
directory to make them easier to manage
also added middleware to check authorization when accessing dash pages
page editing was missing the selector to choose what template the page
was using, so a theme class was created to handle retrieving and sorting
what classes where avaiable in the themes directory
still looking for twig files because themes haven't been converted over
yet, but one step at a time
expanded the auth service class to store member info in the current
session so validation is easier
also added a token to session data that expires every hour so people
won't be logged in forever and take breaks
hey, you matter too
There are some spacing issues that need to be addressed but the page
editor template has been added and the CSS all lines up
scripting is still an issue as the backend that handles content still
isn't in place, but the front facing piece is in place so now those
components can be built
scripting is going to get an overhaul anyway, so this is a good place to
start that process
plugged in classes for a page repository to handle editing and
retrieving page content and an interface class for the controller to talk to to
keep the methodoloy seperate from the controller to keep it all clean
now whatever changes that need to be made won't bother the controller
because it will always be looking for the same functions. super sweet
moved the page listing template over and made all of the apropriate
changes so the CSS lines up as it should
there was also a minor issue that was keeping the sub menu for the start
pages from displaying so that was fixed
plugged in the dash index template which required grabbing markdown
pages and converting them to data the system can use and then pagination
that is used to sort content into pages
start page now switches from login screen to index based on session, but
that might be changes so it's a bit more clean to work with middleware
Added controller to handle the login process and session management
that stores information about the person that has logged in so that info
is available through out the app when logged in
Brought over a template from the old build to see how the conversion
process would go (it's not bad) and see if the CSS would still stick (it
did)
The wiring will be finished when the auth class is completed
Plugged in a basic auth classs for verifying members and a setting class
to retrieve site settings and return necessary info.
Very bare bones to start just to get it working and prep for the
additional features
Added the folder containg Fipamo markdown files to set up a basic route
for the start of the dashboard and quick test to make sure the file
paths can be read
also added CSS files that will style the new template system, which is
currenlty in twig but will be convereted to blade
Removed the Slim Framework from the codebase and installed the latest
Laravel version to be the new foundation for the project moving forward.
Code from the old version will now be ported to the new version.
