@reldens/cms 0.1.0

package/lib/admin-translations.js

@@ -0,0 +1,262 @@
+/**
+ *
+ * Reldens - AdminTranslations
+ *
+ */
+
+class AdminTranslations
+{
+
+    static appendTranslations(translations)
+    {
+        // @TODO - BETA - Fix translations, use snippets, include new snippets under the basic config script.
+        let adminTranslations = {
+            messages: {
+                loginWelcome: 'Administration Panel - Login',
+                reldensTitle: 'Reldens - Administration Panel',
+                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...'
+            },
+            labels: {
+                navigation: 'Reldens - Administration Panel',
+                adminVersion: 'Admin: {{version}}',
+                loginWelcome: 'Reldens',
+                pages: 'Server Management',
+                management: 'Management',
+                mapsWizard: 'Maps Generation and Import',
+                objectsImport: 'Objects Import',
+                skillsImport: 'Skills Import',
+                shuttingDown: 'Server is shutting down in:',
+                submitShutdownLabel: 'Shutdown Server',
+                submitCancelLabel: 'Cancel Server Shutdown',
+            },
+            active_from: 'Active From',
+            active_to: 'Active To',
+            ads_id: 'Ads ID',
+            ads_type: 'Ads Type',
+            affectedProperty: 'Affected Property',
+            aimProperties: 'Aim Properties',
+            allowEffectBelowZero: 'Allow Effect Below Zero',
+            allowSelfTarget: 'Allow Self Target',
+            also_show_in_type: 'Also Show In Type',
+            animationData: 'Animation Data',
+            animationKey: 'Animation Key',
+            applyDirectDamage: 'Apply Direct Damage',
+            asset_file: 'Asset File',
+            asset_key: 'Asset Key',
+            asset_type: 'Asset Type',
+            attackProperties: 'Attack Properties',
+            audio_id: 'Audio ID',
+            audio_key: 'Audio Key',
+            autoFillExperienceMultiplier: 'Auto Fill Experience Multiplier',
+            autoFillRanges: 'Auto Fill Ranges',
+            autoValidation: 'Auto Validation',
+            auto_remove_requirement: 'Auto Remove Requirement',
+            banner_data: 'Banner Data',
+            base_value: 'Base Value',
+            bottom: 'Bottom',
+            castTime: 'Cast Time',
+            category_id: 'Category ID',
+            category_key: 'Category Key',
+            category_label: 'Category Label',
+            chat_player_id: 'Chat Player ID',
+            chat_private_player_id: 'Chat Private Player',
+            chat_room: 'Chat Room',
+            chat_type: 'Chat Type',
+            clan_id: 'Clan ID',
+            classKey: 'Class Key',
+            class_path: 'Class Path',
+            class_path_id: 'Class Path ID',
+            class_path_level: 'Level Key',
+            class_path_level_skill: 'Skill',
+            class_path_owner: 'Class Path Owner',
+            class_type: 'Class Type',
+            client_key: 'Client Key',
+            client_params: 'Client Params',
+            code: 'Code',
+            conditional: 'Conditional',
+            config: 'Config',
+            country_code: 'Country Code',
+            created_at: 'Created At',
+            criticalAffected: 'Critical Affected',
+            criticalChance: 'Critical Chance',
+            criticalFixedValue: 'Critical FixedValue',
+            criticalMultiplier: 'Critical Multiplier',
+            currentExp: 'Current Exp',
+            currentLevel: 'Current Level',
+            customData: 'Custom Data',
+            damageAffected: 'Damage Affected',
+            defenseProperties: 'Defense Properties',
+            description: 'Description',
+            dir: 'Dir',
+            direction: 'Direction',
+            drop_quantity: 'Drop Quantity',
+            drop_rate: 'Drop Rate',
+            dodgeFullEnabled: 'Dodge Full Enabled',
+            dodgeOverAimSuccess: 'Dodge Over Aim Success',
+            dodgeProperties: 'Dodge Properties',
+            duration: 'Duration',
+            email: 'Email',
+            enabled: 'Enabled',
+            ended_at: 'Ended At',
+            event_data: 'Event Data',
+            event_key: 'Event Key',
+            experience: 'Experience',
+            execTimeOut: 'Exec Time Out',
+            extra_params: 'Extra Params',
+            file: 'File',
+            files_name: 'Files Name',
+            from_room_id: 'From Room ID',
+            group_id: 'Group ID',
+            handler_key: 'Handler Key',
+            has_drop_body: 'Has Drop Body',
+            height: 'Height',
+            hitDamage: 'Hit Damage',
+            id: 'ID',
+            instances_limit: 'Instances Limit',
+            is_active: 'Is Active',
+            is_default: 'Is Default',
+            is_enabled: 'Is Enabled',
+            is_unique: 'Is Unique',
+            item_id: 'Item ID',
+            item_key: 'Item Key',
+            items_limit: 'Items Limit',
+            key: 'Key',
+            kill_npc_id: 'Kill NPC ID',
+            kill_player_id: 'Kill Player ID',
+            kill_time: 'Kill Time',
+            label: 'Label',
+            label_level: 'Label Level',
+            language_code: 'Language Code',
+            last_npc_kill_time: 'Last NPC Kill Time',
+            last_player_kill_time: 'Last Player Kill Time',
+            layer: 'Layer',
+            layer_name: 'Layer Name',
+            level: 'Level',
+            level_id: 'Level ID',
+            level_owner: 'Level Owner',
+            level_set: 'Level Set',
+            level_set_id: 'Level Set ID',
+            levels_set_id: 'Levels Set ID',
+            limit_per_item: 'Limit Per Item',
+            locale: 'Locale',
+            locale_id: 'Locale ID',
+            login_count: 'Login Count',
+            login_date: 'Login Date',
+            logout_date: 'Logout Date',
+            map_filename: 'Map Filename',
+            marker_key: 'Marker Key',
+            maxProperty: 'Max Property',
+            maxValue: 'Max Value',
+            message: 'Message',
+            message_time: 'Message Time',
+            message_type: 'Message Type',
+            magnitude: 'Magnitude',
+            minProperty: 'Min Property',
+            minValue: 'Min Value',
+            modifier_id: 'Modifier ID',
+            name: 'Name',
+            next_room_id: 'Next Room ID',
+            npcs_kills_count: 'NPCs Kills Count',
+            objectHeight: 'Object Height',
+            objectWidth: 'Object Width',
+            object_asset_id: 'Object Asset ID',
+            object_class_key: 'Object Class Key',
+            object_id: 'Object ID',
+            obtained_score: 'Obtained Score',
+            operation: 'Operation',
+            owner_id: 'Owner ID',
+            parent_group: 'Parent Group',
+            parent_skill: 'Parent Skill',
+            path: 'Path',
+            password: 'Password',
+            player_id: 'Player ID',
+            played_time: 'Played Time',
+            players_kill_count: 'Players Kills Count',
+            players_kills_count: 'Players Kills Count',
+            points: 'Points',
+            position: 'Position',
+            position_bottom: 'Position Bottom',
+            position_left: 'Position Left',
+            position_right: 'Position Right',
+            position_top: 'Position Top',
+            private_params: 'Private Params',
+            private_player_id: 'Private Player ID',
+            property_key: 'Property Key',
+            provider_id: 'Provider ID',
+            qty: 'Qty',
+            qty_limit: 'Qty Limit',
+            range: 'Range',
+            rangeAutomaticValidation: 'Range Automatic Validation',
+            rangePropertyX: 'Range Property X',
+            rangePropertyY: 'Range Property Y',
+            rangeTargetPropertyX: 'Range Target Property X',
+            rangeTargetPropertyY: 'Range Target Property Y',
+            remaining_uses: 'Remaining Uses',
+            required_experience: 'Required Experience',
+            required_item_key: 'Required Item Key',
+            required_quantity: 'Required Quantity',
+            respawn_time: 'Respawn Time',
+            replay: 'Replay',
+            reward_item_is_required: 'Reward Item Is Required',
+            reward_item_key: 'Reward Item Key',
+            reward_quantity: 'Reward Quantity',
+            rewards_events_id: 'Rewards Events ID',
+            role_id: 'Role ID',
+            room_class_key: 'Room Class Key',
+            room_id: 'Room ID',
+            scene_images: 'Scene Images',
+            scope: 'Scope',
+            server_url: 'Server URL',
+            show_in_general: 'Show In General',
+            show_tab: 'Show Tab',
+            single_audio: 'Single Audio',
+            skill: 'Skill',
+            skillDelay: 'Skill Delay',
+            skill_id: 'Skill ID',
+            sort: 'Sort',
+            start: 'Start',
+            started_at: 'Started At',
+            state: 'State',
+            stat_id: 'Stat ID',
+            status: 'Status',
+            target_id: 'Target ID',
+            target_key: 'Target Key',
+            target_label: 'Target Label',
+            tile_index: 'Tile Index',
+            title: 'Title',
+            top: 'Top',
+            total_score: 'Total Score',
+            type: 'Type',
+            type_id: 'Type ID',
+            updated_at: 'Updated At',
+            useTimeOut: 'Use Time Out',
+            user_id: 'User ID',
+            username: 'Username',
+            usesLimit: 'Uses Limit',
+            uses_limit: 'Uses Limit',
+            validateTargetOnHit: 'Validate Target On Hit',
+            value: 'Value',
+            was_given: 'Was Given',
+            width: 'Width',
+            x: 'X',
+            y: 'Y'
+        };
+        for(let i of Object.keys(translations)){
+            if(!adminTranslations[i]){
+                adminTranslations[i] = {};
+            }
+            Object.assign(adminTranslations[i], translations[i]);
+        }
+        return adminTranslations;
+    }
+
+}
+
+module.exports.AdminTranslations = AdminTranslations;

