@reldens/cms 0.16.0 → 0.18.0

package/lib/cache/add-cache-button-subscriber.js

@@ -0,0 +1,101 @@
+/**
+ *
+ * Reldens - CMS - AddCacheButtonSubscriber
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class AddCacheButtonSubscriber
+{
+
+    constructor(props = {})
+    {
+        this.events = sc.get(props, 'events', false);
+        this.cacheManager = sc.get(props, 'cacheManager', false);
+        this.renderCallback = sc.get(props, 'renderCallback', false);
+        this.cacheCleanButton = sc.get(props, 'cacheCleanButton', '');
+        this.translations = sc.get(props, 'translations', {});
+        this.cacheCleanRoute = sc.get(props, 'cacheCleanRoute', '');
+        this.setupEvents();
+    }
+
+    setupEvents()
+    {
+        if(!this.cacheManager){
+            Logger.error('Cache Manager not found on AddCacheButtonSubscriber.');
+            return false;
+        }
+        if(!this.cacheManager.isEnabled()){
+            Logger.debug('Cache Manager not enabled.');
+            return false;
+        }
+        if(!this.events){
+            Logger.error('Events Manager not found on AddCacheButtonSubscriber.');
+            return false;
+        }
+        //Logger.debug('Listening events PropertiesPopulation.');
+        this.events.on('reldens.adminViewPropertiesPopulation', this.populateViewFields.bind(this));
+        this.events.on('reldens.adminEditPropertiesPopulation', this.populateEditFields.bind(this));
+
+    }
+
+    async populateViewFields(event)
+    {
+        let cacheButton = await this.generateCacheCleanButton(event);
+        if(!cacheButton){
+            Logger.warning('Missing cache button contents on AddCacheButtonSubscriber.');
+            return false;
+        }
+        if(!event.renderedViewProperties.extraContentForView){
+            event.renderedViewProperties.extraContentForView = '';
+        }
+        event.renderedViewProperties.extraContentForView += cacheButton;
+        //Logger.debug('Clean cache button ready on view.');
+        return true;
+    }
+
+    async populateEditFields(event)
+    {
+        let cacheButton = await this.generateCacheCleanButton(event);
+        if(!cacheButton){
+            Logger.warning('Missing cache button contents on AddCacheButtonSubscriber.');
+            return false;
+        }
+        if(!event.renderedEditProperties.extraContentForEdit){
+            event.renderedEditProperties.extraContentForEdit = '';
+        }
+        event.renderedEditProperties.extraContentForEdit += cacheButton;
+        //Logger.debug('Clean cache button ready on edit.');
+        return true;
+    }
+
+    async generateCacheCleanButton(event)
+    {
+        if('routes' !== event.driverResource.id()){
+            return false;
+        }
+        if(!event.loadedEntity || !event.loadedEntity.id){
+            return false;
+        }
+        if(!this.cacheCleanButton){
+            Logger.error('Cache clean button template content not found');
+            return '';
+        }
+        if(!this.renderCallback){
+            Logger.error('Render callback not available for cache button');
+            return '';
+        }
+        return await this.renderCallback(
+            this.cacheCleanButton,
+            {
+                cacheCleanRoute: this.cacheCleanRoute,
+                routeId: event.loadedEntity.id,
+                buttonText: sc.get(this.translations, 'cleanCache', 'Clean Cache')
+            }
+        );
+    }
+
+}
+
+module.exports.AddCacheButtonSubscriber = AddCacheButtonSubscriber;

package/lib/cache/cache-manager.js

@@ -0,0 +1,129 @@
+/**
+ *
+ * Reldens - CMS - CacheManager
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+
+class CacheManager
+{
+
+    constructor(props = {})
+    {
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.cacheBasePath = FileHandler.joinPaths(this.projectRoot, '.reldens_cms_cache');
+        this.enabled = sc.get(props, 'enabled', true);
+    }
+
+    generateCacheKey(domain, path)
+    {
+        let domainFolder = domain || 'default';
+        let pathSegments = path.split('/').filter(segment => '' !== segment);
+        if(0 === pathSegments.length){
+            pathSegments = ['index'];
+        }
+        let fileName = pathSegments.pop() + '.html';
+        let folderPath = FileHandler.joinPaths(this.cacheBasePath, domainFolder, ...pathSegments);
+        return {
+            folderPath,
+            fileName,
+            fullPath: FileHandler.joinPaths(folderPath, fileName)
+        };
+    }
+
+    async get(domain, path)
+    {
+        if(!this.enabled){
+            return false;
+        }
+        let cacheInfo = this.generateCacheKey(domain, path);
+        if(!FileHandler.exists(cacheInfo.fullPath)){
+            return false;
+        }
+        let cachedContent = FileHandler.readFile(cacheInfo.fullPath);
+        if(!cachedContent){
+            Logger.debug('Failed to read cached file: '+cacheInfo.fullPath);
+            return false;
+        }
+        return cachedContent;
+    }
+
+    async set(domain, path, content)
+    {
+        if(!this.enabled){
+            return false;
+        }
+        let cacheInfo = this.generateCacheKey(domain, path);
+        if(!FileHandler.createFolder(cacheInfo.folderPath)){
+            Logger.error('Failed to create cache folder: '+cacheInfo.folderPath);
+            return false;
+        }
+        if(!FileHandler.writeFile(cacheInfo.fullPath, content)){
+            Logger.error('Failed to write cache file: '+cacheInfo.fullPath);
+            return false;
+        }
+        return true;
+    }
+
+    async delete(domain, path)
+    {
+        let cacheByDomains = this.fetchCachePathsByDomain(domain, path);
+        for(let cacheInfo of cacheByDomains){
+            if(!FileHandler.exists(cacheInfo.fullPath)){
+                Logger.debug('File does not exist: '+cacheInfo.fullPath);
+                return true;
+            }
+            if(!FileHandler.remove(cacheInfo.fullPath)){
+                Logger.error('Failed to delete cache file: '+cacheInfo.fullPath);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    fetchCachePathsByDomain(domain, path)
+    {
+        let cacheByDomains = [];
+        if(domain && 'default' !== domain){
+            cacheByDomains.push(this.generateCacheKey(domain, path));
+            return cacheByDomains;
+        }
+        let cachedDomainFolders = FileHandler.readFolder(this.cacheBasePath);
+        for(let cachedDomainFolder of cachedDomainFolders) {
+            cacheByDomains.push(this.generateCacheKey(cachedDomainFolder, path));
+        }
+        return cacheByDomains;
+    }
+
+    async clear()
+    {
+        if(!FileHandler.exists(this.cacheBasePath)){
+            return true;
+        }
+        if(!FileHandler.remove(this.cacheBasePath)){
+            Logger.error('Failed to clear cache folder: '+this.cacheBasePath);
+            return false;
+        }
+        return true;
+    }
+
+    isEnabled()
+    {
+        return this.enabled;
+    }
+
+    enable()
+    {
+        this.enabled = true;
+    }
+
+    disable()
+    {
+        this.enabled = false;
+    }
+
+}
+
+module.exports.CacheManager = CacheManager;

package/lib/cache/cache-routes-handler.js

@@ -0,0 +1,76 @@
+/**
+ *
+ * Reldens - CMS - CacheRoutesHandler
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class CacheRoutesHandler
+{
+
+    constructor(props)
+    {
+        this.router = sc.get(props, 'router', false);
+        this.dataServer = sc.get(props, 'dataServer', false);
+        /** @type {CacheManager} **/
+        this.cacheManager = sc.get(props, 'cacheManager', false);
+        this.rootPath = sc.get(props, 'rootPath', '');
+        this.cacheCleanPath = '/cache-clean';
+        this.cacheCleanRoute = this.rootPath+this.cacheCleanPath;
+        this.setupRoutes();
+    }
+
+    setupRoutes()
+    {
+        if(!this.cacheManager){
+            Logger.error('Cache Manager not found on CacheRoutesHandler.');
+            return false;
+        }
+        if(!this.cacheManager.isEnabled()){
+            Logger.debug('Cache Manager not enabled.');
+            return false;
+        }
+        if(!this.router){
+            Logger.error('Router not found on CacheRoutesHandler.');
+            return false;
+        }
+        this.router.adminRouter.post(
+            this.cacheCleanPath,
+            this.router.isAuthenticated.bind(this.router),
+            async (req, res) => {
+                return await this.processCacheClean(req, res);
+            }
+        );
+        return true;
+    }
+
+    async processCacheClean(req, res)
+    {
+        if(!this.cacheManager){
+            return res.json({error: 'Cache manager not available'});
+        }
+        let routeId = sc.get(req.body, 'routeId', '');
+        if(!routeId){
+            return res.json({error: 'Route ID is required'});
+        }
+        let routesEntity = this.dataServer.getEntity('routes');
+        if(!routesEntity){
+            return res.json({error: 'Routes entity not found'});
+        }
+        let route = await routesEntity.loadById(routeId);
+        if(!route){
+            return res.json({error: 'Route not found'});
+        }
+        let domain = sc.get(route, 'domain', '');
+        let path = route.path;
+        let cleanResult = await this.cacheManager.delete(domain, path);
+        if(!cleanResult){
+            return res.json({error: 'Failed to clean cache'});
+        }
+        return res.redirect(this.rootPath+'/routes/view'+'?id='+routeId+'&result=success');
+    }
+
+}
+
+module.exports.CacheRoutesHandler = CacheRoutesHandler;

