salix/modules/supplier/back/models/supplier.js

const UserError = require('vn-loopback/util/user-error');
const validateTin = require('vn-loopback/util/validateTin');

module.exports = Self => {
    require('../methods/supplier/filter')(Self);
    require('../methods/supplier/getSummary')(Self);
    require('../methods/supplier/updateFiscalData')(Self);
    require('../methods/supplier/consumption')(Self);

    Self.validatesPresenceOf('name', {
        message: 'The social name cannot be empty'
    });

    Self.validatesUniquenessOf('name', {
        message: 'The supplier name must be unique'
    });

    Self.validatesPresenceOf('city', {
        message: 'City cannot be empty'
    });

    Self.validatesPresenceOf('nif', {
        message: 'The nif cannot be empty'
    });

    Self.validatesUniquenessOf('nif', {
        message: 'TIN must be unique'
    });

    Self.validateAsync('nif', tinIsValid, {
        message: 'Invalid TIN'
    });

    Self.validatesLengthOf('postCode', {
        allowNull: true,
        allowBlank: true,
        min: 3, max: 10
    });

    Self.validateAsync('postCode', hasValidPostcode, {
        message: `The postcode doesn't exist. Please enter a correct one`
    });

    async function hasValidPostcode(err, done) {
        if (!this.postcode)
            return done();

        const models = Self.app.models;
        const postcode = await models.Postcode.findById(this.postcode);

        if (!postcode) err();
        done();
    }

    async function tinIsValid(err, done) {
        const filter = {
            fields: ['code'],
            where: {id: this.countryFk}
        };
        const country = await Self.app.models.Country.findOne(filter);
        const code = country ? country.code.toLowerCase() : null;

        if (!this.nif || !validateTin(this.nif, code))
            err();
        done();
    }

    function isAlpha(value) {
        const regexp = new RegExp(/^[ñça-zA-Z0-9\s]*$/i);

        return regexp.test(value);
    }

    Self.validateAsync('payMethodFk', hasSupplierAccount, {
        message: 'You can not select this payment method without a registered bankery account'
    });

    async function hasSupplierAccount(err, done) {
        const payMethod = await Self.app.models.PayMethod.findById(this.payMethodFk);
        const supplierAccount = await Self.app.models.SupplierAccount.findOne({where: {supplierFk: this.id}});
        const hasIban = supplierAccount && supplierAccount.iban;

        if (payMethod && payMethod.ibanRequired && !hasIban)
            err();

        done();
    }

    Self.observe('before save', async function(ctx) {
        let changes = ctx.data || ctx.instance;
        let orgData = ctx.currentInstance;

        const socialName = changes.name || orgData.name;
        const hasChanges = orgData && changes;
        const socialNameChanged = hasChanges
            && orgData.socialName != socialName;

        if ((socialNameChanged) && !isAlpha(socialName))
            throw new UserError('The socialName has an invalid format');
    });
};