back/models/specs/mailAliasAccount.spec.js

@@ -0,0 +1,73 @@
+const models = require('vn-loopback/server/server').models;
+
+describe('loopback model MailAliasAccount', () => {
+    it('should fail to add a mail Alias if the worker doesnt have ACLs', async() => {
+        const tx = await models.MailAliasAccount.beginTransaction({});
+        let error;
+
+        try {
+            const options = {transaction: tx, accessToken: {userId: 57}};
+            await models.MailAliasAccount.create({mailAlias: 2, account: 5}, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error.message).toEqual('The alias cant be modified');
+    });
+
+    it('should add a mail Alias', async() => {
+        const tx = await models.MailAliasAccount.beginTransaction({});
+        let error;
+
+        try {
+            const options = {transaction: tx, accessToken: {userId: 9}};
+            await models.MailAliasAccount.create({mailAlias: 2, account: 5}, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error).toBeUndefined();
+    });
+
+    it('should add a mail Alias of an inherit role', async() => {
+        const tx = await models.MailAliasAccount.beginTransaction({});
+        let error;
+
+        try {
+            const options = {transaction: tx, accessToken: {userId: 9}};
+            await models.MailAliasAccount.create({mailAlias: 3, account: 5}, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error).toBeUndefined();
+    });
+
+    it('should delete a mail Alias', async() => {
+        const tx = await models.MailAliasAccount.beginTransaction({});
+        let error;
+
+        try {
+            const options = {transaction: tx, accessToken: {userId: 1}};
+            const mailAclId = 2;
+            await models.MailAliasAccount.destroyAll({id: mailAclId}, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error).toBeUndefined();
+    });
+});
+

db/changes/235201/00-aclsMails.sql

@@ -0,0 +1,8 @@
+-- Definición de la tabla mailAliasACL
+
+CREATE OR REPLACE TABLE `account`.`mailAliasAcl` (
+  `mailAliasFk` int(10) unsigned NOT NULL,
+  `roleFk` int(10) unsigned NOT NULL,
+  FOREIGN KEY (`mailAliasFk`) REFERENCES `account`.`mailAlias` (`id`),
+  FOREIGN KEY (`roleFk`) REFERENCES `account`.`role` (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci;

db/dump/fixtures.sql

@@ -3010,6 +3010,12 @@ INSERT INTO `vn`.`invoiceCorrectionType` (`id`, `description`)
         (2, 'Error in sales details'),
         (3, 'Error in customer data');
 
+INSERT INTO `account`.`mailAliasAcl` (`mailAliasFk`, `roleFk`)
+    VALUES
+        (1, 1),
+        (2, 9),
+        (3, 15);
+
 INSERT INTO `vn`.`docuwareTablet` (`tablet`,`description`)
 	VALUES
         ('Tablet1','Jarvis tablet'),

front/core/locale/es.yml

@@ -68,3 +68,4 @@ Load more results: Cargar más resultados
 Send cau: Enviar cau
 By sending this ticket, all the data related to the error, the section, the user, etc., are already sent.: Al enviar este cau ya se envían todos los datos relacionados con el error, la sección, el usuario, etc
 ExplainReason: Explique el motivo por el que no deberia aparecer este fallo
+You already have the mailAlias: Ya tienes este alias de correo

loopback/locale/es.json

@@ -331,6 +331,8 @@
 	"Cannot past travels with entries": "No se pueden pasar envíos con entradas",
 	"It was not able to remove the next expeditions:": "No se pudo eliminar las siguientes expediciones: {{expeditions}}",
     "This user does not have an assigned tablet": "Este usuario no tiene tablet asignada",
-	"Incorrect pin.": "Pin incorrecto."
+	"Incorrect pin.": "Pin incorrecto.",
+	"You already have the mailAlias": "Ya tienes este alias de correo",
+	"The alias cant be modified": "Este alias de correo no puede ser modificado"
 }
 

modules/account/back/model-config.json

@@ -14,6 +14,9 @@
     "MailAliasAccount": {
         "dataSource": "vn"
     },
+    "MailAliasAcl": {
+        "dataSource": "vn"
+    },
     "MailConfig": {
         "dataSource": "vn"
     },

modules/account/back/models/mail-alias-account.js

@@ -2,54 +2,44 @@
 const UserError = require('vn-loopback/util/user-error');
 
 module.exports = Self => {
+    Self.rewriteDbError(function(err) {
+        if (err.code === 'ER_DUP_ENTRY')
+            return new UserError(`You already have the mailAlias`);
+        return err;
+    });
+
     Self.observe('before save', async ctx => {
         const changes = ctx.currentInstance || ctx.instance;
 
-        await Self.hasGrant(ctx, changes.mailAlias);
+        await checkModifyPermission(ctx, changes.mailAlias);
     });
 
     Self.observe('before delete', async ctx => {
         const mailAliasAccount = await Self.findById(ctx.where.id);
 
-        await Self.hasGrant(ctx, mailAliasAccount.mailAlias);
+        await checkModifyPermission(ctx, mailAliasAccount.mailAlias);
     });
 
-    /**
-     * Checks if current user has
-     * grant to add/remove alias
-     *
-     * @param {Object} ctx - Request context
-     * @param {Interger} mailAlias - mailAlias id
-     * @return {Boolean} True for user with grant
-     */
-    Self.hasGrant = async function(ctx, mailAlias) {
+    async function checkModifyPermission(ctx, mailAliasFk) {
+        const userId = ctx.options.accessToken.userId;
         const models = Self.app.models;
-        const accessToken = {req: {accessToken: ctx.options.accessToken}};
-        const userId = accessToken.req.accessToken.userId;
 
-        const canEditAlias = await models.ACL.checkAccessAcl(accessToken, 'MailAliasAccount', 'canEditAlias', 'WRITE');
-        if (canEditAlias) return true;
+        const roles = await models.RoleMapping.find({
+            fields: ['roleId'],
+            where: {principalId: userId}
+        });
 
-        const user = await models.VnUser.findById(userId, {fields: ['hasGrant']});
-        if (!user.hasGrant)
-            throw new UserError(`You don't have grant privilege`);
-
-        const account = await models.Account.findById(userId, {
-            fields: ['id'],
-            include: {
-                relation: 'aliases',
-                scope: {
-                    fields: ['mailAlias']
-                }
+        const availableMailAlias = await models.MailAliasAcl.findOne({
+            fields: ['mailAliasFk'],
+            include: {relation: 'mailAlias'},
+            where: {
+                roleFk: {
+                    inq: roles.map(role => role.roleId),
+                },
+                mailAliasFk
             }
         });
 
-        const aliases = account.aliases().map(alias => alias.mailAlias);
-
-        const hasAlias = aliases.includes(mailAlias);
-        if (!hasAlias)
-            throw new UserError(`You cannot assign/remove an alias that you are not assigned to`);
-
-        return true;
-    };
+        if (!availableMailAlias) throw new UserError('The alias cant be modified');
+    }
 };

modules/account/back/models/mail-alias-acl.json

@@ -0,0 +1,31 @@
+{
+    "name": "MailAliasAcl",
+    "base": "VnModel",
+    "options": {
+        "mysql": {
+            "table": "account.mailAliasAcl"
+        }
+    },
+    "properties": {
+        "mailAliasFk": {
+            "id": true,
+            "type": "number"
+        },
+        "roleFk": {
+            "id": true,
+            "type": "number"
+        }
+    },
+    "relations": {
+        "mailAlias": {
+            "type": "belongsTo",
+            "model": "MailAlias",
+            "foreignKey": "mailAliasFk"
+        },
+        "role": {
+            "type": "belongsTo",
+            "model": "Role",
+            "foreignKey": "roleFk"
+        }
+    }
+}

modules/invoiceOut/back/methods/invoiceOut/negativeBases.js

@@ -90,7 +90,7 @@ module.exports = Self => {
                             AND t.refFk IS NULL
                             AND c.typeFk IN ('normal','trust')
                         GROUP BY t.clientFk, negativeBase.taxableBase
-                        HAVING amount <> 0`, [args.from, args.to]));
+                        HAVING amount < 0`, [args.from, args.to]));
 
         stmt = new ParameterizedSQL(`
             SELECT f.*

modules/invoiceOut/back/methods/invoiceOut/negativeBasesCsv.js

@@ -10,13 +10,17 @@ module.exports = Self => {
                 type: 'date',
                 description: 'From date',
                 required: true
-            },
-            {
+            }, {
                 arg: 'to',
                 type: 'date',
                 description: 'To date',
                 required: true
-            }],
+            }, {
+                arg: 'filter',
+                type: 'object',
+                description: 'Filter defining where, order, offset, and limit - must be a JSON-encoded string'
+            },
+        ],
         returns: [
             {
                 arg: 'body',

modules/item/back/locale/item-shelving/en.yml

@@ -0,0 +1,13 @@
+name: itemShelving
+columns:
+    id: id
+    itemFk: item
+    shelvingFk: shelving
+    visible: visible
+    created: created
+    grouping: grouping
+    packing: packing
+    packagingFk: package
+    userFk: user
+    isChecked: isChecked
+    buyFk: buy

modules/item/back/locale/item-shelving/es.yml

@@ -0,0 +1,13 @@
+name: artículo del carro
+columns:
+    id: id
+    itemFk: artículo
+    shelvingFk: matrícula carro
+    visible: visible
+    created: creado
+    grouping: grouping
+    packing: packing
+    packagingFk: embalaje
+    userFk: usuario
+    isChecked: está revisado
+    buyFk: compra

modules/shelving/back/models/sector.json

@@ -20,18 +20,10 @@
             "type": "number",
             "required": true
         },
-        "isPreviousPreparedByPacking": {
-            "type": "boolean",
-            "required": true
-        },
         "code": {
             "type": "string",
             "required": false
         },
-        "isPreviousPrepared": {
-            "type": "boolean",
-            "required": true
-        },
         "isPackagingArea": {
             "type": "boolean",
             "required": true