Merge pull request '6199---Cantidad-mínima-back' (!1790) from 6199---Cantidad-mínima-back into test

Reviewed-on: #1790
Reviewed-by: Javi Gallego <jgallego@verdnatura.es>
Reviewed-by: Carlos Andrés <carlosap@verdnatura.es>

loopback/locale/en.json

@@ -189,5 +189,6 @@
 	"The sales do not exists": "The sales do not exists",
 	"Ticket without Route": "Ticket without route",
 	"Booking completed": "Booking complete",
-    "The ticket is in preparation": "The ticket [{{ticketId}}]({{{ticketUrl}}}) of the sales person {{salesPersonId}} is in preparation"
-}
+	"The ticket is in preparation": "The ticket [{{ticketId}}]({{{ticketUrl}}}) of the sales person {{salesPersonId}} is in preparation",
+	"You can only add negative amounts in refund tickets": "You can only add negative amounts in refund tickets"
+}

loopback/locale/es.json

@@ -319,5 +319,6 @@
 	"The response is not a PDF": "La respuesta no es un PDF",
 	"Ticket without Route": "Ticket sin ruta",
 	"Booking completed": "Reserva completada",
-	"The ticket is in preparation": "El ticket [{{ticketId}}]({{{ticketUrl}}}) del comercial {{salesPersonId}} está en preparación"
+	"The ticket is in preparation": "El ticket [{{ticketId}}]({{{ticketUrl}}}) del comercial {{salesPersonId}} está en preparación",
+	"The amount cannot be less than the minimum": "La cantidad no puede ser menor que la cantidad mímina"
 }

modules/claim/back/methods/claim/specs/regularizeClaim.spec.js

