salix/modules/ticket/back/methods/ticket/saveSign.js

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

module.exports = Self => {
    Self.remoteMethodCtx('saveSign', {
        description: 'Save sign',
        accessType: 'WRITE',
        accepts:
        [
            {
                arg: 'tickets',
                type: ['number'],
                required: true,
                description: 'The tickets'
            },
            {
                arg: 'location',
                type: 'object',
                description: 'The employee location the moment the sign is saved'
            },
            {
                arg: 'signedTime',
                type: 'date',
                description: 'The signed time'
            }
        ],
        http: {
            path: `/saveSign`,
            verb: 'POST'
        }
    });

    Self.saveSign = async(ctx, options) => {
        const args = Object.assign({}, ctx.args);
        const models = Self.app.models;
        const myOptions = {};
        let tx;
        let dms;
        let gestDocCreated = false;

        if (typeof options == 'object')
            Object.assign(myOptions, options);

        if (!myOptions.transaction) {
            tx = await Self.beginTransaction({});
            myOptions.transaction = tx;
        }

        async function setLocation(ticketId) {
            await models.Delivery.create({
                ticketFk: ticketId,
                longitude: args.location.Longitude,
                latitude: args.location.Latitude,
                dated: args.signedTime || new Date()
            }, myOptions);
        }

        async function gestDocExists(ticketId) {
            const ticketDms = await models.TicketDms.findOne({
                where: {ticketFk: ticketId},
                fields: ['dmsFk']
            }, myOptions);

            if (!ticketDms) return false;

            const ticket = await models.Ticket.findById(ticketId, {fields: ['isSigned']}, myOptions);
            if (ticket.isSigned == true)
                return true;
            else
                await models.Dms.destroyAll({where: {reference: ticketId}}, myOptions);

            return false;
        }

        async function createGestDoc(id) {
            const ticket = await models.Ticket.findById(id,
                {include: [
                    {
                        relation: 'warehouse',
                        scope: {
                            fields: ['id']
                        }
                    }, {
                        relation: 'client',
                        scope: {
                            fields: ['name']
                        }
                    }, {
                        relation: 'route',
                        scope: {
                            fields: ['id']
                        }
                    }
                ]
                }, myOptions);
            const dmsType = await models.DmsType.findOne({where: {code: 'Ticket'}, fields: ['id']}, myOptions);
            const ctxUploadFile = Object.assign({}, ctx);
            ctxUploadFile.args = {
                warehouseId: ticket.warehouseFk,
                companyId: ticket.companyFk,
                dmsTypeId: dmsType.id,
                reference: '',
                description: `Firma del cliente - Ruta ${ticket.route().id}`,
                hasFile: false
            };
            dms = await models.Dms.uploadFile(ctxUploadFile, myOptions);
            gestDocCreated = true;
        }

        try {
            for (let i = 0; i < args.tickets.length; i++) {
                const ticketState = await models.TicketState.findOne(
                    {where: {ticketFk: args.tickets[i]},
                        fields: ['alertLevel']
                    }, myOptions);

                const packedAlertLevel = await models.AlertLevel.findOne({where: {code: 'PACKED'},
                    fields: ['id']
                }, myOptions);

                if (ticketState.alertLevel < packedAlertLevel.id)
                    throw new UserError('This ticket cannot be signed because it has not been boxed');
                else if (!await gestDocExists(args.tickets[i])) {
                    if (args.location) setLocation(args.tickets[i]);
                    if (!gestDocCreated) await createGestDoc(args.tickets[i]);
                    await models.TicketDms.create({ticketFk: args.tickets[i], dmsFk: dms[0].id}, myOptions);
                    const ticket = await models.Ticket.findById(args.tickets[i], null, myOptions);
                    await ticket.updateAttribute('isSigned', true, myOptions);
                    await Self.rawSql(`CALL vn.ticket_setState(?, ?)`, [args.tickets[i], 'DELIVERED'], myOptions);
                }
            }

            if (tx) await tx.commit();
            return;
        } catch (e) {
            if (tx) await tx.rollback();
            throw e;
        }
    };
};