Merge branch 'dev' into 5633-accountShortToStandard

.vscode/settings.json

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

CHANGELOG.md

@@ -5,27 +5,29 @@ 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).
 
+## [2348.01] - 2023-11-30
+
+### Added
+### Changed
+### Fixed
+
 ## [2346.01] - 2023-11-16
 
 ### Added
 ### Changed
 ### Fixed
 
+
 ## [2342.01] - 2023-11-02
 
-### Added
-### Changed
-### Fixed
-
-## [2340.01] - 2023-10-05
-
 ### 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
@@ -35,17 +37,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

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/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)
+        let notificationFk;
-            throw new UserError('You dont have permission to modify this user');
+        let workerId;
-    });
 
-    Self.remoteMethod('deleteNotification', {
+        if (instance) {
-        description: 'Deletes a notification subscription',
+            notificationFk = instance.notificationFk;
-        accepts: [
+            workerId = instance.userFk;
-            {
+        } else {
-                arg: 'ctx',
+            const notificationSubscription = await models.NotificationSubscription.findById(ctx.where.id);
-                type: 'object',
+            notificationFk = notificationSubscription.notificationFk;
-                http: {source: 'context'}
+            workerId = notificationSubscription.userFk;
-            },
-            {
-                arg: 'notificationId',
-                type: 'number',
-                required: true
-            },
-        ],
-        returns: {
-            type: 'object',
-            root: true
-        },
-        http: {
-            verb: 'POST',
-            path: '/deleteNotification'
         }
-    });
 
-    Self.deleteNotification = async function(ctx, notificationId) {
+        const worker = await models.Worker.findById(workerId, {fields: ['id', 'bossFk']});
+        const available = await Self.getAvailable(workerId);
+        const hasAcl = available.has(notificationFk);
+
+        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 user = ctx.req.accessToken.userId;
-        const modifiedUser = await getUserToModify(notificationId, null, models);
 
-        if (user != modifiedUser.id && user != modifiedUser.bossFk)
+        const myOptions = {};
-            throw new UserError('You dont have permission to modify this user');
 
-        await models.NotificationSubscription.destroyById(notificationId);
+        if (typeof options == 'object')
-    };
+            Object.assign(myOptions, options);
 
-    async function getUserToModify(notificationId, userFk, models) {
+        const roles = await models.RoleMapping.find({
-        let userToModify = userFk;
+            fields: ['roleId'],
-        if (notificationId) {
+            where: {principalId: userId}
-            const subscription = await models.NotificationSubscription.findById(notificationId);
+        }, myOptions);
-            userToModify = subscription.userFk;
+
-        }
+        const availableNotifications = await models.NotificationAcl.find({
-        return await models.Worker.findOne({
+            fields: ['notificationFk', 'roleFk'],
-            fields: ['id', 'bossFk'],
+            include: {relation: 'notification'},
             where: {
-                id: userToModify
+                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({});
-
-        try {
-            const options = {transaction: tx};
-            const user = 9;
-            const notificationSubscriptionId = 2;
-            const ctx = {req: {accessToken: {userId: user}}};
-            const notification = await models.NotificationSubscription.findById(notificationSubscriptionId);
-
         let error;
 
         try {
-                await models.NotificationSubscription.deleteNotification(ctx, notification.id, options);
+            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).toContain('You dont have permission to modify this user');
+        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();
-            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 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};
+            const options = {transaction: tx, accessToken: {userId: 9}};
-            const user = 9;
+            const notificationSubscriptionId = 2;
+            await models.NotificationSubscription.destroyAll({id: notificationSubscriptionId}, 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 add 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}};
+            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}}};
+            await models.NotificationSubscription.destroyAll({id: notificationSubscriptionId}, options);
-            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;
+            error = e;
         }
-    });
 
-    it('Should delete a notification if the user is editing a subordinate', async() => {
+        expect(error).toBeUndefined();
-        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;
-        }
     });
 });
 

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

@@ -74,7 +74,7 @@ BEGIN
 			clientFk,
 			dued,
 			companyFk,
-			cplusInvoiceType477Fk
+			siiTypeInvoiceOutFk
 		)
 		SELECT
 				1,

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

@@ -96,7 +96,7 @@ BEGIN
 			clientFk,
 			dued,
 			companyFk,
-			cplusInvoiceType477Fk
+			siiTypeInvoiceOutFk
 		)
 			SELECT
 					1,

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

@@ -96,7 +96,7 @@ BEGIN
 			clientFk,
 			dued,
 			companyFk,
-			cplusInvoiceType477Fk
+			siiTypeInvoiceOutFk
 		)
 			SELECT
 					1,

db/changes/234004/00-workerTimeControl.sql

@@ -0,0 +1,41 @@
+UPDATE `vn`.`workerTimeControlConfig`
+	SET `timeToBreakTime` = 18000;
+
+ALTER TABLE `vn`.`workerTimeControlConfig`
+	DROP COLUMN IF EXISTS `maxTimeToBreak`; 
+ALTER TABLE `vn`.`workerTimeControlConfig` 
+    ADD COLUMN maxTimeToBreak INT DEFAULT 3600 NULL;
+
+ALTER TABLE `vn`.`workerTimeControlConfig` 
+	DROP COLUMN IF EXISTS `maxWorkShortCycle`;
+
+ALTER TABLE `vn`.`workerTimeControlConfig` 
+	ADD COLUMN `maxWorkShortCycle` INT(10) UNSIGNED DEFAULT 561600 
+ 	COMMENT 'Máximo tiempo que un trabajador puede estar trabajando con el que adquirirá el derecho a un descanso semanal corto';
+ 
+ALTER TABLE `vn`.`workerTimeControlConfig` 
+	DROP COLUMN IF EXISTS `maxWorkLongCycle`; 
+
+ALTER TABLE `vn`.`workerTimeControlConfig` 
+	ADD COLUMN  `maxWorkLongCycle` INT(10) UNSIGNED DEFAULT 950400 
+ 	COMMENT 'Máximo tiempo que un trabajador puede estar trabajando con el que adquirirá el derecho a un descanso semanal largo';
+
+CREATE TABLE IF NOT EXISTS  `vn`.`workerTimeControlError` (
+  `id` mediumint(8) unsigned NOT NULL AUTO_INCREMENT,
+  `code` char(35) NOT NULL,
+  `description` varchar(255) NOT NULL,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `code` (`code`)
+) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_unicode_ci;
+
+INSERT IGNORE INTO `vn`.`workerTimeControlError` (`code`, `description`) 
+	VALUES
+		('IS_NOT_ALLOWED_FUTURE', 	'No se permite fichar a futuro'),
+		('INACTIVE_BUSINESS', 		'No hay un contrato en vigor'),
+		('IS_NOT_ALLOWED_WORK', 	'No está permitido trabajar'),
+		('ODD_WORKERTIMECONTROL', 	'Fichadas impares'),
+		('DAY_MAX_TIME', 			'Superado el tiempo máximo entre entrada y salida'),
+		('BREAK_DAY', 				'Descanso diario'),
+		('BREAK_WEEK', 				'Descanso semanal'),
+		('WRONG_DIRECTION', 		'Dirección incorrecta'),
+		('UNDEFINED_ERROR', 		'Error sin definir');

db/changes/234004/01-timeControl_calculate.sql

@@ -0,0 +1,194 @@
+DELIMITER $$
+CREATE OR REPLACE DEFINER=`root`@`localhost` PROCEDURE `vn`.`timeControl_calculate`(
+	vDatedFrom DATETIME, 
+	vDatedTo DATETIME)
+BEGIN
+/*
+ * Agrupa por trabajador y día, el tiempo de trabajo y descanso retribuido(si tiene).
+ * Los registros horarios incorrectos (tmp.timeControlError) no se considerarán.
+ * Si un trabajador ha trabajado más de un cierto umbral de tiempo (vTimeToBreakTime) 
+ * y no ha tenido descansos que superen un parámetro determinado(vMaxTimeToBreak), 
+ * se le añadirá un tiempo de descanso (vBreakTime) a sus horas trabajadas.
+ * El tiempo de descanso solo se añade si el trabajador realmente disfrutó del descanso.
+ * Si disfrutó de menos tiempo de descanso, solo se añade el tiempo que disfrutó.
+ * 
+ * @param vDatedFrom
+ * @param vDatedTo 
+ *
+ * @return tmp.timeControlCalculate 
+ * (workerFk, dated, timeWorkSeconds, timeWorkSexagesimal, timeWorkDecimal, timed)
+ */
+	DECLARE vHourSeconds INTEGER;
+	DECLARE vDatedFromYesterday DATETIME;
+	DECLARE vDatedToTomorrow DATETIME; 
+	DECLARE vTimeToBreakTime INT;
+	DECLARE vBreakTime INT;
+	DECLARE vMaxTimeToBreak INT;
+	
+	SELECT DATE_SUB(vDatedFrom, INTERVAL 1 DAY), DATE_ADD(vDatedTo, INTERVAL 1 DAY)
+		INTO vDatedFromYesterday, vDatedToTomorrow;
+	
+	SELECT timeToBreakTime, breakTime, maxTimeToBreak, TIME_TO_SEC('01:00:00')
+			INTO vTimeToBreakTime, vBreakTime, vMaxTimeToBreak, vHourSeconds
+		FROM workerTimeControlConfig 
+		LIMIT 1;
+
+	CALL timeControl_getError(vDatedFromYesterday, vDatedToTomorrow);
+
+	CREATE OR REPLACE TEMPORARY TABLE tmp.workerTimeControl
+		(INDEX(userFk, timed), INDEX(timed), INDEX(direction))
+		ENGINE = MEMORY
+		SELECT wtc.userFk, 
+				wtc.timed, 
+				DATE(wtc.timed) dated,
+				wtc.direction,
+				TRUE isReal
+			FROM workerTimeControl wtc
+				JOIN tmp.`user` u ON u.userFk = wtc.userFk 
+				LEFT JOIN (
+					SELECT wtc.userFk, MIN(wtc.timed) firstIn
+					FROM workerTimeControl wtc
+						JOIN tmp.`user` u ON u.userFk = wtc.userFk
+						LEFT JOIN tmp.timeControlError tce ON tce.id = wtc.id
+					WHERE wtc.timed BETWEEN vDatedFromYesterday AND vDatedToTomorrow
+						AND wtc.direction = 'in'
+						AND tce.id IS NULL
+					GROUP BY userFk
+				) fi ON wtc.userFk = fi.userFk
+				LEFT JOIN (
+					SELECT wtc.userFk, MAX(wtc.timed) lastOut
+					FROM workerTimeControl wtc
+						JOIN tmp.`user` u ON u.userFk = wtc.userFk
+						LEFT JOIN tmp.timeControlError tce ON tce.id = wtc.id
+					WHERE wtc.timed BETWEEN vDatedFromYesterday AND vDatedToTomorrow
+						AND wtc.direction = 'out'
+						AND tce.id IS NULL
+					GROUP BY userFk
+				) lo ON wtc.userFk = lo.userFk
+				LEFT JOIN tmp.timeControlError tce ON tce.id = wtc.id
+			WHERE wtc.timed BETWEEN fi.firstIn AND lo.lastOut
+				AND tce.id IS NULL
+			ORDER BY wtc.userFk, wtc.timed;
+	
+	 CREATE OR REPLACE TEMPORARY TABLE tmp.wtcToinsert
+		(INDEX(timed))	
+	 	ENGINE = MEMORY
+	 	WITH wtc AS(
+			SELECT timed,
+					userFk,
+					dated,
+					direction,
+					LEAD(dated) OVER 
+						(PARTITION BY userFk, dated ORDER BY timed) nextDay,
+					LEAD(userFk) OVER 
+						(PARTITION BY userFk ORDER BY timed) nextUserFk,
+					ROW_NUMBER() OVER (ORDER BY userFk, timed) MOD 2 isOdd
+				FROM tmp.workerTimeControl
+				WHERE timed BETWEEN vDatedFromYesterday AND vDatedToTomorrow
+				ORDER BY userFk, timed
+		), wtcToinsert AS(	
+			SELECT userFk, 
+					dated,
+					IF(userFk = nextUserFk 
+						AND nextDay IS NULL 
+						AND isOdd 
+						AND direction <> 'out', TRUE, FALSE) outNextDay,
+					IF(userFk = nextUserFk 
+						AND nextDay IS NULL 
+						AND NOT isOdd 
+						AND direction <> 'out', TRUE, FALSE) outNextDayWhitBreak	
+				FROM wtc
+				HAVING outNextDay OR outNextDayWhitBreak
+		)SELECT userFk, util.dayEnd(dated) timed, 'out' direction 
+			FROM wtcToinsert
+			WHERE outNextDay
+		UNION ALL 
+		SELECT userFk, dated + INTERVAL 1 DAY, 'in'
+			FROM wtcToinsert
+			WHERE outNextDay
+		UNION ALL 
+		SELECT userFk, util.dayEnd(dated) - INTERVAL 1 SECOND, 'middle' 
+			FROM wtcToinsert
+			WHERE outNextDayWhitBreak
+		UNION ALL
+		SELECT userFk, util.dayEnd(dated), 'out'
+			FROM wtcToinsert
+			WHERE outNextDayWhitBreak	
+		UNION ALL 
+		SELECT userFk, dated + INTERVAL 1 DAY, 'in'
+			FROM wtcToinsert
+			WHERE outNextDayWhitBreak
+		UNION ALL 
+		SELECT userFk, dated + INTERVAL 1 DAY + INTERVAL 1 SECOND, 'middle'
+			FROM wtcToinsert
+			WHERE outNextDayWhitBreak;
+	
+	INSERT INTO tmp.workerTimeControl (userFk, timed, dated, direction, isReal)
+		SELECT userFk, timed, DATE(timed), direction, FALSE
+			FROM tmp.wtcToinsert;
+
+	SET @accumulatedForBreakTime = 0;
+	SET @oldrealDay = NULL;	
+	CREATE OR REPLACE TEMPORARY TABLE tmp.timeControlCalculate	
+		WITH workerTimed AS (
+			SELECT
+				userFk,
+				dated,
+				timed,
+				(direction ='in' AND isReal) breakPoint,
+				SUM(CASE WHEN (direction ='in' AND isReal) THEN TRUE ELSE FALSE END)
+					OVER (ORDER BY userFk, timed) AS realDay,
+				TIMESTAMPDIFF(SECOND, LAG(timed) 
+					OVER (PARTITION BY userFk, dated ORDER BY timed), timed) gapTime,
+				ROW_NUMBER() 
+					OVER (PARTITION BY userFk, dated ORDER BY timed) MOD 2 isOdd
+			FROM tmp.workerTimeControl
+			WHERE timed BETWEEN vDatedFromYesterday AND vDatedToTomorrow
+		), accumulated AS (
+			SELECT 	SUM(IF(isOdd, 0, gapTime)) 
+						OVER (PARTITION BY userFk,dated ORDER BY userFk,timed) accumulatedWorkTime,
+					SUM(IF(NOT isOdd OR breakPoint, 0, IFNULL(gapTime, 0))) 
+						OVER (PARTITION BY realDay ORDER BY realDay,timed) accumulatedBreakTime,	
+					IF(realDay <> @oldrealDay OR (isOdd AND gapTime >= vMaxTimeToBreak), 
+						@accumulatedForBreakTime := 0,
+						@accumulatedForBreakTime := @accumulatedForBreakTime + 
+						 	IF(isOdd, 0, gapTime )) accumulatedForBreakTime,
+					@oldrealDay := realDay,
+					userFk,
+					dated,
+					realDay
+			FROM workerTimed
+		), totalWorked AS ( 
+			SELECT userFk,
+				dated,
+				MAX(accumulatedWorkTime) + 
+					IF(MAX(accumulatedForBreakTime) >= vTimeToBreakTime, 
+						LEAST(vBreakTime, MAX(accumulatedBreakTime)), 
+						0) timeWorkSeconds
+			FROM accumulated
+			GROUP BY userFk, dated
+		)SELECT tw.userFk,
+				tw.dated,
+				timeWorkSeconds,
+				SEC_TO_TIME(timeWorkSeconds) timeWorkSexagesimal,
+				timeWorkSeconds / vHourSeconds timeWorkDecimal,
+				sub.tableTimed
+			FROM totalWorked tw
+				JOIN (
+					SELECT userFk,
+							dated,
+							GROUP_CONCAT(DATE_FORMAT(timed, "%H:%i") ORDER BY timed ASC 
+								SEPARATOR ' - ')tableTimed
+						FROM tmp.workerTimeControl
+						WHERE timed BETWEEN vDatedFromYesterday AND vDatedToTomorrow
+							AND isReal
+						GROUP BY userFk, dated
+				)sub ON sub.dated = tw.dated
+					AND sub.userFk = tw.userFk
+			WHERE tw.dated BETWEEN vDatedFrom AND vDatedTo;
+		
+	DROP TEMPORARY TABLE tmp.timeControlError;
+	DROP TEMPORARY TABLE tmp.wtcToinsert;
+	DROP TEMPORARY TABLE tmp.workerTimeControl;
+END$$
+DELIMITER ;

db/changes/234004/02-workerTimeControl_clockIn.sql

