client module changes for transactions

back/methods/dms/removeFile.js

@@ -21,8 +21,9 @@ module.exports = Self => {
     });
 
     Self.removeFile = async(ctx, id, options) => {
+        const models = Self.app.models;
         let tx;
-        let myOptions = {};
+        const myOptions = {};
 
         if (typeof options == 'object')
             Object.assign(myOptions, options);
@@ -33,7 +34,6 @@ module.exports = Self => {
         }
 
         try {
-            const models = Self.app.models;
             const dms = await models.Dms.findById(id, null, myOptions);
             const trashDmsType = await models.DmsType.findOne({
                 where: {code: 'trash'}

modules/claim/back/methods/claim/createFromSales.js

@@ -25,8 +25,9 @@ module.exports = Self => {
     });
 
     Self.createFromSales = async(ctx, ticketId, sales, options) => {
+        const models = Self.app.models;
         let tx;
-        let myOptions = {};
+        const myOptions = {};
 
         if (typeof options == 'object')
             Object.assign(myOptions, options);
@@ -35,7 +36,6 @@ module.exports = Self => {
             tx = await Self.beginTransaction({});
             myOptions.transaction = tx;
         }
-        const models = Self.app.models;
         const userId = ctx.req.accessToken.userId;
 
         try {

modules/client/back/methods/client-dms/removeFile.js

@@ -4,12 +4,12 @@ module.exports = Self => {
         accessType: 'WRITE',
         accepts: {
             arg: 'id',
-            type: 'Number',
+            type: 'number',
             description: 'The document id',
             http: {source: 'path'}
         },
         returns: {
-            type: 'Object',
+            type: 'object',
             root: true
         },
         http: {
@@ -18,13 +18,33 @@ module.exports = Self => {
         }
     });
 
-    Self.removeFile = async(ctx, id) => {
+    Self.removeFile = async(ctx, id, options) => {
         const models = Self.app.models;
-        const clientDms = await Self.findById(id);
+        let tx;
+        const myOptions = {};
 
-        await models.Dms.removeFile(ctx, clientDms.dmsFk);
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
 
-        return clientDms.destroy();
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
+
+        try {
+            const clientDms = await Self.findById(id, null, myOptions);
+
+            await models.Dms.removeFile(ctx, clientDms.dmsFk, myOptions);
+
+            const destroyedClient = await clientDms.destroy(myOptions);
+
+            if (tx) await tx.commit();
+
+            return destroyedClient;
+        } catch (e) {
+            if (tx) await tx.rollback();
+            throw e;
+        }
     };
 };
 

modules/client/back/methods/client-dms/specs/removeFile.spec.js

@@ -1,17 +1,24 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('ClientDms removeFile()', () => {
-    const clientDmsFk = 3;
     it(`should return an error for a user without enough privileges`, async() => {
-        let clientId = 1101;
+        const tx = await models.Client.beginTransaction({});
-        let ctx = {req: {accessToken: {userId: clientId}}};
 
         let error;
-        await app.models.ClientDms.removeFile(ctx, clientDmsFk).catch(e => {
+
+        try {
+            const options = {transaction: tx};
+            const clientDmsFk = 3;
+            const clientId = 1101;
+            const ctx = {req: {accessToken: {userId: clientId}}};
+
+            await models.ClientDms.removeFile(ctx, clientDmsFk, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
             error = e;
-        }).finally(() => {
+        }
-            expect(error.message).toEqual(`You don't have enough privileges`);
-        });
 
         expect(error).toBeDefined();
     });

modules/client/back/methods/client/addressesPropagateRe.js

@@ -12,7 +12,7 @@ module.exports = function(Self) {
             },
             {
                 arg: 'data',
-                type: 'Object',
+                type: 'object',
                 required: true,
                 description: 'data with new value',
                 http: {source: 'body'}
@@ -29,12 +29,21 @@ module.exports = function(Self) {
         }
     });
 
-    Self.addressesPropagateRe = async(id, data) => {
+    Self.addressesPropagateRe = async(id, data, options) => {
-        if (data.hasOwnProperty('isEqualizated')) {
+        const models = Self.app.models;
-            let client = await Self.app.models.Client.findById(id);
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const isEqualizated = Object.prototype.hasOwnProperty.call(data, 'isEqualizated');
+        if (isEqualizated) {
+            const client = await models.Client.findById(id, null, myOptions);
+
             if (client) {
-                await Self.app.models.Address.updateAll({clientFk: id}, data);
+                await models.Address.updateAll({clientFk: id}, data, myOptions);
-                await client.updateAttributes({hasToInvoiceByAddress: false});
+                await client.updateAttributes({hasToInvoiceByAddress: false}, myOptions);
+
                 return true;
             }
         }

modules/client/back/methods/client/canCreateTicket.js

@@ -20,8 +20,15 @@ module.exports = Self => {
         }
     });
 
-    Self.canCreateTicket = async id => {
+    Self.canCreateTicket = async(id, options) => {
-        const client = await Self.app.models.Client.findById(id);
+        const models = Self.app.models;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const client = await models.Client.findById(id, null, myOptions);
+
         const canCreateTicket = client && client.isActive;
         if (!canCreateTicket)
             return false;

modules/client/back/methods/client/confirmTransaction.js

@@ -9,7 +9,7 @@ module.exports = Self => {
             description: 'Transaction id'
         }],
         returns: {
-            type: 'Object',
+            type: 'object',
             root: true
         },
         http: {
@@ -18,23 +18,32 @@ module.exports = Self => {
         }
     });
 
-    Self.confirmTransaction = async(ctx, id) => {
+    Self.confirmTransaction = async(ctx, id, options) => {
-        let userId = ctx.req.accessToken.userId;
+        const models = Self.app.models;
-        let tx = await Self.beginTransaction({});
+        const userId = ctx.req.accessToken.userId;
+
+        let tx;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
 
         try {
-            let options = {transaction: tx};
+            const oldTpvTransaction = await models.TpvTransaction.findById(id, null, myOptions);
 
-            let oldTpvTransaction = await Self.app.models.TpvTransaction.findById(id, null, options);
+            const confirm = await Self.rawSql('CALL hedera.tpvTransaction_confirmById(?)', [id], myOptions);
 
-            let confirm = await Self.rawSql('CALL hedera.tpvTransaction_confirmById(?)', [id], options);
+            const tpvTransaction = await models.TpvTransaction.findById(id, null, myOptions);
 
-            let tpvTransaction = await Self.app.models.TpvTransaction.findById(id, null, options);
+            const oldInstance = {status: oldTpvTransaction.status};
+            const newInstance = {status: tpvTransaction.status};
 
-            let oldInstance = {status: oldTpvTransaction.status};
+            const logRecord = {
-            let newInstance = {status: tpvTransaction.status};
-
-            let logRecord = {
                 originFk: tpvTransaction.clientFk,
                 userFk: userId,
                 action: 'update',
@@ -44,12 +53,13 @@ module.exports = Self => {
                 newInstance: newInstance
             };
 
-            await Self.app.models.ClientLog.create(logRecord, options);
+            await models.ClientLog.create(logRecord, myOptions);
+
+            if (tx) await tx.commit();
 
-            await tx.commit();
             return confirm;
         } catch (e) {
-            await tx.rollback();
+            if (tx) await tx.rollback();
             throw e;
         }
     };

modules/client/back/methods/client/consumption.js

@@ -10,44 +10,52 @@ module.exports = Self => {
         accepts: [
             {
                 arg: 'filter',
-                type: 'Object',
+                type: 'object',
                 description: 'Filter defining where, order, offset, and limit - must be a JSON-encoded string'
-            }, {
+            },
+            {
                 arg: 'search',
-                type: 'String',
+                type: 'string',
                 description: `If it's and integer searchs by id, otherwise it searchs by name`
-            }, {
+            },
+            {
                 arg: 'itemId',
-                type: 'Number',
+                type: 'number',
                 description: 'Item id'
-            }, {
+            },
+            {
                 arg: 'categoryId',
-                type: 'Number',
+                type: 'number',
                 description: 'Category id'
-            }, {
+            },
+            {
                 arg: 'typeId',
-                type: 'Number',
+                type: 'number',
                 description: 'Item type id',
-            }, {
+            },
+            {
                 arg: 'buyerId',
-                type: 'Number',
+                type: 'number',
                 description: 'Buyer id'
-            }, {
+            },
+            {
                 arg: 'from',
-                type: 'Date',
+                type: 'date',
                 description: `The from date filter`
-            }, {
+            },
+            {
                 arg: 'to',
-                type: 'Date',
+                type: 'date',
                 description: `The to date filter`
-            }, {
+            },
+            {
                 arg: 'grouped',
-                type: 'Boolean',
+                type: 'boolean',
                 description: 'Group by item'
             }
         ],
         returns: {
-            type: ['Object'],
+            type: ['object'],
             root: true
         },
         http: {
@@ -56,7 +64,12 @@ module.exports = Self => {
         }
     });
 
-    Self.consumption = async(ctx, filter) => {
+    Self.consumption = async(ctx, filter, options) => {
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
         const conn = Self.dataSource.connector;
         const args = ctx.args;
         const where = buildFilter(ctx.args, (param, value) => {
@@ -83,7 +96,7 @@ module.exports = Self => {
         });
         filter = mergeFilters(filter, {where});
 
-        let stmt = new ParameterizedSQL('SELECT');
+        const stmt = new ParameterizedSQL('SELECT');
         if (args.grouped)
             stmt.merge(`SUM(s.quantity) AS quantity,`);
         else
@@ -121,6 +134,6 @@ module.exports = Self => {
 
         stmt.merge(conn.makePagination(filter));
 
-        return conn.executeStmt(stmt);
+        return conn.executeStmt(stmt, myOptions);
     };
 };

modules/client/back/methods/client/createAddress.js

@@ -62,7 +62,7 @@ module.exports = function(Self) {
         }],
         returns: {
             root: true,
-            type: 'Object'
+            type: 'object'
         },
         http: {
             verb: 'post',
@@ -70,18 +70,26 @@ module.exports = function(Self) {
         }
     });
 
-    Self.createAddress = async(ctx, clientFk) => {
+    Self.createAddress = async(ctx, clientFk, options) => {
         const models = Self.app.models;
         const args = ctx.args;
-        const tx = await models.Address.beginTransaction({});
+        let tx;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
 
         try {
-            const options = {transaction: tx};
             const province = await models.Province.findById(args.provinceFk, {
                 include: {
                     relation: 'country'
                 }
-            }, options);
+            }, myOptions);
 
             const isUeeMember = province.country().isUeeMember;
             if (!isUeeMember && !args.incotermsFk)
@@ -91,19 +99,20 @@ module.exports = function(Self) {
                 throw new UserError(`Customs agent is required for a non UEE member`);
 
             delete args.ctx; // Remove unwanted properties
-            const newAddress = await models.Address.create(args, options);
+            const newAddress = await models.Address.create(args, myOptions);
-            const client = await Self.findById(clientFk, null, options);
+            const client = await Self.findById(clientFk, null, myOptions);
 
             if (args.isDefaultAddress) {
                 await client.updateAttributes({
                     defaultAddressFk: newAddress.id
-                }, options);
+                }, myOptions);
             }
 
-            await tx.commit();
+            if (tx) await tx.commit();
+
             return newAddress;
         } catch (e) {
-            await tx.rollback();
+            if (tx) await tx.rollback();
             throw e;
         }
     };

modules/client/back/methods/client/createReceipt.js

@@ -48,19 +48,26 @@ module.exports = function(Self) {
         }
     });
 
-    Self.createReceipt = async ctx => {
+    Self.createReceipt = async(ctx, options) => {
         const models = Self.app.models;
         const args = ctx.args;
-        const tx = await models.Address.beginTransaction({});
+        let tx;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
 
         try {
-            const options = {transaction: tx};
-
             delete args.ctx; // Remove unwanted properties
-            const newReceipt = await models.Receipt.create(args, options);
+            const newReceipt = await models.Receipt.create(args, myOptions);
-            const clientOriginal = await models.Client.findById(args.clientFk);
+            const originalClient = await models.Client.findById(args.clientFk, myOptions);
-            const bank = await models.Bank.findById(args.bankFk);
+            const bank = await models.Bank.findById(args.bankFk, null, myOptions);
-            const accountingType = await models.AccountingType.findById(bank.accountingTypeFk);
+            const accountingType = await models.AccountingType.findById(bank.accountingTypeFk, null, myOptions);
 
             if (accountingType.code == 'compensation') {
                 if (!args.compensationAccount)
@@ -70,14 +77,16 @@ module.exports = function(Self) {
                     where: {
                         account: args.compensationAccount
                     }
-                });
+                }, myOptions);
+
                 let clientCompensation = {};
+
                 if (!supplierCompensation) {
                     clientCompensation = await models.Client.findOne({
                         where: {
                             accountingAccount: args.compensationAccount
                         }
-                    });
+                    }, myOptions);
                 }
                 if (!supplierCompensation && !clientCompensation)
                     throw new UserError('Invalid account');
@@ -87,20 +96,21 @@ module.exports = function(Self) {
                     [
                         args.compensationAccount,
                         args.bankFk,
-                        accountingType.receiptDescription + clientOriginal.accountingAccount,
+                        accountingType.receiptDescription + originalClient.accountingAccount,
                         args.amountPaid,
                         args.companyFk,
-                        clientOriginal.accountingAccount
+                        originalClient.accountingAccount
                     ],
-                    options);
+                    myOptions
+                );
             } else if (accountingType.isAutoConciliated == true) {
-                const description = `${clientOriginal.id} : ${clientOriginal.socialName} - ${accountingType.receiptDescription}`;
+                const description = `${originalClient.id} : ${originalClient.socialName} - ${accountingType.receiptDescription}`;
                 const [xdiarioNew] = await Self.rawSql(
                     `SELECT xdiario_new(?, CURDATE(), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ledger;`,
                     [
                         null,
                         bank.account,
-                        clientOriginal.accountingAccount,
+                        originalClient.accountingAccount,
                         description,
                         args.amountPaid,
                         0,
@@ -112,13 +122,14 @@ module.exports = function(Self) {
                         false,
                         args.companyFk
                     ],
-                    options);
+                    myOptions
+                );
 
                 await Self.rawSql(
                     `SELECT xdiario_new(?, CURDATE(), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);`,
                     [
                         xdiarioNew.ledger,
-                        clientOriginal.accountingAccount,
+                        originalClient.accountingAccount,
                         bank.account,
                         description,
                         0,
@@ -131,13 +142,15 @@ module.exports = function(Self) {
                         false,
                         args.companyFk
                     ],
-                    options);
+                    myOptions
+                );
             }
 
-            await tx.commit();
+            if (tx) await tx.commit();
+
             return newReceipt;
         } catch (e) {
-            await tx.rollback();
+            if (tx) await tx.rollback();
             throw e;
         }
     };

modules/client/back/methods/client/createWithUser.js

@@ -16,22 +16,29 @@ module.exports = function(Self) {
         }
     });
 