package/lib/installer.js

@@ -0,0 +1,283 @@
+/**
+ *
+ * Reldens - CMS - Installer
+ *
+ */
+
+const { FileHandler, Encryptor } = require('@reldens/server-utils');
+const { DriversMap, EntitiesGenerator, PrismaSchemaGenerator } = require('@reldens/storage');
+const { Logger, sc } = require('@reldens/utils');
+const mustache = require('mustache');
+
+class Installer
+{
+
+    constructor(props)
+    {
+        this.app = sc.get(props, 'app', false);
+        this.appServerFactory = sc.get(props, 'appServerFactory', false);
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.encoding = sc.get(props, 'encoding', 'utf8');
+        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');
+    }
+
+    isInstalled()
+    {
+        return FileHandler.exists(this.installLockPath);
+    }
+
+    async prepareSetup(app, appServerFactory)
+    {
+        if(!app){
+            Logger.error('Missing app on prepareSetup for Installer.');
+            return false;
+        }
+        if(!appServerFactory){
+            Logger.error('Missing appServerFactory on prepareSetup for Installer.');
+            return false;
+        }
+        this.app = app;
+        this.appServerFactory = appServerFactory;
+        app.use('/install-assets', appServerFactory.applicationFramework.static(this.installerPath, {index: false}));
+        app.use(appServerFactory.session({
+            secret: Encryptor.generateSecretKey(),
+            resave: true,
+            saveUninitialized: true
+        }));
+        app.use(async (req, res, next) => {
+            return await this.executeForEveryRequest(req, res, next);
+        });
+        app.post('/install', async (req, res) => {
+            return await this.executeInstallProcess(req, res);
+        });
+        return true;
+    }
+
+    async executeForEveryRequest(req, res, next)
+    {
+        if(this.isInstalled()){
+            return next();
+        }
+        if('' === req._parsedUrl.pathname || '/' === req._parsedUrl.pathname){
+            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, {
+                encoding: this.encoding
+            });
+            return res.send(mustache.render(content, req.session?.templateVariables || this.fetchDefaults()));
+        }
+        next();
+    }
+
+    async executeInstallProcess(req, res)
+    {
+        if(this.isInstalled()){
+            return res.redirect('/?redirect=already-installed');
+        }
+        let templateVariables = req.body;
+        req.session.templateVariables = templateVariables;
+        let selectedDriver = templateVariables['db-storage-driver'];
+        let driverClass = DriversMap[selectedDriver];
+        if(!driverClass){
+            Logger.error('Invalid storage driver: ' + selectedDriver);
+            return res.redirect('/?error=invalid-driver');
+        }
+        let dbConfig = {
+            client: templateVariables['db-client'],
+            config: {
+                host: templateVariables['db-host'],
+                port: Number(templateVariables['db-port']),
+                database: templateVariables['db-name'],
+                user: templateVariables['db-username'],
+                password: templateVariables['db-password'],
+                multipleStatements: true
+            },
+            debug: false
+        };
+        if('prisma' === selectedDriver){
+            await this.generatePrismaSchema(dbConfig);
+            Logger.info('Generated Prisma schema.');
+        }
+        let dbDriver = new driverClass(dbConfig);
+        if(!await dbDriver.connect()){
+            Logger.error('Connection failed');
+            return res.redirect('/?error=connection-failed');
+        }
+        if(!sc.isObjectFunction(dbDriver, 'rawQuery')){
+            Logger.error('Method "rawQuery" not found');
+            return res.redirect('/?error=raw-query-not-found');
+        }
+        let installSqlPath = FileHandler.joinPaths(this.migrationsPath, 'install.sql');
+        if(!FileHandler.exists(installSqlPath)){
+            Logger.error('SQL installation file not found');
+            return res.redirect('/?error=sql-file-not-found');
+        }
+        await this.executeQueryFile(dbDriver, installSqlPath);
+        Logger.info('Installed tables.');
+        let defaultUserSqlPath = FileHandler.joinPaths(this.migrationsPath, 'default-user.sql');
+        try {
+            if(FileHandler.exists(defaultUserSqlPath)){
+                await this.executeQueryFile(dbDriver, defaultUserSqlPath);
+                Logger.info('Created default user.');
+            }
+            let connectionData = {
+                client: dbConfig.client,
+                connection: dbConfig.config
+            };
+            await this.generateEntities(connectionData);
+            Logger.info('Generated entities.');
+        } catch (error) {
+            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();
+            Logger.info('Installation successful!');
+            let adminPath = templateVariables['app-admin-path'];
+            return res.redirect(adminPath);
+        } catch (error) {
+            Logger.error('Configuration error: '+error.message);
+            return res.redirect('/?error=configuration-error');
+        }
+    }
+
+    async executeQueryFile(dbDriver, filePath)
+    {
+        let sqlContent = FileHandler.readFile(filePath, {
+            encoding: this.encoding
+        });
+        if(!sqlContent){
+            throw new Error('Could not read SQL file: '+filePath);
+        }
+        return await dbDriver.rawQuery(sqlContent.toString());
+    }
+
+    async generateEntities(connectionData)
+    {
+        let generator = new EntitiesGenerator({connectionData: connectionData, projectPath: this.projectRoot});
+        let success = await generator.generate();
+        if(!success){
+            Logger.error('Entities generation failed.');
+            return false;
+        }
+        Logger.info('Entities generation success.');
+        return true;
+    }
+
+    async generatePrismaSchema(connectionData)
+    {
+        let generator = new PrismaSchemaGenerator({
+            ...connectionData,
+            prismaSchemaPath: this.projectRoot+'/prisma'
+        });
+        let success = await generator.generate();
+        if(!success){
+            Logger.error('Prisma schema generation failed.');
+            return false;
+        }
+        return true;
+    }
+
+    async createEnvFile(templateVariables)
+    {
+        let envTemplatePath = FileHandler.joinPaths(this.defaultTemplatesPath, '.env.dist');
+        if(!FileHandler.exists(envTemplatePath)){
+            Logger.error('ENV template not found: '+envTemplatePath);
+            return false;
+        }
+        let envTemplate = FileHandler.readFile(envTemplatePath, {
+            encoding: this.encoding
+        });
+        let envContent = mustache.render(envTemplate, {
+            dbClient: templateVariables['db-client'],
+            dbHost: templateVariables['db-host'],
+            dbPort: templateVariables['db-port'],
+            dbName: templateVariables['db-name'],
+            dbUser: templateVariables['db-username'],
+            dbPassword: templateVariables['db-password'],
+            dbDriver: templateVariables['db-storage-driver'],
+            adminPath: templateVariables['app-admin-path'],
+            adminSecret: Encryptor.generateSecretKey(),
+            host: templateVariables['app-host'] || 'http://localhost',
+            port: templateVariables['app-port'] || '3000'
+        });
+        return FileHandler.writeFile(this.envFilePath, envContent);
+    }
+
+    async createLockFile()
+    {
+        return FileHandler.writeFile(this.installLockPath,
+            'Installation completed on '+new Date().toISOString());
+    }
+
+    async prepareProjectDirectories()
+    {
+        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'));
+        }
+        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'));
+        }
+        return true;
+    }
+
+    fetchDefaults()
+    {
+        return {
+            'app-host': process.env.RELDENS_CMS_HOST || 'http://localhost',
+            'app-port': process.env.RELDENS_CMS_PORT || '3000',
+            'app-admin-path': process.env.RELDENS_CMS_ADMIN_PATH || '/reldens-admin',
+            'db-storage-driver': 'prisma',
+            'db-client': process.env.RELDENS_CMS_DB_CLIENT || 'mysql2',
+            'db-host': process.env.RELDENS_CMS_DB_HOST || 'localhost',
+            'db-port': process.env.RELDENS_CMS_DB_PORT || '3306',
+            'db-name': process.env.RELDENS_CMS_DB_NAME || 'reldens_cms',
+            'db-username': process.env.RELDENS_CMS_DB_USER || '',
+            'db-password': process.env.RELDENS_CMS_DB_PASSWORD || ''
+        };
+    }
+}
+
+module.exports.Installer = Installer;