@@ -0,0 +1,286 @@
+DELIMITER $$
+CREATE OR REPLACE DEFINER=`root`@`localhost` PROCEDURE `vn`.`workerTimeControl_clockIn`(
+		vWorkerFk INT,
+		vTimed DATETIME,
+		vDirection VARCHAR(10)
+)
+BEGIN
+/**
+ * Verifica si el empleado puede fichar
+ * @param vWorkerFk Identificador del trabajador
+ * @param vTimed valor de la fichada, IF vTimed IS NULL vTimed = NOW
+ * @param vDirection solo se pueden pasa los valores del campo
+ * 	workerTimeControl.direction ENUM('in', 'out', 'middle')
+ * @return Si todo es correcto, retorna el número de id la tabla workerTimeControl.
+ * Si hay algún problema, devuelve el mesaje que se debe mostrar al usuario
+ * Solo retorna el primer problema, en caso de no ocurrir ningún error se añadirá
+ * fichada a la tabla vn.workerTimeControl
+ */
+	
+	DECLARE vLastIn DATETIME;
+	DECLARE vLastOut DATETIME;
+	DECLARE vNextIn DATETIME;
+	DECLARE vNextOut DATETIME;
+	DECLARE vNextDirection ENUM('in', 'out');
+	DECLARE vLastDirection ENUM('in', 'out');
+	DECLARE vDayMaxTime INTEGER; 
+	DECLARE vDayBreak INT;
+	DECLARE vShortWeekBreak INT;
+	DECLARE vLongWeekBreak INT;
+	DECLARE vWeekScope INT;
+	DECLARE vMailTo VARCHAR(50) DEFAULT NULL;
+	DECLARE vUserName VARCHAR(50) DEFAULT NULL;
+	DECLARE vIsError BOOLEAN DEFAULT FALSE;
+	DECLARE vErrorMessage VARCHAR(255) DEFAULT NULL;
+	DECLARE vErrorCode VARCHAR(50);
+	DECLARE vDated DATE;
+	DECLARE vIsAllowedToWork VARCHAR(50);
+	DECLARE vIsManual BOOLEAN DEFAULT TRUE;
+	DECLARE vMaxWorkShortCycle INT;
+	DECLARE vMaxWorkLongCycle INT;
+
+	DECLARE EXIT HANDLER FOR SQLSTATE '45000'
+	BEGIN
+
+	SELECT CONCAT(u.name, '@verdnatura.es'),
+				CONCAT(w.firstName, ' ', w.lastName)
+				INTO vMailTo, vUserName
+			FROM account.user u
+				JOIN worker w ON w.bossFk = u.id
+			WHERE w.id = vWorkerFk;
+
+		SELECT `description` INTO vErrorMessage
+			FROM workerTimeControlError 
+			WHERE `code` = vErrorCode;
+
+		IF vErrorMessage IS NULL THEN
+			SET vErrorMessage = 'Error sin definir';
+		END IF;
+
+		SELECT vErrorMessage `error`;
+		SELECT CONCAT(vUserName,
+				' no ha podido fichar por el siguiente problema: ',
+				vErrorMessage)
+			INTO vErrorMessage;
+			
+		CALL mail_insert( vMailTo, vMailTo, 'Error al fichar', vErrorMessage);
+	END;
+
+	IF (vTimed IS NULL) THEN
+		SET vTimed = util.VN_NOW();
+		SET vIsManual = FALSE;
+	END IF;
+
+	SET vDated = DATE(vTimed);
+
+	SELECT IF(pc.name = 'Conductor +3500kg',
+				wc.dayBreakDriver,
+				wc.dayBreak),
+			wc.shortWeekBreak,
+			wc.longWeekBreak,
+			wc.weekScope,
+			wc.dayMaxTime,
+			wc.maxWorkShortCycle,
+			wc.maxWorkLongCycle
+			INTO vDayBreak,
+			vShortWeekBreak,
+			vLongWeekBreak,
+			vWeekScope,
+			vDayMaxTime,
+			vMaxWorkShortCycle,
+			vMaxWorkLongCycle
+		FROM business b
+			JOIN professionalCategory pc
+				ON pc.id = b.workerBusinessProfessionalCategoryFk
+			JOIN workerTimeControlConfig wc
+		WHERE b.workerFk = vWorkerFk
+			AND vDated BETWEEN b.started AND IFNULL(b.ended, vDated);
+		
+	-- CONTRATO EN VIGOR
+	IF vDayBreak IS NULL THEN
+		SET vErrorCode = 'INACTIVE_BUSINESS';
+		CALL util.throw(vErrorCode);
+	END IF;
+	
+	-- FICHADAS A FUTURO
+	IF vTimed > util.VN_NOW() +  INTERVAL 1 MINUTE THEN
+		SET vErrorCode = 'IS_NOT_ALLOWED_FUTURE';
+		CALL util.throw(vErrorCode);
+	END IF;
+	
+	-- VERIFICAR SI ESTÁ PERMITIDO TRABAJAR
+	CALL timeBusiness_calculateByWorker(vWorkerFk, vDated, vDated);
+	SELECT isAllowedToWork INTO vIsAllowedToWork
+		FROM tmp.timeBusinessCalculate;
+		DROP TEMPORARY TABLE tmp.timeBusinessCalculate;
+
+	IF NOT vIsAllowedToWork THEN
+		SET vErrorCode = 'IS_NOT_ALLOWED_WORK';
+		CALL util.throw(vErrorCode);
+	END IF;
+
+	-- DIRECCION CORRECTA
+	CALL workerTimeControl_direction(vWorkerFk, vTimed);
+	IF (SELECT
+			IF(IF(option1 IN ('inMiddle', 'outMiddle'),
+					'middle',
+					option1) <> vDirection
+				AND IF(option2 IN ('inMiddle', 'outMiddle'),
+					'middle',
+					IFNULL(option2, '')) <> vDirection,
+				TRUE ,
+				FALSE)
+			FROM tmp.workerTimeControlDirection
+		) THEN
+		SET vIsError = TRUE;
+	END IF;
+	
+	DROP TEMPORARY TABLE tmp.workerTimeControlDirection;
+	IF vIsError THEN
+		SET vErrorCode = 'WRONG_DIRECTION';
+		CALL util.throw(vErrorCode);
+	END IF;
+
+	-- FICHADAS IMPARES
+	SELECT timed INTO vLastIn
+		FROM workerTimeControl
+		WHERE userFk = vWorkerFk
+			AND direction = 'in'
+			AND timed < vTimed
+		ORDER BY timed DESC
+		LIMIT 1;
+	
+	IF (SELECT IF(vDirection = 'in',
+				MOD(COUNT(*), 2) ,
+				IF (vDirection = 'out', NOT MOD(COUNT(*), 2), FALSE))
+			FROM workerTimeControl
+			WHERE userFk = vWorkerFk
+				AND timed BETWEEN vLastIn AND vTimed
+		) THEN
+		SET vErrorCode = 'ODD_WORKERTIMECONTROL';
+		CALL util.throw(vErrorCode);
+	END IF;
+	
+	-- DESCANSO DIARIO
+	SELECT timed INTO vLastOut
+		FROM workerTimeControl
+		WHERE userFk = vWorkerFk
+			AND direction = 'out'
+			AND timed < vTimed
+		ORDER BY timed DESC
+		LIMIT 1;
+	
+	SELECT timed INTO vNextIn
+		FROM workerTimeControl
+		WHERE userFk = vWorkerFk
+			AND direction = 'in'
+			AND timed > vTimed
+		ORDER BY timed ASC
+		LIMIT 1;
+	
+	CASE vDirection
+		WHEN 'in' THEN
+			IF UNIX_TIMESTAMP(vTimed) - UNIX_TIMESTAMP(vLastOut) <= vDayBreak THEN
+				SET vIsError = TRUE;
+			END IF;
+		WHEN 'out' THEN
+			IF UNIX_TIMESTAMP(vNextIn) - UNIX_TIMESTAMP(vTimed) <= vDayBreak THEN
+				SET vIsError = TRUE;
+			END IF;
+		ELSE BEGIN END;
+	END CASE;
+
+	IF vIsError THEN
+		SET vErrorCode = 'BREAK_DAY';
+		CALL util.throw(vErrorCode);
+	END IF;
+
+
+
+	IF (vDirection IN('in', 'out')) THEN
+		-- VERIFICA MAXIMO TIEMPO DESDE ENTRADA HASTA LA SALIDA
+		
+		SELECT timed INTO vNextOut
+			FROM workerTimeControl
+			WHERE userFk = vWorkerFk
+				AND direction = 'out'
+				AND timed > vTimed
+			ORDER BY timed ASC
+			LIMIT 1;
+	
+		SELECT direction INTO vNextDirection
+			FROM workerTimeControl
+			WHERE userFk = vWorkerFk
+				AND direction IN('in','out')
+				AND timed > vTimed
+			ORDER BY timed ASC
+			LIMIT 1;
+		
+		SELECT direction INTO vLastDirection
+			FROM workerTimeControl
+			WHERE userFk = vWorkerFk
+				AND direction IN('in', 'out')
+				AND timed < vTimed
+			ORDER BY timed ASC
+			LIMIT 1;
+	
+		IF (vDirection ='in' 
+				AND vNextDirection = 'out' 
+				AND UNIX_TIMESTAMP(vNextOut) - UNIX_TIMESTAMP(vTimed) > vDayMaxTime) OR
+			(vDirection ='out' 
+				AND vLastDirection = 'in'
+				AND UNIX_TIMESTAMP(vTimed) -UNIX_TIMESTAMP(vLastIn) > vDayMaxTime) THEN
+			SET vErrorCode = 'DAY_MAX_TIME';
+			CALL util.throw(vErrorCode);
+		END IF;
+		
+		-- VERIFICA DESCANSO SEMANAL
+	
+		WITH wtc AS(
+		(SELECT timed 
+			FROM vn.workerTimeControl 
+			WHERE userFk = vWorkerFk
+				AND direction IN ('in', 'out')
+				AND timed BETWEEN vTimed - INTERVAL (vWeekScope * 2) SECOND 
+					AND vTimed + INTERVAL (vWeekScope * 2) SECOND )
+		UNION 
+		(SELECT vTimed)
+		), wtcGap AS(
+			SELECT timed,
+				TIMESTAMPDIFF(SECOND, LAG(timed) OVER (ORDER BY timed), timed) gap 
+			FROM wtc
+			ORDER BY timed
+		), wtcBreak AS( 
+			SELECT timed,
+					IF(IFNULL(gap, 0) > vShortWeekBreak, TRUE, FALSE) hasShortBreak,
+					IF(IFNULL(gap, 0) > vLongWeekBreak, TRUE, FALSE) hasLongBreak
+				FROM wtcGap
+				ORDER BY timed
+		), wtcBreakCounter AS(
+			SELECT timed,
+					SUM(hasShortBreak) OVER (ORDER BY timed) breakCounter ,
+					LEAD(hasLongBreak) OVER (ORDER BY timed) nextHasLongBreak
+				FROM wtcBreak
+		)SELECT TIMESTAMPDIFF(SECOND, MIN(timed), MAX(timed)) > vMaxWorkLongCycle OR 
+				(TIMESTAMPDIFF(SECOND, MIN(timed), MAX(timed))> vMaxWorkShortCycle 
+					AND NOT SUM(IFNULL(nextHasLongBreak, 1)))
+				hasError INTO vIsError
+			FROM wtcBreakCounter
+			GROUP BY breakCounter
+			HAVING hasError
+			LIMIT 1;
+	
+		IF vIsError THEN
+			SET vErrorCode = 'BREAK_WEEK';
+			CALL util.throw(vErrorCode);
+		END IF;
+	END IF;
+	
+	-- SE PERMITE FICHAR
+	INSERT INTO workerTimeControl(userFk, timed, direction, `manual`)
+		VALUES(vWorkerFk, vTimed, vDirection, vIsManual);
+
+	SELECT LAST_INSERT_ID() id;
+
+END$$
+DELIMITER ;

db/changes/234201/00-packagingFkviews.sql

@@ -1,3 +1,43 @@
+CREATE SCHEMA IF NOT EXISTS `vn2008`;
+
+CREATE OR REPLACE DEFINER=`root`@`localhost`
+	SQL SECURITY DEFINER
+	VIEW `vn`.`awbVolume`
+AS SELECT `d`.`awbFk` AS `awbFk`,
+	`b`.`stickers` * `i`.`density` * IF(
+		`p`.`volume` > 0,
+		`p`.`volume`,
+		`p`.`width` * `p`.`depth` * IF(`p`.`height` = 0, `i`.`size` + 10, `p`.`height`)
+	) / (`vc`.`aerealVolumetricDensity` * 1000) AS `volume`,
+	`b`.`id` AS `buyFk`
+FROM (
+		(
+			(
+				(
+					(
+						(
+							(
+								(
+									`vn`.`buy` `b`
+									JOIN `vn`.`item` `i` ON(`b`.`itemFk` = `i`.`id`)
+								)
+								JOIN `vn`.`itemType` `it` ON(`i`.`typeFk` = `it`.`id`)
+							)
+							JOIN `vn`.`packaging` `p` ON(`p`.`id` = `b`.`packagingFk`)
+						)
+						JOIN `vn`.`entry` `e` ON(`b`.`entryFk` = `e`.`id`)
+					)
+					JOIN `vn`.`travel` `t` ON(`t`.`id` = `e`.`travelFk`)
+				)
+				JOIN `vn`.`duaEntry` `de` ON(`de`.`entryFk` = `e`.`id`)
+			)
+			JOIN `vn`.`dua` `d` ON(`d`.`id` = `de`.`duaFk`)
+		)
+		JOIN `vn`.`volumeConfig` `vc`
+	)
+WHERE `t`.`shipped` > makedate(year(`util`.`VN_CURDATE`()) - 1, 1);
+
+
 CREATE OR REPLACE DEFINER=`root`@`localhost`
 	SQL SECURITY DEFINER
 	VIEW `vn2008`.`Compres`
@@ -108,39 +148,3 @@ FROM (
 		LEFT JOIN `edi`.`supplier` `s` ON(`e`.`pro` = `s`.`supplier_id`)
 	);
 
-CREATE OR REPLACE DEFINER=`root`@`localhost`
-	SQL SECURITY DEFINER
-	VIEW `vn`.`awbVolume`
-AS SELECT `d`.`awbFk` AS `awbFk`,
-	`b`.`stickers` * `i`.`density` * IF(
-		`p`.`volume` > 0,
-		`p`.`volume`,
-		`p`.`width` * `p`.`depth` * IF(`p`.`height` = 0, `i`.`size` + 10, `p`.`height`)
-	) / (`vc`.`aerealVolumetricDensity` * 1000) AS `volume`,
-	`b`.`id` AS `buyFk`
-FROM (
-		(
-			(
-				(
-					(
-						(
-							(
-								(
-									`vn`.`buy` `b`
-									JOIN `vn`.`item` `i` ON(`b`.`itemFk` = `i`.`id`)
-								)
-								JOIN `vn`.`itemType` `it` ON(`i`.`typeFk` = `it`.`id`)
-							)
-							JOIN `vn`.`packaging` `p` ON(`p`.`id` = `b`.`packagingFk`)
-						)
-						JOIN `vn`.`entry` `e` ON(`b`.`entryFk` = `e`.`id`)
-					)
-					JOIN `vn`.`travel` `t` ON(`t`.`id` = `e`.`travelFk`)
-				)
-				JOIN `vn`.`duaEntry` `de` ON(`de`.`entryFk` = `e`.`id`)
-			)
-			JOIN `vn`.`dua` `d` ON(`d`.`id` = `de`.`duaFk`)
-		)
-		JOIN `vn`.`volumeConfig` `vc`
-	)
-WHERE `t`.`shipped` > makedate(year(`util`.`VN_CURDATE`()) - 1, 1);

db/changes/234601/00-ACLticketTrackingState.sql

@@ -2,11 +2,3 @@ UPDATE `salix`.`ACL`
     SET `property` = 'state',
         `model` = 'Ticket'
     WHERE `property` = 'changeState';
-
-REVOKE INSERT, UPDATE, DELETE ON `vn`.`ticketTracking` FROM 'productionboss'@;
-REVOKE INSERT, UPDATE, DELETE ON `vn`.`ticketTracking` FROM 'productionAssi'@;
-REVOKE INSERT, UPDATE, DELETE ON `vn`.`ticketTracking` FROM 'hr'@;
-REVOKE INSERT, UPDATE, DELETE ON `vn`.`ticketTracking` FROM 'salesPerson'@;
-REVOKE INSERT, UPDATE, DELETE ON `vn`.`ticketTracking` FROM 'deliveryPerson'@;
-REVOKE INSERT, UPDATE, DELETE ON `vn`.`ticketTracking` FROM 'employee'@;
-REVOKE EXECUTE ON `vn`.`ticket_setState` FROM 'employee'@;

db/changes/234601/00-addressShortage.sql

