@reldens/cms 0.15.0 → 0.16.0

package/lib/admin-manager.js

@@ -79,7 +79,7 @@ class AdminManager
         this.adminContents.login = await this.buildLogin();
         this.adminContents.dashboard = await this.buildDashboard();
         this.adminContents.entities = await this.buildEntitiesContents();
-        this.events.emit('reldens.buildAdminContentsAfter', {adminManager: this});
+        await this.events.emit('reldens.buildAdminContentsAfter', {adminManager: this});
     }
 
     async buildLayout()
@@ -195,15 +195,18 @@ class AdminManager
                     value: '{{&'+property+'}}'
                 };
             });
-            let extraContentForList = sc.get(this.adminFilesContents?.sections?.list, driverResource.entityPath, '');
+            let sectionsContents = this.adminFilesContents?.sections;
+            let extraContentForList = sc.get(sectionsContents?.list, driverResource.entityPath, '');
             let extraContentForView = await this.render(
-                sc.get(this.adminFilesContents?.sections?.view, driverResource.entityPath, ''),
+                sc.get(sectionsContents?.view, driverResource.entityPath, ''),
                 {
                     id: '{{&id}}',
                     entitySerializedData: '{{&entitySerializedData}}'
                 }
             );
-            let extraContentForEdit = sc.get(this.adminFilesContents?.sections?.edit, driverResource.entityPath, '');
+            let extraFormContentForView = sc.get(sectionsContents?.viewForm, driverResource.entityPath, '');
+            let extraContentForEdit = sc.get(sectionsContents?.edit, driverResource.entityPath, '');
+            let extraFormContentForEdit = sc.get(sectionsContents?.editForm, driverResource.entityPath, '');
             entitiesContents[entityName] = {
                 list: await this.render(
                     this.adminFilesContents.list,
@@ -230,6 +233,7 @@ class AdminManager
                         entityEditRoute: '{{&entityEditRoute}}',
                         entityNewRoute: '{{&entityNewRoute}}',
                         extraContent: extraContentForView,
+                        extraFormContent: extraFormContentForView
                     }
                 ),
                 edit: await this.render(
@@ -244,6 +248,7 @@ class AdminManager
                         templateTitle: '{{&templateTitle}}',
                         entityViewRoute: '{{&entityViewRoute}}',
                         extraContent: extraContentForEdit,
+                        extraFormContent: extraFormContentForEdit
                     }
                 )
             };
