refactor: refs #7937 streamline importToNewRefundTicket function and add comprehensive tests

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

@@ -74,10 +74,6 @@ module.exports = Self => {
         }
 
         try {
-            const worker = await models.Worker.findOne({
-                where: {id: userId}
-            }, myOptions);
-
             const observationSalesPerson = await models.ObservationType.findOne({
                 where: {code: 'salesPerson'}
             }, myOptions);
@@ -89,6 +85,7 @@ module.exports = Self => {
             let nickname;
             let state;
             let discountValue = null;
+            let packages = 0;
 
             if (claim.pickup === null) {
                 state = await models.State.findOne({
@@ -105,6 +102,7 @@ module.exports = Self => {
                 const claimConfig = await models.ClaimConfig.findOne();
 
                 discountValue = 100;
+                packages = 1;
                 state = await models.State.findOne({
                     where: {code: 'WAITING_FOR_PICKUP'}
                 }, myOptions);
@@ -125,7 +123,8 @@ module.exports = Self => {
                 companyFk: claim.ticket().companyFk,
                 addressFk: claim.ticket().addressFk,
                 agencyModeFk,
-                zoneFk: null
+                zoneFk: claim.ticket().zoneFk,
+                packages
             }, myOptions);
 
             if (claim.pickup == 'pickup') {
@@ -149,20 +148,16 @@ module.exports = Self => {
                 observationTypeFk: observationSalesPerson.id
             }, myOptions);
 
+            const salesToRefund = await models.ClaimBeginning.find(salesFilter, myOptions);
+            const createdSales = await addSalesToTicket(salesToRefund, newRefundTicket.id, discountValue, myOptions);
+            await insertIntoClaimEnd(createdSales, id, userId, myOptions);
+
             await models.Ticket.state(ctx, {
                 ticketFk: newRefundTicket.id,
                 stateFk: state.id,
-                userFk: worker.id
+                userFk: userId
             }, 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;
@@ -172,23 +167,36 @@ module.exports = Self => {
         }
     };
 
-    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
+    async function addSalesToTicket(salesToRefund, newTicketId, discountValue, options) {
+        const createdSales = [];
+        const models = Self.app.models;
+        for (const saleToRefund of salesToRefund) {
+            const oldSale = saleToRefund.sale();
+            const newSaleData = {
+                itemFk: oldSale.itemFk,
+                ticketFk: newTicketId,
+                concept: oldSale.concept,
+                quantity: -Math.abs(saleToRefund.quantity),
+                price: oldSale.price,
+                discount: discountValue ?? oldSale.discount,
+                reserved: oldSale.reserved,
+                isPicked: oldSale.isPicked,
+                created: oldSale.created
             };
-            formatedSales.push(formatedSale);
-        });
-        return await Self.app.models.Sale.create(formatedSales, options);
+            const newSale = await models.Sale.create(newSaleData, options);
+            const oldSaleComponents = await models.SaleComponent.find({
+                where: {saleFk: oldSale.id}
+            }, options);
+            const newComponents = oldSaleComponents.map(component => {
+                const data = component.toJSON ? component.toJSON() : {...component};
+                delete data.id;
+                data.saleFk = newSale.id;
+                return data;
+            });
+            await models.SaleComponent.create(newComponents, options);
+            createdSales.push(newSale);
+        }
+        return createdSales;
     }
 
     async function insertIntoClaimEnd(createdSales, claimId, workerId, options) {

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

@@ -1,44 +0,0 @@
-const app = require('vn-loopback/server/server');
-const LoopBackContext = require('loopback-context');
-const models = app.models;
-
-describe('claimBeginning', () => {
-    const claimManagerId = 72;
-    const activeCtx = {
-        accessToken: {userId: claimManagerId},
-        __: value => value
-    };
-    const ctx = {req: activeCtx};
-
-    describe('importToNewRefundTicket()', () => {
-        it('should create a new ticket with negative sales and insert the negative sales into claimEnd', async() => {
-            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
-                active: activeCtx
-            });
-            let claimId = 1;
-
-            const tx = await models.Entry.beginTransaction({});
-            try {
-                const options = {transaction: tx};
-
-                const ticket = await models.ClaimBeginning.importToNewRefundTicket(ctx, claimId, options);
-
-                const refundTicketSales = await models.Sale.find({
-                    where: {ticketFk: ticket.id}
-                }, options);
-                const salesInsertedInClaimEnd = await models.ClaimEnd.find({
-                    where: {claimFk: claimId}
-                }, options);
-
-                expect(refundTicketSales.length).toEqual(1);
-                expect(refundTicketSales[0].quantity).toEqual(-5);
-                expect(salesInsertedInClaimEnd[0].saleFk).toEqual(refundTicketSales[0].id);
-
-                await tx.rollback();
-            } catch (e) {
-                await tx.rollback();
-                throw e;
-            }
-        });
-    });
-});

modules/claim/back/methods/claim-beginning/specs/importToNewRefundTicket.spec.js

@@ -0,0 +1,97 @@
+const app = require('vn-loopback/server/server');
+const LoopBackContext = require('loopback-context');
+const models = app.models;
+
+describe('importToNewRefundTicket()', () => {
+    let tx;
+    const claimManagerId = 72;
+    const activeCtx = {
+        accessToken: {userId: claimManagerId},
+    };
+    let ctx = {req: activeCtx};
+    let options;
+    const claimId = 1;
+
+    beforeEach(async() => {
+        LoopBackContext.getCurrentContext = () => ({
+            active: activeCtx,
+        });
+        tx = await models.Entry.beginTransaction({});
+        options = {transaction: tx};
+    });
+
+    afterEach(async() => {
+        await tx.rollback();
+    });
+
+    it('should create a new ticket with negative sales and insert the negative sales into claimEnd', async() => {
+        const ticket = await models.ClaimBeginning.importToNewRefundTicket(ctx, claimId, options);
+
+        const refundTicketSales = await models.Sale.find({
+            where: {ticketFk: ticket.id}
+        }, options);
+        const salesInsertedInClaimEnd = await models.ClaimEnd.find({
+            where: {claimFk: claimId}
+        }, options);
+
+        expect(refundTicketSales.length).toEqual(1);
+        expect(refundTicketSales[0].quantity).toEqual(-5);
+        expect(salesInsertedInClaimEnd[0].saleFk).toEqual(refundTicketSales[0].id);
+    });
+
+    it('debe establecer estado DELIVERED y modo de agencia refund', async() => {
+        const state = await models.State.findOne({
+            where: {code: 'DELIVERED'}
+        }, options);
+        const ticket = await models.ClaimBeginning.importToNewRefundTicket(ctx, claimId, options);
+        const ticketTracking = await models.TicketTracking.findOne({
+            where: {ticketFk: ticket.id},
+            order: 'id DESC'
+        }, options);
+
+        const newSales = await models.Sale.find({
+            where: {ticketFk: ticket.id}
+        }, options);
+
+        newSales.forEach(sale => {
+            expect(sale.discount).toEqual(0);
+        });
+
+        expect(ticketTracking.stateFk).toEqual(state.id);
+    });
+
+    it('debe establecer estado WAITING_FOR_PICKUP para las recogidas por reparto', async() => {
+        const state = await models.State.findOne({
+            where: {code: 'WAITING_FOR_PICKUP'}
+        }, options);
+        await models.Claim.updateAll({id: claimId}, {pickup: 'delivery'}, options);
+        const ticket = await models.ClaimBeginning.importToNewRefundTicket(ctx, claimId, options);
+        const ticketTracking = await models.TicketTracking.findOne({
+            where: {ticketFk: ticket.id},
+            order: 'id DESC'
+        }, options);
+
+        expect(ticketTracking.stateFk).toEqual(state.id);
+    });
+
+    it('debe establecer estado WAITING_FOR_PICKUP para las recogidas por agencia', async() => {
+        const state = await models.State.findOne({
+            where: {code: 'WAITING_FOR_PICKUP'}
+        }, options);
+        await models.Claim.updateAll({id: claimId}, {pickup: 'agency'}, options);
+        const ticket = await models.ClaimBeginning.importToNewRefundTicket(ctx, claimId, options);
+        const ticketTracking = await models.TicketTracking.findOne({
+            where: {ticketFk: ticket.id},
+            order: 'id DESC'
+        }, options);
+        const newSales = await models.Sale.find({
+            where: {ticketFk: ticket.id}
+        }, options);
+
+        newSales.forEach(sale => {
+            expect(sale.discount).toEqual(100);
+        });
+
+        expect(ticketTracking.stateFk).toEqual(state.id);
+    });
+});