@@ -0,0 +1,98 @@
+
+-- Place your SQL code here
+
+ALTER TABLE `vn`.`productionConfig` ADD shortageAddressFk int(11) COMMENT 'Consignatario por defecto para añadir un item de alta';
+ALTER TABLE  `vn`.`productionConfig` ADD CONSTRAINT productionConfig_FK FOREIGN KEY (shortageAddressFk) REFERENCES vn.address(id) ON DELETE RESTRICT ON UPDATE CASCADE;
+
+ALTER TABLE `vn`.`sale` MODIFY COLUMN originalQuantity double(9,1) DEFAULT NULL NULL COMMENT 'Se utiliza para notificar a través de rocket los cambios de quantity';
+
+INSERT INTO `salix`.`ACL` ( model, property, accessType, permission, principalType, principalId) VALUES( 'AddressShortage', '*', 'READ', 'ALLOW', 'ROLE', 'production');
+
+-- vn.addressShortage definition
+
+CREATE TABLE `vn`.`addressShortage` (
+  `addressFk` int(11) NOT NULL,
+  PRIMARY KEY (`addressFk`),
+  CONSTRAINT `addressShortage_FK` FOREIGN KEY (`addressFk`) REFERENCES `address` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_unicode_ci;
+
+
+DELIMITER $$
+
+CREATE OR REPLACE DEFINER=`root`@`localhost` PROCEDURE `vn`.`item_setVisibleDiscard`(
+	vItemFk INT,
+	vWarehouseFk INT,
+	vQuantity INT,
+	vAddressFk INT)
+BEGIN
+/**
+ * Procedimiento para dar dar de baja/alta un item, si vAddressFk es NULL se entiende que se da de alta y se toma el addressFk de la configuración
+ *
+ * @param vItemFk Identificador del ítem
+ * @param vWarehouseFk id del warehouse
+ * @param vQuantity a dar de alta/baja
+ * @param vAddressFk id address
+ */
+	DECLARE vTicketFk INT;
+	DECLARE vClientFk INT;
+	DECLARE vDefaultCompanyFk INT;
+	DECLARE vCalc INT;
+	DECLARE vAddressShortage INT;
+
+	SELECT barcodeToItem(vItemFk) INTO vItemFk;
+
+	SELECT DEFAULT(companyFk)  INTO vDefaultCompanyFk
+		FROM vn.ticket LIMIT 1;
+	
+	IF vAddressFk IS NULL THEN 
+		SELECT pc.shortageAddressFk INTO vAddressShortage
+			FROM productionConfig pc ;
+	ELSE 
+		SET vAddressShortage = vAddressFk;
+	END IF;
+
+	SELECT a.clientFk INTO vClientFk
+		FROM address a
+		WHERE a.id = vAddressFk;
+
+	SELECT t.id INTO vTicketFk
+		FROM ticket t
+			JOIN address a ON a.id = t.addressFk
+			JOIN ticketState ts ON ts.ticketFk = t.id
+		WHERE t.warehouseFk = vWarehouseFk
+			AND a.id = vAddressShortage
+			AND DATE(t.shipped) = util.VN_CURDATE()
+			AND ts.code = 'DELIVERED'
+		LIMIT 1;
+
+	CALL cache.visible_refresh(vCalc, TRUE, vWarehouseFk);
+
+	IF vTicketFk IS NULL THEN
+		CALL ticket_add(
+			vClientFk,
+			util.VN_CURDATE(),
+			vWarehouseFk,
+			vDefaultCompanyFk,
+			vAddressFk,
+			NULL,
+			NULL,
+			util.VN_CURDATE(),
+			account.myUser_getId(),
+			FALSE,
+			vTicketFk);
+	END IF;
+
+	INSERT INTO sale(ticketFk, itemFk, concept, quantity)
+		SELECT vTicketFk,
+				vItemFk,
+				CONCAT(longName,' ', worker_getCode(), ' ', LEFT(CAST(util.VN_NOW() AS TIME),5)),
+				vQuantity
+			FROM item
+			WHERE id = vItemFk;
+
+	UPDATE cache.visible
+		SET visible = visible - vQuantity
+		WHERE calc_id = vCalc
+			AND item_id = vItemFk;
+END$$
+DELIMITER ;

db/changes/234601/00-claimViewerAcl.sql

@@ -21,11 +21,11 @@ DELETE FROM `salix`.`ACL`
 			'getSummary'
 		);
 
-INSERT INTO `salix`.`ACL` (`model`,`property`,`accessType`,`permission`,`principalType`,`principalid`)
+INSERT INTO `salix`.`ACL` (`model`,`property`,`accessType`,`permission`,`principalType`,`principalId`)
 	VALUES ('Claim','filter','READ','ALLOW','ROLE','claimViewer');
-INSERT INTO `salix`.`ACL` (`model`,`property`,`accessType`,`permission`,`principalType`,`principalid`)
+INSERT INTO `salix`.`ACL` (`model`,`property`,`accessType`,`permission`,`principalType`,`principalId`)
 	VALUES ('Claim','find','READ','ALLOW','ROLE','claimViewer');
-INSERT INTO `salix`.`ACL` (`model`,`property`,`accessType`,`permission`,`principalType`,`principalid`)
+INSERT INTO `salix`.`ACL` (`model`,`property`,`accessType`,`permission`,`principalType`,`principalId`)
 	VALUES ('Claim','findById','READ','ALLOW','ROLE','claimViewer');
-INSERT INTO `salix`.`ACL` (`model`,`property`,`accessType`,`permission`,`principalType`,`principalid`)
+INSERT INTO `salix`.`ACL` (`model`,`property`,`accessType`,`permission`,`principalType`,`principalId`)
 	VALUES ('Claim','getSummary','READ','ALLOW','ROLE','claimViewer');

db/changes/234601/00-clientAfterUpdate.sql

@@ -0,0 +1,95 @@
+ALTER TABLE `vn`.`client` MODIFY COLUMN `credit` decimal(10,2) unsigned DEFAULT 0.00 NOT NULL;
+
+DELETE FROM `salix`.`ACL` WHERE `model` = 'Client' AND `property` = 'create';
+
+DELIMITER $$
+CREATE OR REPLACE DEFINER=`root`@`localhost` TRIGGER `vn`.`client_beforeUpdate`
+	BEFORE UPDATE ON `client`
+	FOR EACH ROW
+BEGIN
+	DECLARE vText VARCHAR(255) DEFAULT NULL;
+    DECLARE vPayMethodFk INT;
+
+	SET NEW.editorFk = account.myUser_getId();
+
+	IF NOT(NEW.credit <=> OLD.credit) THEN
+		INSERT INTO clientCredit
+			SET clientFk = NEW.id,
+				amount = NEW.credit,
+				workerFk = NEW.editorFk;
+	END IF;
+	-- Comprueba que el formato de los teléfonos es válido
+
+	IF !(NEW.phone <=> OLD.phone) AND (NEW.phone <> '') THEN
+		CALL pbx.phone_isValid(NEW.phone);
+	END IF;
+
+    IF !(NEW.mobile <=> OLD.mobile) AND (NEW.mobile <> '')THEN
+		CALL pbx.phone_isValid(NEW.mobile);
+	END IF;
+
+	SELECT id INTO vPayMethodFk
+		FROM vn.payMethod
+		WHERE code = 'bankDraft';
+
+	IF NEW.payMethodFk = vPayMethodFk AND NEW.dueDay = 0 THEN
+		SET NEW.dueDay = 5;
+    END IF;
+
+	-- Avisar al comercial si ha llegado la documentación sepa/core
+
+	IF NEW.hasSepaVnl AND !OLD.hasSepaVnl THEN
+		SET vText = 'Sepa de VNL';
+	END IF;
+
+	IF NEW.hasCoreVnl AND !OLD.hasCoreVnl THEN
+		SET vText = 'Core de VNL';
+	END IF;
+
+	IF vText IS NOT NULL
+    THEN
+		INSERT INTO mail(receiver, replyTo, `subject`, body)
+			SELECT
+					CONCAT(IF(ac.id,u.name, 'jgallego'), '@verdnatura.es'),
+                    'administracion@verdnatura.es',
+                    CONCAT('Cliente ', NEW.id),
+					CONCAT('Recibida la documentación: ', vText)
+				FROM worker w
+					LEFT JOIN account.user u ON w.id = u.id AND u.active
+					LEFT JOIN account.account ac ON ac.id = u.id
+				WHERE w.id = NEW.salesPersonFk;
+	END IF;
+
+    IF NEW.salespersonFk IS NULL AND OLD.salespersonFk IS NOT NULL THEN
+		IF (SELECT COUNT(clientFk)
+				FROM clientProtected
+                WHERE clientFk = NEW.id
+			) > 0 THEN
+			CALL util.throw("HAS_CLIENT_PROTECTED");
+		END IF;
+	END IF;
+
+	IF !(NEW.salesPersonFk <=> OLD.salesPersonFk) THEN
+		SET NEW.lastSalesPersonFk = IFNULL(NEW.salesPersonFk, OLD.salesPersonFk);
+	END IF;
+
+	IF !(NEW.businessTypeFk <=> OLD.businessTypeFk) AND (NEW.businessTypeFk = 'individual' OR OLD.businessTypeFk = 'individual') THEN
+		SET NEW.isTaxDataChecked = 0;
+	END IF;
+END$$
+DELIMITER ;
+
+DELIMITER $$
+CREATE OR REPLACE DEFINER=`root`@`localhost` TRIGGER `vn`.`client_AfterInsert`
+	AFTER INSERT ON `client`
+	FOR EACH ROW
+BEGIN
+	IF NEW.credit IS NOT NULL AND NEW.credit THEN
+		INSERT INTO clientCredit
+			SET clientFk = NEW.id,
+				workerFk = NEW.editorFk,
+				amount = NEW.credit;
+	END IF;
+END$$
+DELIMITER ;
+

db/changes/234601/00-transferInvoice.sql

@@ -1,6 +1,6 @@
 INSERT INTO `salix`.`ACL` (model, property, accessType, permission, principalType, principalId)
     VALUES
         ('CplusRectificationType', '*', 'READ', 'ALLOW', 'ROLE', 'administrative'),
-        ('CplusInvoiceType477', '*', 'READ', 'ALLOW', 'ROLE', 'administrative'),
+        ('SiiTypeInvoiceOut', '*', 'READ', 'ALLOW', 'ROLE', 'administrative'),
         ('InvoiceCorrectionType', '*', 'READ', 'ALLOW', 'ROLE', 'administrative'),
         ('InvoiceOut', 'transferInvoice', 'WRITE', 'ALLOW', 'ROLE', 'administrative');

db/changes/234602/00-roleSync.sql

@@ -0,0 +1 @@
+CALL `account`.`role_sync`();

db/changes/234801/00-ACL_executeRoutine.sql

@@ -0,0 +1,4 @@
+INSERT INTO `salix`.`ACL` (model, property, accessType, permission, principalType, principalId)
+    VALUES
+        ('Application', 'executeProc', '*', 'ALLOW', 'ROLE', 'employee'),
+        ('Application', 'executeFunc', '*', 'ALLOW', 'ROLE', 'employee');

db/changes/234801/00-notificationSubscription.sql

@@ -0,0 +1,3 @@
+INSERT INTO `salix`.`ACL` (`model`, `property`, `accessType`, `permission`, `principalType`, `principalId`)
+    VALUES
+        ('NotificationSubscription', 'getList', 'READ', 'ALLOW', 'ROLE', 'employee');

db/dump/dumpedFixtures.sql

