@reldens/cms 0.20.0 → 0.21.0

package/lib/admin-manager/default-translations.js

@@ -0,0 +1,38 @@
+/**
+ *
+ * Reldens - DefaultTranslations
+ *
+ */
+
+module.exports.DefaultTranslations = {
+    messages: {
+        loginWelcome: 'CMS - Login',
+        reldensTitle: 'Reldens - CMS',
+        reldensSlogan: 'You can do it',
+        reldensDiscordTitle: 'Join our Discord server!',
+        reldensDiscordText: 'Talk with the creators and other Reldens users',
+        reldensGithubTitle: 'Find us on GitHub!',
+        reldensGithubText: 'Need a new feature?'
+            +' Would you like to contribute with code?'
+            +' Find the source code or create an issue in GitHub',
+        reldensLoading: 'Loading...',
+        confirmClearCacheMessage: 'Are you sure you want to clear all cache? This action cannot be undone.',
+        clearCacheWarning: 'This will clear all cached routes and may impact site performance temporarily.'
+    },
+    labels: {
+        navigation: 'Reldens - CMS',
+        adminVersion: 'Admin: {{version}}',
+        loginWelcome: 'Reldens',
+        pages: 'Server Management',
+        management: 'Management',
+        shuttingDown: 'Server is shutting down in:',
+        submitShutdownLabel: 'Shutdown Server',
+        submitCancelLabel: 'Cancel Server Shutdown',
+        cleanCache: 'Clean Cache',
+        clearAllCache: 'Clear All Cache',
+        confirmClearCache: 'Confirm Clear Cache',
+        warning: 'Warning:',
+        cancel: 'Cancel',
+        confirm: 'Continue',
+    }
+};

package/lib/admin-manager/router-contents.js

@@ -6,6 +6,7 @@
 
 const { PageRangeProvider, Logger, sc } = require('@reldens/utils');
 const { FileHandler } = require('@reldens/server-utils');