-    Self.createWithUser = async data => {
+    Self.createWithUser = async(data, options) => {
-        let firstEmail = data.email ? data.email.split(',')[0] : null;
+        const models = Self.app.models;
-        let user = {
+        let tx;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
+
+        const firstEmail = data.email ? data.email.split(',')[0] : null;
+        const user = {
             name: data.userName,
             email: firstEmail,
             password: parseInt(Math.random() * 100000000000000)
         };
-        const Account = Self.app.models.Account;
-        const Address = Self.app.models.Address;
-        const tx = await Account.beginTransaction({});
 
         try {
-            let options = {transaction: tx};
+            const account = await models.Account.create(user, myOptions);
-
+            const client = await Self.create({
-            let account = await Account.create(user, options);
-            let client = await Self.create({
                 id: account.id,
                 name: data.name,
                 fi: data.fi,
@@ -44,9 +51,9 @@ module.exports = function(Self) {
                 provinceFk: data.provinceFk,
                 countryFk: data.countryFk,
                 isEqualizated: data.isEqualizated
-            }, options);
+            }, myOptions);
 
-            let address = await Address.create({
+            const address = await models.Address.create({
                 clientFk: client.id,
                 nickname: client.name,
                 city: client.city,
@@ -55,16 +62,17 @@ module.exports = function(Self) {
                 provinceFk: client.provinceFk,
                 isEqualizated: client.isEqualizated,
                 isActive: true
-            }, options);
+            }, myOptions);
 
             await client.updateAttributes({
                 defaultAddressFk: address.id
-            }, options);
+            }, myOptions);
+
+            if (tx) await tx.commit();
 
-            await tx.commit();
             return client;
         } catch (e) {
-            await tx.rollback();
+            if (tx) await tx.rollback();
             throw e;
         }
     };

modules/client/back/methods/client/getAverageInvoiced.js

@@ -19,9 +19,14 @@ module.exports = Self => {
         }
     });
 
-    Self.getAverageInvoiced = async clientFk => {
+    Self.getAverageInvoiced = async(clientFk, options) => {
-        let query = `SELECT invoiced FROM vn.annualAverageInvoiced WHERE clientFk = ?`;
+        const myOptions = {};
-        let [invoiced] = await Self.rawSql(query, [clientFk]);
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const query = `SELECT invoiced FROM vn.annualAverageInvoiced WHERE clientFk = ?`;
+        const [invoiced] = await Self.rawSql(query, [clientFk], myOptions);
 
         return invoiced;
     };

modules/client/back/methods/client/getCard.js

@@ -9,7 +9,7 @@ module.exports = function(Self) {
             http: {source: 'path'}
         },
         returns: {
-            type: 'Object',
+            type: 'object',
             root: true
         },
         http: {
@@ -18,8 +18,13 @@ module.exports = function(Self) {
         }
     });
 
-    Self.getCard = async function(id) {
+    Self.getCard = async(id, options) => {
-        let client = await Self.findOne({
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const client = await Self.findOne({
             where: {
                 id: id
             },
@@ -29,38 +34,44 @@ module.exports = function(Self) {
                     scope: {
                         fields: ['id', 'name']
                     }
-                }, {
+                },
+                {
                     relation: 'province',
                     scope: {
                         fields: ['id', 'name']
                     }
-                }, {
+                },
-                }, {
+                {
                     relation: 'salesPersonUser',
                     scope: {
                         fields: ['id', 'name']
                     }
-                }, {
+                },
+                {
                     relation: 'country',
                     scope: {
                         fields: ['id', 'country']
                     }
-                }, {
+                },
+                {
                     relation: 'payMethod',
                     scope: {
                         fields: ['id', 'name']
                     }
-                }, {
+                },
+                {
                     relation: 'account',
                     scope: {
                         fields: ['id', 'name', 'active']
                     }
                 }
             ]
-        });
+        }, myOptions);
 
-        let query = `SELECT vn.clientGetDebt(?, CURDATE()) AS debt`;
+        const query = `SELECT vn.clientGetDebt(?, CURDATE()) AS debt`;
-        client.debt = (await Self.rawSql(query, [id]))[0].debt;
+        const data = await Self.rawSql(query, [id], myOptions);
+
+        client.debt = data[0].debt;
 
         return client;
     };

modules/client/back/methods/client/getDebt.js

@@ -19,9 +19,14 @@ module.exports = Self => {
         }
     });
 
-    Self.getDebt = async clientFk => {
+    Self.getDebt = async(clientFk, options) => {
-        let query = `SELECT vn.clientGetDebt(?, CURDATE()) AS debt`;
+        const myOptions = {};
-        let [debt] = await Self.rawSql(query, [clientFk]);
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const query = `SELECT vn.clientGetDebt(?, CURDATE()) AS debt`;
+        const [debt] = await Self.rawSql(query, [clientFk], myOptions);
 
         return debt;
     };

modules/client/back/methods/client/getMana.js

@@ -19,9 +19,14 @@ module.exports = Self => {
         }
     });
 
