@reldens/cms 0.7.0 → 0.9.0

package/admin/reldens-admin-client.css

@@ -86,7 +86,6 @@
     }
 
     & .button {
-
         padding: 0.5rem 1rem;
         border: none;
         border-radius: 4px;
@@ -94,44 +93,44 @@
         cursor: pointer;
         text-decoration: none;
 
-        &-primary {
-            color: var(--white);
-            background-color: var(--lightBlue);
-
-            &:hover {
-                background-color: var(--lightBlue);
-            }
+        &:disabled {
+            background-color: var(--grey) !important;
         }
+    }
 
-        &-secondary {
-            color: var(--white);
-            background-color: var(--grey);
+    & .button-primary {
+        color: var(--white);
+        background-color: var(--lightBlue);
 
-            &:hover {
-                background-color: var(--grey);
-            }
+        &:hover {
+            background-color: var(--lightBlue);
         }
+    }
 
-        &-warning {
-            color: var(--white);
-            background-color: var(--orange);
+    & .button-secondary {
+        color: var(--white);
+        background-color: var(--grey);
 
-            &:hover {
-                background-color: var(--orange);
-            }
+        &:hover {
+            background-color: var(--grey);
         }
+    }
 
-        &-danger {
-            color: var(--white);
-            background-color: var(--red);
+    & .button-warning {
+        color: var(--white);
+        background-color: var(--orange);
 
-            &:hover {
-                background-color: var(--red);
-            }
+        &:hover {
+            background-color: var(--orange);
         }
+    }
 
-        &:disabled {
-            background-color: var(--grey) !important;
+    & .button-danger {
+        color: var(--white);
+        background-color: var(--red);
+
+        &:hover {
+            background-color: var(--red);
         }
     }
 
@@ -556,7 +555,7 @@
                     padding: 0.5rem;
                     border: 1px solid #ccc;
                     border-radius: 4px;
-                    min-width: 150px; /* Minimum width for input fields */
+                    min-width: 150px;
                 }
             }
 

package/install/index.html

@@ -17,7 +17,7 @@
         <div class="forms-container">
             <div class="row">
                 <form name="install-form" id="install-form" class="install-form" action="/install" method="post">
-                    <h3 class="form-title">- Server Configuration -</h3>
+                    <h3 class="form-title">Server Configuration</h3>
                     <div class="input-box app-host">
                         <label for="app-host">Host</label>
                         <input type="text" name="app-host" id="app-host" value="{{app-host}}" class="required" required/>
@@ -30,10 +30,14 @@
                         <label for="app-admin-path">Admin Panel Path</label>
                         <input type="text" name="app-admin-path" id="app-admin-path" value="{{app-admin-path}}"/>
                     </div>
+                    <div class="input-box app-admin-secret">
+                        <label for="app-admin-secret">Admin Panel Secret</label>
+                        <input type="text" name="app-admin-secret" id="app-admin-secret" value="{{app-admin-secret}}"/>
+                    </div>
                     <div class="input-box app-error">
                         <p class="error installation-process-failed">There was an error during the installation process.</p>
                     </div>
-                    <h3 class="form-title">- Database Configuration -</h3>
+                    <h3 class="form-title">Database Configuration</h3>
                     <div class="input-box db-storage-driver">
                         <label for="db-storage-driver">Storage Driver</label>
                         <select name="db-storage-driver" id="db-storage-driver" class="required" required>
@@ -72,6 +76,23 @@
                         <p class="error sql-file-not-found">SQL installation file not found.</p>
                         <p class="error db-installation-process-failed">There was an error during the installation process.</p>
                     </div>
+                    <h3 class="form-title">Installation Options</h3>
+                    <div class="input-box install-cms-tables">
+                        <input type="checkbox" name="install-cms-tables" id="install-cms-tables" checked/>
+                        <label for="install-cms-tables">Install default CMS pages tables</label>
+                    </div>
+                    <div class="input-box install-user-auth">
+                        <input type="checkbox" name="install-user-auth" id="install-user-auth" checked/>
+                        <label for="install-user-auth">Install users authentication</label>
+                    </div>
+                    <div class="input-box install-default-user">
+                        <input type="checkbox" name="install-default-user" id="install-default-user" checked/>
+                        <label for="install-default-user">Install default admin user (root@cms-admin.com / root)</label>
+                    </div>
+                    <div class="input-box install-default-homepage">
+                        <input type="checkbox" name="install-default-homepage" id="install-default-homepage" checked/>
+                        <label for="install-default-homepage">Install default homepage</label>
+                    </div>
                     <div class="input-box submit-container">
                         <img class="install-loading hidden" src="/install-assets/img/loading.gif"/>
                         <input id="install-submit-button" type="submit" value="Install"/>

package/install/success.html

@@ -17,6 +17,12 @@
         <div class="forms-container">
             <div class="row">
                 Installation completed!
+                <p>
+                    Default data<br/>
+                    username: root
+                    email: root@cms-admin.com
+                    password: root
+                </p>
             </div>
         </div>
     </div>

package/lib/admin-manager.js

@@ -380,6 +380,9 @@ class AdminManager
         this.adminRouter = this.applicationFramework.Router();
         // apply session middleware only to /admin routes:
         if(this.session){
+            if(!this.secret){
+                Logger.warning('Admin Manager "secret" key was not provided.');
+            }
             this.adminRouter.use(this.session({secret: this.secret, resave: false, saveUninitialized: true}));
         }
         this.adminRouter.use(this.bodyParser.json());
@@ -636,6 +639,26 @@ 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);
@@ -660,6 +683,7 @@ class AdminManager
             if(resourceProperty.isUpload && loadedEntity){
                 isRequired = '';
             }
+            let inputType = this.getInputType(resourceProperty, fieldDisabled);
             renderedEditProperties[propertyKey] = await this.render(
                 this.adminFilesContents.fields.edit[this.propertyType(resourceProperty, 'edit')],
                 {
@@ -667,11 +691,13 @@ class AdminManager
                     fieldValue: await this.generatePropertyEditRenderedValue(
                         loadedEntity,
                         propertyKey,
-                        resourceProperty
+                        resourceProperty,
+                        fieldDisabled
                     ),
                     fieldDisabled: fieldDisabled ? ' disabled="disabled"' : '',
                     required: isRequired,
-                    multiple: resourceProperty.isArray ? ' multiple="multiple"' : ''
+                    multiple: resourceProperty.isArray ? ' multiple="multiple"' : '',
+                    inputType
                 }
             );
         }
@@ -679,6 +705,14 @@ class AdminManager
         return await this.renderRoute(renderedView, this.adminContents.sideBar);
     }
 
