db/routines/vn/triggers/ticket_beforeUpdate.sql

@@ -4,7 +4,6 @@ CREATE OR REPLACE DEFINER=`root`@`localhost` TRIGGER `vn`.`ticket_beforeUpdate`
 	FOR EACH ROW
 BEGIN
 	DECLARE vNewTime TIME;
-	DECLARE vHasTicketRefund BOOL;
 
 	SET NEW.editorFk = account.myUser_getId();
 
@@ -64,14 +63,5 @@ BEGIN
 
 		CALL vn.routeUpdateM3(NEW.routeFk);
 	END IF;
-
-	SELECT COUNT(*) INTO vHasTicketRefund 
-		FROM ticketRefund 
-		WHERE originalTicketFk = NEW.id 
-			OR refundTicketFk = NEW.id;
-	
-	IF vHasTicketRefund AND NEW.clientFk <> OLD.clientFk THEN
-		CALL util.throw('The ticket has a refund associated');
-	END IF;
 END$$
 DELIMITER ;

db/versions/10885-wheatHydrangea/00-revokeUpdateClient.sql

@@ -0,0 +1,37 @@
+REVOKE UPDATE ON vn.ticket FROM employee;
+
+GRANT UPDATE (id,
+            warehouseFk,
+            shipped,
+            nickname,
+            refFk,
+            addressFk,
+            workerFk,
+            observations,
+            isSigned,
+            isLabeled,
+            isPrinted,
+            packages,
+            location,
+            hour,
+            created,
+            isBlocked,
+            solution,
+            routeFk,
+            priority,
+            hasPriority,
+            companyFk,
+            agencyModeFk,
+            landed,
+            isBoxed,
+            isDeleted,
+            zoneFk,
+            zonePrice,
+            zoneBonus,
+            totalWithVat,
+            totalWithoutVat,
+            weight,
+            clonedFrom,
+            cmrFk,
+            editorFk)
+        ON vn.ticket TO employee;

modules/ticket/back/methods/ticket/specs/transferClient.spec.js

