salix/loopback/common/models/loggable.js

const pick = require('object.pick');
const LoopBackContext = require('loopback-context');

module.exports = function(Self) {
    Self.setup = function() {
        Self.super_.setup.call(this);
    };

    Self.observe('after save', async function(ctx) {
        const loopBackContext = LoopBackContext.getCurrentContext();
        await logInModel(ctx, loopBackContext);
    });

    Self.observe('before save', async function(ctx) {
        const loopBackContext = LoopBackContext.getCurrentContext();
        const models = ctx.Model.app.models;
        const definition = ctx.Model.definition;
        const Model = models[definition.name];
        const settings = definition.settings;
        let opts = ctx.options;
        if (!opts) opts = ctx.options = {};

        // Check for transactions
        let tx;
        if (!opts.transaction) {
            opts.transaction = tx = await Model.beginTransaction({});
            opts.tx = true;
        }

        try {
            // Check if grabUser is active
            if (loopBackContext && settings.log && settings.log.grabUser) {
                const userId = loopBackContext.active.accessToken.userId;
                const user = await models.Account.findById(userId, {fields: ['name']}, opts);
                await Model.rawSql(`CALL account.myUser_loginWithName(?)`, [user.name], opts);
            }

            let oldInstance;
            let newInstance;
            if (ctx.data) {
                const changes = pick(ctx.currentInstance, Object.keys(ctx.data));
                newInstance = ctx.data;
                oldInstance = changes;

                if (ctx.where && !ctx.currentInstance) {
                    const fields = Object.keys(ctx.data);

                    ctx.oldInstances = await Model.find({
                        where: ctx.where,
                        fields: fields
                    }, opts);
                }
            }

            // Get changes from created instance
            if (ctx.isNewInstance)
                newInstance = ctx.instance.__data;

            ctx.hookState.oldInstance = oldInstance;
            ctx.hookState.newInstance = newInstance;
        } catch (e) {
            if (tx) await tx.rollback();
            throw e;
        }
    });

    Self.observe('before delete', async function(ctx) {
        const models = ctx.Model.app.models;
        const definition = ctx.Model.definition;
        const relations = ctx.Model.relations;
        let opts = ctx.options;
        if (!opts) opts = ctx.options = {};

        if (ctx.where) {
            const affectedModel = definition.name;
            let deletedInstances = await models[affectedModel].find({
                where: ctx.where
            }, opts);

            const relation = definition.settings.log.relation;

            if (relation) {
                const primaryKey = relations[relation].keyFrom;

                let arrangedDeletedInstances = [];
                for (let i = 0; i < deletedInstances.length; i++) {
                    if (primaryKey)
                        deletedInstances[i].originFk = deletedInstances[i][primaryKey];
                    let arrangedInstance = await fkToValue(deletedInstances[i], ctx);
                    arrangedDeletedInstances[i] = arrangedInstance;
                }
                ctx.hookState.oldInstance = arrangedDeletedInstances;
            }
        }
    });

    Self.observe('after delete', async function(ctx) {
        const loopBackContext = LoopBackContext.getCurrentContext();
        if (ctx.hookState.oldInstance) logDeletedInstances(ctx, loopBackContext);
    });

    async function logDeletedInstances(ctx, loopBackContext) {
        const models = ctx.Model.app.models;
        const definition = ctx.Model.definition;
        const settings = definition.settings;
        let opts = ctx.options;
        if (!opts) opts = ctx.options = {};

        ctx.hookState.oldInstance.forEach(async instance => {
            let userFk;
            if (loopBackContext)
                userFk = loopBackContext.active.accessToken.userId;

            const changedModelValue = settings.log.changedModelValue;
            const logRecord = {
                originFk: instance.originFk,
                userFk: userFk,
                action: 'delete',
                changedModel: definition.name,
                changedModelId: instance.id,
                changedModelValue: instance[changedModelValue],
                oldInstance: instance,
                newInstance: {}
            };

            delete instance.originFk;

            const logModel = settings.log.model;
            await models[logModel].create(logRecord, opts);
        });
    }

    // Get log values from a foreign key
    async function fkToValue(instance, ctx) {
        const models = ctx.Model.app.models;
        const relations = ctx.Model.relations;
        let opts = ctx.options;
        if (!opts) opts = ctx.options = {};

        const instanceCopy = JSON.parse(JSON.stringify(instance));
        const result = {};
        for (const key in instanceCopy) {
            let value = instanceCopy[key];

            if (value instanceof Object || value === undefined)
                continue;

            if (value) {
                for (const relationName in relations) {
                    const relation = relations[relationName];
                    if (relation.keyFrom == key && key != 'id') {
                        const model = relation.modelTo;
                        const modelName = relation.modelTo.modelName;
                        const properties = model && model.definition.properties;
                        const settings = model && model.definition.settings;

                        const recordSet = await models[modelName].findById(value, null, opts);

                        const hasShowField = settings.log && settings.log.showField;
                        let showField = hasShowField && recordSet
                            && recordSet[settings.log.showField];

                        if (!showField) {
                            const showFieldNames = [
                                'name',
                                'description',
                                'code',
                                'nickname'
                            ];
                            for (field of showFieldNames) {
                                const propField = properties && properties[field];
                                const recordField = recordSet && recordSet[field];

                                if (propField && recordField) {
                                    showField = field;
                                    break;
                                }
                            }
                        }

                        if (showField && recordSet && recordSet[showField]) {
                            value = recordSet[showField];
                            break;
                        }

                        value = recordSet && recordSet.id || value;
                        break;
                    }
                }
            }
            result[key] = value;
        }
        return result;
    }

    async function logInModel(ctx, loopBackContext) {
        const models = ctx.Model.app.models;
        const definition = ctx.Model.definition;
        const Model = models[definition.name];
        const settings = ctx.Model.definition.settings;
        const relations = ctx.Model.relations;

        let opts = ctx.options;
        if (!opts) opts = ctx.options = {};

        // Check for transactions
        let tx;
        if (opts.tx === true) tx = opts.transaction;

        try {
            let primaryKey;
            for (let property in definition.properties) {
                if (definition.properties[property].id) {
                    primaryKey = property;
                    break;
                }
            }

            if (!primaryKey) throw new Error('Primary key not found');
            let originId;

            // RELATIONS LOG
            let changedModelId;

            if (ctx.instance && !settings.log.relation) {
                originId = ctx.instance.id;
                changedModelId = ctx.instance.id;
            } else if (settings.log.relation) {
                primaryKey = relations[settings.log.relation].keyFrom;

                if (ctx.where && ctx.where[primaryKey])
                    originId = ctx.where[primaryKey];
                else if (ctx.instance) {
                    originId = ctx.instance[primaryKey];
                    changedModelId = ctx.instance.id;
                }
            } else {
                originId = ctx.currentInstance.id;
                changedModelId = ctx.currentInstance.id;
            }

            // Sets the changedModelValue to save and the instances changed in case its an updateAll
            let showField = settings.log.showField;
            let where;
            if (showField && (!ctx.instance || !ctx.instance[showField]) && ctx.where) {
                changedModelId = [];
                where = [];
                let changedInstances = await models[definition.name].find({
                    where: ctx.where,
                    fields: ['id', showField, primaryKey]
                }, opts);

                changedInstances.forEach(element => {
                    where.push(element[showField]);
                    changedModelId.push(element.id);
                    originId = element[primaryKey];
                });
            } else if (ctx.hookState.oldInstance)
                where = ctx.instance[showField];

            // Set oldInstance, newInstance, userFk and action
            let oldInstance = {};
            if (ctx.hookState.oldInstance)
                Object.assign(oldInstance, ctx.hookState.oldInstance);

            let newInstance = {};
            if (ctx.hookState.newInstance)
                Object.assign(newInstance, ctx.hookState.newInstance);

            let userFk;
            if (loopBackContext)
                userFk = loopBackContext.active.accessToken.userId;

            const action = setActionType(ctx);

            removeUnloggable(definition, oldInstance);
            removeUnloggable(definition, newInstance);

            oldInstance = await fkToValue(oldInstance, ctx);
            newInstance = await fkToValue(newInstance, ctx);

            // Prevent log with no new changes
            const hasNewChanges = Object.keys(newInstance).length;
            if (!hasNewChanges) return;

            let logRecord = {
                originFk: originId,
                userFk: userFk,
                action: action,
                changedModel: definition.name,
                changedModelId: changedModelId, // Model property with an different data type will throw a NaN error
                changedModelValue: where,
                oldInstance: oldInstance,
                newInstance: newInstance
            };

            const logsToSave = setLogsToSave(where, changedModelId, logRecord, ctx);
            const logModel = settings.log.model;
            await models[logModel].create(logsToSave, opts);

            // Check if grabUser is active
            if (settings.log && settings.log.grabUser) await Model.rawSql(`CALL account.myUser_logout()`, null, opts);
            if (tx) {
                await tx.commit();
                delete opts.transaction;
                delete opts.tx;
            }
        } catch (e) {
            if (tx) await tx.rollback();
            throw e;
        }
    }

    /**
     * Removes unwanted properties
     * @param {*} definition Model definition
     * @param {*} properties Modified object properties
     */
    function removeUnloggable(definition, properties) {
        const objectCopy = Object.assign({}, properties);
        const propList = Object.keys(objectCopy);
        const propDefs = new Map();

        for (let property in definition.properties) {
            const propertyDef = definition.properties[property];
            propDefs.set(property, propertyDef);
        }

        for (let property of propList) {
            const propertyDef = propDefs.get(property);
            const firstChar = property.substring(0, 1);
            const isPrivate = firstChar == '$';

            if (isPrivate || !propertyDef)
                delete properties[property];

            if (!propertyDef) continue;

            if (propertyDef.log === false)
                delete properties[property];
            else if (propertyDef.logValue === false)
                properties[property] = null;
        }
    }

    // this function retuns all the instances changed in case this is an updateAll
    function setLogsToSave(changedInstances, changedInstancesIds, logRecord, ctx) {
        let promises = [];
        if (changedInstances && typeof changedInstances == 'object') {
            for (let i = 0; i < changedInstances.length; i++) {
                logRecord.changedModelId = changedInstancesIds[i];
                logRecord.changedModelValue = changedInstances[i];
                if (ctx.oldInstances)
                    logRecord.oldInstance = ctx.oldInstances[i];
                promises.push(JSON.parse(JSON.stringify(logRecord)));
            }
        } else
            return logRecord;

        return promises;
    }

    function setActionType(ctx) {
        let oldInstance = ctx.hookState.oldInstance;
        let newInstance = ctx.hookState.newInstance;

        if (oldInstance && newInstance)
            return 'update';
        else if (!oldInstance && newInstance)
            return 'insert';

        return 'delete';
    }
};