+const { AdminFiltersManager } = require('./admin-filters-manager');
 
 class RouterContents
 {
@@ -30,29 +31,64 @@ class RouterContents
         this.fetchTranslation = props.fetchTranslation;
         this.fetchEntityIdPropertyKey = props.fetchEntityIdPropertyKey;
         this.fetchUploadProperties = props.fetchUploadProperties;
+        this.filtersManager = new AdminFiltersManager();
     }
 
     async generateListRouteContent(req, driverResource, entityPath)
     {
         let currentPage = Number(req?.query?.page || 1);
         let pageSize = Number(req?.query?.pageSize || 25);
-        let filtersFromParams = req?.body?.filters || {};
-        let filters = this.prepareFilters(filtersFromParams, driverResource);
-        let totalEntities = await this.countTotalEntities(driverResource, filters);
+        let shouldClearFilters = 'true' === req?.query?.clearFilters;
+        let sessionFilters = this.filtersManager.getFiltersFromSession(req, entityPath);
+        let filtersFromParams = shouldClearFilters ? {} : req?.body?.filters || req?.query?.filters || {};
+        let entityFilterTerm = shouldClearFilters ? '' : req?.body?.entityFilterTerm || req?.query?.entityFilterTerm || '';
+        if(shouldClearFilters){
+            this.filtersManager.clearFiltersFromSession(req, entityPath);
+        }
+        let hasNewEntityFilterTerm = entityFilterTerm && '' !== entityFilterTerm;
+        let hasNewToggleFilters = Object.keys(filtersFromParams).length > 0;
+        if(hasNewEntityFilterTerm && hasNewToggleFilters){
+            filtersFromParams = {};
+            hasNewToggleFilters = false;
+        }
+        if(hasNewEntityFilterTerm || hasNewToggleFilters){
+            let filtersToSave = {
+                regular: hasNewToggleFilters ? filtersFromParams : {},
+                entityFilterTerm: hasNewEntityFilterTerm ? entityFilterTerm : ''
+            };
+            this.filtersManager.saveFiltersToSession(req, entityPath, filtersToSave);
+            sessionFilters = filtersToSave;
+        }
+        let mergedFilters = shouldClearFilters ? {} : Object.assign({}, sessionFilters.regular || {});
+        let finalEntityFilterTerm = shouldClearFilters ? '' : sessionFilters.entityFilterTerm || '';
+        let filters = this.filtersManager.prepareFilters(mergedFilters, driverResource);
+        let textFilters = this.filtersManager.prepareTextFilters(finalEntityFilterTerm, driverResource);
+        let combinedFilters = this.filtersManager.combineFilters(filters, textFilters);
+        let totalEntities = await this.countTotalEntities(driverResource, combinedFilters);
         let totalPages = totalEntities <= pageSize ? 1 : Math.ceil(totalEntities / pageSize);
         let renderedPagination = '';
         for(let paginationItem of PageRangeProvider.fetch(currentPage, totalPages)){
+            let paginationUrl = this.rootPath+'/'+driverResource.entityPath+'?page='+ paginationItem.value;
+            if(finalEntityFilterTerm){
+                paginationUrl += '&entityFilterTerm='+encodeURIComponent(finalEntityFilterTerm);
+            }
+            for(let filterKey of Object.keys(mergedFilters)){
+                if(mergedFilters[filterKey]){
+                    paginationUrl += '&filters['+filterKey+']='+encodeURIComponent(mergedFilters[filterKey]);
+                }
+            }
             renderedPagination += await this.adminContentsRender(
                 this.adminFilesContents.fields.view['link'],
                 {
                     fieldName: paginationItem.label,
-                    fieldValue: this.rootPath+'/'+driverResource.entityPath+'?page='+ paginationItem.value,
+                    fieldValue: paginationUrl,
                     fieldOriginalValue: paginationItem.value,
                 }
             );
         }
         let listProperties = {
-            entityNewRoute: this.rootPath+'/'+driverResource.entityPath+this.editPath
+            entityNewRoute: this.rootPath+'/'+driverResource.entityPath+this.editPath,
+            entityFilterTermValue: finalEntityFilterTerm || ''
         };
         await this.emitEvent('reldens.adminListPropertiesPopulation', {
             req,
@@ -73,12 +109,13 @@ class RouterContents
                             );
                             return {name: property, value: '' !== alias ? alias + ' ('+propertyTitle+')' : propertyTitle};
                         }),
-                        rows: await this.loadEntitiesForList(driverResource, pageSize, currentPage, req, filters)
+                        rows: await this.loadEntitiesForList(driverResource, pageSize, currentPage, req, combinedFilters)
                     }),
                     pagination: renderedPagination,
-                    extraContentForList: sc.get(listProperties, 'extraContentForList', '')
+                    extraContentForList: sc.get(listProperties, 'extraContentForList', ''),
+                    entityFilterTermValue: listProperties.entityFilterTermValue
                 }, ...driverResource.options.filterProperties.map((property) => {
-                    let filterValue = (filtersFromParams[property] || '');
+                    let filterValue = (mergedFilters[property] || '');
                     return {[property]: '' === filterValue ? '' : 'value="'+filterValue+'"'};
                 }))
             ),
@@ -237,9 +274,13 @@ class RouterContents
                     }
                 }
             }
-            if('saveAndContinue' === sc.get(req.body, 'saveAction', 'save')){
+            let saveAction = sc.get(req.body, 'saveAction', 'save');
+            if('saveAndContinue' === saveAction){
                 return this.generateEntityRoute('editPath', driverResource, idProperty, saveResult) +'&result=success';
             }
+            if('saveAndGoBack' === saveAction){
+                return this.rootPath+'/'+entityPath+'?result=success';
+            }
             return this.generateEntityRoute('viewPath', driverResource, idProperty, saveResult) +'&result=success';
         } catch (error) {
             Logger.error('Save entity error.', error);
@@ -577,42 +618,6 @@ class RouterContents
         return this.rootPath + '/' + driverResource.entityPath + this[routeType] + idParam;
     }
 