@@ -275,13 +275,13 @@ INSERT INTO `cplusInvoiceType472` VALUES (1,'F1 - Factura'),(2,'F2 - Factura sim
 UNLOCK TABLES;
 
 --
--- Dumping data for table `cplusInvoiceType477`
+-- Dumping data for table `siiTypeInvoiceOut`
 --
 
-LOCK TABLES `cplusInvoiceType477` WRITE;
+LOCK TABLES `siiTypeInvoiceOut` WRITE;
-/*!40000 ALTER TABLE `cplusInvoiceType477` DISABLE KEYS */;
+/*!40000 ALTER TABLE `siiTypeInvoiceOut` DISABLE KEYS */;
-INSERT INTO `cplusInvoiceType477` VALUES (1,'F1 - Factura'),(2,'F2 - Factura simplificada (ticket)'),(3,'F3 - Factura emitida en sustitución de facturas  simplificadas facturadas y declaradas'),(4,'F4 - Asiento resumen de facturas'),(5,'R1 - Factura rectificativa (Art. 80.1, 80.2  y error fundado en derecho)'),(6,'R2 - Factura rectificativa (Art. 80.3)'),(7,'R3 - Factura rectificativa (Art. 80.4)'),(8,'R4 - Factura rectificativa (Resto)'),(9,'R5 - Factura rectificativa en facturas simplificadas');
+INSERT INTO `siiTypeInvoiceOut` VALUES (1,'F1 - Factura'),(2,'F2 - Factura simplificada (ticket)'),(3,'F3 - Factura emitida en sustitución de facturas  simplificadas facturadas y declaradas'),(4,'F4 - Asiento resumen de facturas'),(5,'R1 - Factura rectificativa (Art. 80.1, 80.2  y error fundado en derecho)'),(6,'R2 - Factura rectificativa (Art. 80.3)'),(7,'R3 - Factura rectificativa (Art. 80.4)'),(8,'R4 - Factura rectificativa (Resto)'),(9,'R5 - Factura rectificativa en facturas simplificadas');
-/*!40000 ALTER TABLE `cplusInvoiceType477` ENABLE KEYS */;
+/*!40000 ALTER TABLE `siiTypeInvoiceOut` ENABLE KEYS */;
 UNLOCK TABLES;
 
 --

db/dump/fixtures.sql

@@ -367,7 +367,7 @@ INSERT INTO `vn`.`client`(`id`,`name`,`fi`,`socialName`,`contact`,`street`,`city
         (1105,     'Max Eisenhardt',     '251628698',  'MAGNETO',        'Rogue',            'UNKNOWN WHEREABOUTS',                          'Gotham', 46460, 1111111111, 222222222, 1, 'MaxEisenhardt@mydomain.com',         NULL, 0, 1234567890, 0, 3, 1, 300,  8,  1, NULL, 10, 5,    util.VN_CURDATE(), 1, 5, 1, 1, 1, '0000-00-00', 1, 1, 1, 1, NULL, 0, 0, 18,   0, 1, 'florist','normal'),
         (1106,     'DavidCharlesHaller', '53136686Q',  'LEGION',         'Charles Xavier',   'CITY OF NEW YORK, NEW YORK, USA',              'Gotham', 46460, 1111111111, 222222222, 1, 'DavidCharlesHaller@mydomain.com',    NULL, 0, 1234567890, 0, 1, 1, 300,  1,  0, NULL, 10, 5,    util.VN_CURDATE(), 1, 5, 1, 1, 1, '0000-00-00', 1, 1, 1, 0, NULL, 0, 0, 19,   0, 1, 'florist','normal'),
         (1107,     'Hank Pym',           '09854837G',  'ANT MAN',        'Hawk',             'ANTHILL, SAN FRANCISCO, CALIFORNIA',           'Gotham', 46460, 1111111111, 222222222, 1, 'HankPym@mydomain.com',               NULL, 0, 1234567890, 0, 1, 1, 300,  1,  1, NULL, 10, 5,    util.VN_CURDATE(), 1, 5, 1, 1, 1, '0000-00-00', 1, 1, 0, 0, NULL, 0, 0, 19,   0, 1, 'florist','normal'),
-        (1108,     'Charles Xavier',     '22641921P',  'PROFESSOR X',    'Beast',            '3800 VICTORY PKWY, CINCINNATI, OH 45207, USA', 'Gotham', 46460, 1111111111, 222222222, 1, 'CharlesXavier@mydomain.com',         NULL, 0, 1234567890, 0, 1, 1, 300,  1,  1, NULL, 10, 5,    util.VN_CURDATE(), 1, 5, 1, 1, 1, '0000-00-00', 1, 1, 1, 1, NULL, 0, 0, 19,   0, 1, 'florist','normal'),
+        (1108,     'Charles Xavier',     '22641921P',  'PROFESSOR X',    'Beast',            '3800 VICTORY PKWY, CINCINNATI, OH 45207, USA', 'Gotham', 46460, 1111111111, 222222222, 1, 'CharlesXavier@mydomain.com',         NULL, 0, 1234567890, 0, 5, 1, 300,  13, 1, NULL, 10, 5,    util.VN_CURDATE(), 1, 5, 1, 1, 1, '0000-00-00', 1, 1, 1, 1, NULL, 0, 0, 19,   0, 1, 'florist','normal'),
         (1109,     'Bruce Banner',       '16104829E',  'HULK',           'Black widow',      'SOMEWHERE IN NEW YORK',                        'Gotham', 46460, 1111111111, 222222222, 1, 'BruceBanner@mydomain.com',           NULL, 0, 1234567890, 0, 1, 1, 300,  1,  1, NULL, 10, 5,    util.VN_CURDATE(), 1, 5, 1, 1, 1, '0000-00-00', 1, 1, 0, 0, NULL, 0, 0, 9,    0, 1, 'florist','normal'),
         (1110,     'Jessica Jones',      '58282869H',  'JESSICA JONES',  'Luke Cage',        'NYCC 2015 POSTER',                             'Gotham', 46460, 1111111111, 222222222, 1, 'JessicaJones@mydomain.com',          NULL, 0, 1234567890, 0, 1, 1, 300,  1,  1, NULL, 10, 5,    util.VN_CURDATE(), 1, 5, 1, 1, 1, '0000-00-00', 1, 1, 0, 0, NULL, 0, 0, NULL, 0, 1, 'florist','normal'),
         (1111,     'Missing',            NULL,         'MISSING MAN',    'Anton',            'THE SPACE, UNIVERSE FAR AWAY',                 'Gotham', 46460, 1111111111, 222222222, 1, NULL,                                 NULL, 0, 1234567890, 0, 1, 1, 300,  1,  1, NULL, 10, 5,    util.VN_CURDATE(), 1, 5, 1, 1, 1, '0000-00-00', 4, 0, 1, 0, NULL, 1, 0, NULL, 0, 1, 'others','normal'),
@@ -405,7 +405,7 @@ INSERT INTO `vn`.`address`(`id`, `nickname`, `street`, `city`, `postalCode`, `pr
         (5,     'Max Eisenhardt',               'Unknown Whereabouts',                          'Gotham', 46460,        1, 1111111111, 222222222, 1, 1105,    2, NULL, NULL, 0, 1),
         (6,     'DavidCharlesHaller',           'Evil hideout',                                 'Gotham', 46460,        1, 1111111111, 222222222, 1, 1106,    2, NULL, NULL, 0, 1),
         (7,     'Hank Pym',                     'Anthill',                                      'Gotham', 46460,        1, 1111111111, 222222222, 1, 1107,    2, NULL, NULL, 0, 1),
-        (8,     'Charles Xavier',               '3800 Victory Pkwy, Cincinnati, OH 45207, USA', 'Gotham', 46460,        1, 1111111111, 222222222, 1, 1108,    2, NULL, NULL, 0, 1),
+        (8,     'Charles Xavier',               '3800 Victory Pkwy, Cincinnati, OH 45207, USA', 'Gotham', 46460,        5, 1111111111, 222222222, 1, 1108,    2, NULL, NULL, 0, 1),
         (9,     'Bruce Banner',                 'Somewhere in New York',                        'Gotham', 46460,        1, 1111111111, 222222222, 1, 1109,    2, NULL, NULL, 0, 1),
         (10,    'Jessica Jones',                'NYCC 2015 Poster',                             'Gotham', 46460,        1, 1111111111, 222222222, 1, 1110,    2, NULL, NULL, 0, 1),
         (11,    'Missing',                      'The space',                                    'Gotham', 46460,        1, 1111111111, 222222222, 1, 1111,   10, NULL, NULL, 0, 1),
@@ -437,7 +437,7 @@ INSERT INTO `vn`.`address`(`id`, `nickname`, `street`, `city`, `postalCode`, `pr
         (125,   'The plastic cell',             'address 25',                                   'Gotham', 46460,        1, 1111111111, 222222222, 1, 1105,    2, NULL, NULL, 0, 0),
         (126,   'Many places',                  'address 26',                                   'Gotham', 46460,        1, 1111111111, 222222222, 1, 1106,    2, NULL, NULL, 0, 0),
         (127,   'Your pocket',                  'address 27',                                   'Gotham', 46460,        1, 1111111111, 222222222, 1, 1107,    2, NULL, NULL, 0, 0),
-        (128,   'Cerebro',                      'address 28',                                   'Gotham', 46460,        1, 1111111111, 222222222, 1, 1108,    2, NULL, NULL, 0, 0),
+        (128,   'Cerebro',                      'address 28',                                   'Gotham', 46460,        5, 1111111111, 222222222, 1, 1108,    2, NULL, NULL, 0, 0),
         (129,   'Luke Cages Bar',               'address 29',                                   'Gotham', 'EC170150',   1, 1111111111, 222222222, 1, 1110,    2, NULL, NULL, 0, 0),
         (130,   'Non valid address',            'address 30',                                   'Gotham', 46460,        1, 1111111111, 222222222, 0, 1101,    2, NULL, NULL, 0, 0);
 
@@ -470,22 +470,22 @@ CREATE TEMPORARY TABLE tmp.address
         WHERE `defaultAddressFk` IS NULL;
 DROP TEMPORARY TABLE tmp.address;
 
-INSERT INTO `vn`.`clientCredit`(`id`, `clientFk`, `workerFk`, `amount`, `created`)
+INSERT INTO `vn`.`clientCredit`(`clientFk`, `workerFk`, `amount`, `created`)
     VALUES
-        (1 , 1101, 5, 300, DATE_ADD(util.VN_CURDATE(), INTERVAL -11 MONTH)),
+        (1101, 5, 300, DATE_ADD(util.VN_CURDATE(), INTERVAL -11 MONTH)),
-        (2 , 1101, 5, 900, DATE_ADD(util.VN_CURDATE(), INTERVAL -10 MONTH)),
+        (1101, 5, 900, DATE_ADD(util.VN_CURDATE(), INTERVAL -10 MONTH)),
-        (3 , 1101, 5, 800, DATE_ADD(util.VN_CURDATE(), INTERVAL -9 MONTH)),
+        (1101, 5, 800, DATE_ADD(util.VN_CURDATE(), INTERVAL -9 MONTH)),
-        (4 , 1101, 5, 700, DATE_ADD(util.VN_CURDATE(), INTERVAL -8 MONTH)),
+        (1101, 5, 700, DATE_ADD(util.VN_CURDATE(), INTERVAL -8 MONTH)),
-        (5 , 1101, 5, 600, DATE_ADD(util.VN_CURDATE(), INTERVAL -7 MONTH)),
+        (1101, 5, 600, DATE_ADD(util.VN_CURDATE(), INTERVAL -7 MONTH)),
-        (6 , 1101, 5, 500, DATE_ADD(util.VN_CURDATE(), INTERVAL -6 MONTH)),
+        (1101, 5, 500, DATE_ADD(util.VN_CURDATE(), INTERVAL -6 MONTH)),
-        (7 , 1101, 5, 400, DATE_ADD(util.VN_CURDATE(), INTERVAL -5 MONTH)),
+        (1101, 5, 400, DATE_ADD(util.VN_CURDATE(), INTERVAL -5 MONTH)),
-        (8 , 1101, 9, 300, DATE_ADD(util.VN_CURDATE(), INTERVAL -4 MONTH)),
+        (1101, 9, 300, DATE_ADD(util.VN_CURDATE(), INTERVAL -4 MONTH)),
-        (9 , 1101, 9, 200, DATE_ADD(util.VN_CURDATE(), INTERVAL -3 MONTH)),
+        (1101, 9, 200, DATE_ADD(util.VN_CURDATE(), INTERVAL -3 MONTH)),
-        (10, 1101, 9, 100, DATE_ADD(util.VN_CURDATE(), INTERVAL -2 MONTH)),
+        (1101, 9, 100, DATE_ADD(util.VN_CURDATE(), INTERVAL -2 MONTH)),
-        (11, 1101, 9, 50 , DATE_ADD(util.VN_CURDATE(), INTERVAL -1 MONTH)),
+        (1101, 9, 50 , DATE_ADD(util.VN_CURDATE(), INTERVAL -1 MONTH)),
-        (12, 1102, 9, 800, util.VN_CURDATE()),
+        (1102, 9, 800, util.VN_CURDATE()),
-        (14, 1104, 9, 90 , util.VN_CURDATE()),
+        (1104, 9, 90 , util.VN_CURDATE()),
-        (15, 1105, 9, 90 , util.VN_CURDATE());
+        (1105, 9, 90 , util.VN_CURDATE());
 
 INSERT INTO `vn`.`clientCreditLimit`(`id`, `maxAmount`, `roleFk`)
     VALUES
@@ -2003,6 +2003,10 @@ UPDATE `vn`.`business` b
     SET b.`departmentFk` = 43
     WHERE b.id IN(18, 19);
 
+UPDATE `vn`.`business` b
+    SET b.`started` = b.`started` - INTERVAL 100 DAY
+    WHERE b.id = 1107;
+
 INSERT INTO `vn`.`workCenterHoliday` (`workCenterFk`, `days`, `year`)
     VALUES
         ('1', '27.5',   YEAR(util.VN_CURDATE())),
@@ -2051,22 +2055,22 @@ INSERT INTO `vn`.`absenceType` (`id`, `name`, `rgb`, `code`, `holidayEntitlement
 
 INSERT INTO `vn`.`calendar` (`businessFk`, `dayOffTypeFk`, `dated`)
     VALUES
-        (1,    6, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, DATE_ADD(util.VN_CURDATE(), INTERVAL -10 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 10 DAY))),
+        (1,    6, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, util.VN_CURDATE() - INTERVAL 10 DAY, util.VN_CURDATE() + INTERVAL 10 DAY)),
-        (1106, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, DATE_ADD(util.VN_CURDATE(), INTERVAL -10 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 10 DAY))),
+        (1106, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, util.VN_CURDATE() - INTERVAL 10 DAY, util.VN_CURDATE() + INTERVAL 10 DAY)),
-        (1106, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, DATE_ADD(util.VN_CURDATE(), INTERVAL -11 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 11 DAY))),
+        (1106, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, util.VN_CURDATE() - INTERVAL 11 DAY, util.VN_CURDATE() + INTERVAL 11 DAY)),
-        (1106, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, DATE_ADD(util.VN_CURDATE(), INTERVAL -12 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 12 DAY))),
+        (1106, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, util.VN_CURDATE() - INTERVAL 12 DAY, util.VN_CURDATE() + INTERVAL 12 DAY)),
-        (1106, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, DATE_ADD(util.VN_CURDATE(), INTERVAL -20 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 20 DAY))),
+        (1106, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, util.VN_CURDATE() - INTERVAL 20 DAY, util.VN_CURDATE() + INTERVAL 20 DAY)),
-        (1106, 2, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, DATE_ADD(util.VN_CURDATE(), INTERVAL -13 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 8  DAY))),
+        (1106, 2, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, util.VN_CURDATE() - INTERVAL 13 DAY, util.VN_CURDATE() + INTERVAL 8  DAY)),
-        (1106, 1, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, DATE_ADD(util.VN_CURDATE(), INTERVAL -14 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 9  DAY))),
+        (1106, 1, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, util.VN_CURDATE() - INTERVAL 14 DAY, util.VN_CURDATE() + INTERVAL 9  DAY)),
-        (1106, 2, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, DATE_ADD(util.VN_CURDATE(), INTERVAL -15 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 7  DAY))),
+        (1106, 2, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, util.VN_CURDATE() - INTERVAL 15 DAY, util.VN_CURDATE() + INTERVAL 7  DAY)),
-        (1107, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, DATE_ADD(util.VN_CURDATE(), INTERVAL -10 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 10 DAY))),
+        (1107, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, util.VN_CURDATE() - INTERVAL 10 DAY, util.VN_CURDATE() + INTERVAL 10 DAY)),
-        (1107, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, DATE_ADD(util.VN_CURDATE(), INTERVAL -11 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 11 DAY))),
+        (1107, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, util.VN_CURDATE() - INTERVAL 11 DAY, util.VN_CURDATE() + INTERVAL 11 DAY)),
-        (1107, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, DATE_ADD(util.VN_CURDATE(), INTERVAL -12 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 12 DAY))),
+        (1107, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, util.VN_CURDATE() - INTERVAL 12 DAY, util.VN_CURDATE() + INTERVAL 12 DAY)),
-        (1107, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, DATE_ADD(util.VN_CURDATE(), INTERVAL -20 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 20 DAY))),
+        (1107, 1, IF(MONTH(util.VN_CURDATE()) = 12 AND DAY(util.VN_CURDATE()) > 10, util.VN_CURDATE() - INTERVAL 20 DAY, util.VN_CURDATE() + INTERVAL 20 DAY)),
-        (1107, 2, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, DATE_ADD(util.VN_CURDATE(), INTERVAL -13 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 8  DAY))),
+        (1107, 2, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, util.VN_CURDATE() - INTERVAL 13 DAY, util.VN_CURDATE() + INTERVAL 8  DAY)),
-        (1107, 1, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, DATE_ADD(util.VN_CURDATE(), INTERVAL -14 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 9  DAY))),
+        (1107, 1, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, util.VN_CURDATE() - INTERVAL 14 DAY, util.VN_CURDATE() + INTERVAL 9  DAY)),
-        (1107, 2, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, DATE_ADD(util.VN_CURDATE(), INTERVAL -15 DAY), DATE_ADD(util.VN_CURDATE(), INTERVAL 7  DAY))),
+        (1107, 2, IF(MONTH(util.VN_CURDATE()) >= 1 AND DAY(util.VN_CURDATE()) > 20, util.VN_CURDATE() - INTERVAL 15 DAY, util.VN_CURDATE() + INTERVAL 7  DAY)),
-        (1107, 2, DATE_ADD(util.VN_CURDATE(), INTERVAL - 16 DAY));
+        (1107, 2, util.VN_CURDATE() - INTERVAL 16 DAY);
 
 INSERT INTO `vn`.`smsConfig` (`id`, `uri`, `title`, `apiKey`)
     VALUES