+    getInputType(resourceProperty, fieldDisabled)
+    {
+        if('datetime' === resourceProperty.type && !fieldDisabled){
+            return 'datetime-local';
+        }
+        return 'text';
+    }
+
     async loadEntityById(driverResource, id)
     {
         let entityRepository = this.dataServer.getEntity(driverResource.entityKey);
@@ -936,13 +970,16 @@ class AdminManager
         return {fieldValue, fieldName};
     }
 
-    async generatePropertyEditRenderedValue(entity, propertyKey, resourceProperty)
+    async generatePropertyEditRenderedValue(entity, propertyKey, resourceProperty, isFieldDisabled)
     {
         let entityPropertyValue = sc.get(entity, propertyKey, null);
         let fieldValue = (0 === entityPropertyValue ? '0' : entityPropertyValue || '').toString();
         if('boolean' === resourceProperty.type){
             fieldValue = '1' === fieldValue || 'true' === fieldValue ? ' checked="checked"' : '';
         }
+        if('datetime' === resourceProperty.type){
+            fieldValue = this.formatDateTimeForEdit(entityPropertyValue, isFieldDisabled);
+        }
         if('reference' === resourceProperty.type){
             let relationDriverResource = this.resourcesByReference[resourceProperty.reference];
             let relation = this.relations[resourceProperty.reference];

package/lib/entities-loader.js

@@ -4,7 +4,6 @@
  *
  */
 
-const { LoadedEntitiesProcessor } = require('./loaded-entities-processor');
 const { FileHandler } = require('@reldens/server-utils');
 const { Logger, sc } = require('@reldens/utils');
 
@@ -30,7 +29,7 @@ class EntitiesLoader
         }
         try {
             let {rawRegisteredEntities, entitiesConfig, entitiesTranslations} = require(entitiesPath);
-            return LoadedEntitiesProcessor.process(rawRegisteredEntities, entitiesTranslations, entitiesConfig);
+            return {rawRegisteredEntities, entitiesTranslations, entitiesConfig};
         } catch(error){
             Logger.error('Failed to load generated entities: ' + error.message);
         }

package/lib/frontend.js

@@ -19,6 +19,10 @@ class Frontend
         this.projectRoot = sc.get(props, 'projectRoot', './');
         this.templatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
         this.publicPath = FileHandler.joinPaths(this.projectRoot, 'public');
+        this.partialsExtensions = sc.get(props, 'partialsExtensions', ['.html', '.mustache', '.template']);
+        this.partialsCache = {};
+        this.domainPartialsCache = new Map();
+        this.domainTemplatesMap = new Map();
         this.error = false;
     }
 