-    prepareFilters(filtersList, driverResource)
-    {
-        if(0 === Object.keys(filtersList).length){
-            return {};
-        }
-        let filters = {};
-        for(let i of Object.keys(filtersList)){
-            let filter = filtersList[i];
-            if('' === filter || null === filter || undefined === filter){
-                continue;
-            }
-            let rawConfigFilterProperties = driverResource.options.properties[i];
-            if(!rawConfigFilterProperties){
-                Logger.critical('Could not found property by key.', i);
-                continue;
-            }
-            if(rawConfigFilterProperties.isUpload){
-                continue;
-            }
-            if('reference' === rawConfigFilterProperties.type){
-                filters[i] = Number(filter);
-                continue;
-            }
-            if('boolean' === rawConfigFilterProperties.type){
-                filters[i] = ('true' === filter || '1' === filter || 1 === filter);
-                continue;
-            }
-            if('number' === rawConfigFilterProperties.type || rawConfigFilterProperties.isId){
-                filters[i] = Number(filter);
-                continue;
-            }
-            filters[i] = {operator: 'LIKE', value: '%'+filter+'%'};
-        }
-        return filters;
-    }
-
 }
 
 module.exports.RouterContents = RouterContents;

package/lib/admin-manager/router.js

@@ -37,6 +37,7 @@ class Router
         this.generateEditRouteContent = props.generateEditRouteContent;
         this.processDeleteEntities = props.processDeleteEntities;
         this.processSaveEntity = props.processSaveEntity;
+        this.checkAndReloadAdminTemplates = props.checkAndReloadAdminTemplates;
         this.setupAdminRouter();
     }
 
@@ -61,12 +62,22 @@ class Router
         return true;
     }
 