@@ -2754,9 +2758,9 @@ INSERT INTO `vn`.`sectorCollectionSaleGroup` (`sectorCollectionFk`, `saleGroupFk
     VALUES
         (1, 1);
 
-INSERT INTO `vn`.`workerTimeControlConfig` (`id`, `dayBreak`, `dayBreakDriver`, `shortWeekBreak`, `longWeekBreak`, `weekScope`, `mailPass`, `mailHost`, `mailSuccessFolder`, `mailErrorFolder`, `mailUser`, `minHoursToBreak`, `breakHours`, `hoursCompleteWeek`, `startNightlyHours`, `endNightlyHours`, `maxTimePerDay`, `breakTime`, `timeToBreakTime`, `dayMaxTime`, `shortWeekDays`, `longWeekDays`, `teleworkingStart`, `teleworkingStartBreakTime`)
+INSERT INTO `vn`.`workerTimeControlConfig` (`id`, `dayBreak`, `dayBreakDriver`, `shortWeekBreak`, `longWeekBreak`, `weekScope`, `mailPass`, `mailHost`, `mailSuccessFolder`, `mailErrorFolder`, `mailUser`, `minHoursToBreak`, `breakHours`, `hoursCompleteWeek`, `startNightlyHours`, `endNightlyHours`, `maxTimePerDay`, `breakTime`, `timeToBreakTime`, `dayMaxTime`, `shortWeekDays`, `longWeekDays`, `teleworkingStart`, `teleworkingStartBreakTime`, `maxTimeToBreak`, `maxWorkShortCycle`, `maxWorkLongCycle`)
     VALUES
-        (1, 43200, 32400, 129600, 259200, 604800, '', '', 'Leidos.exito', 'Leidos.error', 'timeControl', 5.33, 0.33, 40, '22:00:00', '06:00:00', 57600, 1200, 18000, 57600, 6, 13, 28800, 32400);
+        (1, 43200, 32400, 129600, 259200, 1080000, '', 'imap.verdnatura.es', 'Leidos.exito', 'Leidos.error', 'timeControl', 5.00, 0.33, 40, '22:00:00', '06:00:00', 72000, 1200, 18000, 72000, 6, 13, 28800, 32400, 3600, 561600, 950400);
 
 INSERT INTO `vn`.`host` (`id`, `code`, `description`, `warehouseFk`, `bankFk`)
     VALUES
@@ -2784,6 +2788,11 @@ INSERT INTO `util`.`notification` (`id`, `name`, `description`)
 INSERT INTO `util`.`notificationAcl` (`notificationFk`, `roleFk`)
     VALUES
         (1, 9),
+        (1, 1),
+        (2, 1),
+        (3, 9),
+        (4, 1),
+        (5, 9),
         (6, 9);
 
 INSERT INTO `util`.`notificationQueue` (`id`, `notificationFk`, `params`, `authorFk`, `status`, `created`)
@@ -2796,6 +2805,8 @@ INSERT INTO `util`.`notificationSubscription` (`notificationFk`, `userFk`)
     VALUES
         (1, 1109),
         (1, 1110),
+        (2, 1110),
+        (4, 1110),
         (2, 1109),
 	    (1, 9),
         (1, 3),

db/dump/structure.sql

@@ -2352,6 +2352,90 @@ BEGIN
 	END IF;
 END ;;
 DELIMITER ;
+
+
+DELIMITER ;;
+CREATE DEFINER=`root`@`localhost` FUNCTION `account`.`user_hasRoutinePriv`(vType ENUM('PROCEDURE', 'FUNCTION'),
+	vChain VARCHAR(100),
+	vUserFk INT
+) RETURNS tinyint(1)
+    READS SQL DATA
+BEGIN
+
+/**
+ * Search if the user has privileges on routines.
+ *
+ * @param vType procedure or function
+ * @param vChain string passed with this syntax dbName.tableName
+ * @param vUserFk user to ckeck
+ * @return vHasPrivilege
+ */
+	DECLARE vHasPrivilege BOOL DEFAULT FALSE;
+	DECLARE vDb VARCHAR(50);
+	DECLARE vObject VARCHAR(50);
+	DECLARE vChainExists BOOL;
+	DECLARE vExecutePriv INT DEFAULT 262144;
+	-- 262144 = CONV(1000000000000000000, 2, 10)
+	-- 1000000000000000000 execution permission expressed in binary base
+
+	SET vDb = SUBSTRING_INDEX(vChain, '.', 1);
+	SET vChain = SUBSTRING(vChain, LENGTH(vDb) + 2);
+	SET vObject = SUBSTRING_INDEX(vChain, '.', 1);
+
+	SELECT COUNT(*) INTO vChainExists
+		FROM mysql.proc
+			WHERE db = vDb
+				AND `name` = vObject
+				AND `type` = vType
+			LIMIT 1;
+
+	IF NOT vChainExists THEN
+		RETURN FALSE;
+	END IF;
+
+	DROP TEMPORARY TABLE IF EXISTS tRole;
+	CREATE TEMPORARY TABLE tRole
+		(INDEX (`name`))
+		ENGINE = MEMORY
+		SELECT r.`name`
+			FROM user u
+				JOIN roleRole rr ON rr.role = u.role
+				JOIN `role` r ON r.id = rr.inheritsFrom
+			WHERE u.id = vUserFk;
+
+	SELECT TRUE INTO vHasPrivilege
+		FROM mysql.global_priv gp
+			JOIN tRole tr ON tr.name = gp.`User`
+				OR CONCAT('$', tr.name) = gp.`User`
+		WHERE JSON_VALUE(gp.Priv, '$.access') >= vExecutePriv
+			AND gp.Host = ''
+		LIMIT 1;
+
+	IF NOT vHasPrivilege THEN
+		SELECT TRUE INTO vHasPrivilege
+			FROM mysql.db db
+				JOIN tRole tr ON tr.name = db.`User`
+			WHERE db.Db = vDb
+				AND db.Execute_priv = 'Y';
+	END IF;
+
+	IF NOT vHasPrivilege THEN
+		SELECT TRUE INTO vHasPrivilege
+			FROM mysql.procs_priv pp
+				JOIN tRole tr ON tr.name = pp.`User`
+			WHERE pp.Db = vDb
+				AND pp.Routine_name = vObject
+				AND pp.Routine_type = vType
+				AND pp.Proc_priv = 'Execute'
+			LIMIT 1;
+	END IF;
+
+	DROP TEMPORARY TABLE tRole;
+	RETURN vHasPrivilege;
+END ;;
+DELIMITER ;
+
+
 /*!50003 SET sql_mode              = @saved_sql_mode */ ;
 /*!50003 SET character_set_client  = @saved_cs_client */ ;
 /*!50003 SET character_set_results = @saved_cs_results */ ;
@@ -25993,13 +26077,13 @@ CREATE TABLE `cplusInvoiceType472` (
 /*!40101 SET character_set_client = @saved_cs_client */;
 
 --
--- Table structure for table `cplusInvoiceType477`
+-- Table structure for table `siiTypeInvoiceOut`
 --
 
-DROP TABLE IF EXISTS `cplusInvoiceType477`;
+DROP TABLE IF EXISTS `siiTypeInvoiceOut`;
 /*!40101 SET @saved_cs_client     = @@character_set_client */;
 /*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `cplusInvoiceType477` (
+CREATE TABLE `siiTypeInvoiceOut` (
   `id` int(10) unsigned NOT NULL,
   `description` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci NOT NULL,
   PRIMARY KEY (`id`)
@@ -29450,16 +29534,16 @@ CREATE TABLE `invoiceCorrection` (
   `correctingFk` int(10) unsigned NOT NULL COMMENT 'Factura rectificativa',
   `correctedFk` int(10) unsigned NOT NULL COMMENT 'Factura rectificada',
   `cplusRectificationTypeFk` int(10) unsigned NOT NULL,
-  `cplusInvoiceType477Fk` int(10) unsigned NOT NULL,
+  `siiTypeInvoiceOutFk` int(10) unsigned NOT NULL,
   `invoiceCorrectionTypeFk` int(11) NOT NULL DEFAULT 3,
   PRIMARY KEY (`correctingFk`),
   KEY `correctedFk_idx` (`correctedFk`),
   KEY `invoiceCorrection_ibfk_1_idx` (`cplusRectificationTypeFk`),
-  KEY `cplusInvoiceTyoeFk_idx` (`cplusInvoiceType477Fk`),
+  KEY `cplusInvoiceTyoeFk_idx` (`siiTypeInvoiceOutFk`),
   KEY `invoiceCorrectionTypeFk_idx` (`invoiceCorrectionTypeFk`),
   CONSTRAINT `corrected_fk` FOREIGN KEY (`correctedFk`) REFERENCES `invoiceOut` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
   CONSTRAINT `correcting_fk` FOREIGN KEY (`correctingFk`) REFERENCES `invoiceOut` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
-  CONSTRAINT `cplusInvoiceTyoeFk` FOREIGN KEY (`cplusInvoiceType477Fk`) REFERENCES `cplusInvoiceType477` (`id`) ON UPDATE CASCADE,
+  CONSTRAINT `cplusInvoiceTyoeFk` FOREIGN KEY (`siiTypeInvoiceOutFk`) REFERENCES `siiTypeInvoiceOut` (`id`) ON UPDATE CASCADE,
   CONSTRAINT `invoiceCorrectionType_Fk33` FOREIGN KEY (`invoiceCorrectionTypeFk`) REFERENCES `invoiceCorrectionType` (`id`) ON UPDATE CASCADE,
   CONSTRAINT `invoiceCorrection_ibfk_1` FOREIGN KEY (`cplusRectificationTypeFk`) REFERENCES `cplusRectificationType` (`id`) ON UPDATE CASCADE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_unicode_ci COMMENT='Relacion entre las facturas rectificativas y las rectificadas.';
@@ -30130,7 +30214,7 @@ CREATE TABLE `invoiceOut` (
   `companyFk` int(10) unsigned NOT NULL DEFAULT 442,
   `hasPdf` tinyint(3) unsigned NOT NULL DEFAULT 0,
   `booked` date DEFAULT NULL,
-  `cplusInvoiceType477Fk` int(10) unsigned NOT NULL DEFAULT 1,
+  `siiTypeInvoiceOutFk` int(10) unsigned NOT NULL DEFAULT 1,
   `cplusTaxBreakFk` int(10) unsigned NOT NULL DEFAULT 1,
   `cplusSubjectOpFk` int(10) unsigned NOT NULL DEFAULT 1,
   `cplusTrascendency477Fk` int(10) unsigned NOT NULL DEFAULT 1,
@@ -30140,13 +30224,13 @@ CREATE TABLE `invoiceOut` (
   KEY `Id_Cliente` (`clientFk`),
   KEY `empresa_id` (`companyFk`),
   KEY `Fecha` (`issued`),
-  KEY `Facturas_ibfk_2_idx` (`cplusInvoiceType477Fk`),
+  KEY `Facturas_ibfk_2_idx` (`siiTypeInvoiceOutFk`),
   KEY `Facturas_ibfk_3_idx` (`cplusSubjectOpFk`),
   KEY `Facturas_ibfk_4_idx` (`cplusTaxBreakFk`),
   KEY `Facturas_ibfk_5_idx` (`cplusTrascendency477Fk`),
   KEY `Facturas_idx_Vencimiento` (`dued`),
   KEY `invoiceOut_serial` (`serial`),
-  CONSTRAINT `invoiceOut_ibfk_2` FOREIGN KEY (`cplusInvoiceType477Fk`) REFERENCES `cplusInvoiceType477` (`id`) ON UPDATE CASCADE,
+  CONSTRAINT `invoiceOut_ibfk_2` FOREIGN KEY (`siiTypeInvoiceOutFk`) REFERENCES `siiTypeInvoiceOut` (`id`) ON UPDATE CASCADE,
   CONSTRAINT `invoiceOut_ibfk_3` FOREIGN KEY (`cplusSubjectOpFk`) REFERENCES `cplusSubjectOp` (`id`) ON UPDATE CASCADE,
   CONSTRAINT `invoiceOut_ibfk_4` FOREIGN KEY (`cplusTaxBreakFk`) REFERENCES `cplusTaxBreak` (`id`) ON UPDATE CASCADE,
   CONSTRAINT `invoiceOut_serial` FOREIGN KEY (`serial`) REFERENCES `invoiceOutSerial` (`code`),
@@ -30308,7 +30392,7 @@ CREATE TABLE `invoiceOutSerial` (
   `isTaxed` tinyint(1) NOT NULL DEFAULT 1,
   `taxAreaFk` varchar(15) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci NOT NULL DEFAULT 'NATIONAL',
   `isCEE` tinyint(1) NOT NULL DEFAULT 0,
-  `cplusInvoiceType477Fk` int(10) unsigned DEFAULT 1,
+  `siiTypeInvoiceOutFk` int(10) unsigned DEFAULT 1,
   `footNotes` longtext DEFAULT NULL,
   `isRefEditable` tinyint(4) NOT NULL DEFAULT 0,
   `type` enum('global','quick') DEFAULT NULL,
@@ -58288,7 +58372,7 @@ BEGIN
 				io.cplusTrascendency477Fk AS TIPOCLAVE,
 				io.cplusTaxBreakFk AS TIPOEXENCI,
 				io.cplusSubjectOpFk AS TIPONOSUJE,
-				io.cplusInvoiceType477Fk AS TIPOFACT,
+				io.siiTypeInvoiceOutFk AS TIPOFACT,
 				ic.cplusRectificationTypeFk AS TIPORECTIF,
 				io.companyFk,
 				RIGHT(io.ref, LENGTH(io.ref) - 1) AS invoiceNum,
@@ -58868,7 +58952,7 @@ BEGIN
 			clientFk,
 			dued,
 			companyFk,
-			cplusInvoiceType477Fk
+			siiTypeInvoiceOutFk
 		)
 			SELECT
 					1,

db/export-data.sh

@@ -46,7 +46,7 @@ TABLES=(
     bookingPlanner
     businessType
     cplusInvoiceType472
-    cplusInvoiceType477
+    siiTypeInvoiceOut
     cplusRectificationType
     cplusSubjectOp
     cplusTaxBreak

db/tests/vn/timeControl_calculateByUser.spec.js

@@ -1,91 +0,0 @@
-const app = require('vn-loopback/server/server');
-const ParameterizedSQL = require('loopback-connector').ParameterizedSQL;
-
-describe('timeControl_calculateByUser()', () => {
-    it(`should return today's worked hours`, async() => {
-        let start = Date.vnNew();
-        start.setHours(0, 0, 0, 0);
-        start.setDate(start.getDate() - 1);
-
-        let end = Date.vnNew();
-        end.setHours(0, 0, 0, 0);
-        end.setDate(end.getDate() + 1);
-
-        let stmts = [];
-        let stmt;
-
-        let params = {
-            workerID: 1106,
-            start: start,
-            end: end
-        };
-
-        stmt = new ParameterizedSQL('CALL vn.timeControl_calculateByUser(?, ?, ?)', [
-            params.workerID,
-            params.start,
-            params.end
-        ]);
-        stmts.push(stmt);
-
-        let tableIndex = stmts.push('SELECT * FROM tmp.timeControlCalculate') - 1;
-
-        let sql = ParameterizedSQL.join(stmts, ';');
-        let result = await app.models.Ticket.rawStmt(sql);
-
-        let [timeControlCalculateTable] = result[tableIndex];
-
-        expect(timeControlCalculateTable.timeWorkSeconds).toEqual(28200);
-    });
-    // #2261
-    xit(`should return the worked hours between last sunday and monday`, async() => {
-        let lastSunday = Date.vnNew();
-        let daysSinceSunday = lastSunday.getDay();
-        if (daysSinceSunday === 0) // this means today is sunday but you need the previous sunday :)
-            daysSinceSunday = 7;
-        lastSunday.setHours(23, 0, 0, 0);
-        lastSunday.setDate(lastSunday.getDate() - daysSinceSunday);
-
-        let monday = Date.vnNew();
-        let daysSinceMonday = daysSinceSunday - 1; // aiming for monday (today could be monday)
-        monday.setHours(7, 0, 0, 0);
-        monday.setDate(monday.getDate() - daysSinceMonday);
-
-        let stmts = [];
-        let stmt;
-
-        stmts.push('START TRANSACTION');
-
-        const workerID = 1108;
-
-        stmt = new ParameterizedSQL(`
-            INSERT INTO vn.workerTimeControl(userFk, timed, manual, direction)
-                VALUES
-                    (?, ?, 1, 'in'),
-                    (?, ?, 1, 'out')
-        `, [
-            workerID,
-            lastSunday,
-            workerID,
-            monday
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.timeControl_calculateByUser(?, ?, ?)', [
-            workerID,
-            lastSunday,
-            monday
-        ]);
-        stmts.push(stmt);
-
-        let tableIndex = stmts.push('SELECT * FROM tmp.timeControlCalculate') - 1;
-
-        stmts.push('ROLLBACK');
-
-        let sql = ParameterizedSQL.join(stmts, ';');
-        let result = await app.models.Ticket.rawStmt(sql);
-
-        let [timeControlCalculateTable] = result[tableIndex];
-
-        expect(timeControlCalculateTable.timeWorkSeconds).toEqual(30000);
-    });
-});

db/tests/vn/workerTimeControlCheck.spec.js

