375 lines
14 KiB
JavaScript
375 lines
14 KiB
JavaScript
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';
|
|
}
|
|
};
|