+    async reloadTemplatesIfNeeded()
+    {
+        if(!this.checkAndReloadAdminTemplates){
+            return false;
+        }
+        return await this.checkAndReloadAdminTemplates();
+    }
+
     setupAdminRoutes()
     {
         this.adminRouter.get(this.loginPath, async (req, res) => {
+            await this.reloadTemplatesIfNeeded();
             return res.send(this.adminContents().login);
         });
         this.adminRouter.post(this.loginPath, async (req, res) => {
+            //await this.reloadTemplatesIfNeeded();
             let { email, password } = req.body;
             let loginResult = await this.authenticationCallback(email, password, this.adminRoleId);
             if(loginResult){
@@ -76,6 +87,7 @@ class Router
             return res.redirect(this.rootPath+this.loginPath+'?login-error=true');
         });
         this.adminRouter.get('/', this.isAuthenticated.bind(this), async (req, res) => {
+            await this.reloadTemplatesIfNeeded();
             return res.send(this.adminContents().dashboard);
         });
         this.adminRouter.get(this.logoutPath, (req, res) => {
@@ -95,12 +107,15 @@ class Router
             let entityPath = driverResource.entityPath;
             let entityRoute = '/'+entityPath;
             this.adminRouter.get(entityRoute, this.isAuthenticated.bind(this), async (req, res) => {
+                await this.reloadTemplatesIfNeeded();
                 return res.send(await this.generateListRouteContent(req, driverResource, entityPath));
             });
             this.adminRouter.post(entityRoute, this.isAuthenticated.bind(this), async (req, res) => {
+                await this.reloadTemplatesIfNeeded();
                 return res.send(await this.generateListRouteContent(req, driverResource, entityPath));
             });
             this.adminRouter.get(entityRoute+this.viewPath, this.isAuthenticated.bind(this), async (req, res) => {
+                await this.reloadTemplatesIfNeeded();
                 let routeContents = await this.generateViewRouteContent(req, driverResource, entityPath);
                 if('' === routeContents){
                     return res.redirect(this.rootPath+'/'+entityPath+'?result=errorView');
@@ -108,6 +123,7 @@ class Router
                 return res.send(routeContents);
             });
             this.adminRouter.get(entityRoute+this.editPath, this.isAuthenticated.bind(this), async (req, res) => {
+                await this.reloadTemplatesIfNeeded();
                 await this.emitEvent('reldens.adminBeforeEntityEdit', {
                     req,
                     res,
@@ -122,6 +138,7 @@ class Router
             });
             this.setupSavePath(entityRoute, driverResource, entityPath);
             this.adminRouter.post(entityRoute+this.deletePath, this.isAuthenticated.bind(this), async (req, res) => {
+                //await this.reloadTemplatesIfNeeded();
                 return res.redirect(await this.processDeleteEntities(req, res, driverResource, entityPath));
             });
             await this.emitEvent('reldens.setupEntitiesRoutes', {
@@ -140,6 +157,7 @@ class Router
                 entityRoute+this.savePath,
                 this.isAuthenticated.bind(this),
                 async (req, res) => {
+                    //await this.reloadTemplatesIfNeeded();
                     await this.emitEvent('reldens.adminBeforeEntitySave', {
                         req,
                         res,
@@ -168,6 +186,7 @@ class Router
             this.isAuthenticated.bind(this),
             this.uploaderFactory.createUploader(fields, this.buckets, allowedFileTypes),
             async (req, res) => {
+                //await this.reloadTemplatesIfNeeded();
                 await this.emitEvent('reldens.adminBeforeEntitySave', {
                     req,
                     res,

package/lib/frontend/content-renderer.js

@@ -0,0 +1,178 @@
+/**
+ *
+ * Reldens - CMS - Frontend - ContentRenderer
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+
+class ContentRenderer
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.templateEngine = sc.get(props, 'templateEngine', false);
+        this.templateResolver = sc.get(props, 'templateResolver', false);
+        this.templateCache = sc.get(props, 'templateCache', false);
+        this.metaDefaults = sc.get(props, 'metaDefaults', {});
+    }
+
+    fetchMetaFields(data)
+    {
+        if(!sc.isObject(data) || 0 === Object.keys(data).length){
+            return this.metaDefaults;
+        }
+        let result = Object.assign({}, this.metaDefaults);
+        for(let key of Object.keys(data)){
+            let value = data[key];
+            if(null !== value && '' !== value && 'undefined' !== typeof value){
+                result[key] = value;
+            }
+        }
+        let titleValue = sc.get(result, 'title', '');
+        let metaTitleValue = sc.get(result, 'meta_title', titleValue);
+        if(metaTitleValue && '' !== metaTitleValue){
+            result.meta_title = metaTitleValue;
+        }
+        let metaOgTitleValue = sc.get(result, 'meta_og_title', metaTitleValue);
+        if(metaOgTitleValue && '' !== metaOgTitleValue){
+            result.meta_og_title = metaOgTitleValue;
+        }
+        let metaDescValue = sc.get(result, 'meta_description', sc.get(result, 'description', ''));
+        if(metaDescValue && '' !== metaDescValue){
+            result.meta_description = metaDescValue;
+        }
+        let metaOgDescValue = sc.get(result, 'meta_og_description', metaDescValue);
+        if(metaOgDescValue && '' !== metaOgDescValue){
+            result.meta_og_description = metaOgDescValue;
+        }
+        let jsonData = sc.get(result, 'json_data', null);
+        if(sc.isString(jsonData)){
+            jsonData = sc.toJson(jsonData, {});
+        }
+        if(!sc.isObject(jsonData)){
+            jsonData = {};
+        }
+        let viewportValue = sc.get(jsonData, 'viewport', this.metaDefaults.viewport);
+        if(viewportValue && '' !== viewportValue){
+            jsonData.viewport = viewportValue;
+        }
+        result.json_data = jsonData;
+        return result;
+    }
+
+    async generateRouteContent(route, domain, req)
+    {
+        if(!route.router){
+            return false;
+        }
+        let entity = this.dataServer.getEntity(route.router);
+        if(!entity){
+            return false;
+        }
+        let content = await entity.loadOneWithRelations({route_id: route.id});
+        if(!content){
+            return false;
+        }
+        return await this.renderWithTemplateContent(content, Object.assign({}, route, content), domain, req, route);
+    }
+
+    async generateTemplateContent(templatePath, domain, req, data = {})
+    {
+        let template = FileHandler.readFile(templatePath);
+        if(!template){
+            Logger.error('Failed to read template: ' + templatePath);
+            return false;
+        }
+        return await this.templateEngine.render(
+            template,
+            data,
+            this.templateCache.getPartialsForDomain(domain),
+            domain,
+            req,
+            null,
+            null
+        );
+    }
+
+    async renderWithTemplateContent(content, data, domain, req, route)
+    {
+        let templateName = sc.get(content, 'template', 'page');
+        if(!templateName){
+            templateName = 'page';
+        }
+        let layoutName = sc.get(content, 'layout', '');
+        if(!layoutName){
+            layoutName = 'default';
+        }
+        let currentEntityData = Object.assign({}, content, data);
+        let layoutContent = await this.processContentWithLayout(
+            content,
+            data,
+            layoutName,
+            domain,
+            req,
+            route,
+            currentEntityData
+        );
+        let templatePath = this.templateResolver.findTemplatePath(templateName, domain);
+        if(!templatePath){
+            return layoutContent;
+        }
+        let routerKey = route?.router;
+        let categoryName = currentEntityData?.cms_categories?.name;
+        let siteHandle = this.templateResolver.resolveDomainToSiteKey(domain)
+            + (routerKey ? ' '+routerKey : '')
+            + (categoryName ? ' cat-'+categoryName : '');
+        return await this.generateTemplateContent(
+            templatePath,
+            domain,
+            req,
+            Object.assign(
+                {},
+                this.fetchMetaFields(data),
+                {
+                    content: layoutContent,
+                    siteHandle
+                }
+            )
+        );
+    }
+
+    async processContentWithLayout(content, data, layoutName, domain, req, route, currentEntityData)
+    {
+        let processedContent = await this.processContent(content, data, domain, req, route, currentEntityData);
+        let layoutPath = this.templateResolver.findLayoutPath(layoutName, domain);
+        if(!layoutPath){
+            return processedContent;
+        }
+        return await this.generateTemplateContent(
+            layoutPath,
+            domain,
+            req,
+            Object.assign({}, data, {content: processedContent})
+        );
+    }
+
+    async processContent(content, data, domain, req, route, currentEntityData)
+    {
+        let contentText = sc.get(content, 'content', '');
+        if(!contentText){
+            return '';
+        }
+        return await this.templateEngine.render(
+            contentText,
+            data,
+            this.templateCache.getPartialsForDomain(domain),
+            domain,
+            req,
+            route,
+            currentEntityData
+        );
+    }
+
+}
+
+module.exports.ContentRenderer = ContentRenderer;

package/lib/frontend/entity-access-manager.js

@@ -0,0 +1,63 @@
+/**
+ *
+ * Reldens - CMS - Frontend - EntityAccessManager
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class EntityAccessManager
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.entityAccessCache = new Map();
+    }
+
+    async loadEntityAccessRules()
+    {
+        let accessEntity = this.dataServer.getEntity('entitiesAccess');
+        if(!accessEntity){
+            Logger.warning('Entities Access not found.');
+            return;
+        }
+        let accessRules = await accessEntity.loadAll();
+        for(let rule of accessRules){
+            this.entityAccessCache.set(rule.entity_name, rule.is_public);
+        }
+    }
+
+    async isEntityAccessible(entityName)
+    {
+        if(this.entityAccessCache.has(entityName)){
+            return this.entityAccessCache.get(entityName);
+        }
+        return false;
+    }
+
+    async findEntityByPath(path)
+    {
+        let pathSegments = path.split('/').filter(segment => '' !== segment);
+        if(2 > pathSegments.length){
+            return false;
+        }
+        let entityName = pathSegments[0];
+        if(!await this.isEntityAccessible(entityName)){
+            return false;
+        }
+        let entityId = pathSegments[1];
+        let entity = this.dataServer.getEntity(entityName);
+        if(!entity){
+            return false;
+        }
+        let loadedEntity = await entity.loadByIdWithRelations(entityId);
+        if(!loadedEntity){
+            return false;
+        }
+        return {entity: loadedEntity, entityName};
+    }
+
+}
+
+module.exports.EntityAccessManager = EntityAccessManager;

package/lib/frontend/request-processor.js

@@ -0,0 +1,128 @@
+/**
+ *
+ * Reldens - CMS - Frontend - RequestProcessor
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class RequestProcessor
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.templateResolver = sc.get(props, 'templateResolver', false);
+        this.domainMapping = sc.get(props, 'domainMapping', {});
+    }
+
+    getDomainFromRequest(req)
+    {
+        let host = req.get('host');
+        if(!host){
+            return false;
+        }
+        return host.split(':')[0];
+    }
+
+    resolveDomainMapping(domain)
+    {
+        if(!domain){
+            return domain;
+        }
+        return sc.get(this.domainMapping, domain, domain);
+    }
+
+    normalizePathForRouteSearch(path)
+    {
+        if(!path || '/' === path){
+            return '/';
+        }
+        return path.endsWith('/') ? path.slice(0, -1) : path;
+    }
+
+    async handleRouteRedirect(route, res)
+    {
+        let redirectUrl = sc.get(route, 'redirect_url', null);
+        if(!redirectUrl){
+            return false;
+        }
+        let redirectType = sc.get(route, 'redirect_type', '301');
+        let statusCode = '301' === redirectType ? 301 : 302;
+        res.redirect(statusCode, redirectUrl);
+        return true;
+    }
+
+    async findRouteByPath(path, domain)
+    {
+        let routesEntity = this.dataServer.getEntity('routes');
+        if(!routesEntity){
+            Logger.error('Routes entity not found in dataServer.');
+            return false;
+        }
+        let normalizedPath = this.normalizePathForRouteSearch(path);
+        let resolvedDomain = this.resolveDomainMapping(domain);
+        let domainFilter = resolvedDomain || null;
+        let routeFilters = {path: normalizedPath, enabled: 1};
+        let routes = await routesEntity.load(routeFilters);
+        let matchingRoute = false;
+        let nullDomain = false;
+        for(let route of routes){
+            if(route.domain === domainFilter){
+                matchingRoute = route;
+                break;
+            }
+            if(!route.domain){
+                nullDomain = route;
+            }
+        }
+        if(matchingRoute){
+            return matchingRoute;
+        }
+        if(nullDomain){
+            return nullDomain;
+        }
+        if(normalizedPath !== path){
+            let routeFiltersWithSlash = {path: path, enabled: 1};
+            let routesWithSlash = await routesEntity.load(routeFiltersWithSlash);
+            for(let route of routesWithSlash){
+                if(route.domain === domainFilter){
+                    return route;
+                }
+                if(!route.domain){
+                    nullDomain = route;
+                }
+            }
+            if(nullDomain){
+                return nullDomain;
+            }
+        }
+        return false;
+    }
+
+    buildCacheKey(path, req)
+    {
+        if(!req || !req.query){
+            return path;
+        }
+        for(let key of Object.keys(req.query)){
+            if(key.endsWith('-key')){
+                let queryString = '';
+                for(let qKey of Object.keys(req.query)){
+                    queryString += (queryString ? '&' : '') + qKey + '=' + req.query[qKey];
+                }
+                let hash = 0;
+                for(let i = 0; i < queryString.length; i++){
+                    let char = queryString.charCodeAt(i);
+                    hash = ((hash << 5) - hash) + char;
+                    hash = hash & hash;
+                }
+                return path + '_' + Math.abs(hash);
+            }
+        }
+        return path;
+    }
+
+}
+
+module.exports.RequestProcessor = RequestProcessor;