@@ -439,6 +444,14 @@ class AdminManager
                 return res.send(routeContents);
             });
             this.adminRouter.get(entityRoute+this.editPath, this.isAuthenticated.bind(this), async (req, res) => {
+                let adminBeforeEntityEditEvent = {
+                    adminManager: this,
+                    req,
+                    res,
+                    driverResource,
+                    entityPath
+                };
+                await this.events.emit('reldens.adminBeforeEntityEdit', adminBeforeEntityEditEvent);
                 let routeContents = await this.generateEditRouteContent(req, driverResource, entityPath);
                 if('' === routeContents){
                     return res.redirect(this.rootPath+'/'+entityPath+'?result=errorEdit');
@@ -468,6 +481,13 @@ class AdminManager
                 entityRoute+this.savePath,
                 this.isAuthenticated.bind(this),
                 async (req, res) => {
+                    await this.events.emit('reldens.adminBeforeEntitySave', {
+                        adminManager: this,
+                        req,
+                        res,
+                        driverResource,
+                        entityPath
+                    });
                     let redirectResult = await this.processSaveEntity(req, res, driverResource, entityPath);
                     return res.redirect(redirectResult);
                 }
@@ -491,6 +511,13 @@ class AdminManager
             this.isAuthenticated.bind(this),
             this.uploaderFactory.createUploader(fields, this.buckets, allowedFileTypes),
             async (req, res) => {
+                await this.events.emit('reldens.adminBeforeEntitySave', {
+                    adminManager: this,
+                    req,
+                    res,
+                    driverResource,
+                    entityPath
+                });
                 let redirectResult = await this.processSaveEntity(req, res, driverResource, entityPath);
                 return res.redirect(redirectResult);
             }
@@ -554,13 +581,21 @@ class AdminManager
             Logger.error('Bad patch data.', entityDataPatch);
             return this.rootPath+'/'+entityPath+'?result=saveBadPatchData';
         }
-        let editRoute = this.generateEntityRoute('editPath', driverResource, idProperty);
+        let editRoute = this.generateEntityRoute('editPath', driverResource, idProperty, null, id);
         try {
             let saveResult = await this.saveEntity(id, entityRepository, entityDataPatch);
             if(!saveResult){
                 Logger.error('Save result error.', saveResult, entityDataPatch);
                 return editRoute+'?result=saveEntityStorageError';
             }
+            await this.events.emit('reldens.adminAfterEntitySave', {
+                adminManager: this,
+                req,
+                res,
+                driverResource,
+                entityPath,
+                entityData: saveResult
+            });
             if(sc.isFunction(this.autoSyncDistCallback)){
                 let uploadProperties = this.fetchUploadProperties(driverResource);
                 if(0 < Object.keys(uploadProperties).length){
@@ -574,6 +609,10 @@ class AdminManager
                     }
                 }
             }
+            let saveAction = sc.get(req.body, 'saveAction', 'save');
+            if('saveAndContinue' === saveAction){
+                return this.generateEntityRoute('editPath', driverResource, idProperty, saveResult) +'&result=success';
+            }
             return this.generateEntityRoute('viewPath', driverResource, idProperty, saveResult) +'&result=success';
         } catch (error) {
             Logger.error('Save entity error.', error);
@@ -639,32 +678,12 @@ class AdminManager
         return fileNames.join(property.isArray);
     }
 
-    formatDateTimeForEdit(dateValue, isDisabled)
-    {
-        if(!dateValue || '' === dateValue){
-            return '';
-        }
-        let date = new Date(dateValue);
-        if(isNaN(date.getTime())){
-            return '';
-        }
-        if(isDisabled){
-            return sc.formatDate(date);
-        }
-        let year = date.getFullYear();
-        let month = String(date.getMonth() + 1).padStart(2, '0');
-        let day = String(date.getDate()).padStart(2, '0');
-        let hours = String(date.getHours()).padStart(2, '0');
-        let minutes = String(date.getMinutes()).padStart(2, '0');
-        return year+'-'+month+'-'+day+'T'+hours+':'+minutes;
-    }
-
     async generateEditRouteContent(req, driverResource, entityPath)
     {
         let idProperty = this.fetchEntityIdPropertyKey(driverResource);
         let idValue = String(sc.get(req?.query, idProperty, ''));
         let templateTitle = (!idValue ? 'Create' : 'Edit')+' '+this.translations.labels[driverResource.id()];
-        let loadedEntity = !idValue ? null :await this.loadEntityById(driverResource, idValue);
+        let loadedEntity = !idValue ? null : await this.loadEntityById(driverResource, idValue);
         let entityViewRoute = !idValue
             ? this.rootPath+'/'+driverResource.entityPath
             : this.generateEntityRoute('viewPath', driverResource, idProperty, loadedEntity);
@@ -675,6 +694,14 @@ class AdminManager
             templateTitle,
             entityViewRoute
         };
+        let editPropertiesEvent = {
+            adminManager: this,
+            req,
+            driverResource,
+            renderedEditProperties,
+            loadedEntity
+        };
+        await this.events.emit('reldens.adminEditPropertiesPopulation', editPropertiesEvent);
         let propertiesKeys = Object.keys(driverResource.options.properties);
         for(let propertyKey of propertiesKeys){
             let property = driverResource.options.properties[propertyKey];
@@ -719,6 +746,11 @@ class AdminManager
         if(!entityRepository){
             return false;
         }
+        await this.events.emit('reldens.adminBeforeEntityLoad', {
+            adminManager: this,
+            driverResource,
+            entityId: id
+        });
         return await entityRepository.loadByIdWithRelations(id);
     }
 
@@ -764,6 +796,15 @@ class AdminManager
         await this.events.emit('adminEntityExtraData', extraDataEvent);
         entitySerializedData = extraDataEvent.entitySerializedData;
         renderedViewProperties.entitySerializedData = JSON.stringify(entitySerializedData).replace(/"/g, '&quot;');
+        let viewPropertiesEvent = {
+            adminManager: this,
+            idProperty,
+            req,
+            driverResource,
+            loadedEntity,
+            renderedViewProperties
+        };
+        await this.events.emit('reldens.adminViewPropertiesPopulation', viewPropertiesEvent);
         return await this.renderRoute(
             await this.render(this.adminContents.entities[entityPath].view, renderedViewProperties),
             this.adminContents.sideBar
@@ -792,10 +833,7 @@ class AdminManager
             }
         }
         if('textarea' === propertyType){
-            if('edit' === templateType){
-                return 'textarea';
-            }
-            return 'text';
+            return 'textarea';
         }
         if(-1 !== ['reference', 'number', 'datetime'].indexOf(propertyType)){
             propertyType = 'text';
@@ -992,7 +1030,9 @@ class AdminManager
             fieldValue = '1' === fieldValue || 'true' === fieldValue ? ' checked="checked"' : '';
         }
         if('datetime' === resourceProperty.type){
-            fieldValue = this.formatDateTimeForEdit(entityPropertyValue, isFieldDisabled);
+            fieldValue = !entityPropertyValue || '' === entityPropertyValue
+                ? ''
+                : sc.formatDate(new Date(entityPropertyValue), 'Y-m-d H:i:s');
         }
         if('reference' === resourceProperty.type){
             let relationDriverResource = this.resourcesByReference[resourceProperty.reference];
@@ -1036,11 +1076,17 @@ class AdminManager
         return idProperty;
     }
 
-    generateEntityRoute(routeType, driverResource, idProperty, entity)
+    generateEntityRoute(routeType, driverResource, idProperty, entity, entityId)
     {
-        let idParam = '';
+        if(!idProperty || (!entity && !entityId)){
+            return this.rootPath + '/' + driverResource.entityPath;
+        }
+        let idParam = '?' + idProperty + '=';
         if(entity){
-            idParam = '?' + idProperty + '=' + entity[idProperty];
+            idParam = idParam + entity[idProperty];
+        }
+        if(entityId){
+            idParam = idParam + entityId;
         }
         return this.rootPath + '/' + driverResource.entityPath + this[routeType] + idParam;
     }

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

@@ -0,0 +1,105 @@
+/**
+ *
+ * Reldens - CMS Pages Route Manager
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class CmsPagesRouteManager
+{
+
+    constructor(props)
+    {
+        this.dataServer = props.dataServer;
+        this.events = props.events;
+        this.setupEventListeners();
+    }
+
+    setupEventListeners()
+    {
+        this.events.on('reldens.adminViewPropertiesPopulation', this.populateViewFields.bind(this));
+        this.events.on('reldens.adminEditPropertiesPopulation', this.populateEditFields.bind(this));
+        this.events.on('reldens.adminAfterEntitySave', this.handleAfterEntitySave.bind(this));
+    }
+
+    async populateViewFields(event)
+    {
+        if('cms_pages' !== event.driverResource.id()){
+            return;
+        }
+        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)
+        });
+        event.renderedViewProperties.routePath = sc.get(existingRoute, 'path', '');
+        event.renderedViewProperties.routeDomain = sc.get(existingRoute, 'domain', '');
+        return true;
+    }
+
+    async populateEditFields(event)
+    {
+        if('cms_pages' !== event.driverResource.id()){
+            return;
+        }
+        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)
+        });
+        event.renderedEditProperties.routePath = sc.get(existingRoute, 'path', '');
+        event.renderedEditProperties.routeDomain = sc.get(existingRoute, 'domain', '');
+        return true;
+    }
+
+    async handleAfterEntitySave(event)
+    {
+        let {req, driverResource, entityData} = event;
+        if('cms_pages' !== driverResource.id()){
+            return;
+        }
+        let routesRepository = this.dataServer.getEntity('routes');
+        if(!routesRepository){
+            Logger.error('Routes repository not found.');
+            return;
+        }
+        let cmsPageId = Number(entityData.id);
+        let existingRoute = await routesRepository.loadOne({router: 'cmsPages', cms_page_id: cmsPageId});
+        let patchData = {
+            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);
+        }
+        return result;
+    }
+
+    generateDefaultRoutePath(pageData)
+    {
+        return '/' + sc.get(pageData, 'title', 'page').toLowerCase()
+            .replace(/[^a-z0-9\s-]/g, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+    }
+
+}
+
+module.exports.CmsPagesRouteManager = CmsPagesRouteManager;

package/lib/frontend.js

@@ -55,7 +55,8 @@ class Frontend
         }
         this.templateEngine = new TemplateEngine({
             renderEngine: this.renderEngine,
-            dataServer: this.dataServer
+            dataServer: this.dataServer,
+            getPartials: this.getPartialsForDomain.bind(this)
         });
         await this.loadPartials();
         await this.setupDomainTemplates();
@@ -69,9 +70,9 @@ class Frontend
 
     async loadEntityAccessRules()
     {
-        let accessEntity = this.dataServer.getEntity('cmsEntityAccess');
+        let accessEntity = this.dataServer.getEntity('entitiesAccess');
         if(!accessEntity){
-            Logger.warning('CMS Entity Access not found.');
+            Logger.warning('Entities Access not found.');
             return;
         }
         let accessRules = await accessEntity.loadAll();
@@ -250,7 +251,9 @@ class Frontend
         try {
             let path = req.path;
             let domain = this.getDomainFromRequest(req);
-            let route = await this.findRouteByPath(path);
+            console.log('---------------> ', {path, domain});
+            this.templateEngine.setCurrentDomain(domain);
+            let route = await this.findRouteByPath(path, domain);
             if(route){
                 return await this.renderRoute(route, domain, res);
             }
@@ -269,19 +272,25 @@ class Frontend
         }
     }
 
-    async findRouteByPath(path)
+    async findRouteByPath(path, domain)
     {
         let routesEntity = this.dataServer.getEntity('routes');
         if(!routesEntity){
             Logger.error('Routes entity not found in dataServer');
             return false;
         }
-        let route = await routesEntity.loadOneBy('path', path);
-        if(route){
-            return route;
+        let domainFilter = domain || null;
+        let routeFilters = {path, enabled: 1};
+        let routes = await routesEntity.load(routeFilters);
+        let matchingRoute = false;
+        for(let route of routes){
+            if(!route.domain || route.domain === domainFilter){
+                matchingRoute = route;
+                break;
+            }
         }
-        if('/' === path){
-            return await routesEntity.loadOneBy('path', '/home');
+        if(matchingRoute){
+            return matchingRoute;
         }
         return false;
     }
@@ -331,20 +340,20 @@ class Frontend
 
     async renderRoute(route, domain, res)
     {
-        if(!route.router || !route.content_id){
+        if(!route.router || !route.cms_page_id){
             return await this.renderNotFound(domain, res);
         }
         let entity = this.dataServer.getEntity(route.router);
         if(!entity){
             return await this.renderNotFound(domain, res);
         }
-        let content = await entity.loadById(route.content_id);
+        let content = await entity.loadById(route.cms_page_id);
         if(!content){
             return await this.renderNotFound(domain, res);
         }
         return await this.renderWithLayout(
             content,
-            Object.assign({}, route, content, {currentYear: new Date().getFullYear()}),
+            Object.assign({}, route, content),
             sc.get(content, 'layout', 'default'),
             domain,
             res
@@ -355,7 +364,7 @@ class Frontend
     {
         return await this.renderWithLayout(
             entityResult.entity,
-            Object.assign({}, entityResult.entity, {currentYear: new Date().getFullYear()}),
+            Object.assign({}, entityResult.entity),
             sc.get(entityResult.entity, 'layout', 'default'),
             domain,
             res
@@ -364,12 +373,11 @@ class Frontend
 
     async renderTemplate(templatePath, domain, res)
     {
-        let data = { currentYear: new Date().getFullYear() };
-        let content = await this.renderContentWithTemplate(templatePath, data, domain);
+        let content = await this.renderContentWithTemplate(templatePath, {}, domain);
         if(!content){
             return res.status(500).send('Template error: '+templatePath);
         }
-        return await this.renderWithLayout({content}, data, 'default', domain, res);
+        return await this.renderWithLayout({content}, {}, 'default', domain, res);
     }
 
     async renderContentWithTemplate(templatePath, data, domain)
@@ -389,51 +397,46 @@ class Frontend
         if(layoutPath){
             let layoutTemplate = FileHandler.readFile(layoutPath);
             if(layoutTemplate){
+                let processedContent = sc.get(content, 'content', '');
+                if(processedContent){
+                    processedContent = await this.templateEngine.render(
+                        processedContent,
+                        data,
+                        this.getPartialsForDomain(domain)
+                    );
+                }
                 layoutContent = await this.templateEngine.render(
                     layoutTemplate,
-                    Object.assign({}, data, {
-                        content: sc.get(content, 'content', '')
-                    }),
+                    Object.assign({}, data, {content: processedContent}),
                     this.getPartialsForDomain(domain)
                 );
             }
         }
         if('' === layoutContent){
-            layoutContent = sc.get(content, 'content', '');
-        }
-        let pagePath = this.findTemplatePath('page', domain);
-        if(!pagePath){
-            return res.send(layoutContent);
-        }
-        let pageTemplate = FileHandler.readFile(pagePath);
-        if(!pageTemplate){
-            return res.send(layoutContent);
-        }
-        return res.send(
-            await this.templateEngine.render(
-                pageTemplate,
-                Object.assign({}, data, {
-                    content: layoutContent,
-                    siteHandle: this.resolveDomainToSiteKey(domain)
-                }),
-                this.getPartialsForDomain(domain)
-            )
-        );
+            let processedContent = sc.get(content, 'content', '');
+            if(processedContent){
+                layoutContent = await this.templateEngine.render(
+                    processedContent,
+                    data,
+                    this.getPartialsForDomain(domain)
+                );
+            }
+        }
+        res.setHeader('Content-Type', 'text/html; charset=utf-8');
+        return res.send(layoutContent);
     }
 
     async renderNotFound(domain, res)
     {
-        let templatePath = this.findTemplatePath('404', domain);
-        if(!templatePath){
-            return res.status(404).send('Page not found');
-        }
-        let data = {title: '404 - Page Not Found', currentYear: new Date().getFullYear()};
-        let content = await this.renderContentWithTemplate(templatePath, data, domain);
-        if(!content){
-            return res.status(404).send('Page not found');
+        let notFoundPath = this.findTemplatePath('404', domain);
+        if(notFoundPath){
+            let content = await this.renderContentWithTemplate(notFoundPath, {}, domain);
+            if(content){
+                res.status(404);
+                return await this.renderWithLayout({content}, {}, 'default', domain, res);
+            }
         }
-        res.status(404);
-        return await this.renderWithLayout({content}, data, 'default', domain, res);
+        return res.status(404).send('Page not found');
     }
 
 }