Merge branch 'dev' of https://gitea.verdnatura.es/verdnatura/salix into 6125-roleCreditLimit

Reviewed-on: #1800
Reviewed-by: Javi Gallego <jgallego@verdnatura.es>

.vscode/settings.json

@@ -10,5 +10,9 @@
     "eslint.format.enable": true,
     "[javascript]": {
         "editor.defaultFormatter": "dbaeumer.vscode-eslint"
-    }
+    },
+    "cSpell.words": [
+        "salix",
+        "fdescribe"
+    ]
 }

CHANGELOG.md

@@ -5,21 +5,47 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2342.01] - 2023-10-19
+## [2352.01] - 2023-12-28
 
 ### Added
 ### Changed
 ### Fixed
 
-## [2340.01] - 2023-10-05
+## [2350.01] - 2023-12-14
+
+### Added
+### Changed
+### Fixed
+
+
+## [2348.01] - 2023-11-30
+
+### Características Añadidas 🆕
+- **Tickets → Adelantar:** Permite mover lineas sin generar negativos
+- **Tickets → Adelantar:** Permite modificar la fecha de los tickets
+- **Trabajadores → Notificaciones:** Nueva sección (lilium)
+
+### Correcciones 🛠️
+- **Tickets → RocketChat:** Arreglada detección de cambios
+
+
+## [2346.01] - 2023-11-16
+
+### Added
+### Changed
+### Fixed
+
+
+## [2342.01] - 2023-11-02
 
 ### Added
 - (Usuarios -> Foto) Se muestra la foto del trabajador
-
-### Changed
 ### Fixed
 - (Usuarios -> Historial) Abre el descriptor del usuario correctamente
 
+
+## [2340.01] - 2023-10-05
+
 ## [2338.01] - 2023-09-21
 
 ### Added
@@ -29,17 +55,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 - (Trabajadores -> Calendario) Icono de check arreglado cuando pulsas un tipo de dia
 
-### Fixed
-
 ## [2336.01] - 2023-09-07
 
-### Added
-
-### Changed
-
-### Fixed
-
-
 ## [2334.01] - 2023-08-24
 
 ### Added

Dockerfile

@@ -1,4 +1,4 @@
-FROM debian:bullseye-slim
+FROM debian:bookworm-slim
 ENV TZ Europe/Madrid
 
 ARG DEBIAN_FRONTEND=noninteractive
@@ -25,7 +25,13 @@ RUN apt-get update \
         libnspr4 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 \
         libx11-xcb1 libxcb1 libxcomposite1 libxcursor1 libxdamage1 libxext6 \
         libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 libxtst6 \
