293 lines
9.2 KiB
JavaScript
293 lines
9.2 KiB
JavaScript
let request = require('request-promise-native');
|
|
let UserError = require('vn-loopback/util/user-error');
|
|
let getFinalState = require('vn-loopback/util/hook').getFinalState;
|
|
let isMultiple = require('vn-loopback/util/hook').isMultiple;
|
|
|
|
module.exports = Self => {
|
|
// Methods
|
|
require('../methods/client/activeWorkersWithRole')(Self);
|
|
require('../methods/client/getCard')(Self);
|
|
require('../methods/client/createWithUser')(Self);
|
|
require('../methods/client/listWorkers')(Self);
|
|
require('../methods/client/hasCustomerRole')(Self);
|
|
require('../methods/client/isValidClient')(Self);
|
|
require('../methods/client/addressesPropagateRe')(Self);
|
|
require('../methods/client/getDebt')(Self);
|
|
require('../methods/client/getMana')(Self);
|
|
require('../methods/client/getAverageInvoiced')(Self);
|
|
require('../methods/client/summary')(Self);
|
|
require('../methods/client/updateFiscalData')(Self);
|
|
require('../methods/client/getTransactions')(Self);
|
|
require('../methods/client/confirmTransaction')(Self);
|
|
require('../methods/client/canBeInvoiced')(Self);
|
|
require('../methods/client/uploadFile')(Self);
|
|
require('../methods/client/lastActiveTickets')(Self);
|
|
|
|
// Validations
|
|
|
|
Self.validatesPresenceOf('street', {
|
|
message: 'Street cannot be empty'
|
|
});
|
|
|
|
Self.validatesPresenceOf('city', {
|
|
message: 'City cannot be empty'
|
|
});
|
|
|
|
Self.validatesUniquenessOf('fi', {
|
|
message: 'TIN must be unique'
|
|
});
|
|
|
|
Self.validatesUniquenessOf('socialName', {
|
|
message: 'The company name must be unique'
|
|
});
|
|
|
|
Self.validatesFormatOf('email', {
|
|
message: 'Invalid email',
|
|
allowNull: true,
|
|
allowBlank: true,
|
|
with: /^[\w|.|-]+@[\w|-]+(\.[\w|-]+)*(,[\w|.|-]+@[\w|-]+(\.[\w|-]+)*)*$/
|
|
});
|
|
|
|
Self.validatesLengthOf('postcode', {
|
|
allowNull: true,
|
|
allowBlank: true,
|
|
min: 3, max: 10
|
|
});
|
|
|
|
Self.validateAsync('iban', ibanNeedsValidation, {
|
|
message: 'The IBAN does not have the correct format'
|
|
});
|
|
let validateIban = require('../validations/validateIban');
|
|
async function ibanNeedsValidation(err, done) {
|
|
let filter = {
|
|
fields: ['code'],
|
|
where: {id: this.countryFk}
|
|
};
|
|
let country = await Self.app.models.Country.findOne(filter);
|
|
let code = country ? country.code.toLowerCase() : null;
|
|
if (code != 'es')
|
|
return done();
|
|
|
|
if (!validateIban(this.iban))
|
|
err();
|
|
done();
|
|
}
|
|
|
|
Self.validateAsync('fi', tinIsValid, {
|
|
message: 'Invalid TIN'
|
|
});
|
|
|
|
let validateTin = require('../validations/validateTin');
|
|
async function tinIsValid(err, done) {
|
|
if (!this.isTaxDataChecked)
|
|
return done();
|
|
|
|
let filter = {
|
|
fields: ['code'],
|
|
where: {id: this.countryFk}
|
|
};
|
|
let country = await Self.app.models.Country.findOne(filter);
|
|
let code = country ? country.code.toLowerCase() : null;
|
|
|
|
if (!this.fi || !validateTin(this.fi, code))
|
|
err();
|
|
done();
|
|
}
|
|
|
|
Self.validate('payMethod', hasSalesMan, {
|
|
message: 'Cannot change the payment method if no salesperson'
|
|
});
|
|
|
|
function hasSalesMan(err) {
|
|
if (this.payMethod && !this.salesPerson)
|
|
err();
|
|
}
|
|
|
|
Self.validate('isEqualizated', cannotHaveET, {
|
|
message: 'Cannot check Equalization Tax in this NIF/CIF'
|
|
});
|
|
|
|
function cannotHaveET(err) {
|
|
let tin = this.fi.toUpperCase();
|
|
let cannotHaveET = /^[A-B]/.test(tin);
|
|
|
|
if (cannotHaveET && this.isEqualizated)
|
|
err();
|
|
}
|
|
|
|
Self.validateAsync('payMethodFk', hasIban, {
|
|
message: 'That payment method requires an IBAN'
|
|
});
|
|
|
|
function hasIban(err, done) {
|
|
Self.app.models.PayMethod.findById(this.payMethodFk, (_, instance) => {
|
|
if (instance && instance.ibanRequired && !this.iban)
|
|
err();
|
|
done();
|
|
});
|
|
}
|
|
|
|
Self.validateAsync('bankEntityFk', hasBic, {
|
|
message: 'That payment method requires a BIC'
|
|
});
|
|
|
|
function hasBic(err, done) {
|
|
if (this.iban && !this.bankEntityFk)
|
|
err();
|
|
done();
|
|
}
|
|
|
|
Self.validateAsync('defaultAddressFk', isActive,
|
|
{message: 'Unable to default a disabled consignee'}
|
|
);
|
|
|
|
async function isActive(err, done) {
|
|
if (!this.defaultAddressFk)
|
|
return done();
|
|
|
|
const address = await Self.app.models.Address.findById(this.defaultAddressFk);
|
|
if (address && !address.isActive) err();
|
|
done();
|
|
}
|
|
|
|
Self.validateBinded('socialName', isAlpha, {
|
|
message: 'Value has an invalid format'
|
|
});
|
|
|
|
function isAlpha(value) {
|
|
const regexp = new RegExp(/^[a-zA-Z\s]*$/);
|
|
|
|
return regexp.test(value);
|
|
}
|
|
|
|
Self.observe('before save', async function(ctx) {
|
|
let changes = ctx.data || ctx.instance;
|
|
let orgData = ctx.currentInstance;
|
|
let finalState = getFinalState(ctx);
|
|
let payMethodWithIban = 4;
|
|
|
|
if (changes.salesPerson === null) {
|
|
changes.credit = 0;
|
|
changes.discount = 0;
|
|
changes.payMethodFk = 5; // Credit card
|
|
}
|
|
|
|
let payMethodFk = changes.payMethodFk || (orgData && orgData.payMethodFk);
|
|
let dueDay = changes.dueDay || (orgData && orgData.dueDay);
|
|
|
|
if (payMethodFk == payMethodWithIban && dueDay == 0)
|
|
changes.dueDay = 5;
|
|
|
|
if (isMultiple(ctx)) return;
|
|
|
|
if (changes.credit !== undefined) {
|
|
await validateCreditChange(ctx, finalState);
|
|
let filter = {fields: ['id'], where: {userFk: ctx.options.accessToken.userId}};
|
|
let worker = await Self.app.models.Worker.findOne(filter);
|
|
|
|
let newCredit = {
|
|
amount: changes.credit,
|
|
clientFk: finalState.id,
|
|
workerFk: worker ? worker.id : null
|
|
};
|
|
await Self.app.models.ClientCredit.create(newCredit);
|
|
}
|
|
});
|
|
|
|
Self.observe('after save', async ctx => {
|
|
if (ctx.isNewInstance) return;
|
|
|
|
const hookState = ctx.hookState;
|
|
const newInstance = hookState.newInstance;
|
|
const oldInstance = hookState.oldInstance;
|
|
const instance = ctx.instance;
|
|
|
|
const payMethodChanged = oldInstance.payMethodFk != newInstance.payMethodFk;
|
|
const ibanChanged = oldInstance.iban != newInstance.iban;
|
|
const dueDayChanged = oldInstance.dueDay != newInstance.dueDay;
|
|
|
|
if (payMethodChanged || ibanChanged || dueDayChanged) {
|
|
const message = `La forma de pago del cliente con id ${instance.id} ha cambiado`;
|
|
const salesPersonFk = instance.salesPersonFk;
|
|
|
|
if (salesPersonFk) {
|
|
const salesPerson = await Self.app.models.Worker.findById(salesPersonFk);
|
|
await Self.app.models.Message.send(ctx, {
|
|
recipientFk: salesPerson.userFk,
|
|
message: message
|
|
});
|
|
}
|
|
|
|
const options = {
|
|
method: 'POST',
|
|
uri: 'http://127.0.0.1:3000/api/email/payment-update',
|
|
body: {
|
|
clientFk: instance.id
|
|
},
|
|
json: true
|
|
};
|
|
await request(options);
|
|
}
|
|
});
|
|
|
|
async function validateCreditChange(ctx, finalState) {
|
|
let models = Self.app.models;
|
|
let userId = ctx.options.accessToken.userId;
|
|
|
|
let currentUserIsManager = await models.Account.hasRole(userId, 'manager');
|
|
if (currentUserIsManager)
|
|
return;
|
|
|
|
let filter = {
|
|
fields: ['roleFk'],
|
|
where: {
|
|
maxAmount: {gt: ctx.data.credit}
|
|
}
|
|
};
|
|
|
|
let limits = await models.ClientCreditLimit.find(filter);
|
|
|
|
if (limits.length == 0)
|
|
throw new UserError('Credit limits not found');
|
|
|
|
// Si el usuario no tiene alguno de los roles no continua
|
|
|
|
let requiredRoles = [];
|
|
for (limit of limits)
|
|
requiredRoles.push(limit.roleFk);
|
|
|
|
let where = {
|
|
roleId: {inq: requiredRoles},
|
|
principalType: 'USER',
|
|
principalId: userId
|
|
};
|
|
let count = await models.RoleMapping.count(where);
|
|
|
|
if (count <= 0)
|
|
throw new UserError('The role cannot set this credit amount');
|
|
|
|
// Si se puso a 0 por gerencia, solo gerencia puede aumentarlo
|
|
|
|
let query = 'SELECT * FROM clientCredit WHERE clientFk = ? ORDER BY created DESC LIMIT 1';
|
|
let instances = await Self.rawSql(query, [finalState.id]);
|
|
|
|
if (instances.length !== 1 || instances[0].amount > 0)
|
|
return;
|
|
|
|
query = `
|
|
SELECT COUNT(*) AS hasRoleManager
|
|
FROM worker em
|
|
JOIN account.user ac ON ac.id = em.userFk
|
|
JOIN salix.RoleMapping rm ON rm.principalId = ac.id
|
|
JOIN account.role r on r.id = rm.roleId
|
|
WHERE em.id = ?
|
|
AND rm.principalType = 'USER'
|
|
AND r.name = 'manager'`;
|
|
|
|
let instance = await Self.rawSql(query, [instances[0].workerFk]);
|
|
|
|
if (instance[0].hasRoleManager)
|
|
throw new UserError('Only manager can change the credit');
|
|
}
|
|
};
|