@reldens/cms 0.21.0 → 0.23.0

package/install/index.html

@@ -101,6 +101,10 @@
                         <input type="checkbox" name="install-entity-access" id="install-entity-access" checked/>
                         <label for="install-entity-access">Install entity access control rules</label>
                     </div>
+                    <div class="input-box input-checkbox install-dynamic-forms">
+                        <input type="checkbox" name="install-dynamic-forms" id="install-dynamic-forms" checked/>
+                        <label for="install-dynamic-forms">Install dynamic forms system</label>
+                    </div>
                     <div class="input-box submit-container">
                         <input id="install-submit-button" type="submit" value="Install"/>
                         <img class="install-loading hidden" src="/install-assets/img/loading.gif"/>

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

@@ -461,7 +461,7 @@ class RouterContents
             }
         }
         return await this.adminContentsRender(
-            this.adminFilesContents.fields.view[this.propertyType(resourceProperty, templateType)],
+            this.adminFilesContents.fields.view[this.propertyType(resourceProperty, templateType, fieldValue)],
             {fieldName, fieldValue, fieldOriginalValue, target: ' target="_blank"'}
         );
     }
@@ -469,7 +469,7 @@ class RouterContents
     generatePropertyRenderedValueWithLabel(entity, propertyKey, resourceProperty)
     {
         let fieldValue = (0 === entity[propertyKey] ? '0' : entity[propertyKey] || '');
-        if(sc.isObject(fieldValue) && 'json' === resourceProperty.dbType){
+        if((sc.isObject(fieldValue) || sc.isArray(fieldValue)) && 'json' === resourceProperty.dbType){
             fieldValue = sc.toJsonString(fieldValue);
         }
         let fieldName = propertyKey;
@@ -512,7 +512,7 @@ class RouterContents
         if('null' === fieldValue){
             fieldValue = '';
         }
-        if(sc.isObject(fieldValue) && 'json' === resourceProperty.dbType){
+        if((sc.isObject(fieldValue) || sc.isArray(fieldValue)) && 'json' === resourceProperty.dbType){
             fieldValue = sc.toJsonString(fieldValue);
         }
         if('boolean' === resourceProperty.type){
@@ -562,7 +562,7 @@ class RouterContents
         return await relationEntityRepository.loadAll();
     }
 
-    propertyType(resourceProperty, templateType)
+    propertyType(resourceProperty, templateType, fieldValue)
     {
         let propertyType = sc.get(resourceProperty, 'type', 'text');
         if('reference' === propertyType && 'edit' === templateType){
@@ -573,11 +573,18 @@ class RouterContents
                 return 'file';
             }
             if('view' === templateType){
+                if(!fieldValue || '' === fieldValue){
+                    return 'text';
+                }
                 let multiple = resourceProperty.isArray ? 's' : '';
-                if('image' === resourceProperty.allowedTypes){
-                    return resourceProperty.allowedTypes + multiple;
+                let allowedTypes = sc.get(resourceProperty, 'allowedTypes', '');
+                if('' !== allowedTypes){
+                    let templateName = allowedTypes + multiple;
+                    if(sc.hasOwn(this.adminFilesContents.fields.view, templateName)){
+                        return templateName;
+                    }
                 }
-                if('text' === resourceProperty.allowedTypes){
+                if('text' === allowedTypes){
                     return 'link'+multiple
                 }
                 return 'text';

package/lib/dynamic-form-renderer.js

@@ -0,0 +1,228 @@
+/**
+ *
+ * Reldens - CMS - DynamicFormRenderer
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+
+class DynamicFormRenderer
+{
+
+    constructor(props)
+    {
+        this.renderEngine = sc.get(props, 'renderEngine', false);
+        this.getPartials = sc.get(props, 'getPartials', false);
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.templatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
+        this.defaultDomain = sc.get(props, 'defaultDomain', 'default');
+        this.loadedTemplates = {};
+        this.events = sc.get(props, 'events', false);
+        if(!this.events){
+            Logger.error('EventsManager not provided to DynamicFormRenderer - forms functionality disabled');
+            this.isDisabled = true;
+        }
+    }
+
+    async renderForm(formConfig, fieldsToRender, domain, req, attributes = {}, systemVariables = {}, enhancedData = {})
+    {
+        if(this.isDisabled){
+            return '';
+        }
+        await this.events.emit('reldens.dynamicFormRenderer.beforeFieldsRender', {
+            formConfig,
+            fieldsToRender,
+            domain,
+            req,
+            attributes,
+            systemVariables,
+            enhancedData
+        });
+        let formFields = await this.renderFormFields(fieldsToRender, domain, req);
+        await this.events.emit('reldens.dynamicFormRenderer.afterFieldsRender', {
+            formConfig,
+            fieldsToRender,
+            formFields,
+            domain,
+            req,
+            attributes,
+            systemVariables,
+            enhancedData
+        });
+        let formTemplate = await this.loadFormTemplate('form', domain);
+        if(!formTemplate){
+            Logger.error('Form template not found');
+            return '';
+        }
+        let messageData = this.parseFormMessages(req, attributes);
+        return this.renderEngine.render(formTemplate, Object.assign({}, enhancedData, {
+            formKey: formConfig.form_key,
+            formFields,
+            submitUrl: sc.get(attributes, 'submitUrl', '/dynamic-form'),
+            successRedirect: sc.get(attributes, 'successRedirect', '/'),
+            errorRedirect: sc.get(attributes, 'errorRedirect', '/'),
+            honeypotFieldName: sc.get(attributes, 'honeypotFieldName', 'website_url'),
+            submitButtonText: sc.get(attributes, 'submitButtonText', 'Submit'),
+            cssClass: sc.get(attributes, 'cssClass', 'dynamic-form'),
+            showSuccessMessage: messageData.showSuccessMessage,
+            successMessage: messageData.successMessage,
+            showErrorMessage: messageData.showErrorMessage,
+            errorMessage: messageData.errorMessage,
+            systemVariables
+        }), this.getPartialsForDomain(domain));
+    }
+
+    parseFormMessages(req, attributes)
+    {
+        let queryParams = sc.get(req, 'query', {});
+        let formSuccess = sc.get(queryParams, 'form-success', '');
+        let formError = sc.get(queryParams, 'form-error', '');
+        let formKey = sc.get(queryParams, 'form-key', '');
+        let showSuccessMessage = '1' === formSuccess && '' !== formKey;
+        let showErrorMessage = '' !== formError && '' !== formKey;
+        let successMessage = sc.get(attributes, 'successMessage', 'Form submitted successfully!');
+        let errorMessage = sc.get(attributes, 'errorMessage', formError || 'There was an error submitting the form.');
+        return {
+            showSuccessMessage,
+            successMessage,
+            showErrorMessage,
+            errorMessage
+        };
+    }
+
+    async renderFormFields(fieldsToRender, domain, req, submittedValues = {}, errors = {})
+    {
+        if(!sc.isArray(fieldsToRender) || 0 === fieldsToRender.length){
+            return '';
+        }
+        let renderedFields = '';
+        for(let field of fieldsToRender){
+            if(!sc.isObject(field)){
+                continue;
+            }
+            let fieldHtml = await this.renderFormField(field, domain, submittedValues, errors);
+            if(fieldHtml){
+                renderedFields += fieldHtml;
+            }
+        }
+        return renderedFields;
+    }
+
+    async renderFormField(field, domain, submittedValues = {}, errors = {})
+    {
+        let fieldType = sc.get(field, 'type', 'text');
+        let fieldTemplate = await this.loadFormTemplate('field_'+fieldType, domain);
+        if(!fieldTemplate){
+            fieldTemplate = await this.loadFormTemplate('field_text', domain);
+        }
+        if(!fieldTemplate){
+            Logger.error('Field template not found for type: '+fieldType);
+            return '';
+        }
+        return this.renderEngine.render(
+            fieldTemplate,
+            this.buildFieldTemplateData(field, submittedValues, errors),
+            this.getPartialsForDomain(domain)
+        );
+    }
+
+    buildFieldTemplateData(field, submittedValues = {}, errors = {})
+    {
+        let fieldName = sc.get(field, 'name', '');
+        let fieldType = sc.get(field, 'type', 'text');
+        let fieldLabel = sc.get(field, 'label', fieldName);
+        let fieldValue = sc.get(submittedValues, fieldName, sc.get(field, 'defaultValue', ''));
+        let isRequired = sc.get(field, 'required', false);
+        let fieldError = sc.get(errors, fieldName, '');
+        let options = sc.get(field, 'options', []);
+        if(sc.isArray(options)){
+            options = options.map(option => {
+                if(sc.isObject(option)){
+                    return {
+                        value: sc.get(option, 'value', ''),
+                        label: sc.get(option, 'label', sc.get(option, 'value', '')),
+                        selected: sc.get(option, 'value', '') === fieldValue
+                    };
+                }
+                return {
+                    value: option,
+                    label: option,
+                    selected: option === fieldValue
+                };
+            });
+        }
+        return {
+            field,
+            fieldName,
+            fieldType,
+            fieldLabel,
+            fieldValue,
+            isRequired,
+            fieldError,
+            hasError: '' !== fieldError,
+            requiredClass: isRequired ? 'required' : '',
+            errorClass: '' !== fieldError ? 'error' : '',
+            options,
+            placeholder: sc.get(field, 'placeholder', ''),
+            helpText: sc.get(field, 'helpText', ''),
+            maxLength: sc.get(field, 'maxLength', ''),
+            pattern: sc.get(field, 'pattern', ''),
+            min: sc.get(field, 'min', ''),
+            max: sc.get(field, 'max', ''),
+            step: sc.get(field, 'step', '')
+        };
+    }
+
+    async loadFormTemplate(templateName, domain)
+    {
+        let cacheKey = templateName+'_'+domain;
+        if(sc.hasOwn(this.loadedTemplates, cacheKey)){
+            return this.loadedTemplates[cacheKey];
+        }
+        let templatePath = this.findFormTemplate(templateName, domain);
+        if(!templatePath){
+            Logger.warning('Form template not found: '+templateName+' for domain: '+domain);
+            return false;
+        }
+        let templateContent = await FileHandler.readFile(templatePath);
+        if(!templateContent){
+            Logger.error('Failed to read form template: '+templatePath);
+            return false;
+        }
+        this.loadedTemplates[cacheKey] = templateContent;
+        return templateContent;
+    }
+
+    findFormTemplate(templateName, domain)
+    {
+        let filename = templateName+'.html';
+        let domainTemplatePath = FileHandler.joinPaths(this.templatesPath, 'domains', domain, 'cms_forms', filename);
+        if(FileHandler.exists(domainTemplatePath)){
+            return domainTemplatePath;
+        }
+        if(this.defaultDomain && domain !== this.defaultDomain){
+            let defaultDomainPath = FileHandler.joinPaths(this.templatesPath, 'domains', this.defaultDomain, 'cms_forms', filename);
+            if(FileHandler.exists(defaultDomainPath)){
+                return defaultDomainPath;
+            }
+        }
+        let rootTemplatePath = FileHandler.joinPaths(this.templatesPath, 'cms_forms', filename);
+        if(FileHandler.exists(rootTemplatePath)){
+            return rootTemplatePath;
+        }
+        return false;
+    }
+
+    getPartialsForDomain(domain)
+    {
+        if(!this.getPartials){
+            Logger.error('getPartials function not provided to DynamicFormRenderer');
+            return {};
+        }
+        return this.getPartials(domain);
+    }
+
+}
+
+module.exports.DynamicFormRenderer = DynamicFormRenderer;

package/lib/dynamic-form-request-handler.js

@@ -0,0 +1,135 @@
+/**
+ *
+ * Reldens - CMS - DynamicFormRequestHandler
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class DynamicFormRequestHandler
+{
+
+    constructor(props)
+    {
+        this.dynamicForm = sc.get(props, 'dynamicForm', false);
+        this.contentRenderer = sc.get(props, 'contentRenderer', false);
+        this.requestProcessor = sc.get(props, 'requestProcessor', false);
+        this.cacheManager = sc.get(props, 'cacheManager', false);
+        this.enableJsonResponse = sc.get(props, 'enableJsonResponse', false);
+        this.events = sc.get(props, 'events', false);
+        if(!this.events){
+            Logger.error('EventsManager not provided to DynamicFormRequestHandler - forms functionality disabled');
+            this.isDisabled = true;
+        }
+    }
+
+    async handleFormSubmission(req, res)
+    {
+        if(this.isDisabled){
+            return this.handleBadRequest(res, 'Forms functionality disabled');
+        }
+        try {
+            let formKey = sc.get(req.body, 'formKey', '');
+            let submittedValues = sc.get(req.body, 'submittedValues', {});
+            if(!formKey || !submittedValues){
+                return this.handleBadRequest(res, 'Missing formKey or submittedValues');
+            }
+            await this.events.emit('reldens.dynamicFormRequestHandler.beforeValidation', {
+                formKey,
+                submittedValues,
+                req,
+                res
+            });
+            let validation = await this.dynamicForm.validateFormSubmission(formKey, submittedValues, req);
+            if(!validation.isValid){
+                return this.handleValidationError(req, res, validation.error, formKey);
+            }
+            let preparedValues = this.dynamicForm.prepareSubmittedValues(
+                submittedValues,
+                validation.formConfig.fields_schema
+            );
+            await this.events.emit('reldens.dynamicFormRequestHandler.beforeSave', {
+                formKey,
+                preparedValues,
+                formConfig: validation.formConfig,
+                req,
+                res
+            });
+            let submissionResult = await this.dynamicForm.saveFormSubmission(
+                validation.formConfig,
+                preparedValues
+            );
+            if(!submissionResult){
+                return this.handleValidationError(req, res, 'Failed to save form submission', formKey);
+            }
+            await this.events.emit('reldens.dynamicFormRequestHandler.afterSave', {
+                formKey,
+                submissionResult,
+                formConfig: validation.formConfig,
+                req,
+                res
+            });
+            return this.handleSuccessResponse(req, res, formKey, submissionResult);
+        } catch(error) {
+            Logger.error('Form submission handling error: '+error.message);
+            return this.handleBadRequest(res, 'Internal server error');
+        }
+    }
+
+    handleBadRequest(res, message)
+    {
+        if(this.enableJsonResponse){
+            return res.status(400).json({
+                success: false,
+                error: message
+            });
+        }
+        return res.status(400).send('Bad Request: '+message);
+    }
+
+    handleValidationError(req, res, error, formKey)
+    {
+        if(this.enableJsonResponse){
+            return res.status(400).json({
+                success: false,
+                error: error,
+                formKey: formKey
+            });
+        }
+        return res.redirect(this.buildErrorRedirectPath(req, error, formKey));
+    }
+
+    handleSuccessResponse(req, res, formKey, submissionResult)
+    {
+        if(this.enableJsonResponse){
+            return res.json({
+                success: true,
+                message: 'Form submitted successfully',
+                formKey: formKey,
+                submissionId: submissionResult.id
+            });
+        }
+        return res.redirect(this.buildSuccessRedirectPath(sc.get(req.body, 'successRedirect', '/'), formKey));
+    }
+
+    buildErrorRedirectPath(req, error, formKey)
+    {
+        let baseRedirect = sc.get(req.body, 'errorRedirect', '/');
+        let finalRedirect = sc.get(req.headers, 'referer', baseRedirect) || baseRedirect;
+        return finalRedirect
+            +(finalRedirect.includes('?') ? '&' : '?')
+            +'form-error='+encodeURIComponent(error)
+            +'&form-key='+encodeURIComponent(formKey);
+    }
+
+    buildSuccessRedirectPath(successRedirect, formKey)
+    {
+        return successRedirect
+            +(successRedirect.includes('?') ? '&' : '?')
+            +'form-success=1'
+            +'&form-key='+encodeURIComponent(formKey);
+    }
+
+}
+
+module.exports.DynamicFormRequestHandler = DynamicFormRequestHandler;