@@ -36,6 +40,8 @@ class Frontend
             Logger.error('Public folder not found: '+this.publicPath);
             return false;
         }
+        await this.loadPartials();
+        await this.setupDomainTemplates();
         this.setupStaticAssets();
         this.app.get('*', async (req, res) => {
             return await this.handleRequest(req, res);
@@ -43,6 +49,101 @@ class Frontend
         return true;
     }
 
+    async loadPartials()
+    {
+        let partialsPath = FileHandler.joinPaths(this.templatesPath, 'partials');
+        FileHandler.createFolder(partialsPath);
+        let partialFiles = FileHandler.getFilesInFolder(partialsPath, this.partialsExtensions);
+        for(let file of partialFiles){
+            let partialName = '';
+            for(let extension of this.partialsExtensions){
+                if(file.endsWith(extension)){
+                    partialName = file.replace(extension, '');
+                    break;
+                }
+            }
+            let partialPath = FileHandler.joinPaths(partialsPath, file);
+            let partialContent = FileHandler.readFile(partialPath);
+            this.partialsCache[partialName] = partialContent.toString();
+        }
+    }
+
+    async loadDomainPartials(domain, domainPath)
+    {
+        let domainPartialsPath = FileHandler.joinPaths(domainPath, 'partials');
+        if(!FileHandler.exists(domainPartialsPath)){
+            return;
+        }
+        let domainPartials = {};
+        let partialFiles = FileHandler.getFilesInFolder(domainPartialsPath, this.partialsExtensions);
+        for(let file of partialFiles){
+            let partialName = '';
+            for(let extension of this.partialsExtensions){
+                if(file.endsWith(extension)){
+                    partialName = file.replace(extension, '');
+                    break;
+                }
+            }
+            let partialPath = FileHandler.joinPaths(domainPartialsPath, file);
+            let partialContent = FileHandler.readFile(partialPath);
+            domainPartials[partialName] = partialContent.toString();
+        }
+        this.domainPartialsCache.set(domain, domainPartials);
+    }
+
+    async setupDomainTemplates()
+    {
+        let domainsPath = FileHandler.joinPaths(this.templatesPath, 'domains');
+        if(!FileHandler.exists(domainsPath)){
+            return;
+        }
+        let domainFolders = FileHandler.fetchSubFoldersList(domainsPath);
+        for(let domain of domainFolders){
+            let domainPath = FileHandler.joinPaths(domainsPath, domain);
+            this.domainTemplatesMap.set(domain, domainPath);
+            await this.loadDomainPartials(domain, domainPath);
+        }
+    }
+
+    getDomainFromRequest(req)
+    {
+        let host = req.get('host');
+        if(!host){
+            return false;
+        }
+        return host.split(':')[0];
+    }
+
+    getPartialsForDomain(domain)
+    {
+        let domainPartials = this.domainPartialsCache.get(domain);
+        if(!domainPartials){
+            return this.partialsCache;
+        }
+        return Object.assign({}, this.partialsCache, domainPartials);
+    }
+
+    findTemplatePathForDomain(templateName, domain)
+    {
+        if(!domain){
+            return this.getDefaultTemplatePath(templateName);
+        }
+        let domainPath = this.domainTemplatesMap.get(domain);
+        if(!domainPath){
+            return this.getDefaultTemplatePath(templateName);
+        }
+        let domainTemplatePath = FileHandler.joinPaths(domainPath, templateName + '.html');
+        if(!FileHandler.exists(domainTemplatePath)){
+            return this.getDefaultTemplatePath(templateName);
+        }
+        return domainTemplatePath;
+    }
+
+    getDefaultTemplatePath(templateName)
+    {
+        return FileHandler.joinPaths(this.templatesPath, templateName + '.html');
+    }
+
     setupStaticAssets()
     {
         if(!this.app || !this.appServerFactory || !this.publicPath){
@@ -62,26 +163,32 @@ class Frontend
             return res.status(404).send('');
         }
         try {
+            let domain = this.getDomainFromRequest(req);
             let route = await this.findRouteByPath(path);
             if(route){
-                return await this.renderContentFromRoute(res, route);
+                Logger.debug('Found route for path: '+path, route);
+                return await this.renderContentFromRoute(res, route, domain);
             }
             let pathSegments = path.split('/').filter(segment => segment !== '');
             if(0 < pathSegments.length){
                 let entityResult = await this.findEntityByPath(pathSegments);
                 if(entityResult){
+                    Logger.debug('Found entity for path segments: '+pathSegments.join('/'));
                     return await this.renderContentFromEntity(
                         res,
                         entityResult.entity,
-                        entityResult.entityName
+                        entityResult.entityName,
+                        domain
                     );
                 }
             }
-            let templatePath = this.findTemplateByPath(path);
+            let templatePath = this.findTemplateByPath(path, domain);
             if(templatePath){
-                return await this.renderTemplateOnly(res, templatePath);
+                Logger.debug('Found template for path: '+path+' at: '+templatePath);
+                return await this.renderTemplateOnly(res, templatePath, domain);
             }
-            return await this.renderNotFoundPage(res);
+            Logger.debug('No template found for path: '+path+', rendering 404');
+            return await this.renderNotFoundPage(res, domain);
         } catch (error) {
             Logger.error('Request handling error: '+error.message);
             return res.status(500).send('Internal server error');
@@ -90,32 +197,41 @@ class Frontend
 
     async findRouteByPath(path)
     {
-        if('/' === path){
-            path = '/home';
-        }
         let routesEntity = this.dataServer.getEntity('routes');
         if(!routesEntity){
+            Logger.error('Routes entity not found in dataServer');
             return false;
         }
-        return await routesEntity.loadOneBy('path', path);
+        let route = await routesEntity.loadOneBy('path', path);
+        if(route){
+            return route;
+        }
+        if('/' === path){
+            return await routesEntity.loadOneBy('path', '/home');
+        }
+        return false;
     }
 
     async findEntityByPath(pathSegments)
     {
         if(1 > pathSegments.length){
+            Logger.debug('No path segments provided');
             return false;
         }
         let entityName = pathSegments[0];
         let entityId = 2 > pathSegments.length ? false : pathSegments[1];
         if(!entityId){
+            Logger.debug('No entity ID in path segments');
             return false;
         }
         let entity = this.dataServer.getEntity(entityName);
         if(!entity){
+            Logger.debug('Entity not found: '+entityName);
             return false;
         }
         let loadedEntity = await entity.loadById(entityId);
         if(!loadedEntity){
+            Logger.debug('Entity not loaded by ID: '+entityId);
             return false;
         }
         return {
@@ -124,7 +240,7 @@ class Frontend
         };
     }
 
-    findTemplateByPath(path)
+    findTemplateByPath(path, domain)
     {
         if('/' === path){
             path = '/index';
@@ -135,32 +251,36 @@ class Frontend
         templatePath = templatePath.startsWith('/')
             ? templatePath.substring(1)
             : templatePath;
-        let fullPath = FileHandler.joinPaths(this.templatesPath, templatePath + '.html');
+        let fullPath = this.findTemplatePathForDomain(templatePath, domain);
         if(FileHandler.exists(fullPath)){
             return fullPath;
         }
         return false;
     }
 
-    async renderContentFromRoute(res, route)
+    async renderContentFromRoute(res, route, domain)
     {
         if(!route.router || !route.content_id){
-            return await this.renderNotFoundPage(res);
+            Logger.debug('Route missing router or content_id');
+            return await this.renderNotFoundPage(res, domain);
         }
         let entity = this.dataServer.getEntity(route.router);
         if(!entity){
-            return await this.renderNotFoundPage(res);
+            Logger.debug('Entity not found: '+route.router);
+            return await this.renderNotFoundPage(res, domain);
         }
         let content = await entity.loadById(route.content_id);
         if(!content){
-            return await this.renderNotFoundPage(res);
+            Logger.debug('Content not found for ID: '+route.content_id+' in entity: '+route.router);
+            return await this.renderNotFoundPage(res, domain);
         }
         let templateName = content.template || route.router;
-        let templatePath = FileHandler.joinPaths(this.templatesPath, templateName + '.html');
+        let templatePath = this.findTemplatePathForDomain(templateName, domain);
         if(!FileHandler.exists(templatePath)){
-            templatePath = FileHandler.joinPaths(this.templatesPath, 'page.html');
+            templatePath = this.findTemplatePathForDomain('page', domain);
             if(!FileHandler.exists(templatePath)){
-                return await this.renderNotFoundPage(res);
+                Logger.debug('Neither template found: '+templateName+'.html nor page.html');
+                return await this.renderNotFoundPage(res, domain);
             }
         }
         let template = FileHandler.readFile(templatePath).toString();
@@ -169,17 +289,18 @@ class Frontend
             ...content,
             current_year: new Date().getFullYear()
         };
-        let rendered = mustache.render(template, data);
+        let partials = this.getPartialsForDomain(domain);
+        let rendered = mustache.render(template, data, partials);
         return res.send(rendered);
     }
 
-    async renderContentFromEntity(res, entity, entityName)
+    async renderContentFromEntity(res, entity, entityName, domain)
     {
-        let templatePath = FileHandler.joinPaths(this.templatesPath, entityName + '.html');
+        let templatePath = this.findTemplatePathForDomain(entityName, domain);
         if(!FileHandler.exists(templatePath)){
-            templatePath = FileHandler.joinPaths(this.templatesPath, 'page.html');
+            templatePath = this.findTemplatePathForDomain('page', domain);
             if(!FileHandler.exists(templatePath)){
-                return await this.renderNotFoundPage(res);
+                return await this.renderNotFoundPage(res, domain);
             }
         }
         let template = FileHandler.readFile(templatePath).toString();
@@ -188,24 +309,26 @@ class Frontend
             title: entity.title || entity.name || entityName,
             current_year: new Date().getFullYear()
         };
-        let rendered = mustache.render(template, data);
+        let partials = this.getPartialsForDomain(domain);
+        let rendered = mustache.render(template, data, partials);
         return res.send(rendered);
     }
 
-    async renderTemplateOnly(res, templatePath)
+    async renderTemplateOnly(res, templatePath, domain)
     {
         let template = FileHandler.readFile(templatePath).toString();
         let data = {
             title: 'Page Title',
             current_year: new Date().getFullYear()
         };
-        let rendered = mustache.render(template, data);
+        let partials = this.getPartialsForDomain(domain);
+        let rendered = mustache.render(template, data, partials);
         return res.send(rendered);
     }
 
-    async renderNotFoundPage(res)
+    async renderNotFoundPage(res, domain)
     {
-        let templatePath = FileHandler.joinPaths(this.templatesPath, '404.html');
+        let templatePath = this.findTemplatePathForDomain('404', domain);
         if(!FileHandler.exists(templatePath)){
             return res.status(404).send('Page not found');
         }
@@ -214,7 +337,8 @@ class Frontend
             title: '404 - Page Not Found',
             current_year: new Date().getFullYear()
         };
-        let rendered = mustache.render(template, data);
+        let partials = this.getPartialsForDomain(domain);
+        let rendered = mustache.render(template, data, partials);
         return res.status(404).send(rendered);
     }