@reldens/cms 0.5.0 → 0.7.0

package/lib/installer.js

@@ -6,6 +6,8 @@
 
 const { FileHandler, Encryptor } = require('@reldens/server-utils');
 const { DriversMap, EntitiesGenerator, PrismaSchemaGenerator } = require('@reldens/storage');
+const { EntitiesLoader } = require('./entities-loader');
+const { AdminEntitiesGenerator } = require('./admin-entities-generator');
 const { Logger, sc } = require('@reldens/utils');
 const mustache = require('mustache');
 
@@ -15,15 +17,26 @@ class Installer
     constructor(props)
     {
         this.app = sc.get(props, 'app', false);
+        this.appServer = sc.get(props, 'appServer', false);
         this.appServerFactory = sc.get(props, 'appServerFactory', false);
         this.projectRoot = sc.get(props, 'projectRoot', './');
-        this.encoding = sc.get(props, 'encoding', 'utf8');
+        this.projectTemplatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
+        this.projectPublicPath = FileHandler.joinPaths(this.projectRoot, 'public');
+        this.projectPublicAssetsPath = FileHandler.joinPaths(this.projectPublicPath, 'assets');
+        this.projectCssPath = FileHandler.joinPaths(this.projectPublicPath, 'css');
+        this.projectJsPath = FileHandler.joinPaths(this.projectPublicPath, 'js');
         this.installLockPath = FileHandler.joinPaths(this.projectRoot, 'install.lock');
         this.envFilePath = FileHandler.joinPaths(this.projectRoot, '.env');
         this.modulePath = FileHandler.joinPaths(__dirname, '..');
         this.installerPath = FileHandler.joinPaths(this.modulePath, 'install');
         this.migrationsPath = FileHandler.joinPaths(this.modulePath, 'migrations');
         this.defaultTemplatesPath = FileHandler.joinPaths(this.modulePath, 'templates');
+        this.moduleAdminPath = FileHandler.joinPaths(this.modulePath, 'admin');
+        this.moduleAdminAssetsPath = FileHandler.joinPaths(this.moduleAdminPath, 'assets');
+        this.moduleAdminTemplatesPath = FileHandler.joinPaths(this.moduleAdminPath, 'templates')
+        this.indexTemplatePath = FileHandler.joinPaths(this.defaultTemplatesPath, 'index.js.dist');
+        this.postInstallCallback = sc.get(props, 'postInstallCallback', false);
+        this.entitiesLoader = new EntitiesLoader({projectRoot: this.projectRoot});
     }
 
     isInstalled()
@@ -31,7 +44,7 @@ class Installer
         return FileHandler.exists(this.installLockPath);
     }
 