package/lib/cms-pages-route-manager.js

@@ -26,17 +26,19 @@ class CmsPagesRouteManager
     async populateViewFields(event)
     {
         if('cms_pages' !== event.driverResource.id()){
-            return;
+            return false;
+        }
+        if(!event.loadedEntity || !event.loadedEntity.route_id){
+            event.renderedViewProperties.routePath = '';
+            event.renderedViewProperties.routeDomain = '';
+            return true;
         }
         let routesRepository = this.dataServer.getEntity('routes');
         if(!routesRepository){
             Logger.error('Routes repository not found.');
             return false;
         }
-        let existingRoute = await routesRepository.loadOne({
-            router: 'cmsPages',
-            cms_page_id: Number(event.renderedViewProperties.id)
-        });
+        let existingRoute = await routesRepository.loadById(event.loadedEntity.route_id);
         event.renderedViewProperties.routePath = sc.get(existingRoute, 'path', '');
         event.renderedViewProperties.routeDomain = sc.get(existingRoute, 'domain', '');
         return true;
@@ -45,17 +47,19 @@ class CmsPagesRouteManager
     async populateEditFields(event)
     {
         if('cms_pages' !== event.driverResource.id()){
-            return;
+            return false;
+        }
+        if(!event.loadedEntity || !event.loadedEntity.route_id){
+            event.renderedEditProperties.routePath = '';
+            event.renderedEditProperties.routeDomain = '';
+            return true;
         }
         let routesRepository = this.dataServer.getEntity('routes');
         if(!routesRepository){
             Logger.error('Routes repository not found.');
             return false;
         }
-        let existingRoute = await routesRepository.loadOne({
-            router: 'cmsPages',
-            cms_page_id: Number(event.renderedEditProperties.idValue)
-        });
+        let existingRoute = await routesRepository.loadById(event.loadedEntity.route_id);
         event.renderedEditProperties.routePath = sc.get(existingRoute, 'path', '');
         event.renderedEditProperties.routeDomain = sc.get(existingRoute, 'domain', '');
         return true;
@@ -73,22 +77,30 @@ class CmsPagesRouteManager
             return;
         }
         let cmsPageId = Number(entityData.id);
-        let existingRoute = await routesRepository.loadOne({router: 'cmsPages', cms_page_id: cmsPageId});
-        let patchData = {
+        let routePatchData = {
             path: sc.get(req.body, 'routePath', this.generateDefaultRoutePath(entityData)),
             router: sc.get(req.body, 'routeRouter', 'cmsPages'),
-            cms_page_id: cmsPageId,
             cache_ttl_seconds: Number(sc.get(req.body, 'routeCacheTtl', 3600)),
             enabled: Number(sc.get(req.body, 'routeEnabled', 1)),
             domain: sc.get(req.body, 'routeDomain', null)
         };
-        let result = existingRoute
-            ? await routesRepository.updateById(existingRoute.id, patchData)
-            : await routesRepository.create(patchData);
-        if (!result){
-            Logger.error('Route could not be saved.', patchData, existingRoute);
+        let routeResult = false;
+        if(entityData.route_id){
+            routeResult = await routesRepository.updateById(entityData.route_id, routePatchData);
+        }
+        if(!routeResult){
+            routeResult = await routesRepository.create(routePatchData);
+            if(routeResult){
+                let pagesRepository = this.dataServer.getEntity('cms_pages');
+                if(pagesRepository){
+                    await pagesRepository.updateById(cmsPageId, {route_id: routeResult.id});
+                }
+            }
+        }
+        if(!routeResult){
+            Logger.error('Route could not be saved.', routePatchData);
         }
-        return result;
+        return routeResult;
     }
 
     generateDefaultRoutePath(pageData)