@@ -64,7 +64,7 @@ describe('claim regularizeClaim()', () => {
 
             claimEnds = await importTicket(ticketId, claimId, userId, options);
 
-            for (claimEnd of claimEnds)
+            for (const claimEnd of claimEnds)
                 await claimEnd.updateAttributes({claimDestinationFk: trashDestination}, options);
 
             let claimBefore = await models.Claim.findById(claimId, null, options);

modules/item/back/models/item.json

@@ -157,6 +157,10 @@
             "mysql":{
                 "columnName": "doPhoto"
             }
+        },
+        "minQuantity": {
+            "type": "number",
+            "description": "Min quantity"
         }
     },
     "relations": {

modules/ticket/back/methods/sale/specs/updateQuantity.spec.js

@@ -2,20 +2,6 @@ const models = require('vn-loopback/server/server').models;
 const LoopBackContext = require('loopback-context');
 
 describe('sale updateQuantity()', () => {
-    beforeAll(async() => {
-        const activeCtx = {
-            accessToken: {userId: 9},
-            http: {
-                req: {
-                    headers: {origin: 'http://localhost'}
-                }
-            }
-        };
-        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
-            active: activeCtx
-        });
-    });
-
     const ctx = {
         req: {
             accessToken: {userId: 9},
@@ -23,6 +9,18 @@ describe('sale updateQuantity()', () => {
             __: () => {}
         }
     };
+    function getActiveCtx(userId) {
+        return {
+            active: {
+                accessToken: {userId},
+                http: {
+                    req: {
+                        headers: {origin: 'http://localhost'}
+                    }
+                }
+            }
+        };
+    }
 
     it('should throw an error if the quantity is greater than it should be', async() => {
         const ctx = {
@@ -32,6 +30,8 @@ describe('sale updateQuantity()', () => {
                 __: () => {}
             }
         };
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(1));
+
         const tx = await models.Sale.beginTransaction({});
 
         let error;
@@ -50,6 +50,8 @@ describe('sale updateQuantity()', () => {
     });
 
     it('should add quantity if the quantity is greater than it should be and is role advanced', async() => {
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(9));
+
         const tx = await models.Sale.beginTransaction({});
         const saleId = 17;
         const buyerId = 35;
@@ -87,6 +89,8 @@ describe('sale updateQuantity()', () => {
     });
 
     it('should update the quantity of a given sale current line', async() => {
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(9));
+
         const tx = await models.Sale.beginTransaction({});
         const saleId = 25;
         const newQuantity = 4;
@@ -119,6 +123,8 @@ describe('sale updateQuantity()', () => {
                 __: () => {}
             }
         };
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(1));
+
         const saleId = 17;
         const newQuantity = -10;
 
@@ -140,6 +146,8 @@ describe('sale updateQuantity()', () => {
     });
 
     it('should update a negative quantity when is a ticket refund', async() => {
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(9));
+
         const tx = await models.Sale.beginTransaction({});
         const saleId = 13;
         const newQuantity = -10;
@@ -159,4 +167,31 @@ describe('sale updateQuantity()', () => {
             throw e;
         }
     });
+
+    it('should throw an error if the quantity is less than the minimum quantity of the item', async() => {
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue(getActiveCtx(9));
+
+        const tx = await models.Sale.beginTransaction({});
+        const itemId = 2;
+        const saleId = 17;
+        const minQuantity = 30;
+        const newQuantity = minQuantity - 1;
+
+        let error;
+        try {
+            const options = {transaction: tx};
+
+            const item = await models.Item.findById(itemId, null, options);
+            await item.updateAttribute('minQuantity', minQuantity, options);
+
+            await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error).toEqual(new Error('The amount cannot be less than the minimum'));
+    });
 });

modules/ticket/back/methods/sale/updateQuantity.js

@@ -1,4 +1,3 @@
-let UserError = require('vn-loopback/util/user-error');
 
 module.exports = Self => {
     Self.remoteMethodCtx('updateQuantity', {
@@ -64,17 +63,6 @@ module.exports = Self => {
 
             const sale = await models.Sale.findById(id, filter, myOptions);
 
-            const isRoleAdvanced = await models.ACL.checkAccessAcl(ctx, 'Ticket', 'isRoleAdvanced', '*');
-            if (newQuantity > sale.quantity && !isRoleAdvanced)
-                throw new UserError('The new quantity should be smaller than the old one');
-
-            const ticketRefund = await models.TicketRefund.findOne({
-                where: {refundTicketFk: sale.ticketFk},
-                fields: ['id']}
-            , myOptions);
-            if (newQuantity < 0 && !ticketRefund)
-                throw new UserError('You can only add negative amounts in refund tickets');
-
             const oldQuantity = sale.quantity;
             const result = await sale.updateAttributes({quantity: newQuantity}, myOptions);
 

modules/ticket/back/models/sale.js

@@ -1,3 +1,6 @@
+const UserError = require('vn-loopback/util/user-error');
+const LoopBackContext = require('loopback-context');
+
 module.exports = Self => {
     require('../methods/sale/getClaimableFromTicket')(Self);
     require('../methods/sale/reserve')(Self);
@@ -13,4 +16,65 @@ module.exports = Self => {
     Self.validatesPresenceOf('concept', {
         message: `Concept cannot be blank`
     });
+
+    Self.observe('before save', async ctx => {
+        const models = Self.app.models;
+        const changes = ctx.data || ctx.instance;
+        const instance = ctx.currentInstance;
+
+        const newQuantity = changes?.quantity;
+        if (newQuantity == null) return;
+
+        const loopBackContext = LoopBackContext.getCurrentContext();
+        ctx.req = loopBackContext.active;
+        const canEditQuantity = await models.ACL.checkAccessAcl(ctx, 'Sale', 'canForceQuantity', 'WRITE');
+        if (canEditQuantity) return;
+
+        const ticketId = changes?.ticketFk || instance?.ticketFk;
+        const itemId = changes?.itemFk || instance?.itemFk;
+
+        const ticket = await models.Ticket.findById(
+            ticketId,
+            {
+                fields: ['id', 'clientFk'],
+                include: {
+                    relation: 'client',
+                    scope: {
+                        fields: ['id', 'clientTypeFk'],
+                        include: {
+                            relation: 'type',
+                            scope: {
+                                fields: ['code', 'description']
+                            }
+                        }
+                    }
+                }
+            },
+            ctx.options);
+        if (ticket.client().type().code === 'loses') return;
+
+        const ticketRefund = await models.TicketRefund.findOne({
+            where: {refundTicketFk: ticketId},
+            fields: ['id']}
+        , ctx.options);
+
+        if (newQuantity < 0 && !ticketRefund)
+            throw new UserError('You can only add negative amounts in refund tickets');
+
+        const item = await models.Item.findOne({
+            where: {id: itemId},
+            fields: ['minQuantity']}
+        , ctx.options);
+
+        if (newQuantity < item.minQuantity && !ticketRefund)
+            throw new UserError('The amount cannot be less than the minimum');
+
+        const oldQuantity = instance?.quantity;
+        if (oldQuantity === null) return;
+
+        const isRoleAdvanced = await models.ACL.checkAccessAcl(ctx, 'Ticket', 'isRoleAdvanced', '*');
+        if (newQuantity > oldQuantity && !isRoleAdvanced)
+            throw new UserError('The new quantity should be smaller than the old one');
+    });
 };
+