@@ -1,49 +1,60 @@
 const models = require('vn-loopback/server/server').models;
 
 describe('Ticket transferClient()', () => {
-    const userId = 9;
+    const originalTicketId = 8;
-    const activeCtx = {
+    const refundTicketId = 24;
-        accessToken: {userId: userId},
+    const clientId = 1;
-    };
+    let ctx;
-    const ctx = {req: activeCtx};
+    let options;
+    let tx;
+    beforeEach(async() => {
+        ctx = {
+            req: {
+                accessToken: {userId: 9},
+                headers: {origin: 'http://localhost'}
+            },
+            args: {}
+        };
+
+        options = {transaction: tx};
+        tx = await models.Ticket.beginTransaction({});
+        options.transaction = tx;
+    });
+
+    afterEach(async() => {
+        await tx.rollback();
+    });
 
     it('should throw an error as the ticket is not editable', async() => {
-        const tx = await models.Ticket.beginTransaction({});
-        let error;
-
         try {
-            const options = {transaction: tx};
             const ticketId = 4;
             const clientId = 1;
             await models.Ticket.transferClient(ctx, ticketId, clientId, options);
-
-            await tx.rollback();
         } catch (e) {
-            await tx.rollback();
+            expect(e.message).toEqual(`This ticket is locked`);
-            error = e;
         }
-
-        expect(error.message).toEqual(`This ticket is locked`);
     });
 
-    it('should be assigned a different clientFk', async() => {
+    it('should be assigned a different clientFk in the original ticket', async() => {
-        const tx = await models.Ticket.beginTransaction({});
+        await models.Ticket.transferClient(ctx, 2, clientId, options);
-        let updatedTicket;
+        const afterTransfer = await models.Ticket.findById(2, null, options);
-        const ticketId = 10;
-        const clientId = 1;
 
-        try {
+        expect(afterTransfer.clientFk).toEqual(clientId);
-            const options = {transaction: tx};
+    });
 
-            await models.Ticket.transferClient(ctx, ticketId, clientId, options);
+    it('should be assigned a different clientFk in the original and refund ticket and claim', async() => {
-            updatedTicket = await models.Ticket.findById(ticketId, {fields: ['clientFk']}, options);
+        await models.Ticket.transferClient(ctx, originalTicketId, clientId, options);
 
-            await tx.rollback();
+        const [originalTicket, refundTicket] = await models.Ticket.find({
-        } catch (e) {
+            where: {id: {inq: [originalTicketId, refundTicketId]}}
-            await tx.rollback();
+        }, options);
-            throw e;
-        }
 
-        expect(updatedTicket.clientFk).toEqual(clientId);
+        const claim = await models.Claim.findOne({
+            where: {ticketFk: originalTicketId}
+        }, options);
+
+        expect(originalTicket.clientFk).toEqual(clientId);
+        expect(refundTicket.clientFk).toEqual(clientId);
+        expect(claim.clientFk).toEqual(clientId);
     });
 });

modules/ticket/back/methods/ticket/transferClient.js

@@ -2,20 +2,17 @@ module.exports = Self => {
     Self.remoteMethodCtx('transferClient', {
         description: 'Transfering ticket to another client',
         accessType: 'WRITE',
-        accepts: [
+        accepts: [{
-            {
+            arg: 'id',
-                arg: 'id',
+            type: 'number',
-                type: 'number',
+            required: true,
-                required: true,
+            description: 'the ticket id',
-                description: 'the ticket id',
+            http: {source: 'path'}
-                http: {source: 'path'}
+        }, {
-            },
+            arg: 'clientFk',
-            {
+            type: 'number',
-                arg: 'clientFk',
+            required: true,
-                type: 'number',
+        }],
-                required: true,
-            },
-        ],
         http: {
             path: `/:id/transferClient`,
             verb: 'PATCH'
@@ -25,21 +22,51 @@ module.exports = Self => {
     Self.transferClient = async(ctx, id, clientFk, options) => {
         const models = Self.app.models;
         const myOptions = {};
+        let tx;
+
         if (typeof options == 'object')
             Object.assign(myOptions, options);
 
-        await Self.isEditableOrThrow(ctx, id, myOptions);
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
 
-        const ticket = await models.Ticket.findById(
+        try {
-            id,
+            await Self.isEditableOrThrow(ctx, id, myOptions);
-            {fields: ['id', 'shipped', 'clientFk', 'addressFk']},
-            myOptions
-        );
-        const client = await models.Client.findById(clientFk, {fields: ['id', 'defaultAddressFk']}, myOptions);
 
-        await ticket.updateAttributes({
+            const ticketRefund = await models.TicketRefund.findOne({
-            clientFk,
+                where: {or: [{originalTicketFk: id}, {refundTicketFk: id}]},
-            addressFk: client.defaultAddressFk,
+                include: [{relation: 'refundTicket'}, {relation: 'originalTicket'}]
-        });
+            }, myOptions);
+
+            const {defaultAddressFk: addressFk} = await models.Client.findById(clientFk,
+                {fields: ['id', 'defaultAddressFk']}, myOptions);
+
+            const attributes = {clientFk, addressFk};
+
+            const tickets = [];
+            const ticketIds = [];
+
+            if (ticketRefund) {
+                const {refundTicket, originalTicket} = ticketRefund;
+                tickets.push(refundTicket(), originalTicket());
+
+                for (const ticket of tickets) {
+                    await ticket.updateAttributes(attributes, myOptions);
+                    ticketIds.push(ticket.id);
+                }
+            } else {
+                await Self.updateAll({id}, attributes, myOptions);
+                ticketIds.push(id);
+            }
+
+            await models.Claim.updateAll({ticketFk: {inq: ticketIds}}, {clientFk}, myOptions);
+
+            if (tx) await tx.commit();
+        } catch (e) {
+            if (tx) await tx.rollback();
+            throw e;
+        }
     };
 };