@@ -1,580 +0,0 @@
-const app = require('vn-loopback/server/server');
-const ParameterizedSQL = require('loopback-connector').ParameterizedSQL;
-
-// #2261 xdescribe dbtest workerTimeControl_check()
-xdescribe('worker workerTimeControl_check()', () => {
-    it(`should throw an error if the worker can't sign on that tablet`, async() => {
-        let stmts = [];
-        let stmt;
-        const workerId = 1110;
-        const tabletId = 2;
-        let err;
-        stmts.push('START TRANSACTION');
-        try {
-            stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-                workerId,
-                tabletId
-            ]);
-            stmts.push(stmt);
-
-            stmts.push('ROLLBACK');
-
-            let sql = ParameterizedSQL.join(stmts, ';');
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            err = e;
-        }
-
-        expect(err.sqlMessage).toEqual('No perteneces a este departamento.');
-    });
-
-    it('should check that the worker can sign on that tablet', async() => {
-        let stmts = [];
-        let stmt;
-        const workerId = 1110;
-        const tabletId = 1;
-        let err;
-        stmts.push('START TRANSACTION');
-        try {
-            stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-                workerId,
-                tabletId
-            ]);
-            stmts.push(stmt);
-
-            stmts.push('ROLLBACK');
-
-            let sql = ParameterizedSQL.join(stmts, ';');
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            err = e;
-        }
-
-        expect(err).not.toBeDefined();
-    });
-
-    it('should throw an error if the worker with a special category has not finished the 9h break', async() => {
-        const workerId = 1110;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-        let sql;
-        let error;
-
-        stmts.push('START TRANSACTION');
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-                (?,TIMESTAMPADD(HOUR,-17,NOW()),0,"in"),
-                (?,TIMESTAMPADD(SECOND,-32399,NOW()),0,"out")`, [
-            workerId,
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-        stmts.push('ROLLBACK');
-        sql = ParameterizedSQL.join(stmts, ';');
-
-        try {
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            await app.models.Worker.rawSql('ROLLBACK');
-            error = e;
-        }
-
-        expect(error.sqlMessage).toEqual('Descansos 9 h');
-    });
-
-    it('should check f the worker with a special category has finished the 9h break', async() => {
-        const workerId = 1110;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-        let err;
-        stmts.push('START TRANSACTION');
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-                (?,TIMESTAMPADD(HOUR,-17,NOW()),0,"in"),
-                (?,TIMESTAMPADD(SECOND,-32401,NOW()),0,"out")`, [
-            workerId,
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-        stmts.push('ROLLBACK');
-
-        let sql = ParameterizedSQL.join(stmts, ';');
-
-        try {
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            await app.models.Worker.rawSql('ROLLBACK');
-            err = e;
-        }
-
-        expect(err).not.toBeDefined();
-    });
-
-    it('should throw an error if the worker has not finished the 12h break', async() => {
-        const workerId = 1109;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-        let sql;
-        let error;
-
-        stmts.push('START TRANSACTION');
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-                (?,TIMESTAMPADD(HOUR,-20,NOW()),0,"in"),
-                (?,TIMESTAMPADD(SECOND,-43199,NOW()),0,"out")`, [
-            workerId,
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-        stmts.push('ROLLBACK');
-        sql = ParameterizedSQL.join(stmts, ';');
-
-        try {
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            await app.models.Worker.rawSql('ROLLBACK');
-            error = e;
-        }
-
-        expect(error.sqlMessage).toEqual('Descansos 12 h');
-    });
-
-    it('should throw an error if the worker has finished the 12h break', async() => {
-        const workerId = 1109;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-        let err;
-        stmts.push('START TRANSACTION');
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-                (?,TIMESTAMPADD(HOUR,-20,NOW()),0,"in"),
-                (?,TIMESTAMPADD(SECOND,-43201,NOW()),0,"out")`, [
-            workerId,
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-        stmts.push('ROLLBACK');
-
-        let sql = ParameterizedSQL.join(stmts, ';');
-
-        try {
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            await app.models.Worker.rawSql('ROLLBACK');
-            err = e;
-        }
-
-        expect(err).not.toBeDefined();
-    });
-
-    it('should throw an error if the worker has odd entry records', async() => {
-        const workerId = 1109;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-        let err;
-        stmts.push('START TRANSACTION');
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-                (?,TIMESTAMPADD(HOUR,-24,NOW()),0,"in")`, [
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-        stmts.push('ROLLBACK');
-
-        let sql = ParameterizedSQL.join(stmts, ';');
-
-        try {
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            await app.models.Worker.rawSql('ROLLBACK');
-            err = e;
-        }
-
-        expect(err.sqlMessage).toEqual('Dias con fichadas impares');
-    });
-
-    it('should throw an error if the worker try to sign on a holiday day', async() => {
-        const workerId = 1109;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-        let err;
-
-        stmts.push('START TRANSACTION');
-
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-                (?,TIMESTAMPADD(HOUR,-24,NOW()),0,"in"),
-                (?,TIMESTAMPADD(HOUR,-20,NOW()),0,"out")`, [
-            workerId,
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-        stmts.push('ROLLBACK');
-
-        let sql = ParameterizedSQL.join(stmts, ';');
-
-        try {
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            await app.models.Worker.rawSql('ROLLBACK');
-            err = e;
-        }
-
-        expect(err.sqlMessage).toEqual('Holidays');
-    });
-
-    it('should throw an error if the worker try to sign with your contract ended', async() => {
-        const workerId = 1109;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-        let err;
-
-        stmts.push('START TRANSACTION');
-
-        stmt = new ParameterizedSQL(`UPDATE vn.business SET ended = DATE_ADD(CURDATE(), INTERVAL -1 DAY) WHERE id = ?`, [
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-                (?,TIMESTAMPADD(HOUR,-24,NOW()),0,"in"),
-                (?,TIMESTAMPADD(HOUR,-20,NOW()),0,"out")`, [
-            workerId,
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-        stmts.push('ROLLBACK');
-
-        let sql = ParameterizedSQL.join(stmts, ';');
-
-        try {
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            await app.models.Worker.rawSql('ROLLBACK');
-            err = e;
-        }
-
-        expect(err.sqlMessage).toEqual('No hay un contrato en vigor');
-    });
-
-    it('should throw an error if the worker has not finished the 36h weekly break', async() => {
-        const workerId = 1109;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-
-        stmts.push('SET @warn := NULL');
-
-        stmts.push('START TRANSACTION');
-
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-                (?,TIMESTAMPADD(HOUR,-24,NOW()),0,"in"),
-                (?,TIMESTAMPADD(HOUR,-16,NOW()),0,"out"),
-                (?,TIMESTAMPADD(HOUR,-48,NOW()),0,"in"),
-                (?,TIMESTAMPADD(HOUR,-40,NOW()),0,"out"),
-                (?,TIMESTAMPADD(HOUR,-72,NOW()),0,"in"),
-                (?,TIMESTAMPADD(HOUR,-64,NOW()),0,"out"),
-                (?,TIMESTAMPADD(HOUR,-96,NOW()),0,"in"),
-                (?,TIMESTAMPADD(HOUR,-88,NOW()),0,"out"),
-                (?,TIMESTAMPADD(HOUR,-120,NOW()),0,"in"),
-                (?,TIMESTAMPADD(HOUR,-112,NOW()),0,"out"),
-                (?,TIMESTAMPADD(HOUR,-144,NOW()),0,"in"),
-                (?,TIMESTAMPADD(HOUR,-136,NOW()),0,"out"),
-                (?,TIMESTAMPADD(HOUR,-168,NOW()),0,"in"),
-                (?,TIMESTAMPADD(HOUR,-160,NOW()),0,"out"),
-                (?,TIMESTAMPADD(HOUR,-192,NOW()),0,"in"),
-                (?,TIMESTAMPADD(HOUR,-184,NOW()),0,"out")`, [
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-
-        let warningMessageIndex = stmts.push('SELECT @warn AS warning') - 1;
-        stmts.push('ROLLBACK');
-        let sql = ParameterizedSQL.join(stmts, ';');
-        let result = await app.models.Worker.rawStmt(sql);
-
-        expect(result[warningMessageIndex][0].warning).toEqual('Descansos 36 h');
-    });
-
-    it('should check if the worker has finished the 36h weekly break', async() => {
-        const workerId = 1109;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-
-        stmts.push('SET @warn := NULL');
-
-        stmts.push('START TRANSACTION');
-
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-            (?,TIMESTAMPADD(HOUR,-24,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-16,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-48,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-40,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-72,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-64,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-96,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-88,NOW()),0,"out")`, [
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-        stmts.push('ROLLBACK');
-
-        let warningMessageIndex = stmts.push('SELECT @warn AS warning') - 1;
-
-        let sql = ParameterizedSQL.join(stmts, ';');
-        let result = await app.models.Worker.rawStmt(sql);
-
-        expect(result[warningMessageIndex][0].warning).toBe(null);
-    });
-
-    it('should throw an error if the worker has not finished the 72h biweekly break', async() => {
-        const workerId = 1109;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-        let err;
-        stmts.push('START TRANSACTION');
-
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-            (?,TIMESTAMPADD(HOUR,-24,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-16,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-48,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-40,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-72,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-64,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-96,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-88,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-120,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-112,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-144,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-136,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-168,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-160,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-192,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-184,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-216,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-208,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-240,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-232,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-264,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-256,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-289,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-280,NOW()),0,"out")`, [
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-        stmts.push('ROLLBACK');
-
-        stmts.push('SELECT @warn AS warning') - 1;
-
-        let sql = ParameterizedSQL.join(stmts, ';');
-
-        try {
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            await app.models.Worker.rawSql('ROLLBACK');
-            err = e;
-        }
-
-        expect(err.sqlMessage).toEqual('Descansos 72 h');
-    });
-
-    it('should check if the worker has finished the 72h biweekly break', async() => {
-        const workerId = 1109;
-        const tabletId = 1;
-        let stmts = [];
-        let stmt;
-        let err;
-        stmts.push('START TRANSACTION');
-
-        stmt = new ParameterizedSQL(`INSERT INTO vn.workerTimeControl(userFk,timed,manual,direction)
-            VALUES
-            (?,TIMESTAMPADD(HOUR,-24,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-16,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-48,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-40,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-72,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-64,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-96,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-88,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-120,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-112,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-144,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-136,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-168,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-160,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-192,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-184,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-216,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-208,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-240,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-232,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-264,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-256,NOW()),0,"out"),
-            (?,TIMESTAMPADD(HOUR,-288,NOW()),0,"in"),
-            (?,TIMESTAMPADD(HOUR,-280,NOW()),0,"out")`, [
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId,
-            workerId
-        ]);
-        stmts.push(stmt);
-
-        stmt = new ParameterizedSQL('CALL vn.workerTimeControl_check(?, ?, NULL)', [
-            workerId,
-            tabletId
-        ]);
-        stmts.push(stmt);
-        stmts.push('ROLLBACK');
-
-        stmts.push('SELECT @warn AS warning') - 1;
-
-        let sql = ParameterizedSQL.join(stmts, ';');
-
-        try {
-            await app.models.Worker.rawStmt(sql);
-        } catch (e) {
-            await app.models.Worker.rawSql('ROLLBACK');
-            err = e;
-        }
-
-        expect(err).not.toBeDefined();
-    });
-});

loopback/common/methods/application/execute.js

@@ -0,0 +1,28 @@
+const UserError = require('vn-loopback/util/user-error');
+
+module.exports = Self => {
+    Self.execute = async(ctx, type, query, params, options) => {
+        const userId = ctx.req.accessToken.userId;
+        const models = Self.app.models;
+        params = params ?? [];
+
+        const myOptions = {userId: ctx.req.accessToken.userId};
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const chain = query.split(' ')[1];
+
+        const [canExecute] = await models.ProcsPriv.rawSql(
+            'SELECT account.user_hasRoutinePriv(?,?,?)',
+            [type, chain, userId],
+            myOptions);
+
+        if (!Object.values(canExecute)[0]) throw new UserError(`You don't have enough privileges`, 'ACCESS_DENIED');
+
+        const argString = params.map(() => '?').join(',');
+
+        const response = await models.ProcsPriv.rawSql(query + `(${argString})`, params, myOptions);
+        if (!Array.isArray(response)) return;
+        return response[0];
+    };
+};

loopback/common/methods/application/executeFunc.js

@@ -0,0 +1,41 @@
+module.exports = Self => {
+    Self.remoteMethodCtx('executeFunc', {
+        description: 'Return result of function',
+        accessType: 'EXECUTE',
+        accepts: [
+            {
+                arg: 'routine',
+                type: 'string',
+                description: 'The routine name',
+                required: true,
+                http: {source: 'path'}
+            },
+            {
+                arg: 'schema',
+                type: 'string',
+                description: 'The routine schema',
+                required: true,
+            },
+            {
+                arg: 'params',
+                type: ['any'],
+                description: 'The params array',
+            },
+        ],
+        returns: {
+            type: 'any',
+            root: true
+        },
+        http: {
+            path: `/:routine/execute-func`,
+            verb: 'POST'
+        }
+    });
+
+    Self.executeFunc = async(ctx, routine, schema, params, options) => {
+        const query = `SELECT ${schema}.${routine}`;
+
+        const response = await Self.execute(ctx, 'FUNCTION', query, params, options);
+        return Object.values(response)[0];
+    };
+};

loopback/common/methods/application/executeProc.js

@@ -0,0 +1,39 @@
+module.exports = Self => {
+    Self.remoteMethodCtx('executeProc', {
+        description: 'Return result of procedure',
+        accessType: 'EXECUTE',
+        accepts: [
+            {
+                arg: 'routine',
+                type: 'string',
+                description: 'The routine name',
+                required: true,
+                http: {source: 'path'}
+            },
+            {
+                arg: 'schema',
+                type: 'string',
+                description: 'The routine schema',
+                required: true,
+            },
+            {
+                arg: 'params',
+                type: ['any'],
+                description: 'The params array',
+            },
+        ],
+        returns: {
+            type: 'any',
+            root: true
+        },
+        http: {
+            path: `/:routine/execute-proc`,
+            verb: 'POST'
+        }
+    });
+
+    Self.executeProc = async(ctx, routine, schema, params, options) => {
+        const query = `CALL ${schema}.${routine}`;
+        return Self.execute(ctx, 'PROCEDURE', query, params, options);
+    };
+};

loopback/common/methods/application/spec/execute.spec.js

@@ -0,0 +1,161 @@
+const models = require('vn-loopback/server/server').models;
+
+describe('Application execute()/executeProc()/executeFunc()', () => {
+    const userWithoutPrivileges = 1;
+    const userWithPrivileges = 9;
+    const userWithInheritedPrivileges = 120;
+    let tx;
+
+    function getCtx(userId) {
+        return {
+            req: {
+                accessToken: {userId},
+                headers: {origin: 'http://localhost'}
+            }
+        };
+    }
+
+    beforeEach(async() => {
+        tx = await models.Application.beginTransaction({});
+        const options = {transaction: tx};
+
+        await models.Application.rawSql(`
+            CREATE OR REPLACE PROCEDURE vn.myProcedure(vMyParam INT)
+            BEGIN
+                SELECT vMyParam myParam, t.*
+                    FROM ticket t
+                    LIMIT 2;
+            END
+        `, null, options);
+
+        await models.Application.rawSql(`
+            CREATE OR REPLACE FUNCTION bs.myFunction(vMyParam INT) RETURNS int(11)
+            BEGIN
+                RETURN vMyParam;
+            END
+        `, null, options);
+
+        await models.Application.rawSql(`
+            GRANT EXECUTE ON PROCEDURE vn.myProcedure TO developer;
+            GRANT EXECUTE ON FUNCTION bs.myFunction TO developer;
+        `, null, options);
+    });
+
+    it('should throw error when execute procedure and not have privileges', async() => {
+        const ctx = getCtx(userWithoutPrivileges);
+
+        let error;
+        try {
+            const options = {transaction: tx};
+
+            await models.Application.execute(
+                ctx,
+                'PROCEDURE',
+                'CALL vn.myProcedure',
+                [1],
+                options
+            );
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            error = e;
+        }
+
+        expect(error.message).toEqual(`You don't have enough privileges`);
+    });
+
+    it('should execute procedure and get data', async() => {
+        const ctx = getCtx(userWithPrivileges);
+        try {
+            const options = {transaction: tx};
+
+            const response = await models.Application.execute(
+                ctx,
+                'PROCEDURE',
+                'CALL vn.myProcedure',
+                [1],
+                options
+            );
+
+            expect(response.length).toEqual(2);
+            expect(response[0].myParam).toEqual(1);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    describe('Application executeProc()', () => {
+        it('should execute procedure and get data (executeProc)', async() => {
+            const ctx = getCtx(userWithPrivileges);
+            try {
+                const options = {transaction: tx};
+
+                const response = await models.Application.executeProc(
+                    ctx,
+                    'myProcedure',
+                    'vn',
+                    [1],
+                    options
+                );
+
+                expect(response.length).toEqual(2);
+                expect(response[0].myParam).toEqual(1);
+
+                await tx.rollback();
+            } catch (e) {
+                await tx.rollback();
+                throw e;
+            }
+        });
+    });
+
+    describe('Application executeFunc()', () => {
+        it('should execute function and get data', async() => {
+            const ctx = getCtx(userWithPrivileges);
+            try {
+                const options = {transaction: tx};
+
+                const response = await models.Application.executeFunc(
+                    ctx,
+                    'myFunction',
+                    'bs',
+                    [1],
+                    options
+                );
+
+                expect(response).toEqual(1);
+
+                await tx.rollback();
+            } catch (e) {
+                await tx.rollback();
+                throw e;
+            }
+        });
+
+        it('should execute function and get data with user with inherited privileges', async() => {
+            const ctx = getCtx(userWithInheritedPrivileges);
+            try {
+                const options = {transaction: tx};
+
+                const response = await models.Application.executeFunc(
+                    ctx,
+                    'myFunction',
+                    'bs',
+                    [1],
+                    options
+                );
+
+                expect(response).toEqual(1);
+
+                await tx.rollback();
+            } catch (e) {
+                await tx.rollback();
+                throw e;
+            }
+        });
+    });
+});

loopback/common/models/application.js

@@ -2,4 +2,7 @@
 module.exports = function(Self) {
     require('../methods/application/status')(Self);
     require('../methods/application/post')(Self);
+    require('../methods/application/execute')(Self);
+    require('../methods/application/executeProc')(Self);
+    require('../methods/application/executeFunc')(Self);
 };

loopback/common/models/procs-priv.json

@@ -0,0 +1,44 @@
+{
+    "name": "ProcsPriv",
+    "base": "VnModel",
+    "options": {
+        "mysql": {
+            "table": "mysql.procs_priv"
+        }
+    },
+    "properties": {
+        "name": {
+            "id": 1,
+            "type": "string",
+            "mysql": {
+                "columnName": "Routine_name"
+            }
+        },
+        "schema": {
+            "id": 3,
+			"type": "string",
+			"mysql": {
+				"columnName": "Db"
+			}
+		},
+        "role": {
+			"type": "string",
+			"mysql": {
+				"columnName": "user"
+			}
+		},
+        "type": {
+            "id": 2,
+			"type": "string",
+			"mysql": {
+				"columnName": "Routine_type"
+			}
+		},
+        "host": {
+			"type": "string",
+			"mysql": {
+				"columnName": "Host"
+			}
+		}
+    }
+}

loopback/locale/es.json

@@ -321,9 +321,10 @@
 	"Select a different client": "Seleccione un cliente distinto",
 	"Fill all the fields": "Rellene todos los campos",
 	"The response is not a PDF": "La respuesta no es un PDF",
-	"Ticket without Route": "Ticket sin ruta",
 	"Booking completed": "Reserva completada",
 	"The ticket is in preparation": "El ticket [{{ticketId}}]({{{ticketUrl}}}) del comercial {{salesPersonId}} está en preparación",
 	"The amount cannot be less than the minimum": "La cantidad no puede ser menor que la cantidad mímina",
-	"quantityLessThanMin": "La cantidad no puede ser menor que la cantidad mímina"
+	"quantityLessThanMin": "La cantidad no puede ser menor que la cantidad mímina",
+	"Incoterms data for consignee is missing": "Faltan los datos de los Incoterms para el consignatario",
+	"The notification subscription of this worker cant be modified": "La subscripción a la notificación de este trabajador no puede ser modificada"
 }

loopback/server/model-config.json

@@ -49,5 +49,13 @@
     },
     "Container": {
         "dataSource": "vn"
+    },
+    "ProcsPriv": {
+        "dataSource": "vn",
+        "options": {
+            "mysql": {
+                "table": "mysql.procs_priv"
+            }
+        }
     }
 }

modules/client/back/model-config.json

@@ -5,6 +5,9 @@
     "AddressObservation": {
         "dataSource": "vn"
     },
+    "AddressShortage": {
+        "dataSource": "vn"
+    },
     "BankEntity": {
         "dataSource": "vn"
     },

modules/client/back/models/addressShortage.json

@@ -0,0 +1,22 @@
+{
+    "name": "AddressShortage",
+    "base": "VnModel",
+    "options": {
+        "mysql": {
+            "table": "addressShortage"
+        }
+    },
+    "properties": {
+        "addressFk": {
+            "type": "number",
+            "id": true
+        }
+    },
+    "relations": {
+        "address": {
+            "type": "belongsTo",
+            "model": "Address",
+            "foreignKey": "addressFk"
+        }
+    }
+}

modules/client/back/models/client-config.json

@@ -17,6 +17,9 @@
         },
         "maxCreditRows": {
             "type": "number"
+        },
+        "defaultCredit": {
+            "type": "number"
         }
     }
 }

modules/client/back/models/client.js

@@ -483,12 +483,6 @@ module.exports = Self => {
             if (userRequiredRoles <= 0)
                 throw new UserError(`You don't have enough privileges to set this credit amount`);
         }
-
-        await models.ClientCredit.create({
-            amount: changes.credit,
-            clientFk: finalState.id,
-            workerFk: userId
-        }, ctx.options);
     };
 
     Self.changeCreditManagement = async function changeCreditManagement(ctx, finalState, changes) {

modules/client/back/models/client.json

@@ -158,7 +158,7 @@
 		},
 		"user": {
 			"type": "belongsTo",
-			"model": "Account",
+			"model": "VnUser",
 			"foreignKey": "id"
 		},
 		"payMethod": {

modules/client/back/models/specs/client.spec.js

@@ -62,13 +62,13 @@ describe('Client Model', () => {
                 const options = {transaction: tx};
                 const ctx = {options};
 
-                // Set credit to zero by a financialBoss
                 const financialBoss = await models.VnUser.findOne({
                     where: {name: 'financialBoss'}
                 }, options);
                 ctx.options.accessToken = {userId: financialBoss.id};
 
-                await models.Client.changeCredit(ctx, instance, {credit: 0});
+                const testClient = await models.Client.findById(instance.id, options);
+                await testClient.updateAttributes({credit: 0}, ctx.options);
 
                 const salesAssistant = await models.VnUser.findOne({
                     where: {name: 'salesAssistant'}

modules/invoiceOut/back/methods/invoiceOut/specs/transferinvoice.spec.js

@@ -27,7 +27,7 @@ describe('InvoiceOut tranferInvoice()', () => {
             ref: 'T4444444',
             newClientFk: 1,
             cplusRectificationId: 1,
-            cplusInvoiceType477Id: 1,
+            siiTypeInvoiceOutId: 1,
             invoiceCorrectionTypeId: 1
         };
         ctx.args = args;
@@ -52,7 +52,7 @@ describe('InvoiceOut tranferInvoice()', () => {
             ref: 'T1111111',
             newClientFk: 1101,
             cplusRectificationId: 1,
-            cplusInvoiceType477Id: 1,
+            siiTypeInvoiceOutId: 1,
             invoiceCorrectionTypeId: 1
         };
         ctx.args = args;

modules/invoiceOut/back/methods/invoiceOut/transferInvoice.js

@@ -27,7 +27,7 @@ module.exports = Self => {
                 required: true
             },
             {
-                arg: 'cplusInvoiceType477Id',
+                arg: 'siiTypeInvoiceOutId',
                 type: 'number',
                 required: true
             },
@@ -93,7 +93,7 @@ module.exports = Self => {
                 correctingFk: invoiceId,
                 correctedFk: args.id,
                 cplusRectificationTypeFk: args.cplusRectificationId,
-                cplusInvoiceType477Fk: args.cplusInvoiceType477Id,
+                siiTypeInvoiceOutFk: args.siiTypeInvoiceOutId,
                 invoiceCorrectionTypeFk: args.invoiceCorrectionTypeId
             }, myOptions);
 

modules/invoiceOut/back/model-config.json

@@ -41,7 +41,7 @@
     "InvoiceCorrection": {
         "dataSource": "vn"
     },
-    "CplusInvoiceType477": {
+    "SiiTypeInvoiceOut": {
         "dataSource": "vn"
     }
 }

modules/invoiceOut/back/models/invoice-correction.json

@@ -18,7 +18,7 @@
         "cplusRectificationTypeFk": {
             "type": "number"
         },
-        "cplusInvoiceType477Fk": {
+        "siiTypeInvoiceOutFk": {
             "type": "number"
         },
         "invoiceCorrectionTypeFk": {

modules/invoiceOut/back/models/sii-type-invoice-out.json

@@ -1,9 +1,9 @@
 {
-    "name": "CplusInvoiceType477",
+    "name": "SiiTypeInvoiceOut",
     "base": "VnModel",
     "options": {
         "mysql": {
-            "table": "cplusInvoiceType477"
+            "table": "siiTypeInvoiceOut"
         }
     },
     "properties": {

modules/invoiceOut/front/descriptor-menu/index.html

@@ -6,8 +6,8 @@
 </vn-crud-model>
 <vn-crud-model
     auto-load="true"
-    url="CplusInvoiceType477s"
+    url="SiiTypeInvoiceOuts"
-    data="cplusInvoiceType477">
+    data="siiTypeInvoiceOut">
 </vn-crud-model>
 <vn-crud-model
     auto-load="true"
@@ -223,11 +223,11 @@
             <vn-autocomplete
             vn-one
             vn-id="cplusInvoiceType"
-            data="cplusInvoiceType477"
+            data="siiTypeInvoiceOut"
             show-field="description"
             value-field="id"
             required="true"
-            ng-model="$ctrl.cplusInvoiceType477"
+            ng-model="$ctrl.siiTypeInvoiceOut"
             search-function="{or: [{id: $search}, {description: {like: '%'+ $search +'%'}}]}"
             label="Class">
             </vn-autocomplete>

modules/invoiceOut/front/descriptor-menu/index.js

@@ -132,7 +132,7 @@ class Controller extends Section {
             ref: this.invoiceOut.ref,
             newClientFk: this.invoiceOut.client.id,
             cplusRectificationId: this.cplusRectificationType,
-            cplusInvoiceType477Id: this.cplusInvoiceType477,
+            siiTypeInvoiceOutId: this.siiTypeInvoiceOut,
             invoiceCorrectionTypeId: this.invoiceCorrectionType
         };
         this.$http.post(`InvoiceOuts/transferInvoice`, params).then(res => {

modules/ticket/back/locale/sale-group/en.yml

@@ -0,0 +1,10 @@
+name: saleGroup
+columns:
+    id: id
+    created: created
+    userFk: user
+    parkingFk: parking
+    sectorFk: sector
+    ticketFk: ticket
+    editorFk: editor
+ 

modules/ticket/back/locale/sale-group/es.yml

@@ -0,0 +1,10 @@
+name: saleGroup
+columns:
+    id: id
+    created: creado
+    userFk: usuario
+    parkingFk: parking
+    sectorFk: sector
+    ticketFk: ticket
+    editorFk: editor
+ 

modules/ticket/back/methods/ticket/closure.js

@@ -120,7 +120,7 @@ module.exports = async function(ctx, Self, tickets, reqArgs = {}) {
                 await Self.rawSql(`
                         INSERT INTO clientSample (clientFk, typeFk, companyFk) VALUES(?, ?, ?)
                     `, [ticket.clientFk, sample.id, ticket.companyFk], {userId});
-			};
+            }
         } catch (error) {
             // Domain not found
             if (error.responseCode == 450)

modules/ticket/back/methods/ticket/makeInvoice.js

@@ -49,7 +49,6 @@ module.exports = function(Self) {
             myOptions.transaction = tx;
         }
 
-        let serial;
         try {
             const ticketToInvoice = await Self.rawSql(`
                 SELECT id
@@ -60,7 +59,7 @@ module.exports = function(Self) {
                 where: {
                     id: {inq: ticketsIds}
                 },
-                fields: ['id', 'clientFk']
+                fields: ['id', 'clientFk', 'addressFk']
             }, myOptions);
 
             await models.Ticket.canBeInvoiced(ctx, ticketsIds, myOptions);
@@ -72,13 +71,19 @@ module.exports = function(Self) {
                 throw new UserError(`This client can't be invoiced`);
 
             const query = `SELECT vn.invoiceSerial(?, ?, ?) AS serial`;
-            const [result] = await Self.rawSql(query, [
+            const [{serial}] = await Self.rawSql(query, [
                 clientId,
                 companyFk,
                 invoiceType,
             ], myOptions);
-            serial = result.serial;
 
+            const invoiceOutSerial = await models.InvoiceOutSerial.findById(serial);
+            if (invoiceOutSerial?.taxAreaFk == 'WORLD') {
+                const address = await models.Address.findById(firstTicket.addressFk);
+
+                if (!address || !address.customsAgentFk || !address.incotermsFk)
+                    throw new UserError('Incoterms data for consignee is missing');
+            }
             await Self.rawSql('CALL invoiceOut_new(?, ?, null, @invoiceId)', [serial, invoiceDate], myOptions);
 
             const [resultInvoice] = await Self.rawSql('SELECT @invoiceId id', [], myOptions);

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

@@ -52,4 +52,31 @@ describe('ticket makeInvoice()', () => {
             throw e;
         }
     });
+
+    it('should throw an error when invoicing a client without incoterms', async() => {
+        const tx = await models.Ticket.beginTransaction({});
+        let error;
+        try {
+            const options = {transaction: tx};
+
+            const ticketsId = [18];
+            await models.Ticket.rawSql(`
+                DROP TEMPORARY TABLE IF EXISTS tmp.ticketToInvoice;
+                CREATE TEMPORARY TABLE tmp.ticketToInvoice
+                (PRIMARY KEY  (id))
+                    ENGINE = MEMORY
+                    SELECT id
+                        FROM vn.ticket
+                        WHERE id IN (?)
+            `, [ticketsId], options);
+
+            await models.Ticket.makeInvoice(ctx, invoiceType, companyFk, invoiceDate, options);
+            await tx.rollback();
+        } catch (e) {
+            error = e;
+            await tx.rollback();
+        }
+
+        expect(error.message).toEqual(`Incoterms data for consignee is missing`);
+    });
 });

modules/ticket/front/summary/index.html

@@ -212,7 +212,7 @@
                         <vn-td number shrink>{{::sale.quantity}}</vn-td>
                         <vn-td vn-fetched-tags>
                             <div>
-                                <vn-one title="{{::sale.item.name}}">{{::sale.item.name}}</vn-one>
+                                <vn-one title="{{::sale.concept}}">{{::sale.concept}}</vn-one>
                                 <vn-one ng-if="::sale.item.subName">
                                     <h3 title="{{::sale.item.subName}}">{{::sale.item.subName}}</h3>
                                 </vn-one>

modules/worker/back/methods/worker-time-control/specs/timeEntry.spec.js

@@ -14,7 +14,6 @@ describe('workerTimeControl add/delete timeEntry()', () => {
     const tuesday = 2;
     const thursday = 4;
     const friday = 5;
-    const saturday = 6;
     const sunday = 7;
     const activeCtx = {
         accessToken: {userId: 50},
@@ -200,15 +199,15 @@ describe('workerTimeControl add/delete timeEntry()', () => {
     });
 
     describe('WorkerTimeControl_clockIn calls', () => {
-        it('should fail to add a time entry if the target user has an absence that day', async() => {
+        let workerId;
-            pending('https://redmine.verdnatura.es/issues/4707');
+        beforeEach(() => { 
             activeCtx.accessToken.userId = salesBossId;
-            const workerId = hankPymId;
+            workerId = hankPymId;
+        });
+        it('should fail to add a time entry if the target user has an absence that day', async() => {
             const date = Date.vnNew();
-            date.setDate(date.getDate() - 16);
             date.setHours(8, 0, 0);
-            let error;
+            date.setDate(date.getDate() - 16);
-
             const tx = await models.WorkerTimeControl.beginTransaction({});
             const options = {transaction: tx};
             try {
@@ -225,15 +224,12 @@ describe('workerTimeControl add/delete timeEntry()', () => {
         });
 
         it('should fail to add a time entry for a worker without an existing contract', async() => {
-            activeCtx.accessToken.userId = salesBossId;
-            const workerId = hankPymId;
             const date = Date.vnNew();
             date.setFullYear(date.getFullYear() - 2);
-            let error;
 
             const tx = await models.WorkerTimeControl.beginTransaction({});
-            try {
             const options = {transaction: tx};
+            try {
                 ctx.args = {timed: date, direction: 'in'};
                 await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
 
@@ -246,19 +242,39 @@ describe('workerTimeControl add/delete timeEntry()', () => {
             expect(error.message).toBe(`No hay un contrato en vigor`);
         });
 
-        describe('direction errors', () => {
+        it('should fail to add a time entry for a worker without an existing contract', async() => {
-            it('should throw an error when trying "in" direction twice', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-                activeCtx.accessToken.userId = salesBossId;
-                const workerId = hankPymId;
-
             let date = Date.vnNew();
-                date.setDate(date.getDate() - 21);
+            date.setDate(date.getDate() - 2);
-                date = weekDay(date, monday);
             let error;
 
             const tx = await models.WorkerTimeControl.beginTransaction({});
             const options = {transaction: tx};
+            date.setHours(0, 0, 0);
+            ctx.args = {timed: date, direction: 'in'};
+            await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
+
+            try {
+                date.setHours(20,0, 1);
+                ctx.args = {timed: date, direction: 'out'};
+                await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
+                
+                await tx.rollback();
+            } catch (e) {
+                await tx.rollback();
+                error = e;
+            }
+
+            expect(error.message).toBe(`Superado el tiempo máximo entre entrada y salida`);
+        });
+        
+        describe('direction errors', () => {
+            let date = Date.vnNew();
+            date.setDate(date.getDate() - 1);
+            let error;
+            it('should throw an error when trying "in" direction twice', async() => {
+                const tx = await models.WorkerTimeControl.beginTransaction({});
+                const options = {transaction: tx};
+
                 date.setHours(8, 0, 0);
                 ctx.args = {timed: date, direction: 'in'};
                 await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
@@ -278,21 +294,13 @@ describe('workerTimeControl add/delete timeEntry()', () => {
             });
 
             it('should throw an error when trying "in" direction after insert "in" and "middle"', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-                activeCtx.accessToken.userId = salesBossId;
-                const workerId = hankPymId;
-
-                let date = Date.vnNew();
-                date.setDate(date.getDate() - 21);
-                date = weekDay(date, monday);
-                let error;
-
                 const tx = await models.WorkerTimeControl.beginTransaction({});
                 const options = {transaction: tx};
 
                 date.setHours(8, 0, 0);
                 ctx.args = {timed: date, direction: 'in'};
                 await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
+
                 date.setHours(9, 0, 0);
                 ctx.args = {timed: date, direction: 'middle'};
                 await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
@@ -312,15 +320,6 @@ describe('workerTimeControl add/delete timeEntry()', () => {
             });
 
             it('Should throw an error when trying "out" before closing a "middle" couple', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-                activeCtx.accessToken.userId = salesBossId;
-                const workerId = hankPymId;
-
-                let date = Date.vnNew();
-                date.setDate(date.getDate() - 21);
-                date = weekDay(date, monday);
-                let error;
-
                 const tx = await models.WorkerTimeControl.beginTransaction({});
                 const options = {transaction: tx};
 
@@ -346,15 +345,6 @@ describe('workerTimeControl add/delete timeEntry()', () => {
             });
 
             it('should throw an error when trying "middle" after "out"', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-                activeCtx.accessToken.userId = salesBossId;
-                const workerId = hankPymId;
-
-                let date = Date.vnNew();
-                date.setDate(date.getDate() - 21);
-                date = weekDay(date, monday);
-                let error;
-
                 const tx = await models.WorkerTimeControl.beginTransaction({});
                 const options = {transaction: tx};
 
@@ -380,15 +370,6 @@ describe('workerTimeControl add/delete timeEntry()', () => {
             });
 
             it('should throw an error when trying "out" direction twice', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-                activeCtx.accessToken.userId = salesBossId;
-                const workerId = hankPymId;
-
-                let date = Date.vnNew();
-                date.setDate(date.getDate() - 21);
-                date = weekDay(date, monday);
-                let error;
-
                 const tx = await models.WorkerTimeControl.beginTransaction({});
                 const options = {transaction: tx};
 
@@ -415,14 +396,12 @@ describe('workerTimeControl add/delete timeEntry()', () => {
         });
 
         describe('12h rest', () => {
-            it('should throw an error when the 12h rest is not fulfilled yet', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-
             activeCtx.accessToken.userId = salesBossId;
             const workerId = hankPymId;
+            it('should throw an error when the 12h rest is not fulfilled yet', async() => {
 
                 let date = Date.vnNew();
-                date.setDate(date.getDate() - 21);
+                date.setDate(date.getDate() - 2);
                 date = weekDay(date, monday);
                 let error;
 
@@ -448,16 +427,12 @@ describe('workerTimeControl add/delete timeEntry()', () => {
                     error = e;
                 }
 
-                expect(error.message).toBe(`Descanso diario 12h.`);
+                expect(error.message).toBe(`Descanso diario`);
             });
 
             it('should not fail as the 12h rest is fulfilled', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-                activeCtx.accessToken.userId = salesBossId;
-                const workerId = hankPymId;
-
                 let date = Date.vnNew();
-                date.setDate(date.getDate() - 21);
+                date.setDate(date.getDate() - 2);
                 date = weekDay(date, monday);
                 let error;
 
@@ -488,13 +463,12 @@ describe('workerTimeControl add/delete timeEntry()', () => {
         });
 
         describe('for 3500kg drivers with enforced 9h rest', () => {
-            it('should throw an error when the 9h enforced rest is not fulfilled', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
             activeCtx.accessToken.userId = salesBossId;
             const workerId = jessicaJonesId;
+            it('should throw an error when the 9h enforced rest is not fulfilled', async() => {
 
                 let date = Date.vnNew();
-                date.setDate(date.getDate() - 21);
+                date.setDate(date.getDate() - 2);
                 date = weekDay(date, monday);
                 let error;
 
@@ -520,16 +494,13 @@ describe('workerTimeControl add/delete timeEntry()', () => {
                     error = e;
                 }
 
-                expect(error.message).toBe(`Descanso diario 9h.`);
+                expect(error.message).toBe(`Descanso diario`);
             });
 
             it('should not fail when the 9h enforced rest is fulfilled', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-                activeCtx.accessToken.userId = salesBossId;
-                const workerId = jessicaJonesId;
                 
                 let date = Date.vnNew();
-                date.setDate(date.getDate() - 21);
+                date.setDate(date.getDate() - 2);
                 date = weekDay(date, monday);
                 let error;
 
@@ -559,83 +530,11 @@ describe('workerTimeControl add/delete timeEntry()', () => {
             });
         });
 
-        describe('for 36h weekly rest', () => {
-            it('should throw an error when the 36h weekly rest is not fulfilled', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-                activeCtx.accessToken.userId = salesBossId;
-                const workerId = hankPymId;
-
-                let date = Date.vnNew();
-                date.setMonth(date.getMonth() - 2);
-                date.setDate(1);
-                let error;
-
-                const tx = await models.WorkerTimeControl.beginTransaction({});
-                const options = {transaction: tx};
-
-                await populateWeek(date, monday, sunday, ctx, workerId, options);
-                date = nextWeek(date);
-                await populateWeek(date, monday, thursday, ctx, workerId, options);
-                date = weekDay(date, friday);
-                date.setHours(7, 59, 0);
-                ctx.args = {timed: date, direction: 'in'};
-                await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
-
-                try {
-                    date.setHours(8, 1, 0);
-                    ctx.args = {timed: date, direction: 'out'};
-                    await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
-
-                    await tx.rollback();
-                } catch (e) {
-                    await tx.rollback();
-                    error = e;
-                }
-
-                expect(error.message).toBe(`Descanso semanal 36h. / 72h.`);
-            });
-
-            it('should throw an error when the 36h weekly rest is not fulfilled again', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-                activeCtx.accessToken.userId = salesBossId;
-                const workerId = hankPymId;
-
-                let date = Date.vnNew();
-                date.setMonth(date.getMonth() - 2);
-                date.setDate(1);
-                let error;
-
-                const tx = await models.WorkerTimeControl.beginTransaction({});
-                const options = {transaction: tx};
-
-                await populateWeek(date, monday, sunday, ctx, workerId, options);
-                date = nextWeek(date);
-                await populateWeek(date, monday, thursday, ctx, workerId, options);
-
-                try {
-                    date = weekDay(date, saturday);
-                    date.setHours(3, 59, 0);
-                    ctx.args = {timed: date, direction: 'in'};
-                    await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
-
-                    await tx.rollback();
-                } catch (e) {
-                    await tx.rollback();
-                    error = e;
-                }
-
-                expect(error.message).toBe(`Descanso semanal 36h. / 72h.`);
-            });
-        });
-
         describe('for 72h weekly rest', () => {
-            it('should throw when the 72h weekly rest is not fulfilled yet', async() => {
-                pending('https://redmine.verdnatura.es/issues/4707');
-                activeCtx.accessToken.userId = salesBossId;
-                const workerId = hankPymId;
             
+            it('should throw an error when work 11 consecutive days', async() => {
                 let date = Date.vnNew();
-                date.setMonth(date.getMonth() - 2);
+                date.setMonth(date.getMonth() - 1);
                 date.setDate(1);
                 let error;
 
@@ -645,32 +544,290 @@ describe('workerTimeControl add/delete timeEntry()', () => {
                 await populateWeek(date, monday, sunday, ctx, workerId, options);
                 date = nextWeek(date);
                 await populateWeek(date, monday, thursday, ctx, workerId, options);
+                try {
+                    date = weekDay(date, friday);
+                    date.setHours(10, 0, 1);
+                    ctx.args = {timed: date, direction: 'in'};
+                    await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
+                    await tx.rollback();
+                } catch (e) {
+                    await tx.rollback();
+                    error = e;
+                }
+
+                expect(error.message).toBe(`Descanso semanal`);
+            });
+
+            it('should throw an error when the 72h weekly rest is not fulfilled', async() => {
+
+                let date = Date.vnNew();
+                date.setMonth(date.getMonth() - 1);
+                date.setDate(1);
+                let error;
+
+                const tx = await models.WorkerTimeControl.beginTransaction({});
+                const options = {transaction: tx};
+
+                await populateWeek(date, monday, sunday, ctx, workerId, options);
                 date = nextWeek(date);
-                await populateWeek(date, monday, friday, ctx, workerId, options);
+                await populateWeek(date, monday, thursday, ctx, workerId, options);
-                date = nextWeek(date);
-                await populateWeek(date, monday, saturday, ctx, workerId, options);
-                date = nextWeek(date);
-                await populateWeek(date, monday, saturday, ctx, workerId, options);
-                date = lastWeek(date);
 
                 try {
                     date = weekDay(date, sunday);
-                    date.setHours(8, 0, 0);
+                    date.setHours(17, 59, 0);
                     ctx.args = {timed: date, direction: 'in'};
                     await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
-
                     await tx.rollback();
                 } catch (e) {
                     await tx.rollback();
                     error = e;
                 }
 
-                expect(error.message).toBe(`Descanso semanal 36h. / 72h.`);
+                expect(error.message).toBe(`Descanso semanal`);
+            });
+            
+            it('should throw an error when the 72h weekly rest is fulfilled', async() => {
+
+                let date = Date.vnNew();
+                date.setMonth(date.getMonth() - 1);
+                date.setDate(1);
+                let error;
+
+                const tx = await models.WorkerTimeControl.beginTransaction({});
+                const options = {transaction: tx};
+
+                await populateWeek(date, monday, sunday, ctx, workerId, options);
+                date = nextWeek(date);
+                await populateWeek(date, monday, thursday, ctx, workerId, options);
+
+                try {
+                    date = weekDay(date, sunday);
+                    date.setHours(18, 00, 0);
+                    ctx.args = {timed: date, direction: 'in'};
+                    await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
+                    await tx.rollback();
+                } catch (e) {
+                    await tx.rollback();
+                    error = e;
+                }
+
+                expect(error).not.toBeDefined;
+            });
+        });
+        
+        describe('WorkerTimeControl_calculate calls', () => {
+            let dated = Date.vnNew();
+            dated.setDate(dated.getDate() - 7);
+            dated = new Date(weekDay(dated, monday));
+            const end = new Date(dated);
+            end.setDate(end.getDate() + 1);
+
+            it(`should return today's worked 8 hours without break`, async() => {
+                const tx = await models.WorkerTimeControl.beginTransaction({});
+                const options = {transaction: tx};
+
+                try {
+                    await populateWeek(dated, monday, monday, ctx, hankPymId, options);
+                    const start = new Date(dated - 1);
+                    start.setHours(0, 0, 0);
+                    await models.WorkerTimeControl.rawSql('CALL vn.timeControl_calculateByUser(?, ?, ?)', [
+                        hankPymId,
+                        start,
+                        end
+                    ], options);
+
+                    let [timeControlCalculateTable] = await models.WorkerTimeControl.rawSql('SELECT * FROM tmp.timeControlCalculate', null, options);
+
+                    expect(timeControlCalculateTable.timeWorkSeconds).toEqual(28800);
+                    await tx.rollback();
+                } catch (e) {
+                    await tx.rollback();
+                    throw e;
+                }
+            });
+
+            it(`should return today's worked hours with 15min break and work time consecutive less than 5h`, async() => {
+                const tx = await models.WorkerTimeControl.beginTransaction({});
+                const options = {transaction: tx};
+
+                try {
+                    await populateWeek(dated, monday, monday, ctx, hankPymId, options);
+                    dated.setHours(14, 59, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+                    dated.setHours(15, 14, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+
+                    const start = new Date(dated - 1);
+                    start.setHours(0, 0, 0);
+                    await models.WorkerTimeControl.rawSql('CALL vn.timeControl_calculateByUser(?, ?, ?)', [
+                        hankPymId,
+                        start,
+                        end
+                    ], options);
+
+                    let [timeControlCalculateTable] = await models.WorkerTimeControl.rawSql('SELECT * FROM tmp.timeControlCalculate', null, options);
+
+                    expect(timeControlCalculateTable.timeWorkSeconds).toEqual(28800);
+                    await tx.rollback();
+                } catch (e) {
+                    await tx.rollback();
+                    throw e;
+                }
+            });
+
+            it(`should return today's worked hours with 15min break and work time consecutive greater than 5h`, async() => {
+                const tx = await models.WorkerTimeControl.beginTransaction({});
+                const options = {transaction: tx};
+
+                try {
+                    await populateWeek(dated, monday, monday, ctx, hankPymId, options);
+                    dated.setHours(15, 0, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+                    dated.setHours(15, 15, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+
+                    const start = new Date(dated - 1);
+                    start.setHours(0, 0, 0);
+                    await models.WorkerTimeControl.rawSql('CALL vn.timeControl_calculateByUser(?, ?, ?)', [
+                        hankPymId,
+                        start,
+                        end
+                    ], options);
+
+                    let [timeControlCalculateTable] = await models.WorkerTimeControl.rawSql('SELECT * FROM tmp.timeControlCalculate', null, options);
+
+                    expect(timeControlCalculateTable.timeWorkSeconds).toEqual(28800);
+                    await tx.rollback();
+                } catch (e) {
+                    await tx.rollback();
+                    throw e;
+                }
+            });
+
+            it(`should return today's worked hours with 25min break and work time consecutive less than 5h`, async() => {
+                const tx = await models.WorkerTimeControl.beginTransaction({});
+                const options = {transaction: tx};
+
+                try {
+                    await populateWeek(dated, monday, monday, ctx, hankPymId, options);
+                    dated.setHours(14, 59, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+                    dated.setHours(15, 24, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+
+                    const start = new Date(dated - 1);
+                    start.setHours(0, 0, 0);
+                    await models.WorkerTimeControl.rawSql('CALL vn.timeControl_calculateByUser(?, ?, ?)', [
+                        hankPymId,
+                        start,
+                        end
+                    ], options);
+
+                    let [timeControlCalculateTable] = await models.WorkerTimeControl.rawSql('SELECT * FROM tmp.timeControlCalculate', null, options);
+
+                    expect(timeControlCalculateTable.timeWorkSeconds).toEqual(28500);
+                    await tx.rollback();
+                } catch (e) {
+                    await tx.rollback();
+                    throw e;
+                }
+            });
+
+            it(`should return today's worked hours with 25min break and work time consecutive greater than 5h`, async() => {
+                const tx = await models.WorkerTimeControl.beginTransaction({});
+                const options = {transaction: tx};
+
+                try {
+                    await populateWeek(dated, monday, monday, ctx, hankPymId, options);
+                    dated.setHours(15, 0, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+                    dated.setHours(15, 25, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+
+                    const start = new Date(dated - 1);
+                    start.setHours(0, 0, 0);
+                    await models.WorkerTimeControl.rawSql('CALL vn.timeControl_calculateByUser(?, ?, ?)', [
+                        hankPymId,
+                        start,
+                        end
+                    ], options);
+
+                    let [timeControlCalculateTable] = await models.WorkerTimeControl.rawSql('SELECT * FROM tmp.timeControlCalculate', null, options);
+
+                    expect(timeControlCalculateTable.timeWorkSeconds).toEqual(28500);
+                    await tx.rollback();
+                } catch (e) {
+                    await tx.rollback();
+                    throw e;
+                }
+            });
+
+            it(`should return today's worked hours with 60min break and work time consecutive less than 5h`, async() => {
+                const tx = await models.WorkerTimeControl.beginTransaction({});
+                const options = {transaction: tx};
+
+                try {
+                    await populateWeek(dated, monday, monday, ctx, hankPymId, options);
+                    dated.setHours(14, 59, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+                    dated.setHours(15, 59, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+
+                    const start = new Date(dated - 1);
+                    start.setHours(0, 0, 0);
+                    await models.WorkerTimeControl.rawSql('CALL vn.timeControl_calculateByUser(?, ?, ?)', [
+                        hankPymId,
+                        start,
+                        end
+                    ], options);
+
+                    let [timeControlCalculateTable] = await models.WorkerTimeControl.rawSql('SELECT * FROM tmp.timeControlCalculate', null, options);
+
+                    expect(timeControlCalculateTable.timeWorkSeconds).toEqual(25200);
+                    await tx.rollback();
+                } catch (e) {
+                    await tx.rollback();
+                    throw e;
+                }
+            });
+
+            it(`should return today's worked hours with 60min break and work time consecutive greater than 5h`, async() => {
+                const tx = await models.WorkerTimeControl.beginTransaction({});
+                const options = {transaction: tx};
+
+                try {
+                    await populateWeek(dated, monday, monday, ctx, hankPymId, options);
+                    dated.setHours(15, 0, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+                    dated.setHours(16, 0, 0);
+                    await addTimeEntry(ctx, dated, 'middle', hankPymId, options);
+
+                    const start = new Date(dated - 1);
+                    start.setHours(0, 0, 0);
+                    await models.WorkerTimeControl.rawSql('CALL vn.timeControl_calculateByUser(?, ?, ?)', [
+                        hankPymId,
+                        start,
+                        end
+                    ], options);
+
+                    let [timeControlCalculateTable] = await models.WorkerTimeControl.rawSql('SELECT * FROM tmp.timeControlCalculate', null, options);
+
+                    expect(timeControlCalculateTable.timeWorkSeconds).toEqual(26400);
+                    await tx.rollback();
+                } catch (e) {
+                    await tx.rollback();
+                    throw e;
+                }
             });
         });
     });
 });
 
+async function addTimeEntry(ctx, dated, direction, userId, option) {
+    ctx.args = {timed: dated, direction};
+    await models.WorkerTimeControl.addTimeEntry(ctx, userId, option);
+}
+
 function weekDay(date, dayToSet) {
     const currentDay = date.getDay();
     const distance = dayToSet - currentDay;
@@ -704,10 +861,10 @@ async function populateWeek(date, dayStart, dayEnd, ctx, workerId, options) {
     dateEnd.setDate(dateStart.getDate() + dayEnd);
 
     for (let i = dayStart; i <= dayEnd; i++) {
-        dateStart.setHours(8, 0, 0);
+        dateStart.setHours(10, 0, 0);
         ctx.args = {timed: dateStart, direction: 'in'};
         await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
-        dateStart.setHours(16, 0, 0);
+        dateStart.setHours(18, 0, 0);
         ctx.args = {timed: dateStart, direction: 'out'};
         await models.WorkerTimeControl.addTimeEntry(ctx, workerId, options);
         dateStart.setDate(dateStart.getDate() + 1);

modules/worker/back/models/operator.json

@@ -33,6 +33,16 @@
             "type": "belongsTo",
             "model": "Sector",
             "foreignKey": "sectorFk"
+        },
+		"train": {
+            "type": "belongsTo",
+            "model": "Train",
+            "foreignKey": "trainFk"
+        },
+		"printer": {
+            "type": "belongsTo",
+            "model": "Printer",
+            "foreignKey": "labelerFk"
         }
     }
 }

modules/worker/front/index.js

@@ -20,4 +20,5 @@ import './dms/create';
 import './dms/edit';
 import './note/index';
 import './note/create';
+import './notifications';
 

modules/worker/front/notifications/index.html

@@ -0,0 +1,2 @@
+<vn-card>
+</vn-card>

modules/worker/front/notifications/index.js

@@ -0,0 +1,21 @@
+import ngModule from '../module';
+import Section from 'salix/components/section';
+
+class Controller extends Section {
+    constructor($element, $) {
+        super($element, $);
+    }
+
+    async $onInit() {
+        const url = await this.vnApp.getUrl(`worker/${this.$params.id}/notifications`);
+        window.open(url).focus();
+    }
+}
+
+ngModule.vnComponent('vnWorkerNotifications', {
+    template: require('./index.html'),
+    controller: Controller,
+    bindings: {
+        ticket: '<'
+    }
+});

modules/worker/front/routes.json

@@ -15,6 +15,7 @@
             {"state": "worker.card.timeControl", "icon": "access_time"},
             {"state": "worker.card.calendar", "icon": "icon-calendar"},
             {"state": "worker.card.pda", "icon": "phone_android"},
+            {"state": "worker.card.notifications", "icon": "notifications"},
             {"state": "worker.card.pbx", "icon": "icon-pbx"},
             {"state": "worker.card.dms.index", "icon": "cloud_upload"},
             {
@@ -112,6 +113,14 @@
             "params": {
                 "worker": "$ctrl.worker"
             }
+        }, {
+            "url": "/notifications",
+            "state": "worker.card.notifications",
+            "component": "vn-worker-notifications",
+            "description": "Notifications",
+            "params": {
+                "worker": "$ctrl.worker"
+            }
         }, {
             "url": "/time-control?timestamp",
             "state": "worker.card.timeControl",

modules/worker/front/time-control/index.js

@@ -111,10 +111,11 @@ class Controller extends Section {
             dayIndex.setDate(dayIndex.getDate() + 1);
         }
 
-        if (!this.weekTotalHours) this.fetchHours();
+        if (this.worker) {
-        if (this.worker)
+            this.fetchHours();
             this.getWeekData();
         }
+    }
 
     set weekTotalHours(totalHours) {
         this._weekTotalHours = this.formatHours(totalHours);

package-lock.json

@@ -1,12 +1,12 @@
 {
     "name": "salix-back",
-    "version": "23.46.01",
+    "version": "23.48.01",
     "lockfileVersion": 2,
     "requires": true,
     "packages": {
         "": {
             "name": "salix-back",
-            "version": "23.46.01",
+            "version": "23.48.01",
             "license": "GPL-3.0",
             "dependencies": {
                 "axios": "^1.2.2",

package.json

@@ -1,6 +1,6 @@
 {
     "name": "salix-back",
-    "version": "23.46.01",
+    "version": "23.48.01",
     "author": "Verdnatura Levante SL",
     "description": "Salix backend",
     "license": "GPL-3.0",

print/templates/reports/invoice-incoterms/sql/incoterms.sql

@@ -1,7 +1,7 @@
 SELECT  io.issued,
         c.socialName,
         c.street postalAddress,
-        IF (ios.taxAreaFk IS NOT NULL, CONCAT(cty.code, c.fi), c.fi) fi,
+        c.fi,
         io.clientFk,
         c.postcode,
         c.city,
@@ -50,7 +50,7 @@ SELECT  io.issued,
              ) sub2 ON TRUE
         JOIN vn.itemTaxCountry itc ON itc.countryFk = su.countryFk AND itc.itemFk = s.itemFk
         JOIN vn.taxClass tc ON tc.id = itc.taxClassFk
-        LEFT JOIN vn.invoiceOutSerial ios ON ios.code = io.serial AND ios.taxAreaFk = 'CEE'
+        JOIN vn.invoiceOutSerial ios ON ios.code = io.serial AND ios.taxAreaFk = 'WORLD'
         JOIN vn.country cty ON cty.id = c.countryFk
         JOIN vn.payMethod pm ON pm.id = c .payMethodFk
         JOIN vn.company co ON co.id=io.companyFk