-    Self.getMana = async clientFk => {
+    Self.getMana = async(clientFk, options) => {
-        let query = `SELECT vn.clientGetMana(?) AS mana`;
+        const myOptions = {};
-        let [mana] = await Self.rawSql(query, [clientFk]);
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const query = `SELECT vn.clientGetMana(?) AS mana`;
+        const [mana] = await Self.rawSql(query, [clientFk], myOptions);
 
         return mana;
     };

modules/client/back/methods/client/getTransactions.js

@@ -7,12 +7,12 @@ module.exports = Self => {
         accessType: 'READ',
         accepts: [{
             arg: 'filter',
-            type: 'Object',
+            type: 'object',
             description: 'Filter defining where, order, offset, and limit - must be a JSON-encoded string',
             http: {source: 'query'}
         }],
         returns: {
-            type: ['Object'],
+            type: ['object'],
             root: true
         },
         http: {
@@ -21,9 +21,14 @@ module.exports = Self => {
         }
     });
 
-    Self.getTransactions = async filter => {
+    Self.getTransactions = async(filter, options) => {
-        let conn = Self.dataSource.connector;
+        const myOptions = {};
-        let stmt = new ParameterizedSQL(`
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const conn = Self.dataSource.connector;
+        const stmt = new ParameterizedSQL(`
             SELECT 
                 t.id, 
                 t.clientFk, 
@@ -39,6 +44,6 @@ module.exports = Self => {
 
         stmt.merge(conn.makeSuffix(filter, 't'));
 
-        return await Self.rawStmt(stmt);
+        return Self.rawStmt(stmt, myOptions);
     };
 };

modules/client/back/methods/client/hasCustomerRole.js

@@ -2,23 +2,13 @@ module.exports = Self => {
     Self.remoteMethod('hasCustomerRole', {
         description: 'Comprueba si un usuario tiene el rol de cliente',
         accessType: 'READ',
-        accepts: [
+        accepts: [{
-            {
+            arg: 'id',
-                arg: 'id',
+            type: 'string',
-                type: 'string',
+            required: true,
-                required: true,
+            description: 'The user id',
-                description: 'The user id',
+            http: {source: 'path'}
-                http: {source: 'path'}
+        }],
-            }, {
-                arg: 'context',
-                type: 'object',
-                required: true,
-                description: 'Filter defining where',
-                http: function(context) {
-                    return context.req.query;
-                }
-            }
-        ],
         returns: {
             type: 'boolean',
             root: true
@@ -29,17 +19,19 @@ module.exports = Self => {
         }
     });
 
-    Self.hasCustomerRole = (id, context, callback) => {
+    Self.hasCustomerRole = (id, options) => {
-        let query = `
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const query = `
             SELECT COUNT(*) > 0 isCustomer
                 FROM salix.Account A
                     JOIN salix.Role r ON r.id = A.roleFK
                 WHERE r.name = 'customer'
                     AND A.id IN (?)`;
 
-        Self.rawSql(query, [id]).then(
+        return Self.rawSql(query, [id], myOptions);
-            instances => callback(null, instances[0]),
-            err => callback(err)
-        );
     };
 };

modules/client/back/methods/client/isValidClient.js

@@ -9,14 +9,6 @@ module.exports = Self => {
                 required: true,
                 description: 'The user id',
                 http: {source: 'path'}
-            }, {
-                arg: 'context',
-                type: 'object',
-                required: true,
-                description: 'Filter defining where',
-                http: function(context) {
-                    return context.req.query;
-                }
             }
         ],
         returns: {
@@ -29,8 +21,13 @@ module.exports = Self => {
         }
     });
 
-    Self.isValidClient = async id => {
+    Self.isValidClient = async(id, options) => {
-        let query = `
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const query = `
             SELECT r.name
             FROM salix.Account a
                 JOIN vn.client c ON a.id = c.id
@@ -38,9 +35,9 @@ module.exports = Self => {
                 JOIN salix.Role r ON r.id = rm.roleId
             WHERE a.id = ? AND c.isActive AND c.isTaxDataChecked`;
 
-        let roleNames = await Self.rawSql(query, [id]);
+        const roleNames = await Self.rawSql(query, [id], myOptions);
 
-        let isEmployee = roleNames.findIndex(role => {
+        const isEmployee = roleNames.findIndex(role => {
             return role.name === 'employee';
         });
 

modules/client/back/methods/client/lastActiveTickets.js

@@ -2,19 +2,22 @@ module.exports = Self => {
     Self.remoteMethod('lastActiveTickets', {
         description: 'Returns the last three active tickets of a client',
         accessType: 'READ',
-        accepts: [{
+        accepts: [
-            arg: 'id',
+            {
-            type: 'Number',
+                arg: 'id',
-            required: true,
+                type: 'number',
-            description: 'Client id',
+                required: true,
-            http: {source: 'path'}
+                description: 'Client id',
-        }, {
+                http: {source: 'path'}
-            arg: 'ticketId',
+            },
-            type: 'Number',
+            {
-            required: true
+                arg: 'ticketId',
-        }],
+                type: 'number',
+                required: true
+            }
+        ],
         returns: {
-            type: ['Object'],
+            type: ['object'],
             root: true
         },
         http: {
@@ -23,8 +26,13 @@ module.exports = Self => {
         }
     });
 
-    Self.lastActiveTickets = async(id, ticketId) => {
+    Self.lastActiveTickets = async(id, ticketId, options) => {
-        const ticket = await Self.app.models.Ticket.findById(ticketId);
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const ticket = await Self.app.models.Ticket.findById(ticketId, null, myOptions);
         const query = `
             SELECT 
                 t.id,
@@ -47,7 +55,7 @@ module.exports = Self => {
             ORDER BY t.shipped
                 LIMIT 10`;
 
-        return Self.rawSql(query, [id, ticketId, ticket.warehouseFk]);
+        return Self.rawSql(query, [id, ticketId, ticket.warehouseFk], myOptions);
     };
 };
 

modules/client/back/methods/client/sendSms.js

@@ -5,23 +5,23 @@ module.exports = Self => {
         accessType: 'WRITE',
         accepts: [{
             arg: 'id',
-            type: 'Number',
+            type: 'number',
             required: true,
             description: 'The ticket id',
             http: {source: 'path'}
         },
         {
             arg: 'destination',
-            type: 'String',
+            type: 'string',
             required: true,
         },
         {
             arg: 'message',
-            type: 'String',
+            type: 'string',
             required: true,
         }],
         returns: {
-            type: 'Object',
+            type: 'object',
             root: true
         },
         http: {
@@ -30,11 +30,17 @@ module.exports = Self => {
         }
     });
 
-    Self.sendSms = async(ctx, id, destination, message) => {
+    Self.sendSms = async(ctx, id, destination, message, options) => {
+        const models = Self.app.models;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
         const userId = ctx.req.accessToken.userId;
 
-        let sms = await Self.app.models.Sms.send(ctx, id, destination, message);
+        const sms = await models.Sms.send(ctx, id, destination, message);
-        let logRecord = {
+        const logRecord = {
             originFk: id,
             userFk: userId,
             action: 'insert',
@@ -48,7 +54,7 @@ module.exports = Self => {
             }
         };
 
-        const clientLog = await Self.app.models.ClientLog.create(logRecord);
+        const clientLog = await models.ClientLog.create(logRecord, myOptions);
 
         sms.logId = clientLog.id;
 

modules/client/back/methods/client/specs/addressesPropagateRe.spec.js

@@ -1,40 +1,30 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client addressesPropagateRe', () => {
-    let client;
-    beforeEach(async() => {
-        client = await app.models.Client.findById(1101);
-        await app.models.Address.update({clientFk: 1101}, {isEqualizated: false});
-        await client.updateAttributes({hasToInvoiceByAddress: true});
-    });
-
-    afterAll(async done => {
-        await app.models.Address.update({clientFk: 1101}, {isEqualizated: false});
-        await client.updateAttributes({hasToInvoiceByAddress: true});
-
-        done();
-    });
-
     it('should propagate the isEqualizated on both addresses of Mr Wayne and set hasToInvoiceByAddress to false', async() => {
-        let id = 1101;
+        const tx = await models.Client.beginTransaction({});
-        let data = {
-            isEqualizated: true
-        };
 
-        let resultAddress = await app.models.Address.find({where: {clientFk: id}});
+        try {
-        let resultClient = await app.models.Client.find({where: {id: id}});
+            const options = {transaction: tx};
 
-        expect(resultAddress[0].isEqualizated).toBeFalsy();
+            let id = 1101;
-        expect(resultAddress[1].isEqualizated).toBeFalsy();
+            let data = {
-        expect(resultClient[0].hasToInvoiceByAddress).toBeTruthy();
+                isEqualizated: true
+            };
 
-        await app.models.Client.addressesPropagateRe(id, data);
+            await models.Client.addressesPropagateRe(id, data, options);
 
-        resultAddress = await app.models.Address.find({where: {clientFk: id}});
+            const addresses = await models.Address.find({where: {clientFk: id}}, options);
-        resultClient = await app.models.Client.find({where: {id: id}});
+            const client = await models.Client.findById(id, null, options);
 
-        expect(resultAddress[0].isEqualizated).toBeTruthy();
+            expect(addresses[0].isEqualizated).toBeTruthy();
-        expect(resultAddress[1].isEqualizated).toBeTruthy();
+            expect(addresses[1].isEqualizated).toBeTruthy();
-        expect(resultClient[0].hasToInvoiceByAddress).toBeFalsy();
+            expect(client.hasToInvoiceByAddress).toBeFalsy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
     });
 });

modules/client/back/methods/client/specs/canBeInvoiced.spec.js

@@ -1,4 +1,4 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 const LoopBackContext = require('loopback-context');
 
 describe('client canBeInvoiced()', () => {
@@ -7,7 +7,6 @@ describe('client canBeInvoiced()', () => {
     const activeCtx = {
         accessToken: {userId: userId}
     };
-    const models = app.models;
 
     beforeAll(async done => {
         spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
@@ -18,7 +17,7 @@ describe('client canBeInvoiced()', () => {
     });
 
     it('should return falsy for a client without the data checked', async() => {
-        const tx = await models.Ticket.beginTransaction({});
+        const tx = await models.Client.beginTransaction({});
 
         try {
             const options = {transaction: tx};
@@ -37,7 +36,7 @@ describe('client canBeInvoiced()', () => {
     });
 
     it('should return falsy for a client with invoicing disabled', async() => {
-        const tx = await models.Ticket.beginTransaction({});
+        const tx = await models.Client.beginTransaction({});
 
         try {
             const options = {transaction: tx};
@@ -56,8 +55,18 @@ describe('client canBeInvoiced()', () => {
     });
 
     it('should return truthy for an invoiceable client', async() => {
-        const canBeInvoiced = await models.Client.canBeInvoiced(clientId);
+        const tx = await models.Client.beginTransaction({});
 
-        expect(canBeInvoiced).toEqual(true);
+        try {
+            const options = {transaction: tx};
+
+            const canBeInvoiced = await models.Client.canBeInvoiced(clientId, options);
+
+            expect(canBeInvoiced).toEqual(true);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/canCreateTicket.spec.js

@@ -1,17 +1,37 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client canCreateTicket', () => {
     it('should receive true if the client is active', async() => {
-        let id = 1105;
+        const tx = await models.Client.beginTransaction({});
-        let canCreateTicket = await app.models.Client.canCreateTicket(id);
 
-        expect(canCreateTicket).toBeTruthy();
+        try {
+            const options = {transaction: tx};
+
+            const id = 1105;
+            const canCreateTicket = await models.Client.canCreateTicket(id, null, options);
+
+            expect(canCreateTicket).toBeTruthy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it(`should receive false if the client isn't active`, async() => {
-        let id = 1106;
+        const tx = await models.Client.beginTransaction({});
-        let canCreateTicket = await app.models.Client.canCreateTicket(id);
 
-        expect(canCreateTicket).toBe(false);
+        try {
+            const options = {transaction: tx};
+
+            const id = 1106;
+            const canCreateTicket = await models.Client.canCreateTicket(id, null, options);
+
+            expect(canCreateTicket).toBe(false);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/confirmTransaction.spec.js

@@ -1,24 +1,26 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client confirmTransaction', () => {
-    const transactionId = 2;
-
-    afterAll(async done => {
-        await app.models.Client.rawSql(`
-        CALL hedera.tpvTransaction_undo(?)`, [transactionId]);
-
-        done();
-    });
-
     it('should call confirmTransaction() method to mark transaction as confirmed', async() => {
-        let ctx = {req: {accessToken: {userId: 1}}};
+        const tx = await models.Client.beginTransaction({});
-        await app.models.Client.confirmTransaction(ctx, transactionId);
+        const transactionId = 2;
 
-        let [receipt] = await app.models.Client.rawSql(
+        try {
-            `SELECT receiptFk 
+            const options = {transaction: tx};
-                FROM hedera.tpvTransaction 
-                WHERE id = ?`, [transactionId]);
 
-        expect(receipt.receiptFk).toBeGreaterThan(0);
+            let ctx = {req: {accessToken: {userId: 1}}};
+            await models.Client.confirmTransaction(ctx, transactionId, options);
+
+            let [receipt] = await models.Client.rawSql(
+                `SELECT receiptFk 
+                    FROM hedera.tpvTransaction 
+                    WHERE id = ?`, [transactionId], options);
+
+            expect(receipt.receiptFk).toBeGreaterThan(0);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/consumption.spec.js

@@ -1,60 +1,90 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('client consumption() filter', () => {
     it('should return a list of buyed items by ticket', async() => {
-        const ctx = {req: {accessToken: {userId: 9}}, args: {}};
+        const tx = await models.Client.beginTransaction({});
-        const filter = {
-            where: {
-                clientFk: 1101
-            },
-            order: 'itemTypeFk, itemName, itemSize'
-        };
-        const result = await app.models.Client.consumption(ctx, filter);
 
-        expect(result.length).toEqual(10);
+        try {
+            const options = {transaction: tx};
+
+            const ctx = {req: {accessToken: {userId: 9}}, args: {}};
+            const filter = {
+                where: {
+                    clientFk: 1101
+                },
+                order: 'itemTypeFk, itemName, itemSize'
+            };
+            const result = await app.models.Client.consumption(ctx, filter, options);
+
+            expect(result.length).toEqual(10);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should return a list of tickets grouped by item', async() => {
-        const ctx = {req: {accessToken: {userId: 9}},
+        const tx = await models.Client.beginTransaction({});
-            args: {
-                grouped: true
-            }
-        };
-        const filter = {
-            where: {
-                clientFk: 1101
-            },
-            order: 'itemFk'
-        };
-        const result = await app.models.Client.consumption(ctx, filter);
 
-        const firstRow = result[0];
+        try {
-        const secondRow = result[1];
+            const options = {transaction: tx};
-        const thirdRow = result[2];
 
-        expect(result.length).toEqual(3);
+            const ctx = {req: {accessToken: {userId: 9}},
-        expect(firstRow.quantity).toEqual(10);
+                args: {
-        expect(secondRow.quantity).toEqual(15);
+                    grouped: true
-        expect(thirdRow.quantity).toEqual(20);
+                }
+            };
+            const filter = {
+                where: {
+                    clientFk: 1101
+                },
+                order: 'itemFk'
+            };
+            const result = await app.models.Client.consumption(ctx, filter, options);
+
+            const firstRow = result[0];
+            const secondRow = result[1];
+            const thirdRow = result[2];
+
+            expect(result.length).toEqual(3);
+            expect(firstRow.quantity).toEqual(10);
+            expect(secondRow.quantity).toEqual(15);
+            expect(thirdRow.quantity).toEqual(20);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should return a list of tickets from the item id 4', async() => {
-        const ctx = {req: {accessToken: {userId: 9}},
+        const tx = await models.Client.beginTransaction({});
-            args: {
-                itemId: 4
-            }
-        };
-        const filter = {
-            where: {
-                clientFk: 1101
-            },
-            order: 'itemTypeFk, itemName, itemSize'
-        };
-        const result = await app.models.Client.consumption(ctx, filter);
 
-        const expectedItemId = 4;
+        try {
-        const firstRow = result[0];
+            const options = {transaction: tx};
 
-        expect(firstRow.itemFk).toEqual(expectedItemId);
+            const ctx = {req: {accessToken: {userId: 9}},
+                args: {
+                    itemId: 4
+                }
+            };
+            const filter = {
+                where: {
+                    clientFk: 1101
+                },
+                order: 'itemTypeFk, itemName, itemSize'
+            };
+            const result = await app.models.Client.consumption(ctx, filter, options);
+
+            const expectedItemId = 4;
+            const firstRow = result[0];
+
+            expect(firstRow.itemFk).toEqual(expectedItemId);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/createAddress.spec.js

@@ -1,4 +1,4 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Address createAddress', () => {
     const clientFk = 1101;
@@ -7,107 +7,131 @@ describe('Address createAddress', () => {
     const customAgentOneId = 1;
 
     it('should throw a non uee member error if no incoterms is defined', async() => {
-        const expectedResult = 'My edited address';
+        const tx = await models.Client.beginTransaction({});
-        const ctx = {
+
-            args: {
+        let error;
-                provinceFk: provinceFk,
-                nickname: expectedResult,
-                street: 'Wall Street',
-                city: 'New York',
-                customsAgentFk: customAgentOneId
-            }
-        };
 
         try {
-            await app.models.Client.createAddress(ctx, clientFk);
+            const options = {transaction: tx};
+
+            const expectedResult = 'My edited address';
+            const ctx = {
+                args: {
+                    provinceFk: provinceFk,
+                    nickname: expectedResult,
+                    street: 'Wall Street',
+                    city: 'New York',
+                    customsAgentFk: customAgentOneId
+                }
+            };
+
+            await models.Client.createAddress(ctx, clientFk, options);
+
+            await tx.rollback();
         } catch (e) {
-            err = e;
+            await tx.rollback();
+            error = e;
         }
 
-        expect(err).toBeDefined();
+        expect(error).toBeDefined();
-        expect(err.message).toEqual('Incoterms is required for a non UEE member');
+        expect(error.message).toEqual('Incoterms is required for a non UEE member');
     });
 
     it('should throw a non uee member error if no customsAgent is defined', async() => {
-        const expectedResult = 'My edited address';
+        const tx = await models.Client.beginTransaction({});
-        const ctx = {
+
-            args: {
+        let error;
-                provinceFk: provinceFk,
-                nickname: expectedResult,
-                street: 'Wall Street',
-                city: 'New York',
-                incotermsFk: incotermsFk
-            }
-        };
 
         try {
-            await app.models.Client.createAddress(ctx, clientFk);
+            const options = {transaction: tx};
+
+            const expectedResult = 'My edited address';
+            const ctx = {
+                args: {
+                    provinceFk: provinceFk,
+                    nickname: expectedResult,
+                    street: 'Wall Street',
+                    city: 'New York',
+                    incotermsFk: incotermsFk
+                }
+            };
+
+            await models.Client.createAddress(ctx, clientFk, options);
+
+            await tx.rollback();
         } catch (e) {
-            err = e;
+            await tx.rollback();
+            error = e;
         }
 
-        expect(err).toBeDefined();
+        expect(error).toBeDefined();
-        expect(err.message).toEqual('Customs agent is required for a non UEE member');
+        expect(error.message).toEqual('Customs agent is required for a non UEE member');
-    });
-
-    it('should verify that client defaultAddressFk is untainted', async() => {
-        const client = await app.models.Client.findById(clientFk);
-
-        expect(client.defaultAddressFk).toEqual(1);
     });
 
     it('should create a new address and set as a client default address', async() => {
-        const ctx = {
+        const tx = await models.Client.beginTransaction({});
-            args: {
-                clientFk: 1101,
-                provinceFk: 1,
-                nickname: 'My address',
-                street: 'Wall Street',
-                city: 'New York',
-                phone: 678678678,
-                mobile: 678678678,
-                postalCode: 46680,
-                agencyModeFk: 1,
-                incotermsFk: incotermsFk,
-                customsAgentFk: customAgentOneId,
-                isDefaultAddress: true
-            }
-        };
 
-        const address = await app.models.Client.createAddress(ctx, clientFk);
+        try {
-        const client = await app.models.Client.findById(clientFk);
+            const options = {transaction: tx};
 
-        expect(client.defaultAddressFk).toEqual(address.id);
+            const ctx = {
+                args: {
+                    clientFk: 1101,
+                    provinceFk: 1,
+                    nickname: 'My address',
+                    street: 'Wall Street',
+                    city: 'New York',
+                    phone: 678678678,
+                    mobile: 678678678,
+                    postalCode: 46680,
+                    agencyModeFk: 1,
+                    incotermsFk: incotermsFk,
+                    customsAgentFk: customAgentOneId,
+                    isDefaultAddress: true
+                }
+            };
 
-        // restores
+            const address = await models.Client.createAddress(ctx, clientFk, options);
-        await client.updateAttributes({defaultAddressFk: 1});
+            const client = await models.Client.findById(clientFk, null, options);
-        await address.destroy();
+
+            expect(client.defaultAddressFk).toEqual(address.id);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should create a new address and set all properties', async() => {
-        const ctx = {
+        const tx = await models.Client.beginTransaction({});
-            args: {
-                clientFk: 1101,
-                provinceFk: 1,
-                nickname: 'My address',
-                street: 'Wall Street',
-                city: 'New York',
-                phone: '678678678',
-                mobile: '678678678',
-                postalCode: '46680',
-                agencyModeFk: 1,
-                incotermsFk: incotermsFk,
-                customsAgentFk: customAgentOneId,
-                isDefaultAddress: true
-            }
-        };
 
-        address = await app.models.Client.createAddress(ctx, clientFk);
+        try {
+            const options = {transaction: tx};
 
-        expect(address).toEqual(jasmine.objectContaining(ctx.args));
+            const ctx = {
-        // restores
+                args: {
-        const client = await app.models.Client.findById(clientFk);
+                    clientFk: 1101,
-        await client.updateAttributes({defaultAddressFk: 1});
+                    provinceFk: 1,
-        await address.destroy();
+                    nickname: 'My address',
+                    street: 'Wall Street',
+                    city: 'New York',
+                    phone: '678678678',
+                    mobile: '678678678',
+                    postalCode: '46680',
+                    agencyModeFk: 1,
+                    incotermsFk: incotermsFk,
+                    customsAgentFk: customAgentOneId,
+                    isDefaultAddress: true
+                }
+            };
+
+            address = await models.Client.createAddress(ctx, clientFk, options);
+
+            expect(address).toEqual(jasmine.objectContaining(ctx.args));
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/createReceipt.spec.js

@@ -1,4 +1,4 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 const LoopBackContext = require('loopback-context');
 
 describe('Client createReceipt', () => {
@@ -27,49 +27,55 @@ describe('Client createReceipt', () => {
     });
 
     it('should create a new receipt', async() => {
-        const bankFk = 1;
+        const tx = await models.Client.beginTransaction({});
-        ctx.args = {
-            clientFk: clientFk,
-            payed: payed,
-            companyFk: companyFk,
-            bankFk: bankFk,
-            amountPaid: amountPaid,
-            description: description
-        };
 
-        const receipt = await app.models.Client.createReceipt(ctx);
+        try {
-        delete ctx.args.payed;
+            const options = {transaction: tx};
 
-        const till = await app.models.Till.findOne({
+            const bankFk = 1;
-            where: {
+            ctx.args = {
+                clientFk: clientFk,
+                payed: payed,
+                companyFk: companyFk,
                 bankFk: bankFk,
-                in: amountPaid,
+                amountPaid: amountPaid,
-                number: clientFk
+                description: description
-            }
+            };
-        });
 
-        expect(receipt).toEqual(jasmine.objectContaining(ctx.args));
+            const receipt = await models.Client.createReceipt(ctx, options);
+            delete ctx.args.payed;
 
-        // restores
+            expect(receipt).toEqual(jasmine.objectContaining(ctx.args));
-        await receipt.destroy();
+
-        await till.destroy();
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should throw Compensation account is empty', async() => {
-        const bankFk = 3;
+        const tx = await models.Client.beginTransaction({});
 
-        ctx.args = {
+        let error;
-            clientFk: clientFk,
-            payed: payed,
-            companyFk: companyFk,
-            bankFk: bankFk,
-            amountPaid: amountPaid,
-            description: description
-        };
 
         try {
-            await app.models.Client.createReceipt(ctx);
+            const options = {transaction: tx};
+
+            const bankFk = 3;
+            ctx.args = {
+                clientFk: clientFk,
+                payed: payed,
+                companyFk: companyFk,
+                bankFk: bankFk,
+                amountPaid: amountPaid,
+                description: description
+            };
+
+            await models.Client.createReceipt(ctx, options);
+
+            await tx.rollback();
         } catch (e) {
+            await tx.rollback();
             error = e;
         }
 
@@ -78,21 +84,29 @@ describe('Client createReceipt', () => {
     });
 
     it('should throw Invalid account if compensationAccount does not belongs to a client nor a supplier', async() => {
+        const tx = await models.Client.beginTransaction({});
+
         let error;
-        const bankFk = 3;
-        ctx.args = {
-            clientFk: clientFk,
-            payed: payed,
-            companyFk: companyFk,
-            bankFk: bankFk,
-            amountPaid: amountPaid,
-            description: description,
-            compensationAccount: 'non existing account'
-        };
 
         try {
-            await app.models.Client.createReceipt(ctx);
+            const options = {transaction: tx};
+
+            const bankFk = 3;
+            ctx.args = {
+                clientFk: clientFk,
+                payed: payed,
+                companyFk: companyFk,
+                bankFk: bankFk,
+                amountPaid: amountPaid,
+                description: description,
+                compensationAccount: 'non existing account'
+            };
+
+            await models.Client.createReceipt(ctx, options);
+
+            await tx.rollback();
         } catch (e) {
+            await tx.rollback();
             error = e;
         }
 
@@ -101,84 +115,78 @@ describe('Client createReceipt', () => {
     });
 
     it('should create a new receipt with a compensation for a client', async() => {
-        const bankFk = 3;
+        const tx = await models.Client.beginTransaction({});
 
-        ctx.args = {
+        try {
-            clientFk: clientFk,
+            const options = {transaction: tx};
-            payed: payed,
-            companyFk: companyFk,
-            bankFk: bankFk,
-            amountPaid: amountPaid,
-            description: description,
-            compensationAccount: '4300000001'
-        };
-        const receipt = await app.models.Client.createReceipt(ctx);
-        const receiptCompensated = await app.models.Receipt.findOne({
-            where: {
-                clientFk: 1,
-                bankFk: ctx.args.bankFk
-            }
-        });
 
-        const till = await app.models.Till.findOne({
+            const bankFk = 3;
-            where: {
+
+            ctx.args = {
+                clientFk: clientFk,
+                payed: payed,
+                companyFk: companyFk,
                 bankFk: bankFk,
-                in: amountPaid,
+                amountPaid: amountPaid,
-                number: clientFk
+                description: description,
-            }
+                compensationAccount: '4300000001'
-        });
+            };
+            const receipt = await models.Client.createReceipt(ctx, options);
+            const receiptCompensated = await models.Receipt.findOne({
+                where: {
+                    clientFk: 1,
+                    bankFk: ctx.args.bankFk
+                }
+            }, options);
 
-        delete ctx.args.payed;
+            delete ctx.args.payed;
 
-        expect(receipt).toEqual(jasmine.objectContaining(ctx.args));
+            expect(receipt).toEqual(jasmine.objectContaining(ctx.args));
-        expect(receipt.amountPaid).toEqual(-receiptCompensated.amountPaid);
+            expect(receipt.amountPaid).toEqual(-receiptCompensated.amountPaid);
 
-        // restores
+            await tx.rollback();
-        await receipt.destroy();
+        } catch (e) {
-        await receiptCompensated.destroy();
+            await tx.rollback();
-        await till.destroy();
+        }
     });
 
     it('should create a new receipt with a compensation for a supplier', async() => {
-        const bankFk = 3;
+        const tx = await models.Client.beginTransaction({});
 
-        ctx.args = {
+        try {
-            clientFk: clientFk,
+            const options = {transaction: tx};
-            payed: payed,
-            companyFk: companyFk,
-            bankFk: bankFk,
-            amountPaid: amountPaid,
-            description: description,
-            compensationAccount: '4100000001'
-        };
-        const receipt = await app.models.Client.createReceipt(ctx);
 
-        const paymentCompensated = await app.models.Payment.findOne({
+            const bankFk = 3;
-            where: {
-                clientFk: ctx.args.sale,
-                payed: ctx.args.payed,
-                amountPaid: ctx.args.amountPaid,
-                bankFk: ctx.args.bankFk
-            }
-        });
 
-        const till = await app.models.Till.findOne({
+            ctx.args = {
-            where: {
+                clientFk: clientFk,
-                bankFk: ctx.args.bankFk,
+                payed: payed,
-                in: amountPaid,
+                companyFk: companyFk,
-                number: clientFk
+                bankFk: bankFk,
-            }
+                amountPaid: amountPaid,
-        });
+                description: description,
+                compensationAccount: '4100000001'
+            };
+            const receipt = await models.Client.createReceipt(ctx, options);
 
-        delete ctx.args.payed;
+            const paymentCompensated = await models.Payment.findOne({
+                where: {
+                    clientFk: ctx.args.sale,
+                    payed: ctx.args.payed,
+                    amountPaid: ctx.args.amountPaid,
+                    bankFk: ctx.args.bankFk
+                }
+            }, options);
 
-        expect(receipt).toEqual(jasmine.objectContaining(ctx.args));
+            delete ctx.args.payed;
 
-        expect(paymentCompensated.amountPaid).toEqual(paymentCompensated.amountPaid);
+            expect(receipt).toEqual(jasmine.objectContaining(ctx.args));
 
-        // restores
+            expect(paymentCompensated.amountPaid).toEqual(paymentCompensated.amountPaid);
-        await receipt.destroy();
+
-        await paymentCompensated.destroy();
+            await tx.rollback();
-        await till.destroy();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/createWithUser.spec.js

@@ -1,28 +1,7 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client Create', () => {
-    const clientName = 'Wade';
+    const newAccount = {
-    const AccountName = 'Deadpool';
-
-    afterEach(async done => {
-        let address = await app.models.Address.findOne({where: {nickname: clientName}});
-        let client = await app.models.Client.findOne({where: {name: clientName}});
-        let account = await app.models.Account.findOne({where: {name: AccountName}});
-
-        if (address && client && account) {
-            try {
-                await app.models.Address.destroyById(address.id);
-                await app.models.Client.destroyById(client.id);
-                await app.models.Account.destroyById(account.id);
-            } catch (error) {
-                console.error(error);
-            }
-        }
-
-        done();
-    });
-
-    let newAccount = {
         userName: 'Deadpool',
         email: 'Deadpool@marvel.com',
         fi: '16195279J',
@@ -33,34 +12,66 @@ describe('Client Create', () => {
     };
 
     it(`should not find Deadpool as he's not created yet`, async() => {
-        let account = await app.models.Account.findOne({where: {name: newAccount.userName}});
+        const tx = await models.Client.beginTransaction({});
-        let client = await app.models.Client.findOne({where: {name: newAccount.name}});
 
-        expect(account).toEqual(null);
+        try {
-        expect(client).toEqual(null);
+            const options = {transaction: tx};
+
+            const account = await models.Account.findOne({where: {name: newAccount.userName}}, options);
+            const client = await models.Client.findOne({where: {name: newAccount.name}}, options);
+
+            expect(account).toEqual(null);
+            expect(client).toEqual(null);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should create a new account', async() => {
-        let client = await app.models.Client.createWithUser(newAccount);
+        const tx = await models.Client.beginTransaction({});
-        let account = await app.models.Account.findOne({where: {name: newAccount.userName}});
 
-        expect(account.name).toEqual(newAccount.userName);
+        try {
+            const options = {transaction: tx};
 
-        expect(client.id).toEqual(account.id);
+            const client = await models.Client.createWithUser(newAccount, options);
-        expect(client.name).toEqual(newAccount.name);
+            const account = await models.Account.findOne({where: {name: newAccount.userName}}, options);
-        expect(client.email).toEqual(newAccount.email);
+
-        expect(client.fi).toEqual(newAccount.fi);
+            expect(account.name).toEqual(newAccount.userName);
-        expect(client.socialName).toEqual(newAccount.socialName);
+            expect(client.id).toEqual(account.id);
+            expect(client.name).toEqual(newAccount.name);
+            expect(client.email).toEqual(newAccount.email);
+            expect(client.fi).toEqual(newAccount.fi);
+            expect(client.socialName).toEqual(newAccount.socialName);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should not be able to create a user if exists', async() => {
-        await app.models.Client.createWithUser(newAccount);
+        const tx = await models.Client.beginTransaction({});
+
+        let error;
+
         try {
-            let client = await app.models.Client.createWithUser(newAccount);
+            const options = {transaction: tx};
+
+            await models.Client.createWithUser(newAccount, options);
+            const client = await models.Client.createWithUser(newAccount, options);
 
             expect(client).toBeNull();
-        } catch (err) {
+
-            expect(err.details.codes.name[0]).toEqual('uniqueness');
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
         }
+
+        const errorName = error.details.codes.name[0];
+
+        expect(errorName).toEqual('uniqueness');
     });
 });

modules/client/back/methods/client/specs/getAverageInvoiced.spec.js

@@ -1,9 +1,19 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('client getAverageInvoiced()', () => {
     it('should call the getAverageInvoiced method', async() => {
-        const {invoiced} = await app.models.Client.getAverageInvoiced(1101);
+        const tx = await models.Client.beginTransaction({});
 
-        expect(invoiced).toEqual(1500);
+        try {
+            const options = {transaction: tx};
+
+            const {invoiced} = await models.Client.getAverageInvoiced(1101, options);
+
+            expect(invoiced).toEqual(1500);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/getCard.spec.js

@@ -1,12 +1,22 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client getCard()', () => {
     it('should receive a formated card of Bruce Wayne', async() => {
-        let id = 1101;
+        const tx = await models.Client.beginTransaction({});
-        let result = await app.models.Client.getCard(id);
 
-        expect(result.id).toEqual(id);
+        try {
-        expect(result.name).toEqual('Bruce Wayne');
+            const options = {transaction: tx};
-        expect(result.debt).toEqual(jasmine.any(Number));
+
+            const id = 1101;
+            const result = await models.Client.getCard(id, options);
+
+            expect(result.id).toEqual(id);
+            expect(result.name).toEqual('Bruce Wayne');
+            expect(result.debt).toEqual(jasmine.any(Number));
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/getDebt.spec.js

@@ -1,10 +1,20 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('client getDebt()', () => {
     it('should return the client debt', async() => {
-        let result = await app.models.Client.getDebt(1101);
+        const tx = await models.Client.beginTransaction({});
 
-        expect(result.debt).toEqual(jasmine.any(Number));
+        try {
+            const options = {transaction: tx};
+
+            const result = await models.Client.getDebt(1101, options);
+
+            expect(result.debt).toEqual(jasmine.any(Number));
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });
 

modules/client/back/methods/client/specs/getMana.spec.js

@@ -1,9 +1,19 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('client getMana()', () => {
     it('should call the getMana method', async() => {
-        let result = await app.models.Client.getMana(1105);
+        const tx = await models.Client.beginTransaction({});
 
-        expect(result.mana).toEqual(0.34);
+        try {
+            const options = {transaction: tx};
+
+            const result = await models.Client.getMana(1105, options);
+
+            expect(result.mana).toEqual(0.34);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/getTransactions.spec.js

@@ -1,10 +1,20 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client getTransations', () => {
     it('should call getTransations() method to receive a list of Web Payments from Bruce Wayne', async() => {
-        let filter = {where: {clientFk: 1101}};
+        const tx = await models.Client.beginTransaction({});
-        let result = await app.models.Client.getTransactions(filter);
 
-        expect(result[1].id).toBeTruthy();
+        try {
+            const options = {transaction: tx};
+
+            const filter = {where: {clientFk: 1101}};
+            const result = await models.Client.getTransactions(filter, options);
+
+            expect(result[1].id).toBeTruthy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/hasCustomerRole.spec.js

@@ -1,59 +1,74 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client hasCustomerRole', () => {
-    it('should call the hasCustomerRole() method with a customer id', done => {
+    it('should call the hasCustomerRole() method with a customer id', async() => {
-        let id = 1101;
+        const tx = await models.Client.beginTransaction({});
-        let params = {};
 
-        let callback = (error, result) => {
+        try {
-            if (error) return done.fail(error);
+            const options = {transaction: tx};
+
+            const id = 1101;
+
+            const [result] = await models.Client.hasCustomerRole(id, options);
 
             expect(result).toEqual(jasmine.objectContaining({isCustomer: 1}));
-            done();
-        };
 
-        app.models.Client.hasCustomerRole(id, params, callback);
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
-    it('should call the hasCustomerRole() method with a non customer id', done => {
+    it('should call the hasCustomerRole() method with a non customer id', async() => {
-        let id = 8;
+        const tx = await models.Client.beginTransaction({});
-        let params = {};
 
-        let callback = (error, result) => {
+        try {
-            if (error) return done.fail(error);
+            const options = {transaction: tx};
+
+            const id = 8;
+            const [result] = await models.Client.hasCustomerRole(id, options);
 
             expect(result).toEqual(jasmine.objectContaining({isCustomer: 0}));
-            done();
-        };
 
-        app.models.Client.hasCustomerRole(id, params, callback);
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
-    it('should call the hasCustomerRole() method with an unreal id', done => {
+    it('should call the hasCustomerRole() method with an unreal id', async() => {
-        let id = 999;
+        const tx = await models.Client.beginTransaction({});
-        let params = {};
 
-        let callback = (error, result) => {
+        try {
-            if (error) return done.fail(error);
+            const options = {transaction: tx};
+
+            const id = 999;
+
+            const [result] = await models.Client.hasCustomerRole(id, options);
 
             expect(result).toEqual(jasmine.objectContaining({isCustomer: 0}));
-            done();
-        };
 
-        app.models.Client.hasCustomerRole(id, params, callback);
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
-    it('should call the hasCustomerRole() method with an invalid id', done => {
+    it('should call the hasCustomerRole() method with an invalid id', async() => {
-        let id = 'WRONG!';
+        const tx = await models.Client.beginTransaction({});
-        let params = {};
 
-        let callback = (error, result) => {
+        try {
-            if (error) return done.fail(error);
+            const options = {transaction: tx};
+
+            const id = 'WRONG!';
+
+            const [result] = await models.Client.hasCustomerRole(id, options);
 
             expect(result).toEqual(jasmine.objectContaining({isCustomer: 0}));
-            done();
-        };
 
-        app.models.Client.hasCustomerRole(id, params, callback);
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/isValidClient.spec.js

@@ -1,45 +1,105 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client isValidClient', () => {
     it('should call the isValidClient() method with a client id and receive true', async() => {
-        let id = 1101;
+        const tx = await models.Client.beginTransaction({});
-        let result = await app.models.Client.isValidClient(id);
 
-        expect(result).toBeTruthy();
+        try {
+            const options = {transaction: tx};
+
+            const id = 1101;
+            const result = await models.Client.isValidClient(id, options);
+
+            expect(result).toBeTruthy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should call the isValidClient() method with an employee id to receive false', async() => {
-        let id = 1;
+        const tx = await models.Client.beginTransaction({});
-        let result = await app.models.Client.isValidClient(id);
 
-        expect(result).toBeFalsy();
+        try {
+            const options = {transaction: tx};
+
+            const id = 1;
+            const result = await models.Client.isValidClient(id, options);
+
+            expect(result).toBeFalsy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should call the isValidClient() method with an unexistant id and receive false', async() => {
-        let id = 999;
+        const tx = await models.Client.beginTransaction({});
-        let result = await app.models.Client.isValidClient(id);
 
-        expect(result).toBeFalsy();
+        try {
+            const options = {transaction: tx};
+
+            const id = 999;
+            const result = await models.Client.isValidClient(id, options);
+
+            expect(result).toBeFalsy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should call the isValidClient() method with an invalid id and receive false', async() => {
-        let id = 'Pepinillos';
+        const tx = await models.Client.beginTransaction({});
-        let result = await app.models.Client.isValidClient(id);
 
-        expect(result).toBeFalsy();
+        try {
+            const options = {transaction: tx};
+
+            const id = 'Pepinillos';
+            const result = await models.Client.isValidClient(id, options);
+
+            expect(result).toBeFalsy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should call the isValidClient() method with a customer id which isnt active and return false', async() => {
-        let id = '1106';
+        const tx = await models.Client.beginTransaction({});
-        let result = await app.models.Client.isValidClient(id);
 
-        expect(result).toBeFalsy();
+        try {
+            const options = {transaction: tx};
+
+            const id = '1106';
+            const result = await models.Client.isValidClient(id, options);
+
+            expect(result).toBeFalsy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should call the isValidClient() method with a customer id which his data isnt verified and return false', async() => {
-        let id = '110';
+        const tx = await models.Client.beginTransaction({});
-        let result = await app.models.Client.isValidClient(id);
 
-        expect(result).toBeFalsy();
+        try {
+            const options = {transaction: tx};
+
+            const id = '110';
+            const result = await models.Client.isValidClient(id, options);
+
+            expect(result).toBeFalsy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/lastActiveTickets.spec.js

@@ -1,18 +1,27 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client last active tickets', () => {
     it('should receive an array of last active tickets of Bruce Wayne', async() => {
-        const ticketId = 22;
+        const tx = await models.Client.beginTransaction({});
-        const clientId = 1109;
-        const warehouseId = 5;
-        const result = await app.models.Client.lastActiveTickets(clientId, ticketId, warehouseId);
 
-        const length = result.length;
+        try {
-        const anyResult = result[Math.floor(Math.random() * Math.floor(length))];
+            const options = {transaction: tx};
+            const ticketId = 22;
+            const clientId = 1109;
 
-        const properties = Object.keys(anyResult);
+            const result = await models.Client.lastActiveTickets(clientId, ticketId, options);
 
-        expect(properties.length).toEqual(9);
+            const length = result.length;
-        expect(result.length).toEqual(3);
+            const anyResult = result[Math.floor(Math.random() * Math.floor(length))];
+
+            const properties = Object.keys(anyResult);
+
+            expect(properties.length).toEqual(9);
+            expect(result.length).toEqual(3);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/sendSms.spec.js

@@ -1,29 +1,28 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 const soap = require('soap');
 
 describe('client sendSms()', () => {
-    let createdLog;
-
-    afterAll(async done => {
-        await app.models.ClientLog.destroyById(createdLog.id);
-
-        done();
-    });
-
     it('should now send a message and log it', async() => {
         spyOn(soap, 'createClientAsync').and.returnValue('a so fake client');
-        let ctx = {req: {accessToken: {userId: 9}}};
+        const tx = await models.Client.beginTransaction({});
-        let id = 1101;
-        let destination = 222222222;
-        let message = 'this is the message created in a test';
 
-        let sms = await app.models.Client.sendSms(ctx, id, destination, message);
+        try {
+            const options = {transaction: tx};
+            const ctx = {req: {accessToken: {userId: 9}}};
+            const id = 1101;
+            const destination = 222222222;
+            const message = 'this is the message created in a test';
 
-        logId = sms.logId;
+            const sms = await models.Client.sendSms(ctx, id, destination, message, options);
 
-        createdLog = await app.models.ClientLog.findById(logId);
+            const createdLog = await models.ClientLog.findById(sms.logId);
-        let json = JSON.parse(JSON.stringify(createdLog.newInstance));
+            const json = JSON.parse(JSON.stringify(createdLog.newInstance));
 
-        expect(json.message).toEqual(message);
+            expect(json.message).toEqual(message);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/summary.spec.js

@@ -1,46 +1,123 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('client summary()', () => {
     it('should return a summary object containing data', async() => {
-        let result = await app.models.Client.summary(1101);
+        const clientId = 1101;
+        const tx = await models.Client.beginTransaction({});
 
-        expect(result.id).toEqual(1101);
+        try {
-        expect(result.name).toEqual('Bruce Wayne');
+            const options = {transaction: tx};
+
+            const result = await models.Client.summary(clientId, options);
+
+            expect(result.id).toEqual(clientId);
+            expect(result.name).toEqual('Bruce Wayne');
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should return a summary object containing mana', async() => {
-        let result = await app.models.Client.summary(1105);
+        const clientId = 1105;
+        const tx = await models.Client.beginTransaction({});
 
-        expect(result.mana.mana).toEqual(0.34);
+        try {
+            const options = {transaction: tx};
+
+            const result = await models.Client.summary(clientId, options);
+
+            expect(result.mana.mana).toEqual(0.34);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should return a summary object containing debt', async() => {
-        let result = await app.models.Client.summary(1101);
+        const clientId = 1101;
+        const tx = await models.Client.beginTransaction({});
 
-        expect(result.debt.debt).toEqual(jasmine.any(Number));
+        try {
+            const options = {transaction: tx};
+
+            const result = await models.Client.summary(clientId, options);
+
+            expect(result.debt.debt).toEqual(jasmine.any(Number));
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should return a summary object containing averageInvoiced', async() => {
-        let result = await app.models.Client.summary(1101);
+        const clientId = 1101;
+        const tx = await models.Client.beginTransaction({});
 
-        expect(result.averageInvoiced.invoiced).toEqual(1500);
+        try {
+            const options = {transaction: tx};
+
+            const result = await models.Client.summary(clientId, options);
+
+            expect(result.averageInvoiced.invoiced).toEqual(1500);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should return a summary object containing totalGreuge', async() => {
-        let result = await app.models.Client.summary(1101);
+        const clientId = 1101;
+        const tx = await models.Client.beginTransaction({});
 
-        expect(result.totalGreuge).toEqual(203.71);
+        try {
+            const options = {transaction: tx};
+
+            const result = await models.Client.summary(clientId, options);
+
+            expect(result.totalGreuge).toEqual(203.71);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should return a summary object without containing active recoveries', async() => {
-        let result = await app.models.Client.summary(1101);
+        const clientId = 1101;
+        const tx = await models.Client.beginTransaction({});
 
-        expect(result.recovery).toEqual(null);
+        try {
+            const options = {transaction: tx};
+
+            const result = await models.Client.summary(clientId, options);
+
+            expect(result.recovery).toEqual(null);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should return a summary object containing active recoveries', async() => {
-        let result = await app.models.Client.summary(1102);
+        const clientId = 1102;
+        const tx = await models.Client.beginTransaction({});
 
-        expect(result.recovery.id).toEqual(3);
+        try {
+            const options = {transaction: tx};
+
+            const result = await models.Client.summary(clientId, options);
+
+            expect(result.recovery.id).toEqual(3);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/threeLastActive.spec.js

@@ -1,12 +0,0 @@
-const app = require('vn-loopback/server/server');
-
-describe('client lastActiveTickets()', () => {
-    it('should return the last three active tickets', async() => {
-        const clientId = 1109;
-        const ticketId = 19;
-
-        let result = await app.models.Client.lastActiveTickets(clientId, ticketId);
-
-        expect(result.length).toEqual(3);
-    });
-});

modules/client/back/methods/client/specs/updateAddress.spec.js

@@ -1,4 +1,4 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Address updateAddress', () => {
     const clientId = 1101;
@@ -8,93 +8,105 @@ describe('Address updateAddress', () => {
     const customAgentOneId = 1;
 
     it('should throw the non uee member error if no incoterms is defined', async() => {
-        let err;
+        const tx = await models.Client.beginTransaction({});
-        const ctx = {
+
-            args: {
+        let error;
-                provinceFk: provinceId,
-                customsAgentFk: customAgentOneId
-            }
-        };
 
         try {
-            await app.models.Client.updateAddress(ctx, clientId, addressId);
+            const options = {transaction: tx};
+            const ctx = {
+                args: {
+                    provinceFk: provinceId,
+                    customsAgentFk: customAgentOneId
+                }
+            };
+
+            await models.Client.updateAddress(ctx, clientId, addressId, options);
+
+            await tx.rollback();
         } catch (e) {
-            err = e;
+            await tx.rollback();
+            error = e;
         }
 
-        expect(err).toBeDefined();
+        expect(error).toBeDefined();
-        expect(err.message).toEqual('Incoterms is required for a non UEE member');
+        expect(error.message).toEqual('Incoterms is required for a non UEE member');
     });
 
     it('should throw a non uee member error if no customsAgent is defined', async() => {
-        let err;
+        const tx = await models.Client.beginTransaction({});
-        const ctx = {
+
-            args: {
+        let error;
-                provinceFk: provinceId,
-                incotermsFk: incotermsId
-            }
-        };
 
         try {
-            await app.models.Client.updateAddress(ctx, clientId, addressId);
+            const options = {transaction: tx};
+            const ctx = {
+                args: {
+                    provinceFk: provinceId,
+                    incotermsFk: incotermsId
+                }
+            };
+
+            await models.Client.updateAddress(ctx, clientId, addressId, options);
+
+            await tx.rollback();
         } catch (e) {
-            err = e;
+            await tx.rollback();
+            error = e;
         }
 
-        expect(err).toBeDefined();
+        expect(error).toBeDefined();
-        expect(err.message).toEqual('Customs agent is required for a non UEE member');
+        expect(error.message).toEqual('Customs agent is required for a non UEE member');
     });
 
     it('should update the adress from a non uee member with no error thrown', async() => {
-        const expectedResult = 'My edited address';
+        const tx = await models.Client.beginTransaction({});
-        const ctx = {
-            args: {
-                provinceFk: provinceId,
-                nickname: expectedResult,
-                incotermsFk: incotermsId,
-                customsAgentFk: customAgentOneId
-            }
-        };
 
-        let oldAddress = await app.models.Address.findById(addressId);
+        try {
+            const options = {transaction: tx};
+            const ctx = {
+                args: {
+                    provinceFk: provinceId,
+                    nickname: expectedResult,
+                    incotermsFk: incotermsId,
+                    customsAgentFk: customAgentOneId
+                }
+            };
+            const expectedResult = 'My edited address';
 
-        await app.models.Client.updateAddress(ctx, clientId, addressId);
+            await models.Client.updateAddress(ctx, clientId, addressId, options);
 
-        let address = await app.models.Address.findById(addressId);
+            const address = await models.Address.findById(addressId, null, options);
 
-        expect(address.nickname).toEqual(expectedResult);
+            expect(address.nickname).toEqual(expectedResult);
 
-        // restores
+            await tx.rollback();
-        await address.updateAttributes({
+        } catch (e) {
-            nickname: oldAddress.nickname,
+            await tx.rollback();
-            provinceFk: oldAddress.provinceFk,
+        }
-            customsAgentFk: null,
-            incotermsFk: null
-        });
     });
 
     it('should update the address', async() => {
-        const expectedResult = 'My second time edited address';
+        const tx = await models.Client.beginTransaction({});
-        const ctx = {
-            args: {
-                nickname: expectedResult
-            }
-        };
 
-        oldAddress = await app.models.Address.findById(addressId);
+        try {
+            const options = {transaction: tx};
+            const ctx = {
+                args: {
+                    nickname: expectedResult
+                }
+            };
+            const expectedResult = 'My second time edited address';
 
-        await app.models.Client.updateAddress(ctx, clientId, addressId);
+            await models.Client.updateAddress(ctx, clientId, addressId, options);
 
-        address = await app.models.Address.findById(addressId);
+            const address = await models.Address.findById(addressId, null, options);
 
-        expect(address.nickname).toEqual(expectedResult);
+            expect(address.nickname).toEqual(expectedResult);
 
-        // restores
+            await tx.rollback();
-        await address.updateAttributes({
+        } catch (e) {
-            nickname: oldAddress.nickname,
+            await tx.rollback();
-            provinceFk: oldAddress.provinceFk,
+        }
-            customsAgentFk: null,
-            incotermsFk: null
-        });
     });
 });

modules/client/back/methods/client/specs/updateFiscalData.spec.js

@@ -1,61 +1,76 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client updateFiscalData', () => {
     const clientId = 1101;
     const employeeId = 1;
     const salesAssistantId = 21;
     const administrativeId = 5;
-    afterAll(async done => {
-        const ctx = {req: {accessToken: {userId: administrativeId}}};
-        ctx.args = {postcode: 46460};
-
-        await app.models.Client.updateFiscalData(ctx, clientId);
-
-        done();
-    });
 
     it('should return an error if the user is not salesAssistant and the isTaxDataChecked value is true', async() => {
-        const ctx = {req: {accessToken: {userId: employeeId}}};
+        const tx = await models.Client.beginTransaction({});
-        ctx.args = {};
 
         let error;
-        await app.models.Client.updateFiscalData(ctx, clientId)
+
-            .catch(e => {
+        try {
-                error = e;
+            const options = {transaction: tx};
-            });
+            const ctx = {req: {accessToken: {userId: employeeId}}};
+            ctx.args = {};
+
+            await models.Client.updateFiscalData(ctx, clientId, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
 
         expect(error.message).toEqual(`You can't make changes on a client with verified data`);
     });
 
     it('should return an error if the salesAssistant did not fill the sage data before checking verified data', async() => {
-        const client = await app.models.Client.findById(clientId);
+        const tx = await models.Client.beginTransaction({});
-        await client.updateAttribute('isTaxDataChecked', false);
-
-        const ctx = {req: {accessToken: {userId: salesAssistantId}}};
-        ctx.args = {isTaxDataChecked: true};
 
         let error;
-        await app.models.Client.updateFiscalData(ctx, clientId)
+
-            .catch(e => {
+        try {
-                error = e;
+            const options = {transaction: tx};
-            });
+
+            const client = await models.Client.findById(clientId, options);
+            await client.updateAttribute('isTaxDataChecked', false, options);
+
+            const ctx = {req: {accessToken: {userId: salesAssistantId}}};
+            ctx.args = {isTaxDataChecked: true};
+
+            await models.Client.updateFiscalData(ctx, clientId, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
 
         expect(error.message).toEqual('You need to fill sage information before you check verified data');
-
-        // Restores
-        await client.updateAttribute('isTaxDataChecked', true);
     });
 
-    it('should update the client fiscal data and return the count if changes made', async() => {
+    it('should update the client fiscal data', async() => {
-        const ctx = {req: {accessToken: {userId: administrativeId}}};
+        const tx = await models.Client.beginTransaction({});
-        ctx.args = {postcode: 46680};
 
-        const client = await app.models.Client.findById(clientId);
+        try {
+            const options = {transaction: tx};
+            const ctx = {req: {accessToken: {userId: administrativeId}}};
+            ctx.args = {postcode: 46680};
 
-        expect(client.postcode).toEqual('46460');
+            const client = await models.Client.findById(clientId, null, options);
 
-        const result = await app.models.Client.updateFiscalData(ctx, clientId);
+            expect(client.postcode).toEqual('46460');
 
-        expect(result.postcode).toEqual('46680');
+            const result = await models.Client.updateFiscalData(ctx, clientId, options);
+
+            expect(result.postcode).toEqual('46680');
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/client/specs/uploadFile.spec.js

@@ -1,19 +1,26 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('Client uploadFile()', () => {
     it(`should return an error for a user without enough privileges`, async() => {
-        let clientId = 1101;
+        const tx = await models.Client.beginTransaction({});
-        let currentUserId = 1102;
-        let paymentLawTypeId = 12;
-        let ctx = {req: {accessToken: {userId: currentUserId}}, args: {dmsTypeId: paymentLawTypeId}};
 
         let error;
-        await app.models.Client.uploadFile(ctx, clientId).catch(e => {
-            error = e;
-        }).finally(() => {
-            expect(error.message).toEqual(`You don't have enough privileges`);
-        });
 
-        expect(error).toBeDefined();
+        try {
+            const options = {transaction: tx};
+            const clientId = 1101;
+            const currentUserId = 1102;
+            const paymentLawTypeId = 12;
+            const ctx = {req: {accessToken: {userId: currentUserId}}, args: {dmsTypeId: paymentLawTypeId}};
+
+            await models.Client.uploadFile(ctx, clientId, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error.message).toEqual(`You don't have enough privileges`);
     });
 });

modules/client/back/methods/client/summary.js

@@ -19,21 +19,26 @@ module.exports = Self => {
         }
     });
 
-    Self.summary = async clientFk => {
+    Self.summary = async(clientFk, options) => {
-        let models = Self.app.models;
+        const models = Self.app.models;
-        let summaryObj = await getSummary(models.Client, clientFk);
+        const myOptions = {};
 
-        summaryObj.mana = await models.Client.getMana(clientFk);
+        if (typeof options == 'object')
-        summaryObj.debt = await models.Client.getDebt(clientFk);
+            Object.assign(myOptions, options);
-        summaryObj.averageInvoiced = await models.Client.getAverageInvoiced(clientFk);
+
-        summaryObj.totalGreuge = await models.Greuge.sumAmount(clientFk);
+        const summaryObj = await getSummary(models.Client, clientFk, myOptions);
-        summaryObj.recovery = await getRecoveries(models.Recovery, clientFk);
+
+        summaryObj.mana = await models.Client.getMana(clientFk, myOptions);
+        summaryObj.debt = await models.Client.getDebt(clientFk, myOptions);
+        summaryObj.averageInvoiced = await models.Client.getAverageInvoiced(clientFk, myOptions);
+        summaryObj.totalGreuge = await models.Greuge.sumAmount(clientFk, myOptions);
+        summaryObj.recovery = await getRecoveries(models.Recovery, clientFk, myOptions);
 
         return summaryObj;
     };
 
-    async function getSummary(client, clientId) {
+    async function getSummary(clientModel, clientId, options) {
-        let filter = {
+        const filter = {
             include: [
                 {
                     relation: 'account',
@@ -115,17 +120,17 @@ module.exports = Self => {
             where: {id: clientId}
         };
 
-        return await client.findOne(filter);
+        return clientModel.findOne(filter, options);
     }
 
-    async function getRecoveries(recovery, clientId) {
+    async function getRecoveries(recoveryModel, clientId, options) {
-        let filter = {
+        const filter = {
             where: {
                 and: [{clientFk: clientId}, {or: [{finished: null}, {finished: {gt: Date.now()}}]}]
             },
             limit: 1
         };
 
-        return await recovery.findOne(filter);
+        return recoveryModel.findOne(filter, options);
     }
 };

modules/client/back/methods/client/updateAddress.js

@@ -3,71 +3,73 @@ const UserError = require('vn-loopback/util/user-error');
 module.exports = function(Self) {
     Self.remoteMethod('updateAddress', {
         description: 'Updates a client address updating default address',
-        accepts: [{
+        accepts: [
-            arg: 'ctx',
+            {
-            type: 'object',
+                arg: 'ctx',
-            http: {source: 'context'}
+                type: 'object',
-        },
+                http: {source: 'context'}
-        {
+            },
-            arg: 'clientId',
+            {
-            type: 'number',
+                arg: 'clientId',
-            description: 'The client id',
+                type: 'number',
-            http: {source: 'path'}
+                description: 'The client id',
-        },
+                http: {source: 'path'}
-        {
+            },
-            arg: 'addressId',
+            {
-            type: 'number',
+                arg: 'addressId',
-            description: 'The address id',
+                type: 'number',
-            http: {source: 'path'}
+                description: 'The address id',
-        },
+                http: {source: 'path'}
-        {
+            },
-            arg: 'nickname',
+            {
-            type: 'string'
+                arg: 'nickname',
-        },
+                type: 'string'
-        {
+            },
-            arg: 'city',
+            {
-            type: 'string'
+                arg: 'city',
-        },
+                type: 'string'
-        {
+            },
-            arg: 'street',
+            {
-            type: 'string'
+                arg: 'street',
-        },
+                type: 'string'
-        {
+            },
-            arg: 'phone',
+            {
-            type: 'any'
+                arg: 'phone',
-        },
+                type: 'any'
-        {
+            },
-            arg: 'mobile',
+            {
-            type: 'any'
+                arg: 'mobile',
-        },
+                type: 'any'
-        {
+            },
-            arg: 'postalCode',
+            {
-            type: 'any'
+                arg: 'postalCode',
-        },
+                type: 'any'
-        {
+            },
-            arg: 'provinceFk',
+            {
-            type: 'any'
+                arg: 'provinceFk',
-        },
+                type: 'any'
-        {
+            },
-            arg: 'agencyModeFk',
+            {
-            type: 'any'
+                arg: 'agencyModeFk',
-        },
+                type: 'any'
-        {
+            },
-            arg: 'incotermsFk',
+            {
-            type: 'any'
+                arg: 'incotermsFk',
-        },
+                type: 'any'
-        {
+            },
-            arg: 'customsAgentFk',
+            {
-            type: 'any'
+                arg: 'customsAgentFk',
-        },
+                type: 'any'
-        {
+            },
-            arg: 'isActive',
+            {
-            type: 'boolean'
+                arg: 'isActive',
-        },
+                type: 'boolean'
-        {
+            },
-            arg: 'isEqualizated',
+            {
-            type: 'boolean'
+                arg: 'isEqualizated',
-        }],
+                type: 'boolean'
+            }
+        ],
         returns: {
             root: true,
             type: 'object'
@@ -78,26 +80,37 @@ module.exports = function(Self) {
         }
     });
 
-    Self.updateAddress = async(ctx, clientId, addressId) => {
+    Self.updateAddress = async(ctx, clientId, addressId, options) => {
         const models = Self.app.models;
         const args = ctx.args;
-        const tx = await models.Address.beginTransaction({});
+        let tx;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
+
         try {
-            const options = {transaction: tx};
             const address = await models.Address.findOne({
                 where: {
                     id: addressId,
                     clientFk: clientId
                 }
-            });
+            }, myOptions);
+
             const provinceId = args.provinceFk || address.provinceFk;
             const province = await models.Province.findById(provinceId, {
                 include: {
                     relation: 'country'
                 }
-            }, options);
+            }, myOptions);
 
             const isUeeMember = province.country().isUeeMember;
+
             const incotermsId = args.incotermsFk || address.incotermsFk;
             if (!isUeeMember && !incotermsId)
                 throw new UserError(`Incoterms is required for a non UEE member`);
@@ -107,12 +120,14 @@ module.exports = function(Self) {
                 throw new UserError(`Customs agent is required for a non UEE member`);
 
             delete args.ctx; // Remove unwanted properties
-            const updatedAddress = await address.updateAttributes(ctx.args, options);
 
-            await tx.commit();
+            const updatedAddress = await address.updateAttributes(ctx.args, myOptions);
+
+            if (tx) await tx.commit();
+
             return updatedAddress;
         } catch (e) {
-            await tx.rollback();
+            if (tx) await tx.rollback();
             throw e;
         }
     };

modules/client/back/methods/client/updateFiscalData.js

@@ -4,97 +4,99 @@ module.exports = Self => {
     Self.remoteMethod('updateFiscalData', {
         description: 'Updates fiscal data of a client',
         accessType: 'WRITE',
-        accepts: [{
+        accepts: [
-            arg: 'ctx',
+            {
-            type: 'Object',
+                arg: 'ctx',
-            http: {source: 'context'}
+                type: 'object',
-        },
+                http: {source: 'context'}
-        {
+            },
-            arg: 'id',
+            {
-            type: 'Number',
+                arg: 'id',
-            description: 'The client id',
+                type: 'number',
-            http: {source: 'path'}
+                description: 'The client id',
-        },
+                http: {source: 'path'}
-        {
+            },
-            arg: 'socialName',
+            {
-            type: 'string'
+                arg: 'socialName',
-        },
+                type: 'string'
-        {
+            },
-            arg: 'fi',
+            {
-            type: 'string'
+                arg: 'fi',
-        },
+                type: 'string'
-        {
+            },
-            arg: 'street',
+            {
-            type: 'string'
+                arg: 'street',
-        },
+                type: 'string'
-        {
+            },
-            arg: 'postcode',
+            {
-            type: 'string'
+                arg: 'postcode',
-        },
+                type: 'string'
-        {
+            },
-            arg: 'city',
+            {
-            type: 'string'
+                arg: 'city',
-        },
+                type: 'string'
-        {
+            },
-            arg: 'countryFk',
+            {
-            type: 'number'
+                arg: 'countryFk',
-        },
+                type: 'number'
-        {
+            },
-            arg: 'provinceFk',
+            {
-            type: 'number'
+                arg: 'provinceFk',
-        },
+                type: 'number'
-        {
+            },
-            arg: 'sageTaxTypeFk',
+            {
-            type: 'any'
+                arg: 'sageTaxTypeFk',
-        },
+                type: 'any'
-        {
+            },
-            arg: 'sageTransactionTypeFk',
+            {
-            type: 'any'
+                arg: 'sageTransactionTypeFk',
-        },
+                type: 'any'
-        {
+            },
-            arg: 'transferorFk',
+            {
-            type: 'any'
+                arg: 'transferorFk',
-        },
+                type: 'any'
-        {
+            },
-            arg: 'hasToInvoiceByAddress',
+            {
-            type: 'boolean'
+                arg: 'hasToInvoiceByAddress',
-        },
+                type: 'boolean'
-        {
+            },
-            arg: 'hasToInvoice',
+            {
-            type: 'boolean'
+                arg: 'hasToInvoice',
-        },
+                type: 'boolean'
-        {
+            },
-            arg: 'isActive',
+            {
-            type: 'boolean'
+                arg: 'isActive',
-        },
+                type: 'boolean'
-        {
+            },
-            arg: 'isFreezed',
+            {
-            type: 'boolean'
+                arg: 'isFreezed',
-        },
+                type: 'boolean'
-        {
+            },
-            arg: 'isVies',
+            {
-            type: 'boolean'
+                arg: 'isVies',
-        },
+                type: 'boolean'
-        {
+            },
-            arg: 'isToBeMailed',
+            {
-            type: 'boolean'
+                arg: 'isToBeMailed',
-        },
+                type: 'boolean'
-        {
+            },
-            arg: 'isEqualizated',
+            {
-            type: 'boolean'
+                arg: 'isEqualizated',
-        },
+                type: 'boolean'
-        {
+            },
-            arg: 'isTaxDataVerified',
+            {
-            type: 'boolean'
+                arg: 'isTaxDataVerified',
-        },
+                type: 'boolean'
-        {
+            },
-            arg: 'isTaxDataChecked',
+            {
-            type: 'boolean'
+                arg: 'isTaxDataChecked',
-        },
+                type: 'boolean'
-        {
+            },
-            arg: 'despiteOfClient',
+            {
-            type: 'number'
+                arg: 'despiteOfClient',
-        }],
+                type: 'number'
+            }
+        ],
         returns: {
             arg: 'res',
             type: 'string',
@@ -106,46 +108,65 @@ module.exports = Self => {
         }
     });
 
-    Self.updateFiscalData = async(ctx, clientId) => {
+    Self.updateFiscalData = async(ctx, clientId, options) => {
+        let tx;
+        const myOptions = {};
         const models = Self.app.models;
         const args = ctx.args;
         const userId = ctx.req.accessToken.userId;
-        const isSalesAssistant = await models.Account.hasRole(userId, 'salesAssistant');
         const $t = ctx.req.__;
 
-        const client = await models.Client.findById(clientId);
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
 
-        if (!isSalesAssistant && client.isTaxDataChecked)
+        if (!myOptions.transaction) {
-            throw new UserError(`You can't make changes on a client with verified data`);
+            tx = await Self.beginTransaction({});
-
+            myOptions.transaction = tx;
-        // Sage data validation
-        const taxDataChecked = args.isTaxDataChecked;
-        const sageTaxChecked = client.sageTaxTypeFk || args.sageTaxTypeFk;
-        const sageTransactionChecked = client.sageTransactionTypeFk || args.sageTransactionTypeFk;
-        const hasSageData = sageTaxChecked && sageTransactionChecked;
-
-        if (taxDataChecked && !hasSageData)
-            throw new UserError(`You need to fill sage information before you check verified data`);
-
-        if (args.despiteOfClient) {
-            const logRecord = {
-                originFk: clientId,
-                userFk: userId,
-                action: 'update',
-                changedModel: 'Client',
-                changedModelId: clientId,
-                description: $t(`Client checked as validated despite of duplication`, {
-                    clientId: args.despiteOfClient
-                })
-            };
-
-            await models.ClientLog.create(logRecord);
         }
 
-        // Remove unwanted properties
+        try {
-        delete args.ctx;
+            const isSalesAssistant = await models.Account.hasRole(userId, 'salesAssistant', myOptions);
-        delete args.id;
+            const client = await models.Client.findById(clientId, null, myOptions);
 
-        return client.updateAttributes(args);
+            if (!isSalesAssistant && client.isTaxDataChecked)
+                throw new UserError(`You can't make changes on a client with verified data`);
+
+            // Sage data validation
+            const taxDataChecked = args.isTaxDataChecked;
+            const sageTaxChecked = client.sageTaxTypeFk || args.sageTaxTypeFk;
+            const sageTransactionChecked = client.sageTransactionTypeFk || args.sageTransactionTypeFk;
+            const hasSageData = sageTaxChecked && sageTransactionChecked;
+
+            if (taxDataChecked && !hasSageData)
+                throw new UserError(`You need to fill sage information before you check verified data`);
+
+            if (args.despiteOfClient) {
+                const logRecord = {
+                    originFk: clientId,
+                    userFk: userId,
+                    action: 'update',
+                    changedModel: 'Client',
+                    changedModelId: clientId,
+                    description: $t(`Client checked as validated despite of duplication`, {
+                        clientId: args.despiteOfClient
+                    })
+                };
+
+                await models.ClientLog.create(logRecord, myOptions);
+            }
+
+            // Remove unwanted properties
+            delete args.ctx;
+            delete args.id;
+
+            const updatedClient = await client.updateAttributes(args, myOptions);
+
+            if (tx) await tx.commit();
+
+            return updatedClient;
+        } catch (e) {
+            if (tx) await tx.rollback();
+            throw e;
+        }
     };
 };

modules/client/back/methods/client/uploadFile.js

@@ -2,42 +2,50 @@ module.exports = Self => {
     Self.remoteMethodCtx('uploadFile', {
         description: 'Upload and attach a file to a client',
         accessType: 'WRITE',
-        accepts: [{
+        accepts: [
-            arg: 'id',
+            {
-            type: 'Number',
+                arg: 'id',
-            description: 'The client id',
+                type: 'number',
-            http: {source: 'path'}
+                description: 'The client id',
-        }, {
+                http: {source: 'path'}
-            arg: 'warehouseId',
+            },
-            type: 'Number',
+            {
-            description: 'The warehouse id',
+                arg: 'warehouseId',
-            required: true
+                type: 'number',
-        }, {
+                description: 'The warehouse id',
-            arg: 'companyId',
+                required: true
-            type: 'Number',
+            },
-            description: 'The company id',
+            {
-            required: true
+                arg: 'companyId',
-        }, {
+                type: 'number',
-            arg: 'dmsTypeId',
+                description: 'The company id',
-            type: 'Number',
+                required: true
-            description: 'The dms type id',
+            },
-            required: true
+            {
-        }, {
+                arg: 'dmsTypeId',
-            arg: 'reference',
+                type: 'number',
-            type: 'String',
+                description: 'The dms type id',
-            required: true
+                required: true
-        }, {
+            },
-            arg: 'description',
+            {
-            type: 'String',
+                arg: 'reference',
-            required: true
+                type: 'string',
-        }, {
+                required: true
-            arg: 'hasFile',
+            },
-            type: 'Boolean',
+            {
-            description: 'True if has an attached file',
+                arg: 'description',
-            required: true
+                type: 'string',
-        }],
+                required: true
+            },
+            {
+                arg: 'hasFile',
+                type: 'boolean',
+                description: 'True if has an attached file',
+                required: true
+            }
+        ],
         returns: {
-            type: 'Object',
+            type: 'object',
             root: true
         },
         http: {
@@ -46,31 +54,39 @@ module.exports = Self => {
         }
     });
 
-    Self.uploadFile = async(ctx, id) => {
+    Self.uploadFile = async(ctx, id, options) => {
         const models = Self.app.models;
+        let tx;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
+
         const promises = [];
-        const tx = await Self.beginTransaction({});
 
         try {
-            const options = {transaction: tx};
+            const uploadedFiles = await models.Dms.uploadFile(ctx, myOptions);
-
-            const uploadedFiles = await models.Dms.uploadFile(ctx, options);
             uploadedFiles.forEach(dms => {
                 const newClientDms = models.ClientDms.create({
                     clientFk: id,
                     dmsFk: dms.id
-                }, options);
+                }, myOptions);
 
                 promises.push(newClientDms);
             });
-            const resolvedPromises = await Promise.all(promises);
+            const resolvedPromises = await Promise.all(promises, myOptions);
 
-            await tx.commit();
+            if (tx) await tx.commit();
 
             return resolvedPromises;
-        } catch (err) {
+        } catch (e) {
-            await tx.rollback();
+            if (tx) await tx.rollback();
-            throw err;
+            throw e;
         }
     };
 };

modules/client/back/methods/credit-classification/createWithInsurance.js

@@ -1,17 +1,13 @@
 module.exports = Self => {
     Self.remoteMethod('createWithInsurance', {
         description: 'Creates both classification and one insurance',
-        accepts: [{
+        accepts: [
-            arg: 'data',
+            {
-            type: 'object',
+                arg: 'data',
-            http: {source: 'body'}
+                type: 'object',
-        }, {
+                http: {source: 'body'}
-            arg: 'context',
-            type: 'object',
-            http: function(ctx) {
-                return ctx;
             }
-        }],
+        ],
         returns: {
             root: true,
             type: 'boolean'
@@ -22,29 +18,36 @@ module.exports = Self => {
         }
     });
 
-    Self.createWithInsurance = async(data, ctx) => {
+    Self.createWithInsurance = async(data, options) => {
-        const tx = await Self.beginTransaction({});
         const models = Self.app.models;
+        let tx;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
 
         try {
-            let options = {transaction: tx};
-
             const newClassification = await Self.create({
                 client: data.clientFk,
                 started: data.started
-            }, options);
+            }, myOptions);
 
             await models.CreditInsurance.create({
                 creditClassification: newClassification.id,
                 credit: data.credit,
                 grade: data.grade
-            }, options);
+            }, myOptions);
 
-            await tx.commit();
+            if (tx) await tx.commit();
 
             return newClassification;
         } catch (e) {
-            await tx.rollback();
+            if (tx) await tx.rollback();
             throw e;
         }
     };

modules/client/back/methods/credit-classification/createWithInsurance.spec.js

@@ -1,64 +1,26 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
-const LoopBackContext = require('loopback-context');
 
 describe('Client createWithInsurance', () => {
-    const activeCtx = {
-        accessToken: {userId: 1101},
-        http: {
-            req: {
-                headers: {origin: 'http://localhost'}
-            }
-        }
-    };
-    const ctx = {req: activeCtx};
-    activeCtx.http.req.__ = value => {
-        return value;
-    };
-
-    it('should verify the classifications and insurances are untainted', async() => {
-        let classifications = await app.models.CreditClassification.find();
-        let insurances = await app.models.CreditInsurance.find();
-
-        expect(classifications.length).toEqual(5);
-        expect(insurances.length).toEqual(3);
-    });
-
-    it('should not create the insurance if couldnt create the classification', async() => {
-        let error;
-        let data = {clientFk: null, started: Date.now(), credit: 999, grade: 255};
-        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
-            active: activeCtx
-        });
-        await app.models.CreditClassification.createWithInsurance(data, ctx)
-            .catch(e => {
-                error = e;
-            });
-
-        expect(error.toString()).toBe('Error: ER_BAD_NULL_ERROR: Column \'client\' cannot be null');
-
-        let classifications = await app.models.CreditClassification.find();
-        let insurances = await app.models.CreditInsurance.find();
-
-        expect(classifications.length).toEqual(5);
-        expect(insurances.length).toEqual(3);
-    });
-
     it('should create a new client credit classification with insurance', async() => {
-        let data = {clientFk: 1101, started: Date.now(), credit: 999, grade: 255};
+        const tx = await models.Client.beginTransaction({});
-        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
-            active: activeCtx
-        });
-        let result = await app.models.CreditClassification.createWithInsurance(data, ctx);
 
-        expect(result.client).toEqual(1101);
+        try {
+            const options = {transaction: tx};
+            const data = {clientFk: 1101, started: Date.now(), credit: 999, grade: 255};
 
-        let classifications = await app.models.CreditClassification.find();
+            const result = await models.CreditClassification.createWithInsurance(data, options);
-        let insurances = await app.models.CreditInsurance.find();
 
-        expect(classifications.length).toEqual(6);
+            expect(result.client).toEqual(1101);
-        expect(insurances.length).toEqual(4);
 
-        // restore
+            const classifications = await models.CreditClassification.find();
-        await app.models.CreditClassification.destroyById(result.id);
+            const insurances = await models.CreditInsurance.find();
+
+            expect(classifications.length).toEqual(6);
+            expect(insurances.length).toEqual(4);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/greuge/specs/sumAmount.spec.js

@@ -1,14 +1,21 @@
-const totalGreuge = require('../sumAmount');
+const models = require('vn-loopback/server/server').models;
 
 describe('Greuge totalGreuge()', () => {
     it('should call the sumAmount method', async() => {
-        let clientFk = 1;
+        const tx = await models.Client.beginTransaction({});
-        let self = jasmine.createSpyObj('self', ['remoteMethod', 'rawSql']);
-        self.rawSql.and.returnValue(Promise.resolve([{sumAmount: 6000}]));
-        totalGreuge(self);
 
-        let result = await self.sumAmount(clientFk);
+        try {
+            const options = {transaction: tx};
 
-        expect(result).toBe(6000);
+            const clientId = 1;
+
+            const result = await models.Client.sumAmount(clientId, options);
+
+            expect(result).toBe(6000);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/greuge/sumAmount.js

@@ -18,10 +18,15 @@ module.exports = Self => {
         }
     });
 
-    Self.sumAmount = async clientFk => {
+    Self.sumAmount = async(clientFk, options) => {
-        let query = `SELECT SUM(amount) AS sumAmount FROM vn.greuge WHERE clientFk = ?`;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const query = `SELECT SUM(amount) AS sumAmount FROM vn.greuge WHERE clientFk = ?`;
         try {
-            let [response] = await Self.rawSql(query, [clientFk]);
+            const [response] = await Self.rawSql(query, [clientFk], myOptions);
 
             return response ? response.sumAmount : 0;
         } catch (e) {

modules/client/back/methods/receipt/filter.js

@@ -7,23 +7,25 @@ module.exports = Self => {
         accepts: [
             {
                 arg: 'filter',
-                type: 'Object',
+                type: 'object',
                 description: 'Filter defining where, order, offset, and limit - must be a JSON-encoded string',
                 http: {source: 'query'}
-            }, {
+            },
+            {
                 arg: 'clientId',
-                type: 'Number',
+                type: 'number',
                 description: 'The client id',
                 required: true,
-            }, {
+            },
+            {
                 arg: 'companyId',
-                type: 'Number',
+                type: 'number',
                 description: 'The company id',
                 required: true,
             }
         ],
         returns: {
-            type: ['Object'],
+            type: ['object'],
             root: true
         },
         http: {
@@ -32,51 +34,56 @@ module.exports = Self => {
         }
     });
 
-    Self.filter = async(filter, clientId, companyId) => {
+    Self.filter = async(filter, clientId, companyId, options) => {
-        let stmt = new ParameterizedSQL(
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const stmt = new ParameterizedSQL(
             `SELECT * FROM (
-                    SELECT 
+                SELECT 
-                            r.id,
+                    r.id,
-                            r.isConciliate,
+                    r.isConciliate,
-                            r.payed,
+                    r.payed,
-                            r.workerFk,
+                    r.workerFk,
-                            c.code company,
+                    c.code company,
-                            r.created,
+                    r.created,
-                            r.invoiceFk description,
+                    r.invoiceFk description,
-                            NULL debit,
+                    NULL debit,
-                            r.amountPaid credit,
+                    r.amountPaid credit,
-                            r.bankFk,
+                    r.bankFk,
-                            u.name userName,
+                    u.name userName,
-                            r.clientFk,
+                    r.clientFk,
-                            FALSE hasPdf,
+                    FALSE hasPdf,
-                            FALSE isInvoice
+                    FALSE isInvoice
-                        FROM vn.receipt r
+                FROM vn.receipt r
-                            LEFT JOIN vn.worker w ON w.id = r.workerFk
+                    LEFT JOIN vn.worker w ON w.id = r.workerFk
-                            LEFT JOIN account.user u ON u.id = w.userFk
+                    LEFT JOIN account.user u ON u.id = w.userFk
-                            JOIN vn.company c ON c.id = r.companyFk
+                    JOIN vn.company c ON c.id = r.companyFk
-                        WHERE r.clientFk = ? AND r.companyFk = ?
+                WHERE r.clientFk = ? AND r.companyFk = ?
-                    UNION ALL 
+                UNION ALL 
-                    SELECT
+                SELECT
-                            i.id,
+                    i.id,
-                            TRUE,
+                    TRUE,
-                            i.issued,
+                    i.issued,
-                            NULL,
+                    NULL,
-                            c.code,
+                    c.code,
-                            i.created,
+                    i.created,
-                            i.ref,
+                    i.ref,
-                            i.amount,
+                    i.amount,
-                            NULL,
+                    NULL,
-                            NULL,
+                    NULL,
-                            NULL,
+                    NULL,
-                            i.clientFk,
+                    i.clientFk,
-                            i.hasPdf,
+                    i.hasPdf,
-                            TRUE isInvoice
+                    TRUE isInvoice
-                        FROM vn.invoiceOut i
+                FROM vn.invoiceOut i
-                            JOIN vn.company c ON c.id = i.companyFk
+                    JOIN vn.company c ON c.id = i.companyFk
-                        WHERE i.clientFk = ? AND i.companyFk = ?
+                WHERE i.clientFk = ? AND i.companyFk = ?
-                        ORDER BY payed DESC, created DESC
+                ORDER BY payed DESC, created DESC
-                ) t
+            ) t ORDER BY payed DESC, created DESC`,
-                ORDER BY payed DESC, created DESC`, [
+            [
                 clientId,
                 companyId,
                 clientId,
@@ -85,6 +92,7 @@ module.exports = Self => {
         );
 
         stmt.merge(Self.makeLimit(filter));
-        return await Self.rawStmt(stmt);
+
+        return Self.rawStmt(stmt, myOptions);
     };
 };

modules/client/back/methods/receipt/specs/filter.spec.js

@@ -1,12 +1,22 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('receipt filter()', () => {
     it('should return the receipts', async() => {
-        const filter = {limit: 20};
+        const tx = await models.Client.beginTransaction({});
-        const clientId = 1101;
-        const companyId = 442;
-        let result = await app.models.Receipt.filter(filter, clientId, companyId);
 
-        expect(result.length).toBeGreaterThan(0);
+        try {
+            const options = {transaction: tx};
+            const filter = {limit: 20};
+            const clientId = 1101;
+            const companyId = 442;
+
+            const result = await models.Receipt.filter(filter, clientId, companyId, options);
+
+            expect(result.length).toBeGreaterThan(0);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/recovery/hasActiveRecovery.js

@@ -21,14 +21,20 @@ module.exports = Self => {
         }
     });
 
-    Self.hasActiveRecovery = async id => {
+    Self.hasActiveRecovery = async(id, options) => {
-        let result = await Self.rawSql(
+        const myOptions = {};
-            `SELECT count(*) AS hasActiveRecovery
+
-                FROM vn.recovery
+        if (typeof options == 'object')
-                WHERE clientFk = ?
+            Object.assign(myOptions, options);
-                AND IFNULL(finished,CURDATE()) >= CURDATE();`,
+
-            [id]
+        const query = `
-        );
+            SELECT count(*) AS hasActiveRecovery
-        return result[0].hasActiveRecovery != 0;
+            FROM vn.recovery
+            WHERE clientFk = ?
+                AND IFNULL(finished,CURDATE()) >= CURDATE();
+        `;
+        const [result] = await Self.rawSql(query, [id], myOptions);
+
+        return result.hasActiveRecovery != 0;
     };
 };

modules/client/back/methods/recovery/hasActiveRecovery.spec.js

@@ -1,15 +1,35 @@
-const app = require('vn-loopback/server/server');
+const models = require('vn-loopback/server/server').models;
 
 describe('client hasActiveRecovery', () => {
     it(`should return false if the client doesn't owes`, async() => {
-        let hasActiveRecovery = await app.models.Recovery.hasActiveRecovery(1101);
+        const tx = await models.Client.beginTransaction({});
 
-        expect(hasActiveRecovery).toBeFalsy();
+        try {
+            const options = {transaction: tx};
+
+            const hasActiveRecovery = await models.Recovery.hasActiveRecovery(1101, options);
+
+            expect(hasActiveRecovery).toBeFalsy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 
     it('should return true if the client owes', async() => {
-        let hasActiveRecovery = await app.models.Recovery.hasActiveRecovery(1102);
+        const tx = await models.Client.beginTransaction({});
 
-        expect(hasActiveRecovery).toBeTruthy();
+        try {
+            const options = {transaction: tx};
+
+            const hasActiveRecovery = await models.Recovery.hasActiveRecovery(1102, options);
+
+            expect(hasActiveRecovery).toBeTruthy();
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+        }
     });
 });

modules/client/back/methods/sms/send.js

@@ -6,22 +6,24 @@ module.exports = Self => {
     Self.remoteMethod('send', {
         description: 'Sends SMS to a destination phone',
         accessType: 'WRITE',
-        accepts: [{
+        accepts: [
-            arg: 'destinationFk',
+            {
-            type: 'Integer'
+                arg: 'destinationFk',
-        },
+                type: 'integer'
-        {
+            },
-            arg: 'destination',
+            {
-            type: 'String',
+                arg: 'destination',
-            required: true,
+                type: 'string',
-        },
+                required: true,
-        {
+            },
-            arg: 'message',
+            {
-            type: 'String',
+                arg: 'message',
-            required: true,
+                type: 'string',
-        }],
+                required: true,
+            }
+        ],
         returns: {
-            type: 'Object',
+            type: 'object',
             root: true
         },
         http: {
@@ -82,6 +84,7 @@ module.exports = Self => {
         };
 
         const sms = await Self.create(newSms);
+
         if (statusCode != 200)
             throw new UserError(`We weren't able to send this SMS`);