-    async prepareSetup(app, appServerFactory)
+    async prepareSetup(app, appServer, appServerFactory)
     {
         if(!app){
             Logger.error('Missing app on prepareSetup for Installer.');
@@ -43,6 +56,7 @@ class Installer
         }
         this.app = app;
         this.appServerFactory = appServerFactory;
+        this.appServer = appServer;
         app.use('/install-assets', appServerFactory.applicationFramework.static(this.installerPath, {index: false}));
         app.use(appServerFactory.session({
             secret: Encryptor.generateSecretKey(),
@@ -63,18 +77,44 @@ class Installer
         if(this.isInstalled()){
             return next();
         }
-        if('' === req._parsedUrl.pathname || '/' === req._parsedUrl.pathname){
+        let urlPath = req._parsedUrl.pathname;
+        if('' === urlPath || '/' === urlPath){
             let installerIndexPath = FileHandler.joinPaths(this.installerPath, 'index.html');
             if(!FileHandler.exists(installerIndexPath)){
                 return res.status(500).send('Installer template not found.');
             }
             let content = FileHandler.readFile(installerIndexPath);
             let contentParams = req.session?.templateVariables || this.fetchDefaults();
+            let errorParam = req.query?.error;
+            if(errorParam){
+                contentParams.errorMessage = this.getErrorMessage(errorParam);
+            }
             return res.send(mustache.render(content, contentParams));
         }
+        if('/install' !== urlPath){
+            return res.redirect('/');
+        }
         next();
     }
 
+    getErrorMessage(errorCode)
+    {
+        let errorMessages = {
+            'invalid-driver': 'Invalid storage driver selected.',
+            'connection-failed': 'Database connection failed. Please check your credentials.',
+            'raw-query-not-found': 'Query method not found in driver.',
+            'sql-file-not-found': 'SQL installation file not found.',
+            'sql-tables-creation-failed': 'Failed to create database tables.',
+            'sql-default-user-error': 'Failed to create default user.',
+            'installation-entities-generation-failed': 'Failed to generate entities.',
+            'installation-process-failed': 'Installation process failed.',
+            'installation-entities-callback-failed': 'Failed to process entities for callback.',
+            'configuration-error': 'Configuration error while completing installation.',
+            'already-installed': 'The application is already installed.'
+        };
+        return errorMessages[errorCode] || 'An unknown error occurred during installation.';
+    }
+
     async executeInstallProcess(req, res)
     {
         if(this.isInstalled()){
@@ -101,7 +141,11 @@ class Installer
             debug: false
         };
         if('prisma' === selectedDriver){
-            await this.generatePrismaSchema(dbConfig);
+            let generatedPrismaSchema = await this.generatePrismaSchema(dbConfig);
+            if(!generatedPrismaSchema){
+                Logger.error('Could not generated Prisma schema.');
+                return res.redirect('/?error=prisma-schema-generation-error');
+            }
             Logger.info('Generated Prisma schema.');
         }
         let dbDriver = new driverClass(dbConfig);
@@ -129,7 +173,7 @@ class Installer
             if(FileHandler.exists(defaultUserSqlPath)){
                 let queryUserResult = await this.executeQueryFile(dbDriver, defaultUserSqlPath);
                 if(!queryUserResult){
-                    Logger.error('Default user creation failed.');
+                    Logger.error('Default user creation failed.', queryUserResult);
                     return res.redirect('/?error=sql-default-user-error');
                 }
                 Logger.info('Created default user.');
@@ -144,19 +188,29 @@ class Installer
             Logger.error('Installation error: '+error.message);
             return res.redirect('/?error=installation-process-failed');
         }
-        if('' === templateVariables['app-admin-path']){
-            templateVariables['app-admin-path'] = '/reldens-admin';
-        }
         try {
             await this.createEnvFile(templateVariables);
-            await this.createLockFile();
             await this.prepareProjectDirectories();
+            await this.copyAdminDirectory();
+            await this.createIndexJsFile(templateVariables);
+            if(sc.isFunction(this.postInstallCallback)){
+                if(this.appServer && sc.isFunction(this.appServer.close)){
+                    await this.appServer.close();
+                }
+                Logger.debug('Running postInstallCallback.');
+                await this.postInstallCallback(this.entitiesLoader.loadEntities(selectedDriver));
+            }
+            await this.createLockFile();
             Logger.info('Installation successful!');
-            let adminPath = templateVariables['app-admin-path'];
-            return res.redirect(adminPath);
+            let successContent = 'Installation successful! Run "node ." to start your CMS.';
+            let successFileContent = FileHandler.readFile(FileHandler.joinPaths(this.installerPath, 'success.html'));
+            if(successFileContent){
+                successContent = mustache.render(successFileContent, {adminPath: templateVariables['app-admin-path']});
+            }
+            return res.send(successContent);
         } catch (error) {
-            Logger.error('Configuration error: '+error.message);
-            return res.redirect('/?error=configuration-error');
+            Logger.critical('Configuration error: '+error.message);
+            return res.redirect('/?error=installation-error');
         }
     }
 
@@ -213,56 +267,87 @@ class Installer
             dbDriver: templateVariables['db-storage-driver'],
             adminPath: templateVariables['app-admin-path'],
             adminSecret: Encryptor.generateSecretKey(),
-            host: templateVariables['app-host'] || 'http://localhost',
-            port: templateVariables['app-port'] || '8000'
+            host: templateVariables['app-host'],
+            port: templateVariables['app-port']
         });
         return FileHandler.writeFile(this.envFilePath, envContent);
     }
 
+    async createIndexJsFile(templateVariables)
+    {
+        if(!FileHandler.exists(this.indexTemplatePath)){
+            Logger.error('Index.js template not found: '+this.indexTemplatePath);
+            return false;
+        }
+        let indexTemplate = FileHandler.readFile(this.indexTemplatePath);
+        let driverKey = templateVariables['db-storage-driver'];
+        let indexContent = mustache.render(indexTemplate, {driverKey});
+        let indexFilePath = FileHandler.joinPaths(this.projectRoot, 'index.js');
+        if(FileHandler.exists(indexFilePath)){
+            Logger.info('Index.js file already exists, the CMS installer will not override the existent one.');
+            return true;
+        }
+        return FileHandler.writeFile(indexFilePath, indexContent);
+    }
+
     async createLockFile()
     {
-        return FileHandler.writeFile(this.installLockPath,
-            'Installation completed on '+new Date().toISOString());
+        return FileHandler.writeFile(this.installLockPath, 'Installation completed on '+new Date().toISOString());
     }
 
-    async prepareProjectDirectories()
+    async copyAdminDirectory()
     {
-        let projectTemplatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
-        if(!FileHandler.exists(projectTemplatesPath)){
-            FileHandler.createFolder(projectTemplatesPath);
-        }
-        let projectPublicPath = FileHandler.joinPaths(this.projectRoot, 'public');
-        if(!FileHandler.exists(projectPublicPath)){
-            FileHandler.createFolder(projectPublicPath);
-        }
-        let projectCssPath = FileHandler.joinPaths(projectPublicPath, 'css');
-        if(!FileHandler.exists(projectCssPath)){
-            FileHandler.createFolder(projectCssPath);
-        }
-        let projectJsPath = FileHandler.joinPaths(projectPublicPath, 'js');
-        if(!FileHandler.exists(projectJsPath)){
-            FileHandler.createFolder(projectJsPath);
-        }
-        let defaultPagePath = FileHandler.joinPaths(this.defaultTemplatesPath, 'page.html');
-        let defaultNotFoundPath = FileHandler.joinPaths(this.defaultTemplatesPath, '404.html');
-        let defaultLayoutPath = FileHandler.joinPaths(this.defaultTemplatesPath, 'layout.html');
-        if(FileHandler.exists(defaultPagePath)){
-            FileHandler.copyFile(defaultPagePath, FileHandler.joinPaths(projectTemplatesPath, 'page.html'));
-        }
-        if(FileHandler.exists(defaultNotFoundPath)){
-            FileHandler.copyFile(defaultNotFoundPath, FileHandler.joinPaths(projectTemplatesPath, '404.html'));
+        let projectAdminPath = FileHandler.joinPaths(this.projectRoot, 'admin');
+        if(FileHandler.exists(projectAdminPath)){
+            Logger.info('Admin folder already exists in project root.');
+            return true;
         }
-        if(FileHandler.exists(defaultLayoutPath)){
-            FileHandler.copyFile(defaultLayoutPath, FileHandler.joinPaths(projectTemplatesPath, 'layout.html'));
-        }
-        let defaultCssPath = FileHandler.joinPaths(this.defaultTemplatesPath, 'css', 'styles.css');
-        let defaultJsPath = FileHandler.joinPaths(this.defaultTemplatesPath, 'js', 'scripts.js');
-        if(FileHandler.exists(defaultCssPath)){
-            FileHandler.copyFile(defaultCssPath, FileHandler.joinPaths(projectCssPath, 'styles.css'));
-        }
-        if(FileHandler.exists(defaultJsPath)){
-            FileHandler.copyFile(defaultJsPath, FileHandler.joinPaths(projectJsPath, 'scripts.js'));
+        if(!FileHandler.exists(this.moduleAdminPath)){
+            Logger.error('Admin folder not found in module path: '+this.moduleAdminPath);
+            return false;
         }
+        let projectAdminTemplates = FileHandler.joinPaths(projectAdminPath, 'templates');
+        FileHandler.copyFolderSync(this.moduleAdminTemplatesPath, projectAdminTemplates);
+        FileHandler.copyFolderSync(this.moduleAdminAssetsPath, this.projectPublicAssetsPath);
+        FileHandler.copyFile(
+            FileHandler.joinPaths(this.moduleAdminPath, 'reldens-admin-client.css'),
+            FileHandler.joinPaths(this.projectCssPath, 'reldens-admin-client.css'),
+        );
+        FileHandler.copyFile(
+            FileHandler.joinPaths(this.moduleAdminPath, 'reldens-admin-client.js'),
+            FileHandler.joinPaths(this.projectJsPath, 'reldens-admin-client.js'),
+        );
+        Logger.info('Admin folder copied to project root.');
+        return true;
+    }
+
+    async prepareProjectDirectories()
+    {
+        FileHandler.createFolder(this.projectTemplatesPath);
+        FileHandler.createFolder(this.projectPublicPath);
+        FileHandler.createFolder(this.projectPublicAssetsPath);
+        FileHandler.createFolder(this.projectCssPath);
+        FileHandler.createFolder(this.projectJsPath);
+        FileHandler.copyFile(
+            FileHandler.joinPaths(this.defaultTemplatesPath, 'page.html'),
+            FileHandler.joinPaths(this.projectTemplatesPath, 'page.html')
+        );
+        FileHandler.copyFile(
+            FileHandler.joinPaths(this.defaultTemplatesPath, '404.html'),
+            FileHandler.joinPaths(this.projectTemplatesPath, '404.html')
+        );
+        FileHandler.copyFile(
+            FileHandler.joinPaths(this.defaultTemplatesPath, 'layout.html'),
+            FileHandler.joinPaths(this.projectTemplatesPath, 'layout.html')
+        );
+        FileHandler.copyFile(
+            FileHandler.joinPaths(this.defaultTemplatesPath, 'css', 'styles.css'),
+            FileHandler.joinPaths(this.projectCssPath, 'styles.css')
+        );
+        FileHandler.copyFile(
+            FileHandler.joinPaths(this.defaultTemplatesPath, 'js', 'scripts.js'),
+            FileHandler.joinPaths(this.projectJsPath, 'scripts.js')
+        );
         return true;
     }
 

package/lib/loaded-entities-processor.js

@@ -0,0 +1,30 @@
+/**
+ *
+ * Reldens - LoadedEntitiesProcessor
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class LoadedEntitiesProcessor
+{
+
+    process(rawRegisteredEntities, entitiesTranslations, entitiesConfig)
+    {
+        let exportedEntitiesList = Object.keys(rawRegisteredEntities);
+        if(0 === exportedEntitiesList.length){
+            return {};
+        }
+        let entities = {};
+        for (let i of exportedEntitiesList) {
+            entities[i] = {
+                rawEntity: rawRegisteredEntities[i],
+                config: sc.isFunction(entitiesConfig) ? entitiesConfig(props)[i] : entitiesConfig[i]
+            };
+        }
+        return {entities, entitiesRaw: rawRegisteredEntities, translations: entitiesTranslations};
+    }
+
+}
+
+module.exports.LoadedEntitiesProcessor = new LoadedEntitiesProcessor();

package/lib/manager.js

@@ -4,17 +4,27 @@
  *
  */
 
-const { AppServerFactory, FileHandler, Encryptor } = require('@reldens/server-utils');
-const { DriversMap } = require('@reldens/storage');
+const { TemplatesList } = require('./templates-list');
+const { AdminTranslations } = require('./admin-translations');
+const { AdminTemplatesLoader } = require('./admin-templates-loader');
+const { AdminManagerValidator } = require('./admin-manager-validator');
+const { MimeTypes } = require('./mime-types');
+const { AllowedExtensions } = require('./allowed-extensions');
+const { TemplatesToPathMapper } = require('./templates-to-path-mapper');
+const { AdminEntitiesGenerator } = require('./admin-entities-generator');
+const { LoadedEntitiesProcessor } = require('./loaded-entities-processor');
 const { AdminManager } = require('./admin-manager');
 const { Installer } = require('./installer');
-const { Storefront } = require('./storefront');
-const { Logger, sc } = require('@reldens/utils');
+const { Frontend } = require('./frontend');
+const { EventsManagerSingleton, Logger, sc } = require('@reldens/utils');
+const { DriversMap } = require('@reldens/storage');
+const { AppServerFactory, FileHandler, Encryptor } = require('@reldens/server-utils');
 const dotenv = require('dotenv');
 const mustache = require('mustache');
 
 class Manager
 {
+
     constructor(props = {})
     {
         this.projectRoot = sc.get(props, 'projectRoot', './');
@@ -22,35 +32,54 @@ class Manager
         this.installLockPath = FileHandler.joinPaths(this.projectRoot, 'install.lock');
         dotenv.config({path: this.envFilePath});
         this.config = this.loadConfigFromEnv();
-        this.entities = sc.get(props, 'entities', {});
+        this.adminEntities = sc.get(props, 'adminEntities', {});
+        this.rawRegisteredEntities = sc.get(props, 'rawRegisteredEntities', {});
+        this.entitiesTranslations = sc.get(props, 'entitiesTranslations', {});
+        this.entitiesConfig = sc.get(props, 'entitiesConfig', {});
+        this.processedEntities = sc.get(props, 'processedEntities', {});
         this.authenticationMethod = sc.get(props, 'authenticationMethod', 'db-users');
         this.authenticationCallback = sc.get(props, 'authenticationCallback', false);
+        this.events = sc.get(props, 'events', EventsManagerSingleton);
+        this.adminTemplatesList = sc.get(props, 'adminTemplatesList', TemplatesList);
+        this.projectAdminPath = FileHandler.joinPaths(this.projectRoot, 'admin');
+        this.projectAdminTemplatesPath = FileHandler.joinPaths(this.projectAdminPath, 'templates');
+        this.mimeTypes = sc.get(props, 'mimeTypes', MimeTypes);
+        this.allowedExtensions = sc.get(props, 'allowedExtensions', AllowedExtensions)
+        this.adminRoleId = sc.get(props, 'adminRoleId', 99);
+        this.stylesFilePath = sc.get(props, 'stylesFilePath', '/css/reldens-admin-client.css');
+        this.scriptsFilePath = sc.get(props, 'scriptsFilePath', '/js/reldens-admin-client.js');
+        this.companyName = sc.get(props, 'companyName', 'Reldens - CMS');
+        this.logo = sc.get(props, 'logo', '/assets/web/reldens-your-logo-mage.png');
+        this.favicon = sc.get(props, 'favicon', '/assets/web/favicon.ico');
         this.appServerFactory = new AppServerFactory();
+        this.adminEntitiesGenerator = new AdminEntitiesGenerator();
         this.installer = new Installer({
-            projectRoot: this.projectRoot
+            projectRoot: this.projectRoot,
+            postInstallCallback: this.initializeCmsAfterInstall.bind(this)
         });
         this.dataServer = false;
         this.app = false;
         this.appServer = false;
         this.adminManager = false;
-        this.storefront = false;
+        this.frontend = false;
     }
 
     loadConfigFromEnv()
     {
+        let envVars = process.env;
         return {
-            host: process.env.RELDENS_CMS_HOST || 'http://localhost',
-            port: Number(process.env.RELDENS_CMS_PORT || 8000),
-            adminPath: process.env.RELDENS_CMS_ADMIN_PATH || '/reldens-admin',
-            adminSecret: process.env.RELDENS_CMS_ADMIN_SECRET || '',
+            host: sc.get(envVars, 'RELDENS_CMS_HOST', 'http://localhost'),
+            port: Number(sc.get(envVars, 'RELDENS_CMS_PORT', 8000)),
+            adminPath: sc.get(envVars, 'RELDENS_CMS_ADMIN_PATH', '/reldens-admin'),
+            adminSecret: sc.get(envVars, 'RELDENS_CMS_ADMIN_SECRET', ''),
             database: {
-                client: process.env.RELDENS_CMS_DB_CLIENT || 'mysql',
-                host: process.env.RELDENS_CMS_DB_HOST || 'localhost',
-                port: Number(process.env.RELDENS_CMS_DB_PORT || 3306),
-                name: process.env.RELDENS_CMS_DB_NAME || 'reldens_cms',
-                user: process.env.RELDENS_CMS_DB_USER || '',
-                password: process.env.RELDENS_CMS_DB_PASSWORD || '',
-                driver: process.env.RELDENS_CMS_DB_DRIVER || 'prisma'
+                client: sc.get(envVars, 'RELDENS_CMS_DB_CLIENT', 'mysql'),
+                host: sc.get(envVars, 'RELDENS_CMS_DB_HOST', 'localhost'),
+                port: Number(sc.get(envVars, 'RELDENS_CMS_DB_PORT', 3306)),
+                name: sc.get(envVars, 'RELDENS_CMS_DB_NAME', 'reldens_cms'),
+                user: sc.get(envVars, 'RELDENS_CMS_DB_USER', ''),
+                password: sc.get(envVars, 'RELDENS_CMS_DB_PASSWORD', ''),
+                driver: sc.get(envVars, 'RELDENS_CMS_DB_DRIVER', 'prisma')
             }
         };
     }
@@ -71,24 +100,64 @@ class Manager
         this.appServer = createdAppServer.appServer;
         if(!this.isInstalled()){
             Logger.info('CMS not installed, preparing setup');
-            await this.installer.prepareSetup(this.app, this.appServerFactory);
+            await this.installer.prepareSetup(this.app, this.appServer, this.appServerFactory);
             await this.appServer.listen(this.config.port);
             Logger.info('Installer running on '+this.config.host+':'+this.config.port);
             return true;
         }
         try {
-            await this.initializeDataServer();
-            await this.initializeAdminManager();
-            await this.initializeStorefront();
-            await this.appServer.listen(this.config.port);
+            await this.initializeServices();
             Logger.info('CMS running on '+this.config.host+':'+this.config.port);
             return true;
         } catch (error) {
-            Logger.error('Failed to start CMS: '+error.message);
+            Logger.critical('Failed to start CMS: '+error.message);
+            return false;
+        }
+    }
+
+    async initializeCmsAfterInstall(loadEntities)
+    {
+        try {
+            this.rawRegisteredEntities = loadEntities.rawRegisteredEntities;
+            this.entitiesTranslations = loadEntities.entitiesTranslations;
+            this.entitiesConfig = loadEntities.entitiesConfig;
+            this.dataServer.rawEntities = loadEntities.rawRegisteredEntities;
+            this.config = this.loadConfigFromEnv();
+            await this.initializeServices();
+            Logger.info('CMS initialized after installation on '+this.config.host+':'+this.config.port);
+            return true;
+        } catch (error) {
+            Logger.critical('Failed to initialize CMS after installation: '+error.message);
             return false;
         }
     }
 
+    async initializeServices()
+    {
+        await this.initializeDataServer();
+        if (0 === Object.keys(this.adminEntities).length){
+            if(0 === Object.keys(this.processedEntities).length){
+                this.processedEntities = LoadedEntitiesProcessor.process(
+                    this.rawRegisteredEntities,
+                    this.entitiesTranslations,
+                    this.entitiesConfig
+                );
+            }
+            if(!this.processedEntities.entities){
+                Logger.critical('Processed entities undefined.');
+                return false;
+            }
+            await this.dataServer.generateEntities();
+            this.adminEntities = this.adminEntitiesGenerator.generate(
+                this.processedEntities.entities,
+                this.dataServer.entityManager.entities
+            );
+        }
+        await this.initializeAdminManager();
+        await this.initializeFrontend();
+        await this.appServer.listen(this.config.port);
+    }
+
     async initializeDataServer()
     {
         let dbConfig = {
@@ -99,15 +168,18 @@ class Manager
                 database: this.config.database.name,
                 user: this.config.database.user,
                 password: this.config.database.password
-            }
+            },
+            rawEntities: this.rawRegisteredEntities
         };
         let DriverClass = DriversMap[this.config.database.driver];
         if(!DriverClass){
-            throw new Error('Invalid database driver: '+this.config.database.driver);
+            Logger.critical('Invalid database driver: '+this.config.database.driver);
+            return false;
         }
         this.dataServer = new DriverClass(dbConfig);
         if(!await this.dataServer.connect()){
-            throw new Error('Failed to connect to database');
+            Logger.critical('Failed to connect to database.');
+            return false;
         }
         await this.dataServer.generateEntities();
         return true;
@@ -116,33 +188,58 @@ class Manager
     async initializeAdminManager()
     {
         let authenticationCallback = this.authenticationCallback;
-        if('db-users' === this.authenticationMethod){
+        if('db-users' === this.authenticationMethod && !authenticationCallback){
             authenticationCallback = async (email, password, roleId) => {
+                Logger.debug('Running default "db-users" authentication.');
                 let usersEntity = this.dataServer.getEntity('users');
                 if(!usersEntity){
+                    Logger.critical('No users entity found.');
                     return false;
                 }
                 let user = await usersEntity.loadOneBy('email', email);
                 if(!user){
+                    Logger.debug('User not found by email: '+email+'.', user);
                     return false;
                 }
                 if(Number(user.role_id) !== Number(roleId)){
+                    Logger.debug('Invalid user role ID: '+roleId+' / '+user.role_id+'.');
                     return false;
                 }
-                return Encryptor.validatePassword(password, user.password) ? user : false;
+                let passwordResult = Encryptor.validatePassword(password, user.password) ? user : false;
+                if(!passwordResult){
+                    Logger.debug('Invalid user password for: '+email+'.');
+                }
+                return passwordResult;
             };
         }
         let adminConfig = {
-            events: false,
-            renderCallback: this.renderCallback.bind(this),
+            events: this.events,
             dataServer: this.dataServer,
             authenticationCallback,
             app: this.app,
             appServerFactory: this.appServerFactory,
+            entities: this.adminEntities,
+            validator: new AdminManagerValidator(),
+            renderCallback: this.renderCallback.bind(this),
             secret: this.config.adminSecret,
             rootPath: this.config.adminPath,
-            adminRoleId: 99,
-            entities: this.entities
+            translations: AdminTranslations.appendTranslations(this.entitiesTranslations || {}),
+            adminFilesContents: await AdminTemplatesLoader.fetchAdminFilesContents(
+                TemplatesToPathMapper.map(this.adminTemplatesList, this.projectAdminTemplatesPath)
+            ),
+            mimeTypes: this.mimeTypes,
+            allowedExtensions: this.allowedExtensions,
+            adminRoleId: this.adminRoleId,
+            stylesFilePath: this.stylesFilePath,
+            scriptsFilePath: this.scriptsFilePath,
+            branding: {
+                companyName: this.companyName,
+                logo: this.logo,
+                favicon: this.favicon,
+                copyRight: await FileHandler.fetchFileContents(
+                    FileHandler.joinPaths(this.projectAdminTemplatesPath, this.adminTemplatesList.defaultCopyRight)
+                )
+            }
         };
         this.adminManager = new AdminManager(adminConfig);
         await this.adminManager.setupAdmin();
@@ -157,14 +254,15 @@ class Manager
         return mustache.render(template, params);
     }
 
-    async initializeStorefront()
+    async initializeFrontend()
     {
-        this.storefront = new Storefront({
+        this.frontend = new Frontend({
             app: this.app,
             dataServer: this.dataServer,
-            projectRoot: this.projectRoot
+            projectRoot: this.projectRoot,
+            appServerFactory: this.appServerFactory
         });
-        return await this.storefront.initialize();
+        return await this.frontend.initialize();
     }
 }
 

package/lib/mime-types.js

@@ -0,0 +1,35 @@
+/**
+ *
+ * Reldens - MimeTypes
+ *
+ */
+
+module.exports.MimeTypes = {
+    audio: [
+        'audio/aac',
+        'audio/midi',
+        'audio/x-midi',
+        'audio/mpeg',
+        'audio/ogg',
+        'application/ogg',
+        'audio/opus',
+        'audio/wav',
+        'audio/webm',
+        'audio/3gpp2'
+    ],
+    image: [
+        'image/bmp',
+        'image/gif',
+        'image/jpeg',
+        'image/png',
+        'image/svg+xml',
+        'image/vnd.microsoft.icon',
+        'image/tiff',
+        'image/webp'
+    ],
+    text: [
+        'application/json',
+        'application/ld+json',
+        'text/plain',
+    ]
+};

package/lib/templates-list.js

@@ -8,10 +8,6 @@ module.exports.TemplatesList = {
     login: 'login.html',
     dashboard: 'dashboard.html',
     management: 'management.html',
-    mapsWizard: 'maps-wizard.html',
-    mapsWizardMapsSelection: 'maps-wizard-maps-selection.html',
-    objectsImport: 'objects-import.html',
-    skillsImport: 'skills-import.html',
     list: 'list.html',
     listContent: 'list-content.html',
     view: 'view.html',
@@ -41,10 +37,5 @@ module.exports.TemplatesList = {
             button: 'button.html',
             file: 'file.html'
         }
-    },
-    sections: {
-        view: {
-            rooms: 'rooms.html'
-        }
     }
 };