salix/modules/claim/back/methods/claim-beginning/importToNewRefundTicket.js

module.exports = Self => {
    Self.remoteMethodCtx('importToNewRefundTicket', {
        description: 'Import lines of claimBeginning to new ticket with shipped, landed dates, agency and company',
        accessType: 'WRITE',
        accepts: [{
            arg: 'id',
            type: 'number',
            required: true,
            description: 'the claim id',
            http: {source: 'path'}
        }],
        returns: {
            type: 'string',
            root: true
        },
        http: {
            path: `/:id/importToNewRefundTicket`,
            verb: 'POST'
        }
    });

    Self.importToNewRefundTicket = async(ctx, id, options) => {
        const models = Self.app.models;
        const token = ctx.req.accessToken;
        const userId = token.userId;
        const filter = {
            where: {id: id},
            include: [
                {
                    relation: 'ticket',
                    scope: {
                        fields: ['id', 'clientFk', 'warehouseFk', 'companyFk', 'addressFk'],
                        include: {
                            relation: 'address',
                            scope: {
                                fields: ['nickname']
                            }
                        }
                    }
                }
            ]
        };
        const salesFilter = {
            where: {claimFk: id},
            include: [
                {
                    relation: 'sale',
                    scope: {
                        fields: [
                            'id',
                            'itemFk',
                            'concept',
                            'price',
                            'discount',
                            'reserved',
                            'isPicked',
                            'created',
                            'priceFixed',
                            'isPriceFixed']
                    }
                }
            ]
        };

        let tx;
        const myOptions = {userId: ctx.req.accessToken.userId};

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

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

        try {
            const worker = await models.Worker.findOne({
                where: {id: userId}
            }, myOptions);

            const observationSalesPerson = await models.ObservationType.findOne({
                where: {code: 'salesPerson'}
            }, myOptions);

            const claim = await models.Claim.findOne(filter, myOptions);
            const today = Date.vnNew();
            let warehouseFk;
            let agencyModeFk;
            let nickname;
            let state;
            let discountValue = null;

            if (claim.pickup === null) {
                state = await models.State.findOne({
                    where: {code: 'DELIVERED'}
                }, myOptions);
                const agencyMode = await models.AgencyMode.findOne({
                    where: {code: 'refund'}
                }, myOptions);

                warehouseFk = claim.ticket().warehouseFk;
                agencyModeFk = agencyMode.id;
                nickname = `Abono del: ${claim.ticketFk}`;
            } else {
                const claimConfig = await models.ClaimConfig.findOne();

                discountValue = 100;
                state = await models.State.findOne({
                    where: {code: 'WAITING_FOR_PICKUP'}
                }, myOptions);

                nickname = `Recogida pendiente del: ${claim.ticketFk}`;
                warehouseFk = claimConfig.warehouseFk;
                if (claim.pickup == 'delivery')
                    agencyModeFk = claimConfig.pickupDeliveryFk;
                else
                    agencyModeFk = claimConfig.pickupAgencyFk;
            }
            const newRefundTicket = await models.Ticket.create({
                clientFk: claim.ticket().clientFk,
                shipped: await getNextShipped(today, claim.ticket().addressFk, agencyModeFk, warehouseFk, myOptions),
                landed: null,
                nickname,
                warehouseFk,
                companyFk: claim.ticket().companyFk,
                addressFk: claim.ticket().addressFk,
                agencyModeFk,
                zoneFk: null
            }, myOptions);

            if (claim.pickup == 'pickup') {
                const observationDelivery =
                    await models.ObservationType.findOne({where: {code: 'delivery'}}, myOptions);

                await saveObservation({
                    description: `recoger reclamación: ${claim.id}`,
                    ticketFk: newRefundTicket.id,
                    observationTypeFk: observationDelivery.id
                }, myOptions);
            }
            await models.TicketRefund.create({
                refundTicketFk: newRefundTicket.id,
                originalTicketFk: claim.ticket().id
            }, myOptions);

            await saveObservation({
                description: `Reclama ticket: ${claim.ticketFk}`,
                ticketFk: newRefundTicket.id,
                observationTypeFk: observationSalesPerson.id
            }, myOptions);

            await models.Ticket.state(ctx, {
                ticketFk: newRefundTicket.id,
                stateFk: state.id,
                userFk: worker.id
            }, myOptions);

            const salesToRefund = await models.ClaimBeginning.find(salesFilter, myOptions);
            const createdSales = await addSalesToTicket(salesToRefund, newRefundTicket.id, discountValue, myOptions);
            await insertIntoClaimEnd(createdSales, id, worker.id, myOptions);

            await Self.rawSql('CALL vn.ticketCalculateClon(?, ?)', [
                newRefundTicket.id, claim.ticketFk
            ], myOptions);

            if (tx) await tx.commit();

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

    async function addSalesToTicket(salesToRefund, ticketId, discountValue, options) {
        let formatedSales = [];
        salesToRefund.forEach(sale => {
            let formatedSale = {
                itemFk: sale.sale().itemFk,
                ticketFk: ticketId,
                concept: sale.sale().concept,
                quantity: -Math.abs(sale.quantity),
                price: sale.sale().price,
                discount: discountValue ?? sale.sale().discount,
                reserved: sale.sale().reserved,
                isPicked: sale.sale().isPicked,
                created: sale.sale().created
            };
            formatedSales.push(formatedSale);
        });
        return await Self.app.models.Sale.create(formatedSales, options);
    }

    async function insertIntoClaimEnd(createdSales, claimId, workerId, options) {
        const formatedSales = [];
        createdSales.forEach(sale => {
            let formatedSale = {
                saleFk: sale.id,
                claimFk: claimId,
                workerFk: workerId
            };
            formatedSales.push(formatedSale);
        });
        await Self.app.models.ClaimEnd.create(formatedSales, options);
    }

    async function saveObservation(observation, options) {
        const query = `INSERT INTO vn.ticketObservation (ticketFk, observationTypeFk, description) VALUES(?, ?, ?)
                        ON DUPLICATE KEY
                            UPDATE description = CONCAT(vn.ticketObservation.description, VALUES(description),' ')`;
        await Self.rawSql(query, [
            observation.ticketFk,
            observation.observationTypeFk,
            observation.description
        ], options);
    }

    async function getNextShipped(vLanded, vAddressFk, vAgencyModeFk, warehouseFk, options) {
        await Self.rawSql(
            'CALL vn.zone_getShipped(?, ?, ?, TRUE)', [vLanded, vAddressFk, vAgencyModeFk], options);

        try {
            const [resultSet] = await Self.rawSql(
                'SELECT shipped FROM tmp.zoneGetShipped WHERE warehouseFk = ?', [warehouseFk], options);
            return resultSet.shipped;
        } catch (error) {
            return Date.vnNew();
        }
    }
};