-        fonts-liberation libappindicator1 libnss3 lsb-release xdg-utils wget \
+        fonts-liberation libappindicator1 libnss3 lsb-release xdg-utils wget
+
+# Extra dependencies
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        samba-common-bin samba-dsdb-modules\
     && rm -rf /var/lib/apt/lists/* \
     && npm -g install pm2
 

README.md

@@ -8,7 +8,7 @@ Salix is also the scientific name of a beautifull tree! :)
 
 Required applications.
 
-* Node.js >= 16.x LTS
+* Node.js
 * Docker
 * Git
 
@@ -17,20 +17,7 @@ You will need to install globally the following items.
 $ sudo npm install -g jest gulp-cli
 ```
 
-For the usage of jest --watch on macOs.
-```
-$ brew install watchman
-```
-* [watchman](https://facebook.github.io/watchman/)
-
-## Linux Only Prerequisites
-
-Your user must be on the docker group to use it so you will need to run this command:
-```
-$ sudo usermod -a -G docker yourusername
-```
-
-## Getting Started // Installing
+## Installing dependencies and launching
 
 Pull from repository.
 
@@ -76,29 +63,6 @@ In Visual Studio Code we use the ESLint extension.
 ext install dbaeumer.vscode-eslint
 ```
 
-Gitlens for visualization of code authorship
-```
-ext install eamodio.gitlens
-```
-
-Spanish language pack
-```
-ext install ms-ceintl.vscode-language-pack-es
-```
-
-### Recommended extensions
-
-Material icon Theme
-```
-ext install pkief.material-icon-theme
-```
-
-Material UI Themes
-```
-ext install equinusocio.vsc-material-theme
-```
-
-
 ## Built With
 
 * [angularjs](https://angularjs.org/)

back/methods/chat/sendCheckingPresence.js

@@ -26,15 +26,14 @@ module.exports = Self => {
 
     Self.sendCheckingPresence = async(ctx, recipientId, message) => {
         if (!recipientId) return false;
-
         const models = Self.app.models;
+
         const userId = ctx.req.accessToken.userId;
         const sender = await models.VnUser.findById(userId, {fields: ['id']});
         const recipient = await models.VnUser.findById(recipientId, null);
 
         // Prevent sending messages to yourself
         if (recipientId == userId) return false;
-
         if (!recipient)
             throw new Error(`Could not send message "${message}" to worker id ${recipientId} from user ${userId}`);
 

back/methods/collection/getTickets.js

@@ -26,7 +26,7 @@ module.exports = Self => {
 
     Self.getTickets = async(ctx, id, print, options) => {
         const userId = ctx.req.accessToken.userId;
-        const origin = ctx.req.headers.origin;
+        const url = await Self.app.models.Url.getUrl();
         const $t = ctx.req.__;
         const myOptions = {};
 
@@ -36,7 +36,6 @@ module.exports = Self => {
         myOptions.userId = userId;
 
         const promises = [];
-    
         const [tickets] = await Self.rawSql(`CALL vn.collection_getTickets(?)`, [id], myOptions);
         const sales = await Self.rawSql(`
             SELECT s.ticketFk,
@@ -50,7 +49,7 @@ module.exports = Self => {
                     ish.packing,
                     ish.grouping,
                     s.isAdded,
-                    s.originalQuantity, 
+                    s.originalQuantity,
                     s.quantity saleQuantity,
                     iss.quantity reservedQuantity,
                     SUM(iss.quantity) OVER (PARTITION BY s.id ORDER BY ish.id) accumulatedQuantity,
@@ -76,7 +75,7 @@ module.exports = Self => {
                     LEFT JOIN itemColor ic ON ic.itemFk = s.itemFk
                     LEFT JOIN origin o ON o.id = i.originFk
                 WHERE tc.collectionFk = ?
-                GROUP BY ish.id, p.code, p2.code
+                GROUP BY s.id, ish.id, p.code, p2.code
                 ORDER BY pickingOrder;`, [id], myOptions);
 
         if (print)
@@ -86,24 +85,19 @@ module.exports = Self => {
         if (tickets && tickets.length) {
             for (const ticket of tickets) {
                 const ticketId = ticket.ticketFk;
-
-                // SEND ROCKET
                 if (ticket.observaciones != '') {
                     for (observation of ticket.observaciones.split(' ')) {
                         if (['#', '@'].includes(observation.charAt(0))) {
                             promises.push(Self.app.models.Chat.send(ctx, observation,
                                 $t('The ticket is in preparation', {
                                     ticketId: ticketId,
-                                    ticketUrl: `${origin}/#!/ticket/${ticketId}/summary`,
+                                    ticketUrl: `${url}ticket/${ticketId}/summary`,
                                     salesPersonId: ticket.salesPersonFk
                                 })));
                         }
                     }
                 }
-
-                // SET COLLECTION
                 if (sales && sales.length) {
-                    // GET BARCODES
                     const barcodes = await Self.rawSql(`
                         SELECT s.id saleFk, b.code, c.id
                             FROM vn.sale s
@@ -111,16 +105,13 @@ module.exports = Self => {
                                 LEFT JOIN vn.buy c ON c.itemFk = s.itemFk
                                 LEFT JOIN vn.entry e ON e.id = c.entryFk
                                 LEFT JOIN vn.travel tr ON tr.id = e.travelFk
-                            WHERE s.ticketFk = ? 
+                            WHERE s.ticketFk = ?
                                 AND tr.landed >= util.VN_CURDATE() - INTERVAL 1 YEAR`,
                     [ticketId], myOptions);
-
-                    // BINDINGS
                     ticket.sales = [];
                     for (const sale of sales) {
                         if (sale.ticketFk === ticketId) {
                             sale.Barcodes = [];
-
                             if (barcodes && barcodes.length) {
                                 for (const barcode of barcodes) {
                                     if (barcode.saleFk === sale.saleFk) {
@@ -131,7 +122,6 @@ module.exports = Self => {
                                     }
                                 }
                             }
-
                             ticket.sales.push(sale);
                         }
                     }
@@ -140,7 +130,6 @@ module.exports = Self => {
             }
         }
         await Promise.all(promises);
-
         return collection;
     };
 };

back/methods/collection/newCollection.js

@@ -1,133 +0,0 @@
-module.exports = Self => {
-    Self.remoteMethodCtx('newCollection', {
-        description: 'Make a new collection of tickets',
-        accessType: 'WRITE',
-        accepts: [{
-            arg: 'collectionFk',
-            type: 'Number',
-            required: false,
-            description: 'The collection id'
-        }, {
-            arg: 'sectorFk',
-            type: 'Number',
-            required: true,
-            description: 'The sector of worker'
-        }, {
-            arg: 'vWagons',
-            type: 'Number',
-            required: true,
-            description: 'The number of wagons'
-        }],
-        returns: {
-            type: 'Object',
-            root: true
-        },
-        http: {
-            path: `/newCollection`,
-            verb: 'POST'
-        }
-    });
-
-    Self.newCollection = async(ctx, collectionFk, sectorFk, vWagons) => {
-        let query = '';
-        const userId = ctx.req.accessToken.userId;
-
-        if (!collectionFk) {
-            query = `CALL vn.collectionTrain_newBeta(?,?,?)`;
-            const [result] = await Self.rawSql(query, [sectorFk, vWagons, userId], {userId});
-            if (result.length == 0)
-                throw new Error(`No collections for today`);
-
-            collectionFk = result[0].vCollectionFk;
-        }
-
-        query = `CALL vn.collectionTicket_get(?)`;
-        const [tickets] = await Self.rawSql(query, [collectionFk], {userId});
-
-        query = `CALL vn.collectionSale_get(?)`;
-        const [sales] = await Self.rawSql(query, [collectionFk], {userId});
-
-        query = `CALL vn.collectionPlacement_get(?)`;
-        const [placements] = await Self.rawSql(query, [collectionFk], {userId});
-
-        query = `CALL vn.collectionSticker_print(?,?)`;
-        await Self.rawSql(query, [collectionFk, sectorFk], {userId});
-
-        return makeCollection(tickets, sales, placements, collectionFk);
-    };
-
-    /**
-     * Returns a collection json
-     * @param {*} tickets - Request tickets
-     * @param {*} sales - Request sales
-     * @param {*} placements - Request placements
-     * @param {*} collectionFk - Request placements
-     * @return {Object} Collection JSON
-     */
-    async function makeCollection(tickets, sales, placements, collectionFk) {
-        let collection = [];
-
-        for (let i = 0; i < tickets.length; i++) {
-            let ticket = {};
-            ticket['ticketFk'] = tickets[i]['ticketFk'];
-            ticket['level'] = tickets[i]['level'];
-            ticket['agencyName'] = tickets[i]['agencyName'];
-            ticket['warehouseFk'] = tickets[i]['warehouseFk'];
-            ticket['salesPersonFk'] = tickets[i]['salesPersonFk'];
-
-            let ticketSales = [];
-
-            for (let x = 0; x < sales.length; x++) {
-                if (sales[x]['ticketFk'] == ticket['ticketFk']) {
-                    let sale = {};
-                    sale['collectionFk'] = collectionFk;
-                    sale['ticketFk'] = sales[x]['ticketFk'];
-                    sale['saleFk'] = sales[x]['saleFk'];
-                    sale['itemFk'] = sales[x]['itemFk'];
-                    sale['quantity'] = sales[x]['quantity'];
-                    if (sales[x]['quantityPicked'] != null)
-                        sale['quantityPicked'] = sales[x]['quantityPicked'];
-                    else
-                        sale['quantityPicked'] = 0;
-                    sale['longName'] = sales[x]['longName'];
-                    sale['size'] = sales[x]['size'];
-                    sale['color'] = sales[x]['color'];
-                    sale['discount'] = sales[x]['discount'];
-                    sale['price'] = sales[x]['price'];
-                    sale['stems'] = sales[x]['stems'];
-                    sale['category'] = sales[x]['category'];
-                    sale['origin'] = sales[x]['origin'];
-                    sale['clientFk'] = sales[x]['clientFk'];
-                    sale['productor'] = sales[x]['productor'];
-                    sale['reserved'] = sales[x]['reserved'];
-                    sale['isPreviousPrepared'] = sales[x]['isPreviousPrepared'];
-                    sale['isPrepared'] = sales[x]['isPrepared'];
-                    sale['isControlled'] = sales[x]['isControlled'];
-
-                    let salePlacements = [];
-
-                    for (let z = 0; z < placements.length; z++) {
-                        if (placements[z]['saleFk'] == sale['saleFk']) {
-                            let placement = {};
-                            placement['saleFk'] = placements[z]['saleFk'];
-                            placement['itemFk'] = placements[z]['itemFk'];
-                            placement['placement'] = placements[z]['placement'];
-                            placement['shelving'] = placements[z]['shelving'];
-                            placement['created'] = placements[z]['created'];
-                            placement['visible'] = placements[z]['visible'];
-                            placement['order'] = placements[z]['order'];
-                            placement['grouping'] = placements[z]['grouping'];
-                            salePlacements.push(placement);
-                        }
-                    }
-                    sale['placements'] = salePlacements;
-                    ticketSales.push(sale);
-                }
-            }
-            ticket['sales'] = ticketSales;
-            collection.push(ticket);
-        }
-
-        return collection;
-    }
-};

back/methods/collection/spec/newCollection.spec.js

@@ -1,12 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-
-describe('newCollection()', () => {
-    it('should return a new collection', async() => {
-        pending('#3400 analizar que hacer con rutas de back collection');
-        let ctx = {req: {accessToken: {userId: 1106}}};
-        let response = await models.Collection.newCollection(ctx, 1, 1, 1);
-
-        expect(response.length).toBeGreaterThan(0);
-        expect(response[0].ticketFk).toEqual(2);
-    });
-});

back/methods/collection/spec/setSaleQuantity.spec.js

@@ -18,6 +18,14 @@ describe('setSaleQuantity()', () => {
 
     it('should change quantity sale', async() => {
         const tx = await models.Ticket.beginTransaction({});
+        spyOn(models.Sale, 'rawSql').and.callFake((sqlStatement, params, options) => {
+            if (sqlStatement.includes('catalog_calcFromItem')) {
+                sqlStatement = `CREATE OR REPLACE TEMPORARY TABLE tmp.ticketCalculateItem ENGINE = MEMORY
+                        SELECT 100 as available;`;
+                params = null;
+            }
+            return models.Ticket.rawSql(sqlStatement, params, options);
+        });
 
         try {
             const options = {transaction: tx};

back/methods/notification/getList.js

@@ -0,0 +1,54 @@
+module.exports = Self => {
+    Self.remoteMethod('getList', {
+        description: 'Get list of the available and active notification subscriptions',
+        accessType: 'READ',
+        accepts: [
+            {
+                arg: 'id',
+                type: 'number',
+                description: 'User to modify',
+                http: {source: 'path'}
+            }
+        ],
+        returns: {
+            type: 'object',
+            root: true
+        },
+        http: {
+            path: `/:id/getList`,
+            verb: 'GET'
+        }
+    });
+
+    Self.getList = async(id, options) => {
+        const activeNotificationsMap = new Map();
+
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const availableNotificationsMap = await Self.getAvailable(id, myOptions);
+        const activeNotifications = await Self.app.models.NotificationSubscription.find({
+            fields: ['id', 'notificationFk'],
+            include: {relation: 'notification'},
+            where: {userFk: id}
+        }, myOptions);
+
+        for (active of activeNotifications) {
+            activeNotificationsMap.set(active.notificationFk, {
+                id: active.id,
+                notificationFk: active.notificationFk,
+                name: active.notification().name,
+                description: active.notification().description,
+                active: true
+            });
+            availableNotificationsMap.delete(active.notificationFk);
+        }
+
+        return {
+            active: [...activeNotificationsMap.entries()],
+            available: [...availableNotificationsMap.entries()]
+        };
+    };
+};

back/methods/notification/specs/getList.spec.js

@@ -0,0 +1,13 @@
+const models = require('vn-loopback/server/server').models;
+
+describe('NotificationSubscription getList()', () => {
+    it('should return a list of available and active notifications of a user', async() => {
+        const userId = 9;
+        const {active, available} = await models.NotificationSubscription.getList(userId);
+        const notifications = await models.Notification.find({});
+        const totalAvailable = notifications.length - active.length;
+
+        expect(active.length).toEqual(2);
+        expect(available.length).toEqual(totalAvailable);
+    });
+});

back/methods/url/getByUser.js

@@ -0,0 +1,40 @@
+module.exports = function(Self) {
+    Self.remoteMethod('getByUser', {
+        description: 'returns the starred modules for the current user',
+        accessType: 'READ',
+        accepts: [{
+            arg: 'userId',
+            type: 'number',
+            description: 'The user id',
+            required: true,
+            http: {source: 'path'}
+        }],
+        returns: {
+            type: 'object',
+            root: true
+        },
+        http: {
+            path: `/:userId/get-by-user`,
+            verb: 'GET'
+        }
+    });
+
+    Self.getByUser = async userId => {
+        const models = Self.app.models;
+        const appNames = ['hedera'];
+        const filter = {
+            fields: ['appName', 'url'],
+            where: {
+                appName: {inq: appNames},
+                environment: process.env.NODE_ENV ?? 'development',
+            }
+        };
+
+        const isWorker = await models.Account.findById(userId, {fields: ['id']});
+        if (!isWorker)
+            return models.Url.find(filter);
+
+        appNames.push('salix');
+        return models.Url.find(filter);
+    };
+};

back/methods/url/getUrl.js

@@ -0,0 +1,30 @@
+module.exports = Self => {
+    Self.remoteMethod('getUrl', {
+        description: 'Returns the colling app name',
+        accessType: 'READ',
+        accepts: [
+            {
+                arg: 'app',
+                type: 'string',
+                required: false
+            }
+        ],
+        returns: {
+            type: 'object',
+            root: true
+        },
+        http: {
+            path: `/getUrl`,
+            verb: 'get'
+        }
+    });
+    Self.getUrl = async(appName = 'salix') => {
+        const {url} = await Self.app.models.Url.findOne({
+            where: {
+                appName,
+                enviroment: process.env.NODE_ENV || 'development'
+            }
+        });
+        return url;
+    };
+};

back/methods/url/specs/getByUser.spec.js

@@ -0,0 +1,19 @@
+const {models} = require('vn-loopback/server/server');
+
+describe('getByUser()', () => {
+    const worker = 1;
+    const notWorker = 2;
+    it(`should return only hedera url if not is worker`, async() => {
+        const urls = await models.Url.getByUser(notWorker);
+
+        expect(urls.length).toEqual(1);
+        expect(urls[0].appName).toEqual('hedera');
+    });
+
+    it(`should return more than hedera url`, async() => {
+        const urls = await models.Url.getByUser(worker);
+
+        expect(urls.length).toBeGreaterThan(1);
+        expect(urls.find(url => url.appName == 'salix').appName).toEqual('salix');
+    });
+});

back/methods/viaexpress-config/deleteExpedition.ejs

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
+  <soap12:Body>
+    <DeleteEnvio xmlns="http://82.223.6.71:82">
+        <IdCliente><%= viaexpressConfig.client %></IdCliente>
+        <Usuario><%= viaexpressConfig.user %></Usuario>
+        <Password><%= viaexpressConfig.password %></Password>
+      <etiqueta><%= externalId %></etiqueta>
+    </DeleteEnvio>
+  </soap12:Body>
+</soap12:Envelope>

back/methods/viaexpress-config/deleteExpedition.js

@@ -0,0 +1,45 @@
+const axios = require('axios');
+const {DOMParser} = require('xmldom');
+
+module.exports = Self => {
+    Self.remoteMethod('deleteExpedition', {
+        description: 'Delete a shipment by providing the expedition ID, interacting with Viaexpress API',
+        accessType: 'WRITE',
+        accepts: [{
+            arg: 'expeditionFk',
+            type: 'number',
+            required: true
+        }],
+        returns: {
+            type: ['object'],
+            root: true
+        },
+        http: {
+            path: `/deleteExpedition`,
+            verb: 'POST'
+        }
+    });
+
+    Self.deleteExpedition = async expeditionFk => {
+        const models = Self.app.models;
+
+        const viaexpressConfig = await models.ViaexpressConfig.findOne({
+            fields: ['url']
+        });
+
+        const renderedXml = await models.ViaexpressConfig.deleteExpeditionRenderer(expeditionFk);
+        const response = await axios.post(`${viaexpressConfig.url}ServicioVxClientes.asmx`, renderedXml, {
+            headers: {
+                'Content-Type': 'application/soap+xml; charset=utf-8'
+            }
+        });
+
+        const xmlString = response.data;
+        const parser = new DOMParser();
+        const xmlDoc = parser.parseFromString(xmlString, 'text/xml');
+        const resultElement = xmlDoc.getElementsByTagName('DeleteEnvioResult')[0];
+        const result = resultElement.textContent;
+
+        return result;
+    };
+};

back/methods/viaexpress-config/deleteExpeditionRenderer.js

@@ -0,0 +1,44 @@
+const fs = require('fs');
+const ejs = require('ejs');
+
+module.exports = Self => {
+    Self.remoteMethod('deleteExpeditionRenderer', {
+        description: 'Renders the data from an XML',
+        accessType: 'READ',
+        accepts: [{
+            arg: 'expeditionFk',
+            type: 'number',
+            required: true
+        }],
+        returns: {
+            type: ['object'],
+            root: true
+        },
+        http: {
+            path: `/deleteExpeditionRenderer`,
+            verb: 'GET'
+        }
+    });
+
+    Self.deleteExpeditionRenderer = async expeditionFk => {
+        const models = Self.app.models;
+
+        const viaexpressConfig = await models.ViaexpressConfig.findOne({
+            fields: ['client', 'user', 'password']
+        });
+
+        const expedition = await models.Expedition.findOne({
+            fields: ['id', 'externalId'],
+            where: {id: expeditionFk}
+        });
+
+        const data = {
+            viaexpressConfig,
+            externalId: expedition.externalId
+        };
+
+        const template = fs.readFileSync(__dirname + '/deleteExpedition.ejs', 'utf-8');
+        const renderedXml = ejs.render(template, data);
+        return renderedXml;
+    };
+};

back/methods/vn-user/sign-in.js

@@ -49,8 +49,7 @@ module.exports = Self => {
             if (vnUser.twoFactor)
                 throw new ForbiddenError(null, 'REQUIRES_2FA');
         }
-
-        return Self.validateLogin(user, password);
+        return Self.validateLogin(user, password, ctx);
     };
 
     Self.passExpired = async vnUser => {

back/methods/vn-user/specs/sign-in.spec.js

@@ -2,7 +2,7 @@ const {models} = require('vn-loopback/server/server');
 
 describe('VnUser Sign-in()', () => {
     const employeeId = 1;
-    const unauthCtx = {
+    const unAuthCtx = {
         req: {
             headers: {},
             connection: {
@@ -12,10 +12,24 @@ describe('VnUser Sign-in()', () => {
         },
         args: {}
     };
-    const {VnUser, AccessToken} = models;
+    const {VnUser, AccessToken, SignInLog} = models;
     describe('when credentials are correct', () => {
+        it('should return the token if user uses email', async() => {
+            let login = await VnUser.signIn(unAuthCtx, 'salesAssistant@mydomain.com', 'nightmare');
+            let accessToken = await AccessToken.findById(login.token);
+            let ctx = {req: {accessToken: accessToken}};
+            let signInLog = await SignInLog.find({where: {token: accessToken.id}});
+
+            expect(signInLog.length).toEqual(1);
+            expect(signInLog[0].userFk).toEqual(accessToken.userId);
+            expect(signInLog[0].owner).toEqual(true);
+            expect(login.token).toBeDefined();
+
+            await VnUser.logout(ctx.req.accessToken.id);
+        });
+
         it('should return the token', async() => {
-            let login = await VnUser.signIn(unauthCtx, 'salesAssistant', 'nightmare');
+            let login = await VnUser.signIn(unAuthCtx, 'salesAssistant', 'nightmare');
             let accessToken = await AccessToken.findById(login.token);
             let ctx = {req: {accessToken: accessToken}};
 
@@ -25,7 +39,7 @@ describe('VnUser Sign-in()', () => {
         });
 
         it('should return the token if the user doesnt exist but the client does', async() => {
-            let login = await VnUser.signIn(unauthCtx, 'PetterParker', 'nightmare');
+            let login = await VnUser.signIn(unAuthCtx, 'PetterParker', 'nightmare');
             let accessToken = await AccessToken.findById(login.token);
             let ctx = {req: {accessToken: accessToken}};
 
@@ -40,7 +54,7 @@ describe('VnUser Sign-in()', () => {
             let error;
 
             try {
-                await VnUser.signIn(unauthCtx, 'IDontExist', 'TotallyWrongPassword');
+                await VnUser.signIn(unAuthCtx, 'IDontExist', 'TotallyWrongPassword');
             } catch (e) {
                 error = e;
             }
@@ -61,7 +75,7 @@ describe('VnUser Sign-in()', () => {
                 const options = {transaction: tx};
                 await employee.updateAttribute('twoFactor', 'email', options);
 
-                await VnUser.signIn(unauthCtx, 'employee', 'nightmare', options);
+                await VnUser.signIn(unAuthCtx, 'employee', 'nightmare', options);
                 await tx.rollback();
             } catch (e) {
                 await tx.rollback();
@@ -86,7 +100,7 @@ describe('VnUser Sign-in()', () => {
                 const options = {transaction: tx};
                 await employee.updateAttribute('passExpired', yesterday, options);
 
-                await VnUser.signIn(unauthCtx, 'employee', 'nightmare', options);
+                await VnUser.signIn(unAuthCtx, 'employee', 'nightmare', options);
                 await tx.rollback();
             } catch (e) {
                 await tx.rollback();

back/methods/vn-user/update-user.js

@@ -0,0 +1,39 @@
+module.exports = Self => {
+    Self.remoteMethodCtx('updateUser', {
+        description: 'Update user data',
+        accepts: [
+            {
+                arg: 'id',
+                type: 'integer',
+                description: 'The user id',
+                required: true,
+                http: {source: 'path'}
+            }, {
+                arg: 'name',
+                type: 'string',
+                description: 'The user name',
+            }, {
+                arg: 'nickname',
+                type: 'string',
+                description: 'The user nickname',
+            }, {
+                arg: 'email',
+                type: 'string',
+                description: 'The user email'
+            }, {
+                arg: 'lang',
+                type: 'string',
+                description: 'The user lang'
+            }
+        ],
+        http: {
+            path: `/:id/update-user`,
+            verb: 'PATCH'
+        }
+    });
+
+    Self.updateUser = async(ctx, id, name, nickname, email, lang) => {
+        await Self.userSecurity(ctx, id);
+        await Self.upsertWithWhere({id}, {name, nickname, email, lang});
+    };
+};

back/models/chat.js

@@ -7,17 +7,14 @@ module.exports = Self => {
 
     Self.observe('before save', async function(ctx) {
         if (!ctx.isNewInstance) return;
-
         let {message} = ctx.instance;
         if (!message) return;
 
         const parts = message.match(/(?<=\[)[a-zA-Z0-9_\-+!@#$%^&*()={};':"\\|,.<>/?\s]*(?=])/g);
         if (!parts) return;
-
         const replacedParts = parts.map(part => {
             return part.replace(/[!$%^&*()={};':"\\,.<>/?]/g, '');
         });
-
         for (const [index, part] of parts.entries())
             message = message.replace(part, replacedParts[index]);
 

back/models/collection.js

@@ -1,6 +1,5 @@
 module.exports = Self => {
     require('../methods/collection/getCollection')(Self);
-    require('../methods/collection/newCollection')(Self);
     require('../methods/collection/getSectors')(Self);
     require('../methods/collection/setSaleQuantity')(Self);
     require('../methods/collection/previousLabel')(Self);

back/models/notificationSubscription.js

@@ -1,62 +1,74 @@
 const UserError = require('vn-loopback/util/user-error');
 
 module.exports = Self => {
+    require('../methods/notification/getList')(Self);
+
     Self.observe('before save', async function(ctx) {
+        await checkModifyPermission(ctx);
+    });
+
+    Self.observe('before delete', async function(ctx) {
+        await checkModifyPermission(ctx);
+    });
+
+    async function checkModifyPermission(ctx) {
         const models = Self.app.models;
+        const instance = ctx.instance;
         const userId = ctx.options.accessToken.userId;
-        const user = await ctx.instance.userFk;
-        const modifiedUser = await getUserToModify(null, user, models);
 
-        if (userId != modifiedUser.id && userId != modifiedUser.bossFk)
-            throw new UserError('You dont have permission to modify this user');
-    });
+        let notificationFk;
+        let workerId;
 
-    Self.remoteMethod('deleteNotification', {
-        description: 'Deletes a notification subscription',
-        accepts: [
-            {
-                arg: 'ctx',
-                type: 'object',
-                http: {source: 'context'}
-            },
-            {
-                arg: 'notificationId',
-                type: 'number',
-                required: true
-            },
-        ],
-        returns: {
-            type: 'object',
-            root: true
-        },
-        http: {
-            verb: 'POST',
-            path: '/deleteNotification'
+        if (instance) {
+            notificationFk = instance.notificationFk;
+            workerId = instance.userFk;
+        } else {
+            const notificationSubscription = await models.NotificationSubscription.findById(ctx.where.id);
+            notificationFk = notificationSubscription.notificationFk;
+            workerId = notificationSubscription.userFk;
         }
-    });
 
-    Self.deleteNotification = async function(ctx, notificationId) {
-        const models = Self.app.models;
-        const user = ctx.req.accessToken.userId;
-        const modifiedUser = await getUserToModify(notificationId, null, models);
+        const worker = await models.Worker.findById(workerId, {fields: ['id', 'bossFk']});
+        const available = await Self.getAvailable(workerId);
+        const hasAcl = available.has(notificationFk);
 
-        if (user != modifiedUser.id && user != modifiedUser.bossFk)
-            throw new UserError('You dont have permission to modify this user');
-
-        await models.NotificationSubscription.destroyById(notificationId);
-    };
-
-    async function getUserToModify(notificationId, userFk, models) {
-        let userToModify = userFk;
-        if (notificationId) {
-            const subscription = await models.NotificationSubscription.findById(notificationId);
-            userToModify = subscription.userFk;
-        }
-        return await models.Worker.findOne({
-            fields: ['id', 'bossFk'],
-            where: {
-                id: userToModify
-            }
-        });
+        if (!hasAcl || (userId != worker.id && userId != worker.bossFk))
+            throw new UserError('The notification subscription of this worker cant be modified');
     }
+
+    Self.getAvailable = async function(userId, options) {
+        const availableNotificationsMap = new Map();
+        const models = Self.app.models;
+
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const roles = await models.RoleMapping.find({
+            fields: ['roleId'],
+            where: {principalId: userId}
+        }, myOptions);
+
+        const availableNotifications = await models.NotificationAcl.find({
+            fields: ['notificationFk', 'roleFk'],
+            include: {relation: 'notification'},
+            where: {
+                roleFk: {
+                    inq: roles.map(role => role.roleId),
+                },
+            }
+        }, myOptions);
+
+        for (available of availableNotifications) {
+            availableNotificationsMap.set(available.notificationFk, {
+                id: null,
+                notificationFk: available.notificationFk,
+                name: available.notification().name,
+                description: available.notification().description,
+                active: false
+            });
+        }
+        return availableNotificationsMap;
+    };
 };

back/models/specs/notificationSubscription.spec.js

@@ -1,74 +1,126 @@
 const models = require('vn-loopback/server/server').models;
 
 describe('loopback model NotificationSubscription', () => {
-    it('Should fail to delete a notification if the user is not editing itself or a subordinate', async() => {
+    it('should fail to add a notification subscription if the worker doesnt have ACLs', async() => {
         const tx = await models.NotificationSubscription.beginTransaction({});
+        let error;
 
         try {
-            const options = {transaction: tx};
-            const user = 9;
+            const options = {transaction: tx, accessToken: {userId: 9}};
+            await models.NotificationSubscription.create({notificationFk: 1, userFk: 62}, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error.message).toEqual('The notification subscription of this worker cant be modified');
+    });
+
+    it('should fail to add a notification subscription if the user isnt editing itself or subordinate', async() => {
+        const tx = await models.NotificationSubscription.beginTransaction({});
+        let error;
+
+        try {
+            const options = {transaction: tx, accessToken: {userId: 1}};
+            await models.NotificationSubscription.create({notificationFk: 1, userFk: 9}, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error.message).toEqual('The notification subscription of this worker cant be modified');
+    });
+
+    it('should fail to delete a notification subscription if the user isnt editing itself or subordinate', async() => {
+        const tx = await models.NotificationSubscription.beginTransaction({});
+        let error;
+
+        try {
+            const options = {transaction: tx, accessToken: {userId: 9}};
             const notificationSubscriptionId = 2;
-            const ctx = {req: {accessToken: {userId: user}}};
-            const notification = await models.NotificationSubscription.findById(notificationSubscriptionId);
+            await models.NotificationSubscription.destroyAll({id: notificationSubscriptionId}, options);
 
-            let error;
-
-            try {
-                await models.NotificationSubscription.deleteNotification(ctx, notification.id, options);
-            } catch (e) {
-                error = e;
-            }
-
-            expect(error.message).toContain('You dont have permission to modify this user');
             await tx.rollback();
         } catch (e) {
             await tx.rollback();
-            throw e;
+            error = e;
         }
+
+        expect(error.message).toEqual('The notification subscription of this worker cant be modified');
     });
 
-    it('Should delete a notification if the user is editing itself', async() => {
+    it('should add a notification subscription if the user is editing itself', async() => {
         const tx = await models.NotificationSubscription.beginTransaction({});
+        let error;
 
         try {
-            const options = {transaction: tx};
-            const user = 9;
+            const options = {transaction: tx, accessToken: {userId: 9}};
+            await models.NotificationSubscription.create({notificationFk: 2, userFk: 9}, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error).toBeUndefined();
+    });
+
+    it('should delete a notification subscription if the user is editing itself', async() => {
+        const tx = await models.NotificationSubscription.beginTransaction({});
+        let error;
+
+        try {
+            const options = {transaction: tx, accessToken: {userId: 9}};
+            const notificationSubscriptionId = 6;
+            await models.NotificationSubscription.destroyAll({id: notificationSubscriptionId}, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error).toBeUndefined();
+    });
+
+    it('should add a notification subscription if the user is editing a subordinate', async() => {
+        const tx = await models.NotificationSubscription.beginTransaction({});
+        let error;
+
+        try {
+            const options = {transaction: tx, accessToken: {userId: 9}};
+            await models.NotificationSubscription.create({notificationFk: 1, userFk: 5}, options);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error).toBeUndefined();
+    });
+
+    it('should delete a notification subscription if the user is editing a subordinate', async() => {
+        const tx = await models.NotificationSubscription.beginTransaction({});
+        let error;
+
+        try {
+            const options = {transaction: tx, accessToken: {userId: 19}};
             const notificationSubscriptionId = 4;
-            const ctx = {req: {accessToken: {userId: user}}};
-            const notification = await models.NotificationSubscription.findById(notificationSubscriptionId);
+            await models.NotificationSubscription.destroyAll({id: notificationSubscriptionId}, options);
 
-            await models.NotificationSubscription.deleteNotification(ctx, notification.id, options);
-
-            const deletedNotification = await models.NotificationSubscription.findById(notificationSubscriptionId);
-
-            expect(deletedNotification).toBeNull();
             await tx.rollback();
         } catch (e) {
             await tx.rollback();
-            throw e;
+            error = e;
         }
-    });
 
-    it('Should delete a notification if the user is editing a subordinate', async() => {
-        const tx = await models.NotificationSubscription.beginTransaction({});
-
-        try {
-            const options = {transaction: tx};
-            const user = 9;
-            const notificationSubscriptionId = 5;
-            const ctx = {req: {accessToken: {userId: user}}};
-            const notification = await models.NotificationSubscription.findById(notificationSubscriptionId);
-
-            await models.NotificationSubscription.deleteNotification(ctx, notification.id, options);
-
-            const deletedNotification = await models.NotificationSubscription.findById(notificationSubscriptionId);
-
-            expect(deletedNotification).toBeNull();
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
+        expect(error).toBeUndefined();
     });
 });
 

back/models/specs/vn-user.spec.js

@@ -1,4 +1,5 @@
 const models = require('vn-loopback/server/server').models;
+const ForbiddenError = require('vn-loopback/util/forbiddenError');
 
 describe('loopback model VnUser', () => {
     it('should return true if the user has the given role', async() => {
@@ -12,4 +13,42 @@ describe('loopback model VnUser', () => {
 
         expect(result).toBeFalsy();
     });
+
+    describe('userSecurity', () => {
+        const itManagementId = 115;
+        const hrId = 37;
+        const employeeId = 1;
+
+        it('should check if you are the same user', async() => {
+            const ctx = {options: {accessToken: {userId: employeeId}}};
+            await models.VnUser.userSecurity(ctx, employeeId);
+        });
+
+        it('should check for higher privileges', async() => {
+            const ctx = {options: {accessToken: {userId: itManagementId}}};
+            await models.VnUser.userSecurity(ctx, employeeId);
+        });
+
+        it('should check if you have medium privileges and the user email is not verified', async() => {
+            const ctx = {options: {accessToken: {userId: hrId}}};
+            await models.VnUser.userSecurity(ctx, employeeId);
+        });
+
+        it('should throw an error if you have medium privileges and the users email is verified', async() => {
+            const tx = await models.VnUser.beginTransaction({});
+            const ctx = {options: {accessToken: {userId: hrId}}};
+            try {
+                const options = {transaction: tx};
+                const userToUpdate = await models.VnUser.findById(1, null, options);
+                userToUpdate.updateAttribute('emailVerified', 1, options);
+
+                await models.VnUser.userSecurity(ctx, employeeId, options);
+                await tx.rollback();
+            } catch (error) {
+                await tx.rollback();
+
+                expect(error).toEqual(new ForbiddenError());
+            }
+        });
+    });
 });

back/models/url.js

@@ -0,0 +1,4 @@
+module.exports = Self => {
+    require('../methods/url/getByUser')(Self);
+    require('../methods/url/getUrl')(Self);
+};

back/models/viaexpress-config.js

@@ -1,4 +1,6 @@
 module.exports = Self => {
     require('../methods/viaexpress-config/internationalExpedition')(Self);
     require('../methods/viaexpress-config/renderer')(Self);
+    require('../methods/viaexpress-config/deleteExpedition')(Self);
+    require('../methods/viaexpress-config/deleteExpeditionRenderer')(Self);
 };

back/models/vn-user.js

@@ -1,6 +1,8 @@
 const vnModel = require('vn-loopback/common/models/vn-model');
-const LoopBackContext = require('loopback-context');
 const {Email} = require('vn-print');
+const ForbiddenError = require('vn-loopback/util/forbiddenError');
+const LoopBackContext = require('loopback-context');
+const UserError = require('vn-loopback/util/user-error');
 
 module.exports = function(Self) {
     vnModel(Self);
@@ -12,6 +14,7 @@ module.exports = function(Self) {
     require('../methods/vn-user/privileges')(Self);
     require('../methods/vn-user/validate-auth')(Self);
     require('../methods/vn-user/renew-token')(Self);
+    require('../methods/vn-user/update-user')(Self);
 
     Self.definition.settings.acls = Self.definition.settings.acls.filter(acl => acl.property !== 'create');
 
@@ -122,11 +125,42 @@ module.exports = function(Self) {
         return email.send();
     });
 
-    Self.validateLogin = async function(user, password) {
-        let loginInfo = Object.assign({password}, Self.userUses(user));
-        token = await Self.login(loginInfo, 'user');
+    /**
+     * Sign-in validate
+     * @param {String} user The user
+     * @param {Object} userToken Options
+     * @param {Object} token accessToken
+     * @param {Object} ctx context
+     */
+    Self.signInValidate = async(user, userToken, token, ctx) => {
+        const [[key, value]] = Object.entries(Self.userUses(user));
+        const isOwner = Self.rawSql(`SELECT ? = ? `, [userToken[key], value]);
+        await Self.app.models.SignInLog.create({
+            userName: user,
+            token: token.id,
+            userFk: userToken.id,
+            ip: ctx.req.ip,
+            owner: isOwner
+        });
+        if (!isOwner)
+            throw new UserError('Try again');
+    };
+
+    /**
+     * Validate login params
+     * @param {String} user The user
+     * @param {String} password
+      * @param {Object} ctx context
+     */
+    Self.validateLogin = async function(user, password, ctx) {
+        const loginInfo = Object.assign({password}, Self.userUses(user));
+        const token = await Self.login(loginInfo, 'user');
 
         const userToken = await token.user.get();
+
+        if (ctx)
+            await Self.signInValidate(user, userToken, token, ctx);
+
         try {
             await Self.app.models.Account.sync(userToken.name, password);
         } catch (err) {
@@ -175,48 +209,83 @@ module.exports = function(Self) {
     };
 
     Self.sharedClass._methods.find(method => method.name == 'changePassword').ctor.settings.acls =
-    Self.sharedClass._methods.find(method => method.name == 'changePassword').ctor.settings.acls
-        .filter(acl => acl.property != 'changePassword');
+        Self.sharedClass._methods.find(method => method.name == 'changePassword').ctor.settings.acls
+            .filter(acl => acl.property != 'changePassword');
 
-    // FIXME: https://redmine.verdnatura.es/issues/5761
-    // Self.afterRemote('prototype.patchAttributes', async(ctx, instance) => {
-    //     if (!ctx.args || !ctx.args.data.email) return;
+    Self.userSecurity = async(ctx, userId, options) => {
+        const models = Self.app.models;
+        const accessToken = ctx?.options?.accessToken || LoopBackContext.getCurrentContext().active.accessToken;
+        const ctxToken = {req: {accessToken}};
 
-    //     const loopBackContext = LoopBackContext.getCurrentContext();
-    //     const httpCtx = {req: loopBackContext.active};
-    //     const httpRequest = httpCtx.req.http.req;
-    //     const headers = httpRequest.headers;
-    //     const origin = headers.origin;
-    //     const url = origin.split(':');
+        if (userId === accessToken.userId) return;
 
-    //     class Mailer {
-    //         async send(verifyOptions, cb) {
-    //             const params = {
-    //                 url: verifyOptions.verifyHref,
-    //                 recipient: verifyOptions.to,
-    //                 lang: ctx.req.getLocale()
-    //             };
+        const myOptions = {};
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
 
-    //             const email = new Email('email-verify', params);
-    //             email.send();
+        const hasHigherPrivileges = await models.ACL.checkAccessAcl(ctxToken, 'VnUser', 'higherPrivileges', myOptions);
+        if (hasHigherPrivileges) return;
 
-    //             cb(null, verifyOptions.to);
-    //         }
-    //     }
+        const hasMediumPrivileges = await models.ACL.checkAccessAcl(ctxToken, 'VnUser', 'mediumPrivileges', myOptions);
+        const user = await models.VnUser.findById(userId, {fields: ['id', 'emailVerified']}, myOptions);
+        if (!user.emailVerified && hasMediumPrivileges) return;
 
-    //     const options = {
-    //         type: 'email',
-    //         to: instance.email,
-    //         from: {},
-    //         redirect: `${origin}/#!/account/${instance.id}/basic-data?emailConfirmed`,
-    //         template: false,
-    //         mailer: new Mailer,
-    //         host: url[1].split('/')[2],
-    //         port: url[2],
-    //         protocol: url[0],
-    //         user: Self
-    //     };
+        throw new ForbiddenError();
+    };
 
-    //     await instance.verify(options);
-    // });
+    Self.observe('after save', async ctx => {
+        const instance = ctx?.instance;
+        const newEmail = instance?.email;
+        const oldEmail = ctx?.hookState?.oldInstance?.email;
+        if (!ctx.isNewInstance && (!newEmail || !oldEmail || newEmail == oldEmail)) return;
+
+        const loopBackContext = LoopBackContext.getCurrentContext();
+        const httpCtx = {req: loopBackContext.active};
+        const httpRequest = httpCtx.req.http.req;
+        const headers = httpRequest.headers;
+        const origin = headers.origin;
+        const url = origin.split(':');
+
+        const env = process.env.NODE_ENV;
+        const liliumUrl = await Self.app.models.Url.findOne({
+            where: {
+                and: [
+                    {appName: 'lilium'},
+                    {environment: env}
+                ]
+            }
+        });
+
+        class Mailer {
+            async send(verifyOptions, cb) {
+                const url = new URL(verifyOptions.verifyHref);
+                if (process.env.NODE_ENV) url.port = '';
+
+                const params = {
+                    url: url.href,
+                    recipient: verifyOptions.to
+                };
+
+                const email = new Email('email-verify', params);
+                email.send();
+
+                cb(null, verifyOptions.to);
+            }
+        }
+
+        const options = {
+            type: 'email',
+            to: newEmail,
+            from: {},
+            redirect: `${liliumUrl.url}verifyEmail?userId=${instance.id}`,
+            template: false,
+            mailer: new Mailer,
+            host: url[1].split('/')[2],
+            port: url[2],
+            protocol: url[0],
+            user: Self
+        };
+
+        await instance.verify(options, ctx.options);
+    });
 };

back/models/vn-user.json

@@ -13,19 +13,12 @@
 			"type": "number",
 			"id": true
 		},
-		"name": {
+        "name": {
 			"type": "string",
 			"required": true
 		},
 		"username": {
-			"type": "string",
-			"mysql": {
-				"columnName": "name"
-			}
-		},
-		"password": {
-			"type": "string",
-			"required": true
+			"type": "string"
 		},
 		"roleFk": {
 			"type": "number",
@@ -45,6 +38,9 @@
 		"email": {
 			"type": "string"
 		},
+		"emailVerified": {
+			"type": "boolean"
+		},
 		"created": {
 			"type": "date"
 		},
@@ -144,7 +140,8 @@
                 "image",
                 "hasGrant",
                 "realm",
-                "email"
+                "email",
+				"emailVerified"
             ]
         }
     }

db/.archive/225201/00-invoiceOut_new.sql

@@ -74,7 +74,7 @@ BEGIN
 			clientFk,
 			dued,
 			companyFk,
-			cplusInvoiceType477Fk
+			siiTypeInvoiceOutFk
 		)
 		SELECT
 				1,
@@ -118,13 +118,13 @@ BEGIN
 			SELECT 'UPDATE', account.myUser_getId(), ti.id, CONCAT('Crea factura ', vNewRef)
 				FROM tmp.ticketToInvoice ti;
 
-		CALL invoiceExpenceMake(vNewInvoiceId);
+		CALL invoiceExpenseMake(vNewInvoiceId);
 		CALL invoiceTaxMake(vNewInvoiceId,vTaxArea);
 
 		UPDATE invoiceOut io
 				JOIN (
 					SELECT SUM(amount) AS total
-						FROM invoiceOutExpence
+						FROM invoiceOutExpense
 						WHERE invoiceOutFk = vNewInvoiceId
 					) base
 				JOIN (
@@ -166,18 +166,18 @@ BEGIN
 			SET @vTaxableBaseServices := 0.00;
 			SET @vTaxCodeGeneral := NULL;
 
-			INSERT INTO vn.invoiceInTax(invoiceInFk, taxableBase, expenceFk, taxTypeSageFk, transactionTypeSageFk)
-				SELECT vNewInvoiceInId, @vTaxableBaseServices, sub.expenceFk, sub.taxTypeSageFk , sub.transactionTypeSageFk
+			INSERT INTO vn.invoiceInTax(invoiceInFk, taxableBase, expenseFk, taxTypeSageFk, transactionTypeSageFk)
+				SELECT vNewInvoiceInId, @vTaxableBaseServices, sub.expenseFk, sub.taxTypeSageFk , sub.transactionTypeSageFk
 					FROM (
-						SELECT @vTaxableBaseServices := SUM(tst.taxableBase) taxableBase, i.expenceFk, i.taxTypeSageFk , i.transactionTypeSageFk, @vTaxCodeGeneral := i.taxClassCodeFk
+						SELECT @vTaxableBaseServices := SUM(tst.taxableBase) taxableBase, i.expenseFk, i.taxTypeSageFk , i.transactionTypeSageFk, @vTaxCodeGeneral := i.taxClassCodeFk
 							FROM tmp.ticketServiceTax tst
 								JOIN vn.invoiceOutTaxConfig i ON i.taxClassCodeFk = tst.code
 							WHERE i.isService
 							HAVING taxableBase
 						) sub;
 
-			INSERT INTO vn.invoiceInTax(invoiceInFk, taxableBase, expenceFk, taxTypeSageFk, transactionTypeSageFk)
-				SELECT  vNewInvoiceInId, SUM(tt.taxableBase) - IF(tt.code = @vTaxCodeGeneral, @vTaxableBaseServices, 0) taxableBase, i.expenceFk, i.taxTypeSageFk , i.transactionTypeSageFk
+			INSERT INTO vn.invoiceInTax(invoiceInFk, taxableBase, expenseFk, taxTypeSageFk, transactionTypeSageFk)
+				SELECT  vNewInvoiceInId, SUM(tt.taxableBase) - IF(tt.code = @vTaxCodeGeneral, @vTaxableBaseServices, 0) taxableBase, i.expenseFk, i.taxTypeSageFk , i.transactionTypeSageFk
 					FROM tmp.ticketTax tt
 						JOIN vn.invoiceOutTaxConfig i ON i.taxClassCodeFk = tt.code
 					WHERE !i.isService

db/.archive/231001/02-invoiceOut_new.sql

@@ -96,7 +96,7 @@ BEGIN
 			clientFk,
 			dued,
 			companyFk,
-			cplusInvoiceType477Fk
+			siiTypeInvoiceOutFk
 		)
 			SELECT
 					1,
@@ -139,13 +139,13 @@ BEGIN
 			SELECT 'UPDATE', account.myUser_getId(), ti.id, CONCAT('Crea factura ', vNewRef)
 				FROM tmp.ticketToInvoice ti;
 
-		CALL invoiceExpenceMake(vNewInvoiceId);
+		CALL invoiceExpenseMake(vNewInvoiceId);
 		CALL invoiceTaxMake(vNewInvoiceId,vTaxArea);
 
 		UPDATE invoiceOut io
 				JOIN (
 					SELECT SUM(amount) total
-						FROM invoiceOutExpence
+						FROM invoiceOutExpense
 						WHERE invoiceOutFk = vNewInvoiceId
 					) base
 				JOIN (
@@ -182,15 +182,15 @@ BEGIN
 			SET @vTaxableBaseServices := 0.00;
 			SET @vTaxCodeGeneral := NULL;
 
-			INSERT INTO invoiceInTax(invoiceInFk, taxableBase, expenceFk, taxTypeSageFk, transactionTypeSageFk)
+			INSERT INTO invoiceInTax(invoiceInFk, taxableBase, expenseFk, taxTypeSageFk, transactionTypeSageFk)
 				SELECT vNewInvoiceInFk,
 						@vTaxableBaseServices,
-						sub.expenceFk,
+						sub.expenseFk,
 						sub.taxTypeSageFk,
 						sub.transactionTypeSageFk
 					FROM (
 						SELECT @vTaxableBaseServices := SUM(tst.taxableBase) taxableBase,
-								i.expenceFk,
+								i.expenseFk,
 								i.taxTypeSageFk,
 								i.transactionTypeSageFk,
 								@vTaxCodeGeneral := i.taxClassCodeFk
@@ -200,11 +200,11 @@ BEGIN
 							HAVING taxableBase
 						) sub;
 
-			INSERT INTO invoiceInTax(invoiceInFk, taxableBase, expenceFk, taxTypeSageFk, transactionTypeSageFk)
+			INSERT INTO invoiceInTax(invoiceInFk, taxableBase, expenseFk, taxTypeSageFk, transactionTypeSageFk)
 				SELECT vNewInvoiceInFk,
 						SUM(tt.taxableBase) - IF(tt.code = @vTaxCodeGeneral,
 						@vTaxableBaseServices, 0) taxableBase,
-						i.expenceFk,
+						i.expenseFk,
 						i.taxTypeSageFk ,
 						i.transactionTypeSageFk
 					FROM tmp.ticketTax tt

db/.archive/232001/00-invoiceOut_new.sql

@@ -96,7 +96,7 @@ BEGIN
 			clientFk,
 			dued,
 			companyFk,
-			cplusInvoiceType477Fk
+			siiTypeInvoiceOutFk
 		)
 			SELECT
 					1,
@@ -135,13 +135,13 @@ BEGIN
 		INSERT INTO ticketTracking(stateFk,ticketFk,workerFk)
 			SELECT * FROM tmp.updateInter;
 
-		CALL invoiceExpenceMake(vNewInvoiceId);
+		CALL invoiceExpenseMake(vNewInvoiceId);
 		CALL invoiceTaxMake(vNewInvoiceId,vTaxArea);
 
 		UPDATE invoiceOut io
 				JOIN (
 					SELECT SUM(amount) total
-						FROM invoiceOutExpence
+						FROM invoiceOutExpense
 						WHERE invoiceOutFk = vNewInvoiceId
 					) base
 				JOIN (
@@ -178,15 +178,15 @@ BEGIN
 			SET @vTaxableBaseServices := 0.00;
 			SET @vTaxCodeGeneral := NULL;
 
-			INSERT INTO invoiceInTax(invoiceInFk, taxableBase, expenceFk, taxTypeSageFk, transactionTypeSageFk)
+			INSERT INTO invoiceInTax(invoiceInFk, taxableBase, expenseFk, taxTypeSageFk, transactionTypeSageFk)
 				SELECT vNewInvoiceInFk,
 						@vTaxableBaseServices,
-						sub.expenceFk,
+						sub.expenseFk,
 						sub.taxTypeSageFk,
 						sub.transactionTypeSageFk
 					FROM (
 						SELECT @vTaxableBaseServices := SUM(tst.taxableBase) taxableBase,
-								i.expenceFk,
+								i.expenseFk,
 								i.taxTypeSageFk,
 								i.transactionTypeSageFk,
 								@vTaxCodeGeneral := i.taxClassCodeFk
@@ -196,11 +196,11 @@ BEGIN
 							HAVING taxableBase
 						) sub;
 
-			INSERT INTO invoiceInTax(invoiceInFk, taxableBase, expenceFk, taxTypeSageFk, transactionTypeSageFk)
+			INSERT INTO invoiceInTax(invoiceInFk, taxableBase, expenseFk, taxTypeSageFk, transactionTypeSageFk)
 				SELECT vNewInvoiceInFk,
 						SUM(tt.taxableBase) - IF(tt.code = @vTaxCodeGeneral,
 						@vTaxableBaseServices, 0) taxableBase,
-						i.expenceFk,
+						i.expenseFk,
 						i.taxTypeSageFk ,
 						i.transactionTypeSageFk
 					FROM tmp.ticketTax tt