Custom Forms

lib/helpers.js

@@ -1,12 +1,25 @@
 'use strict';
 
+let path = require('path');
+let fs = require('fs');
+let tools = require('./tools');
 let lists = require('./models/lists');
 let fields = require('./models/fields');
+let forms = require('./models/forms');
 let _ = require('./translate')._;
+let objectHash = require('object-hash');
+let mjml = require('mjml');
+let mjmlTemplates = new Map();
+let hbs = require('hbs');
 
 module.exports = {
     getDefaultMergeTags,
-    getListMergeTags
+    getListMergeTags,
+    captureFlashMessages,
+    injectCustomFormData,
+    injectCustomFormTemplates,
+    filterCustomFields,
+    getMjmlTemplate
 };
 
 function getDefaultMergeTags(callback) {
@@ -73,3 +86,166 @@ function getListMergeTags(listId, callback) {
         });
     });
 }
+
+function filterCustomFields(customFieldsIn = [], fieldIds = [], method = 'include') {
+    let customFields = customFieldsIn.slice();
+    fieldIds = typeof fieldIds === 'string' ? fieldIds.split(',') : fieldIds;
+
+    customFields.unshift({
+        id: 'email',
+        name: 'Email Address',
+        type: 'Email',
+        typeSubsciptionEmail: true
+    }, {
+        id: 'firstname',
+        name: 'First Name',
+        type: 'Text',
+        typeFirstName: true
+    }, {
+        id: 'lastname',
+        name: 'Last Name',
+        type: 'Text',
+        typeLastName: true
+    });
+
+    let filtered = [];
+
+    if (method === 'include') {
+        fieldIds.forEach(id => {
+            let field = customFields.find(f => f.id.toString() === id);
+            field && filtered.push(field);
+        });
+    } else {
+        customFields.forEach(field => {
+            !fieldIds.includes(field.id.toString()) && filtered.push(field);
+        });
+    }
+
+    return filtered;
+}
+
+function injectCustomFormData(customFormId, viewPath, data, callback) {
+
+    let injectDefaultData = data => {
+        data.customFields = filterCustomFields(data.customFields, [], 'exclude');
+        data.formInputStyle = '@import url(/subscription/form-input-style.css);';
+        return data;
+    };
+
+    if (Number(customFormId) < 1) {
+        return callback(null, injectDefaultData(data));
+    }
+
+    forms.get(customFormId, (err, form) => {
+        if (err) {
+            return callback(null, injectDefaultData(data));
+        }
+
+        let view = viewPath.split('/')[1];
+
+        if (view === 'web-subscribe') {
+            data.customFields = form.fieldsShownOnSubscribe
+                ? filterCustomFields(data.customFields, form.fieldsShownOnSubscribe)
+                : filterCustomFields(data.customFields, [], 'exclude');
+        } else if (view === 'web-manage') {
+            data.customFields = form.fieldsShownOnManage
+                ? filterCustomFields(data.customFields, form.fieldsShownOnManage)
+                : filterCustomFields(data.customFields, [], 'exclude');
+        }
+
+        let key = tools.fromDbKey(view);
+        data.template.template = form[key] || data.template.template;
+        data.template.layout = form.layout || data.template.layout;
+
+        data.formInputStyle = form.formInputStyle || '@import url(/subscription/form-input-style.css);';
+
+        callback(null, data);
+    });
+}
+
+function injectCustomFormTemplates(customFormId, templates, callback) {
+    if (Number(customFormId) < 1) {
+        return callback(null, templates);
+    }
+
+    forms.get(customFormId, (err, form) => {
+        if (err) {
+            return callback(null, templates);
+        }
+
+        let lookUp = name => {
+            let key = tools.fromDbKey(
+                /subscription\/([^.]*)/.exec(name)[1]
+            );
+            return form[key] || name;
+        };
+
+        Object.keys(templates).forEach(key => {
+            let value = templates[key];
+
+            if (typeof value === 'string') {
+                templates[key] = lookUp(value);
+            }
+            if (typeof value === 'object' && value.template) {
+                templates[key].template = lookUp(value.template);
+            }
+            if (typeof value === 'object' && value.layout) {
+                templates[key].layout = lookUp(value.layout);
+            }
+        });
+
+        callback(null, templates);
+    });
+}
+
+function getMjmlTemplate(template, callback) {
+    if (!template) {
+        return callback(null, false);
+    }
+
+    let key = (typeof template === 'object') ? objectHash(template) : template;
+
+    if (mjmlTemplates.has(key)) {
+        return callback(null, mjmlTemplates.get(key));
+    }
+
+    let done = source => {
+        let compiled;
+        try {
+            compiled = mjml.mjml2html(source);
+        } catch (err) {
+            return callback(err);
+        }
+        if (compiled.errors.length) {
+            return callback(compiled.errors[0].message || compiled.errors[0]);
+        }
+        let renderer = hbs.handlebars.compile(compiled.html);
+        mjmlTemplates.set(key, renderer);
+        callback(null, renderer);
+    };
+
+    if (typeof template === 'object') {
+        tools.mergeTemplateIntoLayout(template.template, template.layout, (err, source) => {
+            if (err) {
+                return callback(err);
+            }
+            done(source);
+        });
+    } else {
+        fs.readFile(path.join(__dirname, '..', 'views', template), 'utf-8', (err, source) => {
+            if (err) {
+                return callback(err);
+            }
+            done(source);
+        });
+    }
+}
+
+function captureFlashMessages(req, res, callback) {
+    res.render('subscription/capture-flash-messages', { layout: null }, (err, flash) => {
+        if (err) {
+            return callback(err);
+        }
+        callback(null, flash);
+    });
+}