hof 22.8.4 → 22.9.0-beta

package/package/components/combine-and-loop-fields/index.js

@@ -0,0 +1,156 @@
+
+const _ = require('lodash');
+const uuid = require('uuid').v1;
+const path = require('path');
+const express = require('express');
+
+module.exports = config => {
+  const { returnTo, groupName, fieldsToGroup, combineValuesToSingleField, removePrefix, groupOptional } = config;
+
+  if (removePrefix && typeof removePrefix !== 'string') {
+    throw new Error('removePrefix is a string and is optional for loops');
+  }
+
+  if (combineValuesToSingleField && typeof combineValuesToSingleField !== 'string') {
+    throw new Error('combineValuesToSingleField is a string and is optional for loops');
+  }
+
+  if (!returnTo || typeof returnTo !== 'string') {
+    throw new Error('returnTo is a string and is required for loops');
+  }
+
+  if (!groupName || typeof groupName !== 'string') {
+    throw new Error('groupName is a string and is required for loops');
+  }
+
+  if (!fieldsToGroup ||
+    !fieldsToGroup.length ||
+    !Array.isArray(fieldsToGroup) ||
+    _.some(fieldsToGroup, field => typeof field !== 'string')) {
+    throw new Error('fieldsToGroup is an array of strings and is required for loops');
+  }
+
+  return superclass => class extends superclass {
+    get(req, res, next) {
+      if (req.query.delete) {
+        const router = express.Router({ mergeParams: true });
+        router.use([
+          // eslint-disable-next-line no-underscore-dangle
+          this._configure.bind(this),
+          this.removeItem.bind(this),
+          this.reload.bind(this)
+        ]);
+        return router.handle(req, res, next);
+      }
+      return super.get(req, res, next);
+    }
+
+    getLoopFields(req) {
+      let loopedFields = _.pick(req.sessionModel.toJSON(), fieldsToGroup);
+
+      if (removePrefix) {
+        loopedFields = _.mapKeys(loopedFields, (value, key) => key.replace(removePrefix, ''));
+      }
+      return loopedFields;
+    }
+
+    removeItem(req, res, next) {
+      const id = req.query.delete;
+      const items = req.sessionModel.get(groupName).filter(item => item.id !== id);
+      req.sessionModel.set(groupName, items);
+      next();
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    reload(req, res, next) {
+      const items = req.sessionModel.get(groupName);
+      if (!items.length) {
+        req.sessionModel.set(`${groupName}-saved`, false);
+        fieldsToGroup.forEach(field => {
+          req.sessionModel.unset(field);
+        });
+      }
+
+      const target = (items.length || groupOptional) ? req.form.options.route : returnTo;
+      const action = req.params.action || '';
+      res.redirect(path.join(req.baseUrl, target, action));
+    }
+
+    configure(req, res, next) {
+      const field = `${groupName}-add-another`;
+      // add yes/no field
+      req.form.options.fields[field] = Object.assign({
+        mixin: 'radio-group',
+        validate: ['required'],
+        options: [
+          'yes', 'no'
+        ],
+        legend: {
+          className: 'visuallyhidden'
+        }
+      }, req.form.options.fieldSettings);
+
+      // add conditonal fork
+      req.form.options.forks = req.form.options.forks || [];
+      req.form.options.forks.push({
+        target: returnTo,
+        continueOnEdit: true,
+        condition: {
+          field: field,
+          value: 'yes'
+        }
+      });
+      next();
+    }
+
+    getValues(req, res, next) {
+      const fieldsGroup = req.sessionModel.get(groupName) || [];
+      const added = req.sessionModel.get(`${groupName}-saved`);
+      return super.getValues(req, res, (err, values) => {
+        if (err) {
+          return next(err);
+        }
+        if (!added) {
+          const fields = this.getLoopFields(req);
+          if (!_.isEmpty(fields)) {
+            const newField = Object.assign({id: uuid()}, fields);
+
+            if (combineValuesToSingleField) {
+              const combinedValues = _.filter(fieldsToGroup.map(field => req.sessionModel.get(field))).join(', ');
+              newField[combineValuesToSingleField] = combinedValues;
+            }
+
+            fieldsGroup.push(newField);
+            values[groupName] = fieldsGroup;
+            fieldsToGroup.forEach(field => req.sessionModel.unset(field));
+
+            req.sessionModel.set(groupName, fieldsGroup);
+            req.sessionModel.set(`${groupName}-saved`, true);
+          }
+        }
+        return next(null, values);
+      });
+    }
+
+    locals(req, res) {
+      const items = req.form.values[groupName] || [];
+      return Object.assign({}, super.locals(req, res), {
+        items,
+        hasItems: items.length > 0,
+        field: groupName
+      });
+    }
+
+    saveValues(req, res, next) {
+      // remove "yes" value from session so it is no pre-populated next time around
+      super.saveValues(req, res, err => {
+        const field = `${groupName}-add-another`;
+        if (req.form.values[field] === 'yes') {
+          req.sessionModel.unset(field);
+          req.sessionModel.set(`${groupName}-saved`, false);
+        }
+        next(err);
+      });
+    }
+  };
+};

package/package/components/date/fields.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports = key => ({
+  [`${key}-day`]: {
+    label: 'Day',
+    autocomplete: 'bday-day'
+  },
+  [`${key}-month`]: {
+    label: 'Month',
+    autocomplete: 'bday-month'
+  },
+  [`${key}-year`]: {
+    label: 'Year',
+    autocomplete: 'bday-year'
+  }
+});

package/package/components/date/index.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const _ = require('lodash');
+const path = require('path');
+const getFields = require('./fields');
+
+const TEMPLATE = path.resolve(__dirname, './templates/date.html');
+
+// utility function taking the req.body, fields and key,
+// returns a map of values in the format:
+// {
+//   day: '01',
+//   month: '01',
+//   year: '2017'
+// }
+const getParts = (body, fields, key) =>
+  _.mapKeys(_.pick(body, Object.keys(fields)), (value, fieldKey) =>
+    fieldKey.replace(`${key}-`, '')
+  );
+
+// accepts a date value in the format YYYY-MM-DD and fields config,
+// returns a map of key: value pairs for the intermedate fields
+const getPartsFromDate = (date, fields) =>
+  date.split('-')
+    .slice()
+    .reverse()
+    .reduce((obj, value, index) => Object.assign({}, obj, {
+      [fields[index]]: value
+    }), {});
+
+// preprend '0' if number is only a single digit
+const pad = num => num !== '' && num.length < 2 ? `0${num}` : num;
+
+const conditionalTranslate = (key, translate) => {
+  let result = translate(key);
+  if (result === key) {
+    result = null;
+  }
+  return result;
+};
+
+const getLegendClassName = field => field && field.legend && field.legend.className || '';
+const getIsPageHeading = field => field && field.isPageHeading || '';
+
+module.exports = (key, opts) => {
+  if (!key) {
+    throw new Error('Key must be passed to date component');
+  }
+  const options = opts || {};
+  const template = options.template ?
+    path.resolve(__dirname, options.template) :
+    TEMPLATE;
+  const fields = getFields(key);
+
+  options.validate = _.uniq(options.validate ? ['date'].concat(options.validate) : ['date']);
+
+  let dayOptional = !!options.dayOptional;
+  const monthOptional = !!options.monthOptional;
+
+  if (monthOptional) {
+    dayOptional = true;
+  }
+
+  // take the 3 date parts, padding or defaulting
+  // to '01' if applic, then create a date value in the
+  // format YYYY-MM-DD. Save to req.body for processing
+  const preProcess = (req, res, next) => {
+    const parts = getParts(req.body, fields, key);
+    if (_.some(parts, part => part !== '')) {
+      if (dayOptional && parts.day === '') {
+        parts.day = '01';
+      } else {
+        parts.day = pad(parts.day);
+      }
+      if (monthOptional && parts.month === '') {
+        parts.month = '01';
+      } else {
+        parts.month = pad(parts.month);
+      }
+      req.body[key] = `${parts.year}-${parts.month}-${parts.day}`;
+    }
+    next();
+  };
+
+  // defaultFormatters on the base controller replace '--' with '-' on the process step.
+  // This ensures having the correct number of hyphens, so values do not jump from year to month.
+  // This should only be done on a partially completed date field otherwise the validation messages break.
+  const postProcess = (req, res, next) => {
+    const value = req.form.values[key];
+    if (value) {
+      req.form.values[key] = req.body[key];
+    }
+    next();
+  };
+  // if date field is included in errorValues, extend
+  // errorValues with the individual components
+  const preGetErrors = (req, res, next) => {
+    const errorValues = req.sessionModel.get('errorValues');
+    if (errorValues && errorValues[key]) {
+      req.sessionModel.set('errorValues',
+        Object.assign({}, errorValues, getPartsFromDate(errorValues[key], Object.keys(fields)))
+      );
+    }
+    next();
+  };
+
+  // if date field has any validation error, also add errors
+  // for the three child components. null type as we don't want to show
+  // duplicate messages
+  const postGetErrors = (req, res, next) => {
+    const errors = req.sessionModel.get('errors');
+    if (errors && errors[key]) {
+      Object.assign(req.form.errors, Object.keys(fields).reduce((obj, field) =>
+        Object.assign({}, obj, { [field]: { type: null } })
+      , {}));
+    }
+    next();
+  };
+
+  // if date value is set, split its parts and assign to req.form.values.
+  // This is extended with errorValues if they are present
+  const postGetValues = (req, res, next) => {
+    const date = req.form.values[key];
+    if (date) {
+      Object.assign(
+        req.form.values,
+        getPartsFromDate(date, Object.keys(fields)),
+        req.sessionModel.get('errorValues') || {}
+      );
+    }
+    next();
+  };
+
+  // render the template to a string, assign the html output
+  // to the date field in res.locals.fields
+  const preRender = (req, res, next) => {
+    Object.assign(req.form.options.fields, _.mapValues(fields, (v, k) => {
+      const rawKey = k.replace(`${key}-`, '');
+      const labelKey = `fields.${key}.parts.${rawKey}`;
+      const label = req.translate(labelKey);
+      return Object.assign({}, v, {
+        label: label === labelKey ? v.label : label
+      });
+    }));
+    const legend = conditionalTranslate(`fields.${key}.legend`, req.translate);
+    const hint = conditionalTranslate(`fields.${key}.hint`, req.translate);
+    const legendClassName = getLegendClassName(options);
+    const isPageHeading = getIsPageHeading(options);
+    const error = req.form.errors && req.form.errors[key];
+    res.render(template, { key, legend, legendClassName, isPageHeading, hint, error }, (err, html) => {
+      if (err) {
+        next(err);
+      } else {
+        const field = res.locals.fields.find(f => f.key === key);
+        Object.assign(field, { html });
+        next();
+      }
+    });
+  };
+
+  // return config extended with hooks
+  return Object.assign({}, options, {
+    hooks: {
+      'pre-process': preProcess,
+      'post-process': postProcess,
+      'pre-getErrors': preGetErrors,
+      'post-getErrors': postGetErrors,
+      'post-getValues': postGetValues,
+      'pre-render': preRender
+    }
+  });
+};

package/package/components/date/templates/date.html

@@ -0,0 +1,20 @@
+<div class="govuk-form-group {{#error}}govuk-form-group--error{{/error}}">
+<fieldset id="{{key}}-group" class="govuk-fieldset{{#className}} {{className}}{{/className}}" role="group">
+  <legend class="govuk-fieldset__legend {{#isPageHeading}}govuk-fieldset__legend--l{{/isPageHeading}}{{#legendClassName}} {{legendClassName}}{{/legendClassName}}">
+    {{#isPageHeading}}<h1 class="govuk-fieldset__heading">{{/isPageHeading}}
+      {{legend}}
+    {{#isPageHeading}}</h1>{{/isPageHeading}}
+  </legend>
+    {{#hint}}
+      <span id="{{key}}-hint" class="govuk-hint">{{{hint}}}</span>
+    {{/hint}}
+    {{#error}}
+      <p id="{{key}}-error" class="govuk-error-message">
+        <span class="govuk-visually-hidden">Error:</span> {{error.message}}
+      </p>
+    {{/error}}
+  <div id="{{key}}" class="govuk-date-input">
+    {{#input-date}}{{key}}{{/input-date}}
+  </div>
+</fieldset>
+</div>

package/package/components/emailer/email-service.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const Hogan = require('hogan.js');
+const debug = require('debug')('hof:emailer');
+
+const Emailer = require('./emailer');
+
+module.exports = class EmailService {
+  constructor(opts) {
+    const options = opts || {};
+    this.layout = options.layout === undefined ? path.resolve(__dirname, './views/layout.html') : options.layout;
+    this.emailer = new Emailer(options);
+  }
+
+  send(r, b, s) {
+    let body = b;
+    let subject = s;
+    let recipient = r;
+
+    if (arguments.length === 1 && recipient.recipient) {
+      body = recipient.body;
+      subject = recipient.subject;
+      recipient = recipient.recipient;
+    }
+    return this.render(recipient, body, subject)
+      .then(content => this.emailer.send(recipient, subject, content));
+  }
+
+  render(recipient, body, subject) {
+    if (this.layout) {
+      return this.template()
+        .then(template => template.render({ recipient, body, subject }));
+    }
+    return Promise.resolve(body);
+  }
+
+  template() {
+    debug(`Reading template file: ${this.layout}`);
+    return new Promise((resolve, reject) => {
+      fs.readFile(this.layout, (err, content) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(Hogan.compile(content.toString('utf8')));
+        }
+      });
+    });
+  }
+};

package/package/components/emailer/emailer.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const path = require('path');
+const nodemailer = require('nodemailer');
+const transports = require('./transports');
+
+const debug = require('debug')('hof:emailer');
+
+module.exports = class Emailer {
+  constructor(opts) {
+    const options = opts || {};
+    this.options = options;
+
+    options.transport = options.transport || 'smtp';
+    debug(`Using ${options.transport} transport`);
+
+    if (options.transport !== 'stub' && !options.from && !options.replyTo) {
+      throw new Error('At least one of `from` or `replyTo` options must be defined');
+    }
+
+    const transport = transports[options.transport](options.transportOptions || {});
+
+    this.emailer = nodemailer.createTransport(transport);
+  }
+
+  send(to, subject, body) {
+    debug(`Sending email to ${to} with subject ${subject}`);
+    return new Promise((resolve, reject) => {
+      this.emailer.sendMail({
+        to,
+        subject,
+        from: this.options.from || this.options.replyTo,
+        replyTo: this.options.replyTo || this.options.from,
+        html: body,
+        attachments: [{
+          filename: 'govuk_logotype_email.png',
+          path: path.resolve(__dirname, './assets/images/govuk_logotype_email.png'),
+          cid: 'govuk_logotype_email'
+        },
+        {
+          filename: 'ho_crest_27px.png',
+          path: path.resolve(__dirname, './assets/images/ho_crest_27px.png'),
+          cid: 'ho_crest_27px'
+        },
+        {
+          filename: 'spacer.gif',
+          path: path.resolve(__dirname, './assets/images/spacer.gif'),
+          cid: 'spacer_image'
+        }]
+      }, (err, result) => err ? reject(err) : resolve(result));
+    });
+  }
+};

package/package/components/emailer/index.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const EmailService = require('./email-service');
+const Hogan = require('hogan.js');
+const fs = require('fs');
+const debug = require('debug')('hof:behaviour:emailer');
+
+module.exports = config => {
+  const emailer = new EmailService(config);
+  config.parse = config.parse || (data => data);
+
+  if (!config.recipient) {
+    throw new Error('hof-behaviour-emailer: email recipient must be defined');
+  }
+  if (typeof config.template !== 'string') {
+    throw new Error('hof-behaviour-emailer: email template must be defined');
+  }
+
+  return superclass => class EmailBehaviour extends superclass {
+    async successHandler(req, res, next) {
+      req.sessionModel.unset('nodemailer-error');
+
+      try {
+        debug(`Loading email template from ${config.template}`);
+
+        const template = await new Promise((resolve, reject) => {
+          return fs.readFile(config.template, (err, resolvedTemplate) => {
+            return err ? reject(err) : resolve(resolvedTemplate.toString('utf8'));
+          });
+        });
+
+        debug('Rendering email content');
+
+        const data = config.parse(req.sessionModel.toJSON(), req.translate);
+
+        debug('Building email settings');
+
+        const settings = { body: Hogan.compile(template).render(data) };
+
+        if (typeof config.recipient === 'function') {
+          settings.recipient = config.recipient(req.sessionModel.toJSON());
+        } else {
+          settings.recipient = req.sessionModel.get(config.recipient) || config.recipient;
+        }
+        if (typeof settings.recipient !== 'string' || !settings.recipient.includes('@')) {
+          return next(new Error('hof-behaviour-emailer: invalid recipient'));
+        }
+
+        if (typeof config.subject === 'function') {
+          settings.subject = config.subject(req.sessionModel.toJSON(), req.translate);
+        } else {
+          settings.subject = config.subject;
+        }
+
+        debug('Sending email', settings);
+
+        await emailer.send(settings);
+
+        debug('Email sent successfully');
+
+        return super.successHandler(req, res, next);
+      } catch (e) {
+        if (config.emailerFallback) {
+          req.log('error', e.message || e);
+          req.sessionModel.set('nodemailer-error', true);
+          return super.successHandler(req, res, next);
+        }
+        return next(e);
+      }
+    }
+  };
+};
+
+module.exports.EmailService = EmailService;

package/package/components/emailer/transports/debug.js

@@ -0,0 +1,74 @@
+/* eslint-disable max-len, no-console */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+
+const mimes = {
+  '.gif': 'image/gif',
+  '.png': 'image/png'
+};
+
+const mkdir = dir => new Promise((resolve, reject) => {
+  fs.mkdir(dir, {recursive: true}, err => err ? reject(err) : resolve());
+});
+
+const cidToBase64 = (h, attachments) => {
+  let html = h;
+  const list = attachments.reduce((p, attachment) => {
+    const mimeType = mimes[path.extname(attachment.path)];
+    return p
+      .then(map => new Promise((resolve, reject) => fs.readFile(attachment.path, (err, buffer) => err ? reject(err) : resolve(buffer.toString('base64'))))
+        .then(data => {
+          map[attachment.cid] = `"data:${mimeType};base64,${data}"`;
+          return map;
+        }));
+  }, Promise.resolve({}));
+
+  return list.then(files => {
+    Object.keys(files).forEach(cid => {
+      html = html.replace(`"cid:${cid}"`, files[cid]);
+    });
+    return html;
+  });
+};
+
+module.exports = options => {
+  options.log = options.log !== false;
+  return {
+    name: 'debug',
+    version: '1.0.0',
+    send: (mail, callback) => {
+      mail.resolveContent(mail.data, 'html', (err, html) => {
+        if (err) {
+          return callback(err);
+        }
+        const dir = options.dir || path.join(process.cwd(), '.emails');
+        const messageId = options.filename || mail.message.messageId().split('@')[0].slice(1);
+        const outfile = path.resolve(dir, `${messageId}.html`);
+
+        return mkdir(dir)
+          .then(() => cidToBase64(html, mail.data.attachments))
+          .then(inlined => new Promise((resolve, reject) => {
+            fs.writeFile(outfile, inlined, e => e ? reject(e) : resolve(inlined));
+          }))
+          .then(() => {
+            if (options.log) {
+              console.log('Email sent:');
+              console.log(`  to:      ${mail.data.to}`);
+              console.log(`  subject: ${mail.data.subject}`);
+              console.log(`  html:    ${outfile}`);
+            }
+          })
+          .then(() => {
+            if (options.open) {
+              cp.execSync(`open ${outfile}`);
+            }
+            callback();
+          })
+          .catch(callback);
+      });
+    }
+  };
+};

package/package/components/emailer/transports/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  smtp: require('./smtp'),
+  ses: require('./ses'),
+  stub: require('./stub'),
+  debug: require('./debug')
+};

package/package/components/emailer/transports/ses.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const ses = require('nodemailer-ses-transport');
+
+module.exports = options => {
+  if (!options.accessKeyId) {
+    throw new Error('Required option `accessKeyId` not found.');
+  }
+  if (!options.secretAccessKey) {
+    throw new Error('Required option `secretAccessKey` not found.');
+  }
+
+  const opts = {
+    accessKeyId: options.accessKeyId,
+    secretAccessKey: options.secretAccessKey
+  };
+
+  opts.region = options.region || 'eu-west-1';
+
+  if (options.sessionToken) {
+    opts.sessionToken = options.sessionToken;
+  }
+
+  if (options.httpOptions) {
+    opts.httpOptions = options.httpOptions;
+  }
+
+  if (options.rateLimit !== undefined) {
+    opts.rateLimit = options.rateLimit;
+  }
+
+  if (options.maxConnections !== undefined) {
+    opts.maxConnections = options.maxConnections;
+  }
+  return ses(opts);
+};