mgm/controller/BaseController.js

My generic modules

require('../core');
const moment = require('moment');
const RuleException = require('../exception/RuleException');
const BaseEntity = require('../model/BaseEntity');
const ConfigController = require('./ConfigController');

let registeredConverters = [];
module.exports = class BaseController extends ConfigController {

    constructor() {
        super();
        this.listEntity = [];
        this.entity = this.newEntity();
        this.messages = [];
        this.registerConverters('DateConverter', 'StringConverter', 'IntegerConverter');
    }

    registerConverters(...names) {
        names.forEach(nameConverter => {
            if (registeredConverters.find(converter => { converter.getName() === nameConverter }) === undefined) {
                registeredConverters.push(require(`../converter/${nameConverter}`).newInstance());
            }
        });
    }

    getConverter(nameConverter) {
        let converter = registeredConverters.find(converter => converter.getName() === nameConverter);
        if (converter === undefined) {
            throw new Error(`The class ${this.constructor.name} has not registered the converter with name ${nameConverter}`);
        }
        return converter;
    }

    newEntity() {
        throw new Error(`The class ${this.constructor.name} must overwrite the method 'newEntity'`);
    }

    getRenderOptions() {
        throw new Error(`The class ${this.constructor.name} must overwrite the method 'getRenderOptions'`);
    }

    getIndex(listName) {
        return parseInt(this.json.indexes[listName + 'SelectedIndex'], 10);
    }

    doClear() {
        this.entity = this.newEntity();
        this.listEntity = [];
    }

    updateModel() {
        Object.keys(this.json.execute).forEach(key => {
            let paths = key.split("-");
            let dest = this;
            let path = paths.shift();

            while (paths.length > 0) {
                dest = dest[path];
                path = paths.shift();
            }

            dest[path] = this.getConverter(this.json.execute[key].converterName).convertToObject(this.json.execute[key].value);
        });
    }

    render(res, result) {
        res.setHeader('Content-Type', 'application/json');
        res.send(JSON.stringify(result));
    }

    renderResponse(req, res) {
        let result = {
            messages: [],
            messageType: '',
            render: []
        };

        this.json.render.forEach(info => {
            let paths = info.id.split("-");
            let source = this;
            let path = paths.shift();

            while (paths.length > 0) {
                source = source[path];
                path = paths.shift();
            }

            if (source[path] instanceof Array) {

                result.render.push({
                    id: info.id,
                    value: source[path]
                });

            } else {
                let convertedValue;

                if (info.converterName) {
                    convertedValue = this.getConverter(info.converterName).convertToString(source[path]);
                } else {
                    convertedValue = source[path];
                }

                result.render.push({
                    id: info.id,
                    value: convertedValue
                });
            }
        });

        this.render(res, result);
    }

    renderError(e, req, res) {
        let result = {
            messages: e.message.split(',')
        };

        if (e instanceof RuleException) {
            result['messageType'] = 'warn';
        } else {
            result['messageType'] = 'error';
        }
        console.error(e);
        this.render(res, result);
    }
};