Merge branch 'dev' into 4511-kkear-expedition.itemFk

.vscode/settings.json

@@ -2,13 +2,7 @@
 {
     // Carácter predeterminado de final de línea.
     "files.eol": "\n",
-    "editor.bracketPairColorization.enabled": true,
+    "editor.codeActionsOnSave": {
-    "editor.guides.bracketPairs": true,
+        "source.fixAll.eslint": true
-    "editor.formatOnSave": true,
+    }
-    "editor.defaultFormatter": "dbaeumer.vscode-eslint",
-    "editor.codeActionsOnSave": ["source.fixAll.eslint"],
-    "eslint.validate": [
-        "javascript",
-        "json"
-    ]
 }

back/methods/notification/clean.js

@@ -29,6 +29,9 @@ module.exports = Self => {
 
         try {
             const config = await models.NotificationConfig.findOne({}, myOptions);
+
+            if (!config.cleanDays) return;
+
             const cleanDate = new Date();
             cleanDate.setDate(cleanDate.getDate() - config.cleanDays);
 
@@ -36,11 +39,11 @@ module.exports = Self => {
                 where: {status: {inq: status}},
                 created: {lt: cleanDate}
             }, myOptions);
-
-            if (tx) await tx.commit();
         } catch (e) {
             if (tx) await tx.rollback();
             throw e;
         }
+
+        if (tx) await tx.commit();
     };
 };

back/methods/notification/send.js

@@ -1,5 +1,4 @@
 const {Email} = require('vn-print');
-const UserError = require('vn-loopback/util/user-error');
 
 module.exports = Self => {
     Self.remoteMethod('send', {
@@ -35,7 +34,10 @@ module.exports = Self => {
                                 include: {
                                     relation: 'user',
                                     scope: {
-                                        fields: ['name', 'email', 'lang']
+                                        fields: ['name', 'lang'],
+                                        include: {
+                                            relation: 'emailUser'
+                                        }
                                     }
                                 }
                             }
@@ -56,7 +58,7 @@ module.exports = Self => {
             for (const notificationUser of queue.notification().subscription()) {
                 try {
                     const sendParams = {
-                        recipient: notificationUser.user().email,
+                        recipient: notificationUser.user().emailUser().email,
                         lang: notificationUser.user().lang
                     };
 

db/changes/10503-november/00-aclInvoiceOut.sql

@@ -0,0 +1,7 @@
+INSERT INTO `salix`.`ACL` (`model`, `property`, `accessType`, `permission`, `principalType`, `principalId`)
+    VALUES
+        ('InvoiceOut', 'clientsToInvoice', 'WRITE', 'ALLOW', 'ROLE', 'invoicing');
+
+INSERT INTO `salix`.`ACL` (`model`, `property`, `accessType`, `permission`, `principalType`, `principalId`)
+    VALUES
+        ('InvoiceOut', 'invoiceClient', 'WRITE', 'ALLOW', 'ROLE', 'invoicing');        

db/changes/10503-november/00-collection_missingTrash.sql

@@ -0,0 +1 @@
+DROP PROCEDURE IF EXISTS `vn`.`collection_missingTrash`;

db/changes/10503-november/00-deleteInvoiceOutQueue.sql

@@ -0,0 +1 @@
+DROP TABLE `vn`.`invoiceOutQueue`;

db/changes/10503-november/00-editTrackedACL.sql

@@ -0,0 +1,4 @@
+INSERT INTO `salix`.`ACL` (`model`, `property`, `accessType`, `permission`, `principalType`, `principalId`)
+    VALUES
+        ('Sale', 'editTracked', 'WRITE', 'ALLOW', 'ROLE', 'production'),
+        ('Sale', 'editFloramondo', 'WRITE', 'ALLOW', 'ROLE', 'salesAssistant');

db/changes/10503-november/00-greuge.userFK_userFk.sql

@@ -0,0 +1 @@
+ALTER TABLE `vn`.`greuge` CHANGE `userFK` `userFk` int(10) unsigned DEFAULT NULL NULL;

db/changes/10503-november/00-ticket_canMerge.sql

@@ -0,0 +1,14 @@
+DROP PROCEDURE IF EXISTS `vn`.`ticket_canMerge`;
+
+DELIMITER $$
+$$
+CREATE DEFINER=`root`@`localhost` PROCEDURE `vn`.`ticket_canMerge`(vDated DATE, vScopeDays INT, vLitersMax INT, vLinesMax INT, vWarehouseFk INT)
+BEGIN
+ CALL vn.ticket_canbePostponed(vDated,TIMESTAMPADD(DAY, vScopeDays, vDated),vLitersMax,vLinesMax,vWarehouseFk);
+END  $$
+DELIMITER ;
+
+INSERT INTO `salix`.`ACL` (model, property, accessType, permission, principalType, principalId)
+VALUES
+    ('Ticket', 'getTicketsFuture', 'READ', 'ALLOW', 'ROLE', 'employee'),
+    ('Ticket', 'merge', 'WRITE', 'ALLOW', 'ROLE', 'employee');

db/changes/10503-november/00-ticket_canbePostponed.sql

@@ -0,0 +1,79 @@
+DROP PROCEDURE IF EXISTS `vn`.`ticket_canbePostponed`;
+
+DELIMITER $$
+$$
+CREATE DEFINER=`root`@`localhost` PROCEDURE `vn`.`ticket_canbePostponed`(vOriginDated DATE, vFutureDated DATE, vLitersMax INT, vLinesMax INT, vWarehouseFk INT)
+BEGIN
+/**
+ * Devuelve un listado de tickets susceptibles de fusionarse con otros tickets en el futuro
+ *
+ * @param vOriginDated Fecha en cuestión
+ * @param vFutureDated Fecha en el futuro a sondear
+ * @param vLitersMax Volumen máximo de los tickets a catapultar
+ * @param vLinesMax Número máximo de lineas de los tickets a catapultar
+ * @param vWarehouseFk Identificador de vn.warehouse
+ */
+	DROP TEMPORARY TABLE IF EXISTS tmp.filter;
+	CREATE TEMPORARY TABLE tmp.filter
+        (INDEX (id))
+	SELECT 	sv.ticketFk id,
+			GROUP_CONCAT(DISTINCT i.itemPackingTypeFk ORDER BY i.itemPackingTypeFk) ipt,
+			CAST(sum(litros) AS DECIMAL(10,0)) liters,
+			CAST(count(*) AS DECIMAL(10,0)) `lines`,
+			st.name state,
+			sub2.id ticketFuture,
+			t.landed originETD,
+			sub2.landed destETD,
+			sub2.iptd tfIpt,
+			sub2.state tfState,
+			t.clientFk,
+			t.warehouseFk,
+			ts.alertLevel,
+			t.shipped,
+			sub2.shipped tfShipped,
+			t.workerFk,
+			st.code code,
+			sub2.code tfCode
+		FROM vn.saleVolume sv
+			JOIN vn.sale s ON s.id = sv.saleFk
+			JOIN vn.item i ON i.id = s.itemFk
+			JOIN vn.ticket t ON t.id = sv.ticketFk
+			JOIN vn.address a ON a.id = t.addressFk
+			JOIN vn.province p ON p.id = a.provinceFk
+			JOIN vn.country c ON c.id = p.countryFk
+			JOIN vn.ticketState ts ON ts.ticketFk = t.id
+			JOIN vn.state st ON st.id = ts.stateFk
+			JOIN vn.alertLevel al ON al.id = ts.alertLevel
+			LEFT JOIN vn.ticketParking tp ON tp.ticketFk = t.id
+			LEFT JOIN (
+				SELECT *
+					FROM (
+						SELECT
+							t.addressFk ,
+							t.id,
+							t.landed,
+							t.shipped,
+							st.name state,
+							st.code code,
+							GROUP_CONCAT(DISTINCT i.itemPackingTypeFk ORDER BY i.itemPackingTypeFk) iptd
+							FROM vn.ticket t
+								JOIN vn.ticketState ts ON ts.ticketFk = t.id
+								JOIN vn.state st ON st.id = ts.stateFk
+								JOIN vn.sale s ON s.ticketFk = t.id
+								JOIN vn.item i ON i.id = s.itemFk
+							WHERE t.shipped BETWEEN vFutureDated
+											AND util.dayend(vFutureDated)
+								AND t.warehouseFk = vWarehouseFk
+							GROUP BY t.id
+					) sub
+					GROUP BY sub.addressFk
+				) sub2 ON sub2.addressFk = t.addressFk AND t.id != sub2.id
+		WHERE t.shipped BETWEEN vOriginDated AND util.dayend(vOriginDated)
+			AND t.warehouseFk = vWarehouseFk
+			AND al.code = 'FREE'
+			AND tp.ticketFk IS NULL
+		GROUP BY sv.ticketFk
+		HAVING liters <= IFNULL(vLitersMax, 9999) AND `lines` <= IFNULL(vLinesMax, 9999) AND ticketFuture;
+END$$
+DELIMITER ;
+

db/changes/10503-november/00-timeBusiness_calculate.sql

@@ -0,0 +1,88 @@
+DROP PROCEDURE IF EXISTS `vn`.`timeBusiness_calculate`;
+
+DELIMITER $$
+$$
+CREATE DEFINER=`root`@`localhost` PROCEDURE `vn`.`timeBusiness_calculate`(vDatedFrom DATETIME, vDatedTo DATETIME)
+BEGIN
+/**
+ * Horas que debe trabajar un empleado según contrato y día.
+ * @param vDatedFrom workerTimeControl
+ * @param vDatedTo workerTimeControl
+ * @table tmp.user(userFk)
+ * @return tmp.timeBusinessCalculate
+ */
+	DROP TEMPORARY TABLE IF EXISTS tmp.timeBusinessCalculate;
+	CREATE TEMPORARY TABLE tmp.timeBusinessCalculate
+			(INDEX (departmentFk))
+		SELECT dated,
+				businessFk,
+				userFk,
+				departmentFk,
+				hourStart,
+				hourEnd,
+				timeTable,
+				timeWorkSeconds,
+				SEC_TO_TIME(timeWorkSeconds) timeWorkSexagesimal,
+				timeWorkSeconds / 3600 timeWorkDecimal,
+				timeWorkSeconds timeBusinessSeconds,
+				SEC_TO_TIME(timeWorkSeconds) timeBusinessSexagesimal,
+				timeWorkSeconds / 3600 timeBusinessDecimal,
+				name type,
+				permissionRate,
+				hoursWeek,
+				discountRate,
+				isAllowedToWork
+			FROM(SELECT t.dated,
+						b.id businessFk,
+						w.userFk,
+						b.departmentFk,
+						IF(j.start = NULL, NULL, GROUP_CONCAT(DISTINCT LEFT(j.start,5) ORDER BY j.start ASC SEPARATOR ' - ')) hourStart ,
+						IF(j.start = NULL, NULL, GROUP_CONCAT(DISTINCT LEFT(j.end,5) ORDER BY j.end ASC SEPARATOR ' - ')) hourEnd,
+						IF(j.start = NULL, NULL, GROUP_CONCAT(DISTINCT LEFT(j.start,5), " - ",  LEFT(j.end,5) ORDER BY j.end ASC SEPARATOR ' - ')) timeTable,
+						IF(j.start = NULL, 0, IFNULL(SUM(TIME_TO_SEC(j.end)) - SUM(TIME_TO_SEC(j.start)), 0)) timeWorkSeconds,
+						at2.name,
+						at2.permissionRate,
+						at2.discountRate,
+						cl.hours_week hoursWeek,
+						at2.isAllowedToWork
+					FROM time t
+						LEFT JOIN business b ON t.dated BETWEEN b.started AND IFNULL(b.ended, vDatedTo)
+						LEFT JOIN worker w ON w.id = b.workerFk
+						JOIN tmp.`user` u ON u.userFK = w.userFK
+						LEFT JOIN workCenter wc ON wc.id = b.workcenterFK
+						LEFT JOIN postgresql.calendar_labour_type cl ON cl.calendar_labour_type_id = b.calendarTypeFk
+						LEFT JOIN postgresql.journey j ON j.business_id = b.id AND j.day_id = WEEKDAY(t.dated) + 1
+						LEFT JOIN postgresql.calendar_employee ce ON ce.businessFk = b.id AND ce.date = t.dated
+						LEFT JOIN absenceType at2 ON at2.id = ce.calendar_state_id
+					WHERE t.dated BETWEEN vDatedFrom AND vDatedTo
+					GROUP BY w.userFk, t.dated
+				)sub;
+
+	UPDATE tmp.timeBusinessCalculate t
+		LEFT JOIN  postgresql.journey j ON j.business_id = t.businessFk
+		SET t.timeWorkSeconds = t.hoursWeek / 5 * 3600,
+			t.timeWorkSexagesimal = SEC_TO_TIME( t.hoursWeek / 5 * 3600),
+			t.timeWorkDecimal =  t.hoursWeek / 5,
+			t.timeBusinessSeconds = t.hoursWeek / 5 * 3600,
+			t.timeBusinessSexagesimal = SEC_TO_TIME( t.hoursWeek / 5 * 3600),
+			t.timeBusinessDecimal = t.hoursWeek / 5
+		WHERE DAYOFWEEK(t.dated) IN(2,3,4,5,6) AND j.journey_id IS NULL  ;
+
+	UPDATE tmp.timeBusinessCalculate t
+		SET t.timeWorkSeconds = t.timeWorkSeconds - (t.timeWorkSeconds * permissionRate)  ,
+			t.timeWorkSexagesimal = SEC_TO_TIME ((t.timeWorkDecimal - (t.timeWorkDecimal * permissionRate)) * 3600),
+			t.timeWorkDecimal = t.timeWorkDecimal - (t.timeWorkDecimal * permissionRate)
+		WHERE permissionRate <> 0;
+
+	UPDATE tmp.timeBusinessCalculate t
+			JOIN calendarHolidays ch ON ch.dated = t.dated
+			JOIN business b ON b.id = t.businessFk
+				AND b.workcenterFk = ch.workcenterFk
+		SET t.timeWorkSeconds = 0,
+			t.timeWorkSexagesimal = 0,
+			t.timeWorkDecimal = 0,
+			t.permissionrate = 1,
+			t.type = 'Festivo'
+		WHERE t.type IS NULL;
+END$$
+DELIMITER ;

db/dump/fixtures.sql

@@ -686,7 +686,10 @@ INSERT INTO `vn`.`ticket`(`id`, `priority`, `agencyModeFk`,`warehouseFk`,`routeF
         (24 ,NULL,  8,  1, 7,       util.VN_CURDATE(),                              util.VN_CURDATE(),                                                        1101, 'Bruce Wayne',                                   1,   NULL,       0, 5,      5, 1, util.VN_CURDATE()),
         (25 ,NULL,  8,  1, NULL,    util.VN_CURDATE(),                              util.VN_CURDATE(),                                                        1101, 'Bruce Wayne',                                   1,   NULL,       0, 1,      5, 1, util.VN_CURDATE()),
         (26 ,NULL,  8,  1, NULL,    util.VN_CURDATE(),                              util.VN_CURDATE(),                                                        1101, 'An incredibly long alias for testing purposes', 1,   NULL,       0, 1,      5, 1, util.VN_CURDATE()),
-        (27 ,NULL,  8,  1, NULL,    util.VN_CURDATE(),                              util.VN_CURDATE(),                                                        1101, 'Wolverine',                                     1,   NULL,       0, 1,      5, 1, util.VN_CURDATE());
+        (27 ,NULL,  8,  1, NULL,    util.VN_CURDATE(),                              util.VN_CURDATE(),                                                        1101, 'Wolverine',                                     1,   NULL,       0, 1,      5, 1, util.VN_CURDATE()),
+        (28, 1,     8,  1, 1,       util.VN_CURDATE(),                              DATE_ADD(util.VN_CURDATE(), INTERVAL + 1 DAY),                            1103, 'Phone Box',                                     123, NULL,       0, 1,      5, 1, util.VN_CURDATE()),
+        (29, 1,     8,  1, 1,       util.VN_CURDATE(),                              DATE_ADD(util.VN_CURDATE(), INTERVAL + 1 DAY),                            1103, 'Phone Box',                                     123, NULL,       0, 1,      5, 1, util.VN_CURDATE()),
+        (30, 1,     8,  1, 1,       util.VN_CURDATE(),                              DATE_ADD(util.VN_CURDATE(), INTERVAL + 1 DAY),                            1103, 'Phone Box',                                     123, NULL,       0, 1,      5, 1, util.VN_CURDATE());
 
 INSERT INTO `vn`.`ticketObservation`(`id`, `ticketFk`, `observationTypeFk`, `description`)
     VALUES
@@ -984,7 +987,10 @@ INSERT INTO `vn`.`sale`(`id`, `itemFk`, `ticketFk`, `concept`, `quantity`, `pric
         (30, 4, 18, 'Melee weapon heavy shield 1x0.5m', 20, 1.72,   0, 0, 0, util.VN_CURDATE()),
         (31, 2, 23, 'Melee weapon combat fist 15cm',    -5, 7.08,   0, 0, 0, util.VN_CURDATE()),
         (32, 1, 24, 'Ranged weapon longbow 2m',         -1, 8.07,   0, 0, 0, util.VN_CURDATE()),
-        (33, 5, 14, 'Ranged weapon pistol 9mm',          50, 1.79,   0, 0, 0, util.VN_CURDATE());
+        (33, 5, 14, 'Ranged weapon pistol 9mm',         50, 1.79,   0, 0, 0, util.VN_CURDATE()),
+        (34, 4, 28, 'Melee weapon heavy shield 1x0.5m', 20, 1.72,   0, 0, 0, util.VN_CURDATE()),
+        (35, 4, 29, 'Melee weapon heavy shield 1x0.5m', 20, 1.72,   0, 0, 0, util.VN_CURDATE()),
+        (36, 4, 30, 'Melee weapon heavy shield 1x0.5m', 20, 1.72,   0, 0, 0, util.VN_CURDATE());
 
 INSERT INTO `vn`.`saleChecked`(`saleFk`, `isChecked`)
     VALUES
@@ -1149,7 +1155,8 @@ INSERT INTO `vn`.`saleTracking`(`saleFk`, `isChecked`, `created`, `originalQuant
         (1,     0,  util.VN_CURDATE(), 5,  55, 3, 1, 14),
         (1,     1,  util.VN_CURDATE(), 5,  54, 3, 2, 8),
         (2,     1,  util.VN_CURDATE(), 10, 40, 4, 3, 8),
-        (3, 1, util.VN_CURDATE(), 2,  40, 4, 4, 8);
+        (3,     1,  util.VN_CURDATE(), 2,  40, 4, 4, 8),
+        (31,    1,  util.VN_CURDATE(), -5,  40, 4, 5, 8);
 
 INSERT INTO `vn`.`itemBarcode`(`id`, `itemFk`, `code`)
     VALUES
@@ -1356,7 +1363,8 @@ INSERT INTO `vn`.`ticketWeekly`(`ticketFk`, `weekDay`)
         (2, 1),
         (3, 2),
         (4, 4),
-        (5, 6);
+        (5, 6),
+        (15, 6);
 
 INSERT INTO `vn`.`travel`(`id`,`shipped`, `landed`, `warehouseInFk`, `warehouseOutFk`, `agencyModeFk`, `m3`, `kg`,`ref`, `totalEntries`, `cargoSupplierFk`)
     VALUES
@@ -2712,6 +2720,10 @@ INSERT INTO `vn`.`ticketCollection` (`ticketFk`, `collectionFk`, `created`, `lev
     VALUES
         (9, 3, util.VN_NOW(), NULL, 0, NULL, NULL, NULL, NULL);
 
+INSERT INTO `vn`.`saleCloned` (`saleClonedFk`, `saleOriginalFk`)
+    VALUES
+        (29, 25);
+
 UPDATE `account`.`user`
     SET `hasGrant` = 1
         WHERE `id` = 66;

e2e/helpers/selectors.js

@@ -727,6 +727,34 @@ export default {
         saveImport: 'button[response="accept"]',
         anyDocument: 'vn-ticket-dms-index > vn-data-viewer vn-tbody vn-tr'
     },
+    ticketFuture: {
+        openAdvancedSearchButton: 'vn-searchbar .append vn-icon[icon="arrow_drop_down"]',
+        originDated: 'vn-date-picker[label="Origin ETD"]',
+        futureDated: 'vn-date-picker[label="Destination ETD"]',
+        shipped: 'vn-date-picker[label="Origin date"]',
+        tfShipped: 'vn-date-picker[label="Destination date"]',
+        linesMax: 'vn-textfield[label="Max Lines"]',
+        litersMax: 'vn-textfield[label="Max Liters"]',
+        ipt: 'vn-autocomplete[label="Origin IPT"]',
+        tfIpt: 'vn-autocomplete[label="Destination IPT"]',
+        tableIpt: 'vn-autocomplete[name="ipt"]',
+        tableTfIpt: 'vn-autocomplete[name="tfIpt"]',
+        state: 'vn-autocomplete[label="Origin Grouped State"]',
+        tfState: 'vn-autocomplete[label="Destination Grouped State"]',
+        warehouseFk: 'vn-autocomplete[label="Warehouse"]',
+        problems: 'vn-check[label="With problems"]',
+        tableButtonSearch: 'vn-button[vn-tooltip="Search"]',
+        moveButton: 'vn-button[vn-tooltip="Future tickets"]',
+        acceptButton: '.vn-confirm.shown button[response="accept"]',
+        firstCheck: 'tbody > tr:nth-child(1) > td > vn-check',
+        multiCheck: 'vn-multi-check',
+        tableId: 'vn-textfield[name="id"]',
+        tableTfId: 'vn-textfield[name="ticketFuture"]',
+        tableLiters: 'vn-textfield[name="litersMax"]',
+        tableLines: 'vn-textfield[name="linesMax"]',
+        submit: 'vn-submit[label="Search"]',
+        table: 'tbody > tr:not(.empty-rows)'
+    },
     createStateView: {
         state: 'vn-autocomplete[ng-model="$ctrl.stateFk"]',
         worker: 'vn-autocomplete[ng-model="$ctrl.workerFk"]',
@@ -969,6 +997,7 @@ export default {
         manualInvoiceTaxArea: 'vn-autocomplete[ng-model="$ctrl.invoice.taxArea"]',
         saveInvoice: 'button[response="accept"]',
         globalInvoiceForm: '.vn-invoice-out-global-invoicing',
+        globalInvoiceClientsRange: 'vn-radio[val="clientsRange"]',
         globalInvoiceDate: '[ng-model="$ctrl.invoice.invoiceDate"]',
         globalInvoiceFromClient: '[ng-model="$ctrl.invoice.fromClientId"]',
         globalInvoiceToClient: '[ng-model="$ctrl.invoice.toClientId"]',

e2e/paths/04-item/08_regularize.spec.js

@@ -127,8 +127,8 @@ describe('Item regularize path', () => {
         await page.waitForState('ticket.index');
     });
 
-    it('should search for the ticket with id 28 once again', async() => {
+    it('should search for the ticket with id 31 once again', async() => {
-        await page.accessToSearchResult('28');
+        await page.accessToSearchResult('31');
         await page.waitForState('ticket.card.summary');
     });
 

e2e/paths/05-ticket/01-sale/02_edit_sale.spec.js

@@ -291,7 +291,7 @@ describe('Ticket Edit sale path', () => {
     it('should confirm the transfered quantity is the correct one', async() => {
         const result = await page.waitToGetProperty(selectors.ticketSales.secondSaleQuantityCell, 'innerText');
 
-        expect(result).toContain('10');
+        expect(result).toContain('20');
     });
 
     it('should go back to the original ticket sales section', async() => {

e2e/paths/05-ticket/06_basic_data_steps.spec.js

@@ -104,7 +104,6 @@ describe('Ticket Edit basic data path', () => {
 
         await page.waitToClick(selectors.ticketBasicData.nextStepButton);
 
-        await page.waitToClick(selectors.ticketBasicData.withoutNegatives);
         await page.waitToClick(selectors.ticketBasicData.finalizeButton);
 
         await page.waitForState('ticket.card.summary');

e2e/paths/05-ticket/09_weekly.spec.js

@@ -19,7 +19,7 @@ describe('Ticket descriptor path', () => {
     it('should count the amount of tickets in the turns section', async() => {
         const result = await page.countElement(selectors.ticketsIndex.weeklyTicket);
 
-        expect(result).toEqual(5);
+        expect(result).toEqual(6);
     });
 
     it('should go back to the ticket index then search and access a ticket summary', async() => {
@@ -104,7 +104,7 @@ describe('Ticket descriptor path', () => {
         await page.doSearch();
         const nResults = await page.countElement(selectors.ticketsIndex.searchWeeklyResult);
 
-        expect(nResults).toEqual(5);
+        expect(nResults).toEqual(6);
     });
 
     it('should update the agency then remove it afterwards', async() => {

e2e/paths/05-ticket/20_future.spec.js

@@ -0,0 +1,266 @@
+import selectors from '../../helpers/selectors.js';
+import getBrowser from '../../helpers/puppeteer';
+
+describe('Ticket Future path', () => {
+    let browser;
+    let page;
+
+    beforeAll(async () => {
+        browser = await getBrowser();
+        page = browser.page;
+        await page.loginAndModule('employee', 'ticket');
+        await page.accessToSection('ticket.future');
+    });
+
+    afterAll(async () => {
+        await browser.close();
+    });
+
+    const now = new Date();
+    const tomorrow = new Date(now.getDate() + 1);
+    const ticket = {
+        originDated: now,
+        futureDated: now,
+        linesMax: '9999',
+        litersMax: '9999',
+        warehouseFk: 'Warehouse One'
+    };
+
+    it('should show errors snackbar because of the required data', async () => {
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.clearInput(selectors.ticketFuture.warehouseFk);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        let message = await page.waitForSnackbar();
+        expect(message.text).toContain('warehouseFk is a required argument');
+
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.clearInput(selectors.ticketFuture.litersMax);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        message = await page.waitForSnackbar();
+        expect(message.text).toContain('litersMax is a required argument');
+
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.clearInput(selectors.ticketFuture.linesMax);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        message = await page.waitForSnackbar();
+        expect(message.text).toContain('linesMax is a required argument');
+
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.clearInput(selectors.ticketFuture.futureDated);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        message = await page.waitForSnackbar();
+        expect(message.text).toContain('futureDated is a required argument');
+
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.clearInput(selectors.ticketFuture.originDated);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        message = await page.waitForSnackbar();
+        expect(message.text).toContain('originDated is a required argument');
+    });
+
+    it('should search with the required data', async () => {
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+    });
+
+    it('should search with the origin shipped today', async () => {
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.pickDate(selectors.ticketFuture.shipped, now);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+    });
+
+    it('should search with the origin shipped tomorrow', async () => {
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.pickDate(selectors.ticketFuture.shipped, tomorrow);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 0);
+    });
+
+    it('should search with the destination shipped today', async () => {
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.clearInput(selectors.ticketFuture.shipped);
+        await page.pickDate(selectors.ticketFuture.tfShipped, now);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+    });
+
+    it('should search with the destination shipped tomorrow', async () => {
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.pickDate(selectors.ticketFuture.tfShipped, tomorrow);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 0);
+    });
+
+    it('should search with the origin IPT', async () => {
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+
+        await page.clearInput(selectors.ticketFuture.shipped);
+        await page.clearInput(selectors.ticketFuture.tfShipped);
+        await page.clearInput(selectors.ticketFuture.ipt);
+        await page.clearInput(selectors.ticketFuture.tfIpt);
+        await page.clearInput(selectors.ticketFuture.state);
+        await page.clearInput(selectors.ticketFuture.tfState);
+
+        await page.autocompleteSearch(selectors.ticketFuture.ipt, 'Horizontal');
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 0);
+    });
+
+    it('should search with the destination IPT', async () => {
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+
+        await page.clearInput(selectors.ticketFuture.shipped);
+        await page.clearInput(selectors.ticketFuture.tfShipped);
+        await page.clearInput(selectors.ticketFuture.ipt);
+        await page.clearInput(selectors.ticketFuture.tfIpt);
+        await page.clearInput(selectors.ticketFuture.state);
+        await page.clearInput(selectors.ticketFuture.tfState);
+
+        await page.autocompleteSearch(selectors.ticketFuture.tfIpt, 'Horizontal');
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 0);
+    });
+
+    it('should search with the origin grouped state', async () => {
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+
+        await page.clearInput(selectors.ticketFuture.shipped);
+        await page.clearInput(selectors.ticketFuture.tfShipped);
+        await page.clearInput(selectors.ticketFuture.ipt);
+        await page.clearInput(selectors.ticketFuture.tfIpt);
+        await page.clearInput(selectors.ticketFuture.state);
+        await page.clearInput(selectors.ticketFuture.tfState);
+
+        await page.autocompleteSearch(selectors.ticketFuture.state, 'Free');
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 3);
+    });
+
+    it('should search with the destination grouped state', async () => {
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+
+        await page.clearInput(selectors.ticketFuture.shipped);
+        await page.clearInput(selectors.ticketFuture.tfShipped);
+        await page.clearInput(selectors.ticketFuture.ipt);
+        await page.clearInput(selectors.ticketFuture.tfIpt);
+        await page.clearInput(selectors.ticketFuture.state);
+        await page.clearInput(selectors.ticketFuture.tfState);
+
+        await page.autocompleteSearch(selectors.ticketFuture.tfState, 'Free');
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 0);
+
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.clearInput(selectors.ticketFuture.shipped);
+        await page.clearInput(selectors.ticketFuture.tfShipped);
+        await page.clearInput(selectors.ticketFuture.ipt);
+        await page.clearInput(selectors.ticketFuture.tfIpt);
+        await page.clearInput(selectors.ticketFuture.state);
+        await page.clearInput(selectors.ticketFuture.tfState);
+
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+    });
+
+    it('should search in smart-table with an ID Origin', async () => {
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.write(selectors.ticketFuture.tableId, "13");
+        await page.keyboard.press("Enter");
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 2);
+
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+    });
+
+    it('should search in smart-table with an ID Destination', async () => {
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.write(selectors.ticketFuture.tableTfId, "12");
+        await page.keyboard.press("Enter");
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 5);
+
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+    });
+
+    it('should search in smart-table with an IPT Origin', async () => {
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.autocompleteSearch(selectors.ticketFuture.tableIpt, 'Vertical');
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 1);
+
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+    });
+
+    it('should search in smart-table with an IPT Destination', async () => {
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.autocompleteSearch(selectors.ticketFuture.tableTfIpt, 'Vertical');
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 1);
+
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+    });
+
+    it('should search in smart-table with especified Lines', async () => {
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.write(selectors.ticketFuture.tableLines, "0");
+        await page.keyboard.press("Enter");
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 1);
+
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.write(selectors.ticketFuture.tableLines, "1");
+        await page.keyboard.press("Enter");
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 5);
+
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+    });
+
+    it('should search in smart-table with especified Liters', async () => {
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.write(selectors.ticketFuture.tableLiters, "0");
+        await page.keyboard.press("Enter");
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 1);
+
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.write(selectors.ticketFuture.tableLiters, "28");
+        await page.keyboard.press("Enter");
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 5);
+
+        await page.waitToClick(selectors.ticketFuture.tableButtonSearch);
+        await page.waitToClick(selectors.ticketFuture.openAdvancedSearchButton);
+        await page.waitToClick(selectors.ticketFuture.submit);
+        await page.waitForNumberOfElements(selectors.ticketFuture.table, 4);
+    });
+
+    it('should check the three last tickets and move to the future', async () => {
+        await page.waitToClick(selectors.ticketFuture.multiCheck);
+        await page.waitToClick(selectors.ticketFuture.firstCheck);
+        await page.waitToClick(selectors.ticketFuture.moveButton);
+        await page.waitToClick(selectors.ticketFuture.acceptButton);
+        const message = await page.waitForSnackbar();
+        expect(message.text).toContain('Tickets moved successfully!');
+    });
+
+});

e2e/paths/09-invoice-out/04_globalInvoice.spec.js

@@ -33,6 +33,7 @@ describe('InvoiceOut global invoice path', () => {
 
     it('should create a global invoice for charles xavier today', async() => {
         await page.pickDate(selectors.invoiceOutIndex.globalInvoiceDate);
+        await page.waitToClick(selectors.invoiceOutIndex.globalInvoiceClientsRange);
         await page.autocompleteSearch(selectors.invoiceOutIndex.globalInvoiceFromClient, 'Petter Parker');
         await page.autocompleteSearch(selectors.invoiceOutIndex.globalInvoiceToClient, 'Petter Parker');
         await page.waitToClick(selectors.invoiceOutIndex.saveInvoice);
@@ -48,4 +49,15 @@ describe('InvoiceOut global invoice path', () => {
 
         expect(currentInvoices).toBeGreaterThan(invoicesBefore);
     });
+
+    it('should create a global invoice for all clients today', async() => {
+        await page.waitToClick(selectors.invoiceOutIndex.createInvoice);
+        await page.waitToClick(selectors.invoiceOutIndex.createGlobalInvoice);
+        await page.waitForSelector(selectors.invoiceOutIndex.globalInvoiceForm);
+        await page.pickDate(selectors.invoiceOutIndex.globalInvoiceDate);
+        await page.waitToClick(selectors.invoiceOutIndex.saveInvoice);
+        const message = await page.waitForSnackbar();
+
+        expect(message.text).toContain('Data saved!');
+    });
 });

loopback/locale/en.json

@@ -136,5 +136,7 @@
 	"Not enough privileges to edit a client": "Not enough privileges to edit a client",
     "Claim pickup order sent": "Claim pickup order sent [({{claimId}})]({{{claimUrl}}}) to client *{{clientName}}*",
 	"You don't have grant privilege": "You don't have grant privilege",
-	"You don't own the role and you can't assign it to another user": "You don't own the role and you can't assign it to another user"
+	"You don't own the role and you can't assign it to another user": "You don't own the role and you can't assign it to another user",
+	"Ticket merged": "Ticket [{{id}}]({{{fullPath}}}) ({{{originDated}}}) merged with [{{tfId}}]({{{fullPathFuture}}}) ({{{futureDated}}})",
+    "Sale(s) blocked, please contact production": "Sale(s) blocked, please contact production"
 }

loopback/locale/es.json

@@ -241,6 +241,7 @@
 	"Claim pickup order sent": "Reclamación Orden de recogida enviada [({{claimId}})]({{{claimUrl}}}) al cliente *{{clientName}}*",
 	"You don't have grant privilege": "No tienes privilegios para dar privilegios",
 	"You don't own the role and you can't assign it to another user": "No eres el propietario del rol y no puedes asignarlo a otro usuario",
+	"Ticket merged": "Ticket [{{id}}]({{{fullPath}}}) ({{{originDated}}}) fusionado con [{{tfId}}]({{{fullPathFuture}}}) ({{{futureDated}}})",
 	"Already has this status": "Ya tiene este estado",
 	"There aren't records for this week": "No existen registros para esta semana",
 	"Empty data source": "Origen de datos vacio"

loopback/server/boot/acl.js

@@ -0,0 +1,22 @@
+
+module.exports = function(app) {
+    app.models.ACL.checkAccessAcl = async(ctx, modelId, property, accessType = '*') => {
+        const models = app.models;
+        const context = {
+            accessToken: ctx.req.accessToken,
+            model: models[modelId],
+            property: property,
+            modelId: modelId,
+            accessType: accessType,
+            sharedMethod: {
+                name: property,
+                aliases: [],
+                sharedClass: true
+            }
+        };
+
+        const acl = await models.ACL.checkAccessForContext(context);
+
+        return acl.permission == 'ALLOW';
+    };
+};

modules/client/back/methods/client/setPassword.js

@@ -23,12 +23,6 @@ module.exports = Self => {
 
     Self.setPassword = async function(ctx, id, newPassword) {
         const models = Self.app.models;
-        const userId = ctx.req.accessToken.userId;
-
-        const isSalesPerson = await models.Account.hasRole(userId, 'salesPerson');
-
-        if (!isSalesPerson)
-            throw new UserError(`Not enough privileges to edit a client`);
 
         const isClient = await models.Client.findById(id, null);
         const isUserAccount = await models.UserAccount.findById(id, null);

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

@@ -6,21 +6,6 @@ describe('Client setPassword', () => {
         req: {accessToken: {userId: salesPersonId}}
     };
 
-    it(`should throw an error if you don't have enough permissions`, async() => {
-        let error;
-        const employeeId = 1;
-        const ctx = {
-            req: {accessToken: {userId: employeeId}}
-        };
-        try {
-            await models.Client.setPassword(ctx, 1, 't0pl3v3l.p455w0rd!');
-        } catch (e) {
-            error = e;
-        }
-
-        expect(error.message).toEqual(`Not enough privileges to edit a client`);
-    });
-
     it('should throw an error the setPassword target is not just a client but a worker', async() => {
         let error;
 

modules/client/back/models/greuge.js

@@ -1,6 +1,21 @@
+const LoopBackContext = require('loopback-context');
+
 module.exports = function(Self) {
     require('../methods/greuge/sumAmount')(Self);
 
+    Self.observe('before save', function(ctx, next) {
+        const loopBackContext = LoopBackContext.getCurrentContext();
+
+        let userFk = loopBackContext.active.accessToken.userId;
+
+        if (ctx.instance)
+            ctx.instance.userFk = userFk;
+        else
+            ctx.data.userFk = userFk;
+
+        next();
+    });
+
     Self.validatesLengthOf('description', {
         max: 45,
         message: 'Description should have maximum of 45 characters'

modules/client/back/models/greuge.json

@@ -35,7 +35,6 @@
             "type": "number",
             "required": true
         }
-
     },
     "relations": {
         "client": {
@@ -52,6 +51,11 @@
             "type": "belongsTo",
             "model": "GreugeType",
             "foreignKey": "greugeTypeFk"
+        },
+        "user": {
+            "type": "belongsTo",
+            "model": "Account",
+            "foreignKey": "userFk"
         }
     }
 }

modules/client/front/greuge/index/index.html

@@ -29,6 +29,7 @@
                 <vn-thead>
                     <vn-tr>
                         <vn-th field="shipped" default-order="DESC" expand>Date</vn-th>
+                        <vn-th field="userFk">Created by</vn-thfield></vn-th>
                         <vn-th field="description">Comment</vn-th>
                         <vn-th field="greugeTypeFk">Type</vn-th>
                         <vn-th field="amount" number>Amount</vn-th>
@@ -37,6 +38,8 @@
                 <vn-tbody>
                     <vn-tr ng-repeat="greuge in greuges">
                         <vn-td shrink-datetime>{{::greuge.shipped | date:'dd/MM/yyyy HH:mm' }}</vn-td>
+                        <vn-td><span ng-click="workerDescriptor.show($event, greuge.user.id)"
+                        class="link">{{::greuge.user.name}}</span></vn-td>
                         <vn-td>
                             <span title="{{::greuge.description}}">{{::greuge.description}}</span>
                         </vn-td>
@@ -57,3 +60,4 @@
     vn-bind="+"
     fixed-bottom-right>
 </vn-float-button>
+<vn-worker-descriptor-popover vn-id="workerDescriptor"></vn-worker-descriptor-popover>

modules/client/front/greuge/index/index.js

@@ -8,6 +8,12 @@ class Controller extends Section {
             include: [
                 {
                     relation: 'greugeType',
+                    scope: {
+                        fields: ['id', 'name']
+                    },
+                },
+                {
+                    relation: 'user',
                     scope: {
                         fields: ['id', 'name']
                     }

modules/client/front/greuge/index/locale/es.yml

@@ -2,3 +2,4 @@ Date: Fecha
 Comment: Comentario
 Amount: Importe
 Type: Tipo
+Created by: Creado por

modules/invoiceIn/front/descriptor/index.html

@@ -26,11 +26,13 @@
             Clone Invoice
         </vn-item>
         <vn-item
+            ng-if="false"
             ng-click="$ctrl.showPdfInvoice()"
             translate>
             Show agricultural invoice as PDF
         </vn-item>
         <vn-item
+            ng-if="false"
             ng-click="sendPdfConfirmation.show({email: $ctrl.entity.supplierContact[0].email})"
             translate>
             Send agricultural invoice as PDF

modules/invoiceOut/back/methods/invoiceOut/clientsToInvoice.js

@@ -1,6 +1,6 @@
 module.exports = Self => {
-    Self.remoteMethodCtx('globalInvoicing', {
+    Self.remoteMethodCtx('clientsToInvoice', {
-        description: 'Make a global invoice',
+        description: 'Get the clients to make global invoicing',
         accessType: 'WRITE',
         accepts: [
             {
@@ -29,19 +29,22 @@ module.exports = Self => {
                 description: 'The company id to invoice'
             }
         ],
-        returns: {
+        returns: [{
-            type: 'object',
+            arg: 'clientsAndAddresses',
-            root: true
+            type: ['object']
         },
+        {
+            arg: 'invoice',
+            type: 'object'
+        }],
         http: {
-            path: '/globalInvoicing',
+            path: '/clientsToInvoice',
             verb: 'POST'
         }
     });
 
-    Self.globalInvoicing = async(ctx, options) => {
+    Self.clientsToInvoice = async(ctx, options) => {
         const args = ctx.args;
-
         let tx;
         const myOptions = {};
 
@@ -53,8 +56,6 @@ module.exports = Self => {
             myOptions.transaction = tx;
         }
 
-        const invoicesIds = [];
-        const failedClients = [];
         let query;
         try {
             query = `
@@ -78,6 +79,9 @@ module.exports = Self => {
 
             const minShipped = new Date();
             minShipped.setFullYear(minShipped.getFullYear() - 1);
+            minShipped.setMonth(1);
+            minShipped.setDate(1);
+            minShipped.setHours(0, 0, 0, 0);
 
             // Packaging liquidation
             const vIsAllInvoiceable = false;
@@ -93,110 +97,51 @@ module.exports = Self => {
 
             const invoiceableClients = await getInvoiceableClients(ctx, myOptions);
 
-            if (!invoiceableClients.length) return;
+            if (!invoiceableClients) return;
 
-            for (let client of invoiceableClients) {
+            const clientsAndAddresses = invoiceableClients.map(invoiceableClient => {
-                try {
+                return {
-                    if (client.hasToInvoiceByAddress) {
+                    clientId: invoiceableClient.id,
-                        await Self.rawSql('CALL ticketToInvoiceByAddress(?, ?, ?, ?)', [
+                    addressId: invoiceableClient.addressFk
-                            minShipped,
+
-                            args.maxShipped,
+                };
-                            client.addressFk,
-                            args.companyFk
-                        ], myOptions);
-                    } else {
-                        await Self.rawSql('CALL invoiceFromClient(?, ?, ?)', [
-                            args.maxShipped,
-                            client.id,
-                            args.companyFk
-                        ], myOptions);
             }
-
+            );
-                    // Make invoice
-                    const isSpanishCompany = await getIsSpanishCompany(args.companyFk, myOptions);
-
-                    // Validates ticket nagative base
-                    const hasAnyNegativeBase = await getNegativeBase(myOptions);
-                    if (hasAnyNegativeBase && isSpanishCompany)
-                        continue;
-
-                    query = `SELECT invoiceSerial(?, ?, ?) AS serial`;
-                    const [invoiceSerial] = await Self.rawSql(query, [
-                        client.id,
-                        args.companyFk,
-                        'G'
-                    ], myOptions);
-                    const serialLetter = invoiceSerial.serial;
-
-                    query = `CALL invoiceOut_new(?, ?, NULL, @invoiceId)`;
-                    await Self.rawSql(query, [
-                        serialLetter,
-                        args.invoiceDate
-                    ], myOptions);
-
-                    const [newInvoice] = await Self.rawSql(`SELECT @invoiceId id`, null, myOptions);
-                    if (newInvoice.id) {
-                        await Self.rawSql('CALL invoiceOutBooking(?)', [newInvoice.id], myOptions);
-
-                        query = `INSERT IGNORE INTO invoiceOutQueue(invoiceFk) VALUES(?)`;
-                        await Self.rawSql(query, [newInvoice.id], myOptions);
-
-                        invoicesIds.push(newInvoice.id);
-                    }
-                } catch (e) {
-                    failedClients.push({
-                        id: client.id,
-                        stacktrace: e
-                    });
-                    continue;
-                }
-            }
-
-            if (failedClients.length > 0)
-                await notifyFailures(ctx, failedClients, myOptions);
 
             if (tx) await tx.commit();
+
+            return [
+                clientsAndAddresses,
+                {
+                    invoiceDate: args.invoiceDate,
+                    maxShipped: args.maxShipped,
+                    fromClientId: args.fromClientId,
+                    toClientId: args.toClientId,
+                    companyFk: args.companyFk,
+                    minShipped: minShipped
+                }
+            ];
         } catch (e) {
             if (tx) await tx.rollback();
             throw e;
         }
-
-        return invoicesIds;
     };
 
-    async function getNegativeBase(options) {
-        const models = Self.app.models;
-        const query = 'SELECT hasAnyNegativeBase() AS base';
-        const [result] = await models.InvoiceOut.rawSql(query, null, options);
-
-        return result && result.base;
-    }
-
-    async function getIsSpanishCompany(companyId, options) {
-        const models = Self.app.models;
-        const query = `SELECT COUNT(*) AS total
-                            FROM supplier s
-                                JOIN country c ON c.id = s.countryFk
-                                    AND c.code = 'ES'
-                            WHERE s.id = ?`;
-        const [supplierCompany] = await models.InvoiceOut.rawSql(query, [
-            companyId
-        ], options);
-
-        return supplierCompany && supplierCompany.total;
-    }
-
     async function getClientsWithPackaging(ctx, options) {
         const models = Self.app.models;
         const args = ctx.args;
         const query = `SELECT DISTINCT clientFk AS id
                         FROM ticket t 
                             JOIN ticketPackaging tp ON t.id = tp.ticketFk
+                            JOIN client c ON c.id = t.clientFk
                         WHERE t.shipped BETWEEN  '2017-11-21' AND ?
-                            AND t.clientFk BETWEEN ? AND ?`;
+                            AND t.clientFk >= ? 
+                            AND (t.clientFk <= ? OR ? IS NULL)
+                            AND c.isActive`;
         return models.InvoiceOut.rawSql(query, [
             args.maxShipped,
             args.fromClientId,
+            args.toClientId,
             args.toClientId
         ], options);
     }
@@ -225,42 +170,20 @@ module.exports = Self => {
                 LEFT JOIN ticketService ts ON ts.ticketFk = t.id
                 JOIN address a ON a.id = t.addressFk
                 JOIN client c ON c.id = t.clientFk
-            WHERE ISNULL(t.refFk) AND c.id BETWEEN ? AND ?
+            WHERE ISNULL(t.refFk) AND c.id >= ? 
+                AND (t.clientFk <= ? OR ? IS NULL)
                 AND t.shipped BETWEEN ? AND util.dayEnd(?)
                 AND t.companyFk = ? AND c.hasToInvoice
-                AND c.isTaxDataChecked
+                AND c.isTaxDataChecked AND c.isActive
             GROUP BY c.id, IF(c.hasToInvoiceByAddress,a.id,TRUE) HAVING sumAmount > 0`;
 
         return models.InvoiceOut.rawSql(query, [
             args.fromClientId,
             args.toClientId,
+            args.toClientId,
             minShipped,
             args.maxShipped,
             args.companyFk
         ], options);
     }
-
-    async function notifyFailures(ctx, failedClients, options) {
-        const models = Self.app.models;
-        const userId = ctx.req.accessToken.userId;
-        const $t = ctx.req.__; // $translate
-
-        const worker = await models.EmailUser.findById(userId, null, options);
-        const subject = $t('Global invoicing failed');
-        let body = $t(`Wasn't able to invoice the following clients`) + ':<br/><br/>';
-
-        for (client of failedClients) {
-            body += `ID: <strong>${client.id}</strong>
-                <br/> <strong>${client.stacktrace}</strong><br/><br/>`;
-        }
-
-        await Self.rawSql(`
-            INSERT INTO vn.mail (sender, replyTo, sent, subject, body)
-                VALUES (?, ?, FALSE, ?, ?)`, [
-            worker.email,
-            worker.email,
-            subject,
-            body
-        ], options);
-    }
 };

modules/invoiceOut/back/methods/invoiceOut/invoiceClient.js

@@ -0,0 +1,190 @@
+module.exports = Self => {
+    Self.remoteMethodCtx('invoiceClient', {
+        description: 'Make a invoice of a client',
+        accessType: 'WRITE',
+        accepts: [{
+            arg: 'clientId',
+            type: 'number',
+            description: 'The client id to invoice',
+            required: true
+        },
+        {
+            arg: 'addressId',
+            type: 'number',
+            description: 'The address id to invoice',
+            required: true
+        },
+        {
+            arg: 'invoiceDate',
+            type: 'date',
+            description: 'The invoice date',
+            required: true
+        },
+        {
+            arg: 'maxShipped',
+            type: 'date',
+            description: 'The maximum shipped date',
+            required: true
+        },
+        {
+            arg: 'companyFk',
+            type: 'number',
+            description: 'The company id to invoice',
+            required: true
+        },
+        {
+            arg: 'minShipped',
+            type: 'date',
+            description: 'The minium shupped date',
+            required: true
+        }],
+        returns: {
+            type: 'object',
+            root: true
+        },
+        http: {
+            path: '/invoiceClient',
+            verb: 'POST'
+        }
+    });
+
+    Self.invoiceClient = async(ctx, options) => {
+        const args = ctx.args;
+        const models = Self.app.models;
+        const myOptions = {};
+        let tx;
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
+
+        let invoiceId;
+        let invoiceOut;
+        try {
+            const client = await models.Client.findById(args.clientId, {
+                fields: ['id', 'hasToInvoiceByAddress']
+            }, myOptions);
+            try {
+                if (client.hasToInvoiceByAddress) {
+                    await Self.rawSql('CALL ticketToInvoiceByAddress(?, ?, ?, ?)', [
+                        args.minShipped,
+                        args.maxShipped,
+                        args.addressId,
+                        args.companyFk
+                    ], myOptions);
+                } else {
+                    await Self.rawSql('CALL invoiceFromClient(?, ?, ?)', [
+                        args.maxShipped,
+                        client.id,
+                        args.companyFk
+                    ], myOptions);
+                }
+
+                // Make invoice
+                const isSpanishCompany = await getIsSpanishCompany(args.companyFk, myOptions);
+
+                // Validates ticket nagative base
+                const hasAnyNegativeBase = await getNegativeBase(myOptions);
+                if (hasAnyNegativeBase && isSpanishCompany)
+                    return tx.rollback();
+
+                query = `SELECT invoiceSerial(?, ?, ?) AS serial`;
+                const [invoiceSerial] = await Self.rawSql(query, [
+                    client.id,
+                    args.companyFk,
+                    'G'
+                ], myOptions);
+                const serialLetter = invoiceSerial.serial;
+
+                query = `CALL invoiceOut_new(?, ?, NULL, @invoiceId)`;
+                await Self.rawSql(query, [
+                    serialLetter,
+                    args.invoiceDate
+                ], myOptions);
+
+                const [newInvoice] = await Self.rawSql(`SELECT @invoiceId id`, null, myOptions);
+                if (newInvoice.id) {
+                    await Self.rawSql('CALL invoiceOutBooking(?)', [newInvoice.id], myOptions);
+
+                    invoiceId = newInvoice.id;
+                }
+            } catch (e) {
+                const failedClient = {
+                    id: client.id,
+                    stacktrace: e
+                };
+                await notifyFailures(ctx, failedClient, myOptions);
+            }
+
+            invoiceOut = await models.InvoiceOut.findById(invoiceId, {
+                include: {
+                    relation: 'client'
+                }
+            }, myOptions);
+
+            if (tx) await tx.commit();
+        } catch (e) {
+            if (tx) await tx.rollback();
+            throw e;
+        }
+
+        ctx.args = {
+            reference: invoiceOut.ref,
+            recipientId: invoiceOut.clientFk,
+            recipient: invoiceOut.client().email
+        };
+        try {
+            await models.InvoiceOut.invoiceEmail(ctx);
+        } catch (err) {}
+
+        return invoiceId;
+    };
+
+    async function getNegativeBase(options) {
+        const models = Self.app.models;
+        const query = 'SELECT hasAnyNegativeBase() AS base';
+        const [result] = await models.InvoiceOut.rawSql(query, null, options);
+
+        return result && result.base;
+    }
+
+    async function getIsSpanishCompany(companyId, options) {
+        const models = Self.app.models;
+        const query = `SELECT COUNT(*) AS total
+                            FROM supplier s
+                                JOIN country c ON c.id = s.countryFk
+                                    AND c.code = 'ES'
+                            WHERE s.id = ?`;
+        const [supplierCompany] = await models.InvoiceOut.rawSql(query, [
+            companyId
+        ], options);
+
+        return supplierCompany && supplierCompany.total;
+    }
+
+    async function notifyFailures(ctx, failedClient, options) {
+        const models = Self.app.models;
+        const userId = ctx.req.accessToken.userId;
+        const $t = ctx.req.__; // $translate
+
+        const worker = await models.EmailUser.findById(userId, null, options);
+        const subject = $t('Global invoicing failed');
+        let body = $t(`Wasn't able to invoice the following clients`) + ':<br/><br/>';
+
+        body += `ID: <strong>${failedClient.id}</strong>
+                <br/> <strong>${failedClient.stacktrace}</strong><br/><br/>`;
+
+        await Self.rawSql(`
+            INSERT INTO vn.mail (sender, replyTo, sent, subject, body)
+                VALUES (?, ?, FALSE, ?, ?)`, [
+            worker.email,
+            worker.email,
+            subject,
+            body
+        ], options);
+    }
+};

modules/invoiceOut/back/methods/invoiceOut/invoiceEmail.js

@@ -40,19 +40,40 @@ module.exports = Self => {
         }
     });
 
-    Self.invoiceEmail = async ctx => {
+    Self.invoiceEmail = async(ctx, reference) => {
         const args = Object.assign({}, ctx.args);
+        const {InvoiceOut} = Self.app.models;
         const params = {
             recipient: args.recipient,
             lang: ctx.req.getLocale()
         };
 
+        const invoiceOut = await InvoiceOut.findOne({
+            where: {
+                ref: reference
+            }
+        });
+
         delete args.ctx;
         for (const param in args)
             params[param] = args[param];
 
         const email = new Email('invoice', params);
 
-        return email.send();
+        const [stream, ...headers] = await Self.download(ctx, invoiceOut.id);
+        const name = headers[1];
+        const fileName = name.replace(/filename="(.*)"/gm, '$1');
+
+        const mailOptions = {
+            overrideAttachments: true,
+            attachments: [
+                {
+                    filename: fileName,
+                    content: stream
+                }
+            ]
+        };
+
+        return email.send(mailOptions);
     };
 };

modules/invoiceOut/back/methods/invoiceOut/sendQueued.js

@@ -1,133 +0,0 @@
-const {Email, Report, storage} = require('vn-print');
-
-module.exports = Self => {
-    Self.remoteMethod('sendQueued', {
-        description: 'Send all queued invoices',
-        accessType: 'WRITE',
-        accepts: [],
-        returns: {
-            type: 'object',
-            root: true
-        },
-        http: {
-            path: '/send-queued',
-            verb: 'POST'
-        }
-    });
-
-    Self.sendQueued = async() => {
-        const invoices = await Self.rawSql(`
-                SELECT 
-                        io.id,
-                        io.clientFk,
-                        io.issued,
-                        io.ref,
-                        c.email recipient,
-                        c.salesPersonFk,
-                        c.isToBeMailed,
-                        c.hasToInvoice,
-                        co.hasDailyInvoice,
-                        eu.email salesPersonEmail
-                    FROM invoiceOutQueue ioq
-                        JOIN invoiceOut io ON io.id = ioq.invoiceFk
-                        JOIN client c ON c.id = io.clientFk
-                        JOIN province p ON p.id = c.provinceFk
-                        JOIN country co ON co.id = p.countryFk
-                        LEFT JOIN account.emailUser eu ON eu.userFk = c.salesPersonFk
-                WHERE status = ''`);
-
-        let invoiceId;
-        for (const invoiceOut of invoices) {
-            try {
-                const tx = await Self.beginTransaction({});
-                const myOptions = {transaction: tx};
-
-                invoiceId = invoiceOut.id;
-
-                const args = {
-                    reference: invoiceOut.ref,
-                    recipientId: invoiceOut.clientFk,
-                    recipient: invoiceOut.recipient,
-                    replyTo: invoiceOut.salesPersonEmail
-                };
-
-                const invoiceReport = new Report('invoice', args);
-                const stream = await invoiceReport.toPdfStream();
-
-                const issued = invoiceOut.issued;
-                const year = issued.getFullYear().toString();
-                const month = (issued.getMonth() + 1).toString();
-                const day = issued.getDate().toString();
-
-                const fileName = `${year}${invoiceOut.ref}.pdf`;
-
-                // Store invoice
-                storage.write(stream, {
-                    type: 'invoice',
-                    path: `${year}/${month}/${day}`,
-                    fileName: fileName
-                });
-
-                await Self.rawSql(`
-                    UPDATE invoiceOut 
-                        SET hasPdf = true 
-                    WHERE id = ?`,
-                [invoiceOut.id], myOptions);
-
-                const isToBeMailed = invoiceOut.recipient && invoiceOut.salesPersonFk && invoiceOut.isToBeMailed;
-
-                if (isToBeMailed) {
-                    const mailOptions = {
-                        overrideAttachments: true,
-                        attachments: []
-                    };
-
-                    const invoiceAttachment = {
-                        filename: fileName,
-                        content: stream
-                    };
-
-                    if (invoiceOut.serial == 'E' && invoiceOut.companyCode == 'VNL') {
-                        const exportation = new Report('exportation', args);
-                        const stream = await exportation.toPdfStream();
-                        const fileName = `CITES-${invoiceOut.ref}.pdf`;
-
-                        mailOptions.attachments.push({
-                            filename: fileName,
-                            content: stream
-                        });
-                    }
-
-                    mailOptions.attachments.push(invoiceAttachment);
-
-                    const email = new Email('invoice', args);
-                    await email.send(mailOptions);
-                }
-                // Update queue status
-                const date = new Date();
-                await Self.rawSql(`
-                    UPDATE invoiceOutQueue 
-                        SET status = "printed",
-                            printed = ?
-                        WHERE invoiceFk = ?`,
-                [date, invoiceOut.id], myOptions);
-
-                await tx.commit();
-            } catch (error) {
-                await tx.rollback();
-
-                await Self.rawSql(`
-                    UPDATE invoiceOutQueue 
-                        SET status = ?
-                    WHERE invoiceFk = ?`,
-                [error.message, invoiceId]);
-
-                throw e;
-            }
-        }
-
-        return {
-            message: 'Success'
-        };
-    };
-};

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

@@ -13,7 +13,7 @@ describe('InvoiceOut downloadZip()', () => {
     };
 
     it('should return part of link to dowloand the zip', async() => {
-        const tx = await models.Order.beginTransaction({});
+        const tx = await models.InvoiceOut.beginTransaction({});
 
         try {
             const options = {transaction: tx};
@@ -30,7 +30,7 @@ describe('InvoiceOut downloadZip()', () => {
     });
 
     it('should return an error if the size of the files is too large', async() => {
-        const tx = await models.Order.beginTransaction({});
+        const tx = await models.InvoiceOut.beginTransaction({});
 
         let error;
         try {

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

@@ -1,43 +0,0 @@
-const models = require('vn-loopback/server/server').models;
-
-describe('InvoiceOut globalInvoicing()', () => {
-    const userId = 1;
-    const companyFk = 442;
-    const clientId = 1101;
-    const invoicedTicketId = 8;
-    const invoiceSerial = 'A';
-    const activeCtx = {
-        accessToken: {userId: userId},
-        __: value => {
-            return value;
-        }
-    };
-    const ctx = {req: activeCtx};
-
-    it('should make a global invoicing', async() => {
-        spyOn(models.InvoiceOut, 'createPdf').and.returnValue(new Promise(resolve => resolve(true)));
-
-        const tx = await models.InvoiceOut.beginTransaction({});
-        const options = {transaction: tx};
-
-        try {
-            ctx.args = {
-                invoiceDate: new Date(),
-                maxShipped: new Date(),
-                fromClientId: clientId,
-                toClientId: 1106,
-                companyFk: companyFk
-            };
-            const result = await models.InvoiceOut.globalInvoicing(ctx, options);
-            const ticket = await models.Ticket.findById(invoicedTicketId, null, options);
-
-            expect(result.length).toBeGreaterThan(0);
-            expect(ticket.refFk).toContain(invoiceSerial);
-
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
-    });
-});

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

@@ -0,0 +1,56 @@
+const models = require('vn-loopback/server/server').models;
+
+describe('InvoiceOut invoiceClient()', () => {
+    const userId = 1;
+    const clientId = 1101;
+    const addressId = 121;
+    const companyFk = 442;
+    const minShipped = new Date();
+    minShipped.setFullYear(minShipped.getFullYear() - 1);
+    minShipped.setMonth(1);
+    minShipped.setDate(1);
+    minShipped.setHours(0, 0, 0, 0);
+    const invoiceSerial = 'A';
+    const activeCtx = {
+        getLocale: () => {
+            return 'en';
+        },
+        accessToken: {userId: userId},
+        __: value => {
+            return value;
+        }
+    };
+    const ctx = {req: activeCtx};
+
+    it('should make a global invoicing', async() => {
+        spyOn(models.InvoiceOut, 'createPdf').and.returnValue(new Promise(resolve => resolve(true)));
+        spyOn(models.InvoiceOut, 'invoiceEmail');
+
+        const tx = await models.InvoiceOut.beginTransaction({});
+        const options = {transaction: tx};
+
+        try {
+            ctx.args = {
+                clientId: clientId,
+                addressId: addressId,
+                invoiceDate: new Date(),
+                maxShipped: new Date(),
+                companyFk: companyFk,
+                minShipped: minShipped
+            };
+            const invoiceOutId = await models.InvoiceOut.invoiceClient(ctx, options);
+            const invoiceOut = await models.InvoiceOut.findById(invoiceOutId, null, options);
+            const [firstTicket] = await models.Ticket.find({
+                where: {refFk: invoiceOut.ref}
+            }, options);
+
+            expect(invoiceOutId).toBeGreaterThan(0);
+            expect(firstTicket.refFk).toContain(invoiceSerial);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+});

modules/invoiceOut/back/models/invoice-out.js

@@ -8,11 +8,11 @@ module.exports = Self => {
     require('../methods/invoiceOut/book')(Self);
     require('../methods/invoiceOut/createPdf')(Self);
     require('../methods/invoiceOut/createManualInvoice')(Self);
-    require('../methods/invoiceOut/globalInvoicing')(Self);
+    require('../methods/invoiceOut/clientsToInvoice')(Self);
+    require('../methods/invoiceOut/invoiceClient')(Self);
     require('../methods/invoiceOut/refund')(Self);
     require('../methods/invoiceOut/invoiceEmail')(Self);
     require('../methods/invoiceOut/exportationPdf')(Self);
-    require('../methods/invoiceOut/sendQueued')(Self);
     require('../methods/invoiceOut/invoiceCsv')(Self);
     require('../methods/invoiceOut/invoiceCsvEmail')(Self);
 };

modules/invoiceOut/front/index/global-invoicing/index.html

@@ -16,10 +16,21 @@
     </vn-crud-model> 
     <div 
         class="progress vn-my-md" 
-        ng-if="$ctrl.isInvoicing">
+        ng-if="$ctrl.packageInvoicing">
         <vn-horizontal>
-            <vn-icon vn-none icon="warning"></vn-icon> 
+            <div>
-            <span vn-none translate>Adding invoices to queue...</span>
+                {{'Calculating packages to invoice...' | translate}}
+            </div>
+        </vn-horizontal>
+    </div>
+    <div 
+        class="progress vn-my-md" 
+        ng-if="$ctrl.lastClientId">
+        <vn-horizontal>
+            <div>
+                {{'Id Client' | translate}}: {{$ctrl.currentClientId}} 
+                {{'of' | translate}} {{::$ctrl.lastClientId}}
+            </div>
         </vn-horizontal>
     </div>
     <vn-horizontal>
@@ -35,10 +46,24 @@
         </vn-date-picker>
     </vn-horizontal>
     <vn-horizontal>
+        <vn-radio
+            label="All clients"
+            val="allClients"
+            ng-model="$ctrl.clientsNumber"
+            ng-click="$ctrl.$onInit()">
+        </vn-radio>
+        <vn-radio
+            label="Clients range"
+            val="clientsRange"
+            ng-model="$ctrl.clientsNumber">
+        </vn-radio>
+    </vn-horizontal>
+    <vn-horizontal ng-show="$ctrl.clientsNumber == 'clientsRange'">
         <vn-autocomplete
             url="Clients"
             label="From client"
             search-function="{or: [{id: $search}, {name: {like: '%'+$search+'%'}}]}"
+            order="id"
             show-field="name"
             value-field="id"
             ng-model="$ctrl.invoice.fromClientId">
@@ -48,6 +73,7 @@
             url="Clients"
             label="To client"
             search-function="{or: [{id: $search}, {name: {like: '%'+$search+'%'}}]}"
+            order="id"
             show-field="name"
             value-field="id"
             ng-model="$ctrl.invoice.toClientId">
@@ -66,5 +92,5 @@
 </tpl-body>
 <tpl-buttons>
     <input type="button" response="cancel" translate-attr="{value: 'Cancel'}"/>
-    <button response="accept" translate vn-focus>Invoice</button>
+    <button vn-id="invoiceButton" response="accept" translate>Invoice</button>{{$ctrl.isInvoicing}}
 </tpl-buttons>

modules/invoiceOut/front/index/global-invoicing/index.js

@@ -5,11 +5,10 @@ import './style.scss';
 class Controller extends Dialog {
     constructor($element, $, $transclude) {
         super($element, $, $transclude);
-
-        this.isInvoicing = false;
         this.invoice = {
             maxShipped: new Date()
         };
+        this.clientsNumber = 'allClients';
     }
 
     $onInit() {
@@ -46,6 +45,39 @@ class Controller extends Dialog {
         this.invoice.companyFk = value;
     }
 
+    restartValues() {
+        this.lastClientId = null;
+        this.$.invoiceButton.disabled = false;
+    }
+
+    cancelRequest() {
+        this.canceler = this.$q.defer();
+        return {timeout: this.canceler.promise};
+    }
+
+    invoiceOut(invoice, clientsAndAddresses) {
+        const [clientAndAddress] = clientsAndAddresses;
+        if (!clientAndAddress) return;
+        this.currentClientId = clientAndAddress.clientId;
+        const params = {
+            clientId: clientAndAddress.clientId,
+            addressId: clientAndAddress.addressId,
+            invoiceDate: invoice.invoiceDate,
+            maxShipped: invoice.maxShipped,
+            companyFk: invoice.companyFk,
+            minShipped: invoice.minShipped,
+
+        };
+
+        const options = this.cancelRequest();
+
+        return this.$http.post(`InvoiceOuts/invoiceClient`, params, options)
+            .then(() => {
+                clientsAndAddresses.shift();
+                return this.invoiceOut(invoice, clientsAndAddresses);
+            });
+    }
+
     responseHandler(response) {
         try {
             if (response !== 'accept')
@@ -57,14 +89,30 @@ class Controller extends Dialog {
             if (!this.invoice.fromClientId || !this.invoice.toClientId)
                 throw new Error('Choose a valid clients range');
 
-            this.isInvoicing = true;
+            this.on('close', () => {
-            return this.$http.post(`InvoiceOuts/globalInvoicing`, this.invoice)
+                if (this.canceler) this.canceler.resolve();
+                this.vnApp.showSuccess(this.$t('Data saved!'));
+            });
+
+            this.$.invoiceButton.disabled = true;
+            this.packageInvoicing = true;
+            const options = this.cancelRequest();
+
+            this.$http.post(`InvoiceOuts/clientsToInvoice`, this.invoice, options)
+                .then(res => {
+                    this.packageInvoicing = false;
+                    const invoice = res.data.invoice;
+                    const clientsAndAddresses = res.data.clientsAndAddresses;
+                    if (!clientsAndAddresses.length) return super.responseHandler(response);
+                    this.lastClientId = clientsAndAddresses[clientsAndAddresses.length - 1].clientId;
+                    return this.invoiceOut(invoice, clientsAndAddresses);
+                })
                 .then(() => super.responseHandler(response))
                 .then(() => this.vnApp.showSuccess(this.$t('Data saved!')))
-                .finally(() => this.isInvoicing = false);
+                .finally(() => this.restartValues());
         } catch (e) {
             this.vnApp.showError(this.$t(e.message));
-            this.isInvoicing = false;
+            this.restartValues();
             return false;
         }
     }

modules/invoiceOut/front/index/global-invoicing/index.spec.js

@@ -19,6 +19,7 @@ describe('InvoiceOut', () => {
                 }
             };
             controller = $componentController('vnInvoiceOutGlobalInvoicing', {$element, $scope, $transclude});
+            controller.$.invoiceButton = {disabled: false};
         }));
 
         describe('getMinClientId()', () => {
@@ -87,14 +88,26 @@ describe('InvoiceOut', () => {
             it('should make an http POST query and then call to the showSuccess() method', () => {
                 jest.spyOn(controller.vnApp, 'showSuccess');
 
+                const minShipped = new Date();
+                minShipped.setFullYear(minShipped.getFullYear() - 1);
+                minShipped.setMonth(1);
+                minShipped.setDate(1);
+                minShipped.setHours(0, 0, 0, 0);
                 controller.invoice = {
                     invoiceDate: new Date(),
                     maxShipped: new Date(),
                     fromClientId: 1101,
-                    toClientId: 1101
+                    toClientId: 1101,
+                    companyFk: 442,
+                    minShipped: minShipped
+                };
+                const response = {
+                    clientsAndAddresses: [{clientId: 1101, addressId: 121}],
+                    invoice: controller.invoice
                 };
 
-                $httpBackend.expect('POST', `InvoiceOuts/globalInvoicing`).respond({id: 1});
+                $httpBackend.expect('POST', `InvoiceOuts/clientsToInvoice`).respond(response);
+                $httpBackend.expect('POST', `InvoiceOuts/invoiceClient`).respond({id: 1});
                 controller.responseHandler('accept');
                 $httpBackend.flush();
 

modules/invoiceOut/front/index/global-invoicing/locale/es.yml

@@ -7,3 +7,8 @@ From client: Desde el cliente
 To client: Hasta el cliente
 Invoice date and the max date should be filled: La fecha de factura y la fecha límite deben rellenarse
 Choose a valid clients range: Selecciona un rango válido de clientes
+of: de
+Id Client: Id Cliente
+All clients: Todos los clientes
+Clients range: Rango de clientes
+Calculating packages to invoice...: Calculando paquetes a factura...

modules/invoiceOut/front/index/index.html

@@ -30,7 +30,6 @@
                 <vn-th field="companyFk">Company</vn-th>
                 <vn-th field="dued" expand>Due date</vn-th>
                 <vn-th></vn-th>
-                <vn-th></vn-th>
             </vn-tr>
         </vn-thead>
         <vn-tbody>

modules/invoiceOut/front/summary/index.html

@@ -85,7 +85,7 @@
                             </span>
                        </vn-td>
                         <vn-td expand>{{ticket.shipped | date: 'dd/MM/yyyy' | dashIfEmpty}}</vn-td>
-                        <vn-td number>{{ticket.totalWithVat | currency: 'EUR': 2}}</vn-td>
+                        <vn-td number expand>{{ticket.totalWithVat | currency: 'EUR': 2}}</vn-td>
                     </vn-tr>
                 </vn-tbody>
             </vn-table>

modules/item/back/methods/item/new.js

@@ -49,6 +49,10 @@ module.exports = Self => {
             const provisionalName = params.provisionalName;
             delete params.provisionalName;
 
+            const itemType = await models.ItemType.findById(params.typeFk, myOptions);
+
+            params.isLaid = itemType.isLaid;
+
             const item = await models.Item.create(params, myOptions);
 
             const typeTags = await models.ItemTypeTag.find({

modules/item/back/methods/item/specs/new.spec.js

@@ -15,6 +15,11 @@ describe('item new()', () => {
             };
 
             let item = await models.Item.new(itemParams, options);
+
+            let itemType = await models.ItemType.findById(item.typeFk, options);
+
+            item.isLaid = itemType.isLaid;
+
             const temporalNameTag = await models.Tag.findOne({where: {name: 'Nombre temporal'}}, options);
 
             const temporalName = await models.ItemTag.findOne({
@@ -26,9 +31,14 @@ describe('item new()', () => {
 
             item = await models.Item.findById(item.id, null, options);
 
+            itemType = await models.ItemType.findById(item.typeFk, options);
+
+            item.isLaid = itemType.isLaid;
+
             expect(item.intrastatFk).toEqual(5080000);
             expect(item.originFk).toEqual(1);
             expect(item.typeFk).toEqual(2);
+            expect(item.isLaid).toBeFalse();
             expect(item.name).toEqual('planta');
             expect(temporalName.value).toEqual('planta');
 

modules/item/back/models/item-type.json

@@ -26,6 +26,9 @@
         },
         "isUnconventionalSize": {
             "type": "number"
+        },
+        "isLaid": {
+            "type": "boolean"
         }
     },
     "relations": {

modules/item/back/models/item.json

@@ -143,6 +143,9 @@
         },
         "packingShelve": {
             "type": "number"
+        },
+        "isLaid": {
+            "type": "boolean"
         }
     },
     "relations": {

modules/monitor/back/methods/sales-monitor/ordersFilter.js

@@ -53,7 +53,7 @@ module.exports = Self => {
                 JOIN client c ON c.id = o.customer_id
                 JOIN address a ON a.id = o.address_id
                 JOIN agencyMode am ON am.id = o.agency_id
-                JOIN user u ON u.id = c.salesPersonFk
+                JOIN account.user u ON u.id = c.salesPersonFk
                 JOIN workerTeamCollegues wtc ON c.salesPersonFk = wtc.collegueFk`);
 
         if (!filter.where) filter.where = {};

modules/monitor/back/methods/sales-monitor/specs/salesFilter.spec.js

@@ -11,7 +11,7 @@ describe('SalesMonitor salesFilter()', () => {
             const filter = {order: 'id DESC'};
             const result = await models.SalesMonitor.salesFilter(ctx, filter, options);
 
-            expect(result.length).toEqual(27);
+            expect(result.length).toBeGreaterThan(25);
 
             await tx.rollback();
         } catch (e) {
@@ -39,7 +39,7 @@ describe('SalesMonitor salesFilter()', () => {
             const filter = {};
             const result = await models.SalesMonitor.salesFilter(ctx, filter, options);
 
-            expect(result.length).toEqual(16);
+            expect(result.length).toBeGreaterThan(15);
 
             await tx.rollback();
         } catch (e) {
@@ -87,7 +87,7 @@ describe('SalesMonitor salesFilter()', () => {
             const filter = {};
             const result = await models.SalesMonitor.salesFilter(ctx, filter, options);
 
-            expect(result.length).toEqual(27);
+            expect(result.length).toBeGreaterThan(20);
 
             await tx.rollback();
         } catch (e) {
@@ -130,7 +130,7 @@ describe('SalesMonitor salesFilter()', () => {
             const length = result.length;
             const anyResult = result[Math.floor(Math.random() * Math.floor(length))];
 
-            expect(length).toEqual(10);
+            expect(length).toBeGreaterThan(10);
             expect(anyResult.state).toMatch(/(Libre|Arreglar)/);
 
             await tx.rollback();
@@ -171,7 +171,7 @@ describe('SalesMonitor salesFilter()', () => {
             const filter = {};
             const result = await models.SalesMonitor.salesFilter(ctx, filter, options);
 
-            expect(result.length).toEqual(23);
+            expect(result.length).toBeGreaterThan(20);
 
             await tx.rollback();
         } catch (e) {

modules/route/back/methods/route/sendSms.js

@@ -0,0 +1,39 @@
+
+module.exports = Self => {
+    Self.remoteMethodCtx('sendSms', {
+        description: 'Sends a SMS to each client of the routes, each client only recieves the SMS once',
+        accessType: 'WRITE',
+        accepts: [
+            {
+                arg: 'destination',
+                type: 'string',
+                description: 'A comma separated string of destinations',
+                required: true,
+            },
+            {
+                arg: 'message',
+                type: 'string',
+                required: true,
+            }],
+        returns: {
+            type: 'object',
+            root: true
+        },
+        http: {
+            path: `/sendSms`,
+            verb: 'POST'
+        }
+    });
+
+    Self.sendSms = async(ctx, destination, message) => {
+        const targetClients = destination.split(',');
+
+        const allSms = [];
+        for (let client of targetClients) {
+            let sms = await Self.app.models.Sms.send(ctx, client, message);
+            allSms.push(sms);
+        }
+
+        return allSms;
+    };
+};

modules/route/back/models/route.js

@@ -12,6 +12,7 @@ module.exports = Self => {
     require('../methods/route/updateWorkCenter')(Self);
     require('../methods/route/driverRoutePdf')(Self);
     require('../methods/route/driverRouteEmail')(Self);
+    require('../methods/route/sendSms')(Self);
 
     Self.validate('kmStart', validateDistance, {
         message: 'Distance must be lesser than 1000'

modules/route/front/descriptor/index.html

@@ -20,6 +20,13 @@
             translate>
             Update volume
         </vn-item>
+        <vn-item
+            ng-click="$ctrl.deleteCurrentRoute()"
+            vn-acl="deliveryBoss"
+            vn-acl-action="remove"
+            translate>
+            Delete route
+        </vn-item>
     </slot-menu>
     <slot-body>
         <div class="attributes">

modules/route/front/descriptor/index.js

@@ -34,6 +34,14 @@ class Controller extends Descriptor {
             });
     }
 
+    deleteCurrentRoute() {
+        this.$http.delete(`Routes/${this.id}`)
+            .then(() => {
+                this.vnApp.showSuccess(this.$t('Route deleted'));
+                this.$state.go('route.index');
+            });
+    }
+
     loadData() {
         const filter = {
             fields: [

modules/route/front/descriptor/index.spec.js

@@ -23,4 +23,20 @@ describe('vnRouteDescriptorPopover', () => {
             expect(controller.route).toEqual(response);
         });
     });
+
+    describe('deleteCurrentRoute()', () => {
+        it(`should perform a delete query to delete the current route`, () => {
+            const id = 1;
+
+            jest.spyOn(controller.vnApp, 'showSuccess');
+
+            controller._id = id;
+            $httpBackend.expectDELETE(`Routes/${id}`).respond(200);
+            controller.deleteCurrentRoute();
+            $httpBackend.flush();
+
+            expect(controller.route).toBeUndefined();
+            expect(controller.vnApp.showSuccess).toHaveBeenCalledWith('Route deleted');
+        });
+    });
 });

modules/route/front/descriptor/locale/es.yml

@@ -4,4 +4,6 @@ Send route report: Enviar informe de ruta
 Show route report: Ver informe de ruta
 Update volume: Actualizar volumen
 Volume updated: Volumen actualizado
+Delete route: Borrar ruta
+Route deleted: Ruta borrada
 Are you sure you want to update the volume?: Estas seguro que quieres actualizar el volumen?

modules/route/front/index.js

@@ -15,3 +15,4 @@ import './agency-term/index';
 import './agency-term/createInvoiceIn';
 import './agency-term-search-panel';
 import './ticket-popup';
+import './sms';

modules/route/front/index/locale/es.yml

@@ -9,3 +9,5 @@ Go to route: Ir a la ruta
 You must select a valid time: Debe seleccionar una hora válida
 You must select a valid date: Debe seleccionar una fecha válida
 Mark as served: Marcar como servidas
+Retrieving data from the routes: Recuperando datos de las rutas
+Send SMS to all clients: Mandar sms a todos los clientes de las rutas

modules/route/front/sms/index.html

@@ -0,0 +1,36 @@
+<vn-dialog
+    vn-id="SMSDialog"
+    on-accept="$ctrl.onResponse()"
+    message="Send SMS to the selected tickets">
+    <tpl-body>
+        <section class="SMSDialog">
+            <vn-horizontal>
+                <vn-textarea vn-one
+                    vn-id="message"
+                    label="Message" 
+                    ng-model="$ctrl.sms.message"
+                    info="Special characters like accents counts as a multiple"
+                    rows="5"
+                    required="true"
+                    rule>
+                </vn-textarea>
+            </vn-horizontal>
+            <vn-horizontal>
+                <span>
+                    {{'Characters remaining' | translate}}: 
+                    <vn-chip translate-attr="{title: 'Packing'}" ng-class="{
+                        'colored': $ctrl.charactersRemaining() > 25,
+                        'warning': $ctrl.charactersRemaining() <= 25,
+                        'alert': $ctrl.charactersRemaining() < 0,
+                    }"> 
+                        {{$ctrl.charactersRemaining()}}
+                    </vn-chip>
+                </span>
+            </vn-horizontal>
+        </section>
+    </tpl-body>
+    <tpl-buttons>
+        <input type="button" response="cancel" translate-attr="{value: 'Cancel'}"/>
+        <button response="accept" translate>Send</button>
+    </tpl-buttons>
+</vn-dialog>

modules/route/front/sms/index.js

@@ -0,0 +1,47 @@
+import ngModule from '../module';
+import Component from 'core/lib/component';
+import './style.scss';
+
+class Controller extends Component {
+    open() {
+        this.$.SMSDialog.show();
+    }
+
+    charactersRemaining() {
+        const element = this.$.message;
+        const value = element.input.value;
+
+        const maxLength = 160;
+        const textAreaLength = new Blob([value]).size;
+        return maxLength - textAreaLength;
+    }
+
+    onResponse() {
+        try {
+            if (!this.sms.destination)
+                throw new Error(`The destination can't be empty`);
+            if (!this.sms.message)
+                throw new Error(`The message can't be empty`);
+            if (this.charactersRemaining() < 0)
+                throw new Error(`The message it's too long`);
+
+            this.$http.post(`Routes/sendSms`, this.sms).then(res => {
+                this.vnApp.showMessage(this.$t('SMS sent!'));
+
+                if (res.data) this.emit('send', {response: res.data});
+            });
+        } catch (e) {
+            this.vnApp.showError(this.$t(e.message));
+            return false;
+        }
+        return true;
+    }
+}
+
+ngModule.vnComponent('vnRouteSms', {
+    template: require('./index.html'),
+    controller: Controller,
+    bindings: {
+        sms: '<',
+    }
+});

modules/route/front/sms/index.spec.js

@@ -0,0 +1,71 @@
+import './index';
+
+describe('Route', () => {
+    describe('Component vnRouteSms', () => {
+        let controller;
+        let $httpBackend;
+
+        beforeEach(ngModule('route'));
+
+        beforeEach(inject(($componentController, $rootScope, _$httpBackend_) => {
+            $httpBackend = _$httpBackend_;
+            let $scope = $rootScope.$new();
+            const $element = angular.element('<vn-dialog></vn-dialog>');
+            controller = $componentController('vnRouteSms', {$element, $scope});
+            controller.$.message = {
+                input: {
+                    value: 'My SMS'
+                }
+            };
+        }));
+
+        describe('onResponse()', () => {
+            it('should perform a POST query and show a success snackbar', () => {
+                let params = {destinationFk: 1101, destination: 111111111, message: 'My SMS'};
+                controller.sms = {destinationFk: 1101, destination: 111111111, message: 'My SMS'};
+
+                jest.spyOn(controller.vnApp, 'showMessage');
+                $httpBackend.expect('POST', `Routes/sendSms`, params).respond(200, params);
+
+                controller.onResponse();
+                $httpBackend.flush();
+
+                expect(controller.vnApp.showMessage).toHaveBeenCalledWith('SMS sent!');
+            });
+
+            it('should call onResponse without the destination and show an error snackbar', () => {
+                controller.sms = {destinationFk: 1101, message: 'My SMS'};
+
+                jest.spyOn(controller.vnApp, 'showError');
+
+                controller.onResponse();
+
+                expect(controller.vnApp.showError).toHaveBeenCalledWith(`The destination can't be empty`);
+            });
+
+            it('should call onResponse without the message and show an error snackbar', () => {
+                controller.sms = {destinationFk: 1101, destination: 222222222};
+
+                jest.spyOn(controller.vnApp, 'showError');
+
+                controller.onResponse();
+
+                expect(controller.vnApp.showError).toHaveBeenCalledWith(`The message can't be empty`);
+            });
+        });
+
+        describe('charactersRemaining()', () => {
+            it('should return the characters remaining in a element', () => {
+                controller.$.message = {
+                    input: {
+                        value: 'My message 0€'
+                    }
+                };
+
+                let result = controller.charactersRemaining();
+
+                expect(result).toEqual(145);
+            });
+        });
+    });
+});

modules/route/front/sms/locale/es.yml

@@ -0,0 +1,9 @@
+Send SMS to the selected tickets: Enviar SMS a los tickets seleccionados
+Routes to notify: Rutas a notificar
+Message: Mensaje
+SMS sent!: ¡SMS enviado!
+Characters remaining: Carácteres restantes
+The destination can't be empty: El destinatario no puede estar vacio
+The message can't be empty: El mensaje no puede estar vacio
+The message it's too long: El mensaje es demasiado largo
+Special characters like accents counts as a multiple: Carácteres especiales como los acentos cuentan como varios

modules/route/front/sms/style.scss

@@ -0,0 +1,5 @@
+@import "variables";
+
+.SMSDialog {
+    min-width: 400px
+}

modules/route/front/tickets/index.html

@@ -29,13 +29,21 @@
                     disabled="!$ctrl.isChecked"
                     ng-click="$ctrl.deletePriority()"
                     vn-tooltip="Delete priority"
-                    icon="filter_alt_off">
+                    icon="filter_alt">
                 </vn-button>
                 <vn-button 
                     ng-click="$ctrl.setOrderedPriority($ctrl.tickets)"
                     vn-tooltip="Renumber all tickets in the order you see on the screen"
                     icon="format_list_numbered">
                 </vn-button>
+                <vn-button 
+                    vn-acl="deliveryBoss"
+                    vn-acl-action="remove"
+                    disabled="!$ctrl.isChecked"
+                    icon="sms"
+                    vn-tooltip="Send SMS to all clients"
+                    ng-click="$ctrl.sendSms()">
+                </vn-button>
             </vn-tool-bar>
             <vn-table class="vn-pt-md" model="model" auto-load="false" vn-droppable="$ctrl.onDrop($event)">
                 <vn-thead>
@@ -149,19 +157,29 @@
     route="$ctrl.$params"
     parent-reload="$ctrl.$.model.refresh()">
 </vn-route-ticket-popup>
-
+<div fixed-bottom-right>
-<vn-float-button
+    <vn-vertical style="align-items: center;">
-    icon="add"
+        <a vn-bind="+">
+            <vn-button 
+                class="round md vn-mb-sm"
                 ng-click="$ctrl.$.ticketPopup.show()"
+                icon="add"
                 vn-tooltip="Add ticket"
                 vn-acl="delivery"
                 vn-acl-action="remove"
-    vn-bind="+"
+                tooltip-position="left">
-    fixed-bottom-right>
+            </vn-button>
-</vn-float-button>
+        </a>
+    </vn-vertical>
+</div>
 <vn-ticket-descriptor-popover 
     vn-id="ticket-descriptor">
 </vn-ticket-descriptor-popover>
 <vn-client-descriptor-popover 
     vn-id="client-descriptor">
 </vn-client-descriptor-popover>
+<!-- SMS Dialog -->
+<vn-route-sms
+    vn-id="sms"
+    sms="$ctrl.newSMS">
+</vn-route-sms>

modules/route/front/tickets/index.js

@@ -161,6 +161,37 @@ class Controller extends Section {
             throw error;
         });
     }
+
+    async sendSms() {
+        try {
+            const clientsFk = [];
+            const clientsName = [];
+            const clients = [];
+
+            const selectedTickets = this.getSelectedItems(this.$.$ctrl.tickets);
+
+            for (let ticket of selectedTickets) {
+                clientsFk.push(ticket.clientFk);
+                let userContact = await this.$http.get(`Clients/${ticket.clientFk}`);
+                clientsName.push(userContact.data.name);
+                clients.push(userContact.data.phone);
+            }
+
+            const destinationFk = String(clientsFk);
+            const destination = String(clients);
+
+            this.newSMS = Object.assign({
+                destinationFk: destinationFk,
+                destination: destination
+            });
+
+            this.$.sms.open();
+            return true;
+        } catch (e) {
+            this.vnApp.showError(this.$t(e.message));
+            return false;
+        }
+    }
 }
 
 ngModule.vnComponent('vnRouteTickets', {

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

@@ -1,10 +1,12 @@
+const UserError = require('vn-loopback/util/user-error');
+
 module.exports = Self => {
     Self.remoteMethodCtx('canEdit', {
         description: 'Check if all the received sales are aditable',
         accessType: 'READ',
         accepts: [{
             arg: 'sales',
-            type: ['object'],
+            type: ['number'],
             required: true
         }],
         returns: {
@@ -12,29 +14,48 @@ module.exports = Self => {
             root: true
         },
         http: {
-            path: `/isEditable`,
+            path: `/canEdit`,
-            verb: 'get'
+            verb: 'GET'
         }
     });
 
     Self.canEdit = async(ctx, sales, options) => {
         const models = Self.app.models;
-        const userId = ctx.req.accessToken.userId;
         const myOptions = {};
 
         if (typeof options == 'object')
             Object.assign(myOptions, options);
 
-        const idsCollection = sales.map(sale => sale.id);
+        const salesData = await models.Sale.find({
+            fields: ['id', 'itemFk', 'ticketFk'],
+            where: {id: {inq: sales}},
+            include:
+            {
+                relation: 'item',
+                scope: {
+                    fields: ['id', 'isFloramondo'],
+                }
+            }
+        }, myOptions);
 
-        const saleTracking = await models.SaleTracking.find({where: {saleFk: {inq: idsCollection}}}, myOptions);
+        const ticketId = salesData[0].ticketFk;
 
-        const hasSaleTracking = saleTracking.length;
+        const isTicketEditable = await models.Ticket.isEditable(ctx, ticketId, myOptions);
+        if (!isTicketEditable)
+            throw new UserError(`The sales of this ticket can't be modified`);
 
-        const isProductionRole = await models.Account.hasRole(userId, 'production', myOptions);
+        const hasSaleTracking = await models.SaleTracking.findOne({where: {saleFk: {inq: sales}}}, myOptions);
+        const hasSaleCloned = await models.SaleCloned.findOne({where: {saleClonedFk: {inq: sales}}}, myOptions);
+        const hasSaleFloramondo = salesData.find(sale => sale.item().isFloramondo);
 
-        const canEdit = (isProductionRole || !hasSaleTracking);
+        const canEditTracked = await models.ACL.checkAccessAcl(ctx, 'Sale', 'editTracked');
+        const canEditCloned = await models.ACL.checkAccessAcl(ctx, 'Sale', 'editCloned');
+        const canEditFloramondo = await models.ACL.checkAccessAcl(ctx, 'Sale', 'editFloramondo');
 
-        return canEdit;
+        const shouldEditTracked = canEditTracked || !hasSaleTracking;
+        const shouldEditCloned = canEditCloned || !hasSaleCloned;
+        const shouldEditFloramondo = canEditFloramondo || !hasSaleFloramondo;
+
+        return shouldEditTracked && shouldEditCloned && shouldEditFloramondo;
     };
 };

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

@@ -41,7 +41,11 @@ module.exports = Self => {
         }
 
         try {
-            const canEditSales = await models.Sale.canEdit(ctx, sales, myOptions);
+            const saleIds = sales.map(sale => sale.id);
+
+            const canEditSales = await models.Sale.canEdit(ctx, saleIds, myOptions);
+            if (!canEditSales)
+                throw new UserError(`Sale(s) blocked, please contact production`);
 
             const ticket = await models.Ticket.findById(ticketId, {
                 include: {
@@ -57,13 +61,6 @@ module.exports = Self => {
                 }
             }, myOptions);
 
-            const isTicketEditable = await models.Ticket.isEditable(ctx, ticketId, myOptions);
-            if (!isTicketEditable)
-                throw new UserError(`The sales of this ticket can't be modified`);
-
-            if (!canEditSales)
-                throw new UserError(`Sale(s) blocked, please contact production`);
-
             const promises = [];
             let deletions = '';
             for (let sale of sales) {

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

@@ -1,4 +1,5 @@
 const UserError = require('vn-loopback/util/user-error');
+
 module.exports = Self => {
     Self.remoteMethodCtx('recalculatePrice', {
         description: 'Calculates the price of sales and its components',
@@ -34,15 +35,9 @@ module.exports = Self => {
         }
 
         try {
-            const salesIds = [];
+            const salesIds = sales.map(sale => sale.id);
-            for (let sale of sales)
-                salesIds.push(sale.id);
 
-            const isEditable = await models.Ticket.isEditable(ctx, sales[0].ticketFk, myOptions);
+            const canEditSale = await models.Sale.canEdit(ctx, salesIds, myOptions);
-            if (!isEditable)
-                throw new UserError(`The sales of this ticket can't be modified`);
-
-            const canEditSale = await models.Sale.canEdit(ctx, sales, myOptions);
             if (!canEditSale)
                 throw new UserError(`Sale(s) blocked, please contact production`);
 

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

@@ -49,12 +49,9 @@ module.exports = Self => {
         }
 
         try {
-            const isTicketEditable = await models.Ticket.isEditable(ctx, ticketId, myOptions);
+            const salesIds = sales.map(sale => sale.id);
-            if (!isTicketEditable)
-                throw new UserError(`The sales of this ticket can't be modified`);
-
-            const canEditSale = await models.Sale.canEdit(ctx, sales, myOptions);
 
+            const canEditSale = await models.Sale.canEdit(ctx, salesIds, myOptions);
             if (!canEditSale)
                 throw new UserError(`Sale(s) blocked, please contact production`);
 

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

@@ -1,6 +1,9 @@
 const models = require('vn-loopback/server/server').models;
 
 describe('sale canEdit()', () => {
+    const employeeId = 1;
+
+    describe('sale editTracked', () => {
         it('should return true if the role is production regardless of the saleTrackings', async() => {
             const tx = await models.Sale.beginTransaction({});
 
@@ -10,7 +13,7 @@ describe('sale canEdit()', () => {
                 const productionUserID = 49;
                 const ctx = {req: {accessToken: {userId: productionUserID}}};
 
-            const sales = [{id: 3}];
+                const sales = [25];
 
                 const result = await models.Sale.canEdit(ctx, sales, options);
 
@@ -32,7 +35,7 @@ describe('sale canEdit()', () => {
                 const salesPersonUserID = 18;
                 const ctx = {req: {accessToken: {userId: salesPersonUserID}}};
 
-            const sales = [{id: 10}];
+                const sales = [10];
 
                 const result = await models.Sale.canEdit(ctx, sales, options);
 
@@ -51,10 +54,10 @@ describe('sale canEdit()', () => {
             try {
                 const options = {transaction: tx};
 
-            const salesPersonUserID = 18;
+                const buyerId = 35;
-            const ctx = {req: {accessToken: {userId: salesPersonUserID}}};
+                const ctx = {req: {accessToken: {userId: buyerId}}};
 
-            const sales = [{id: 3}];
+                const sales = [31];
 
                 const result = await models.Sale.canEdit(ctx, sales, options);
 
@@ -66,4 +69,125 @@ describe('sale canEdit()', () => {
                 throw e;
             }
         });
+    });
+
+    describe('sale editCloned', () => {
+        const saleCloned = [29];
+        it('should return false if any of the sales is cloned', async() => {
+            const tx = await models.Sale.beginTransaction({});
+
+            try {
+                const options = {transaction: tx};
+
+                const buyerId = 35;
+                const ctx = {req: {accessToken: {userId: buyerId}}};
+
+                const result = await models.Sale.canEdit(ctx, saleCloned, options);
+
+                expect(result).toEqual(false);
+
+                await tx.rollback();
+            } catch (e) {
+                await tx.rollback();
+                throw e;
+            }
+        });
+
+        it('should return true if any of the sales is cloned and has the correct role', async() => {
+            const tx = await models.Sale.beginTransaction({});
+            const roleEnabled = await models.ACL.findOne({
+                where: {
+                    model: 'Sale',
+                    property: 'editCloned',
+                    permission: 'ALLOW'
+                }
+            });
+            if (!roleEnabled || !roleEnabled.principalId) return await tx.rollback();
+
+            try {
+                const options = {transaction: tx};
+
+                const role = await models.Role.findOne({
+                    where: {
+                        name: roleEnabled.principalId
+                    }
+                });
+                const ctx = {req: {accessToken: {userId: role.id}}};
+
+                const result = await models.Sale.canEdit(ctx, saleCloned, options);
+
+                expect(result).toEqual(true);
+
+                await tx.rollback();
+            } catch (e) {
+                await tx.rollback();
+                throw e;
+            }
+        });
+    });
+
+    describe('sale editFloramondo', () => {
+        it('should return false if any of the sales isFloramondo', async() => {
+            const tx = await models.Sale.beginTransaction({});
+            const sales = [26];
+
+            try {
+                const options = {transaction: tx};
+
+                const ctx = {req: {accessToken: {userId: employeeId}}};
+
+                // For test
+                const saleToEdit = await models.Sale.findById(sales[0], null, options);
+                await saleToEdit.updateAttribute('itemFk', 9, options);
+
+                const result = await models.Sale.canEdit(ctx, sales, options);
+
+                expect(result).toEqual(false);
+
+                await tx.rollback();
+            } catch (e) {
+                await tx.rollback();
+                throw e;
+            }
+        });
+
+        it('should return true if any of the sales is of isFloramondo and has the correct role', async() => {
+            const tx = await models.Sale.beginTransaction({});
+            const sales = [26];
+
+            const roleEnabled = await models.ACL.findOne({
+                where: {
+                    model: 'Sale',
+                    property: 'editFloramondo',
+                    permission: 'ALLOW'
+                }
+            });
+
+            if (!roleEnabled || !roleEnabled.principalId) return await tx.rollback();
+
+            try {
+                const options = {transaction: tx};
+
+                const role = await models.Role.findOne({
+                    where: {
+                        name: roleEnabled.principalId
+                    }
+                });
+                const ctx = {req: {accessToken: {userId: role.id}}};
+
+                // For test
+                const saleToEdit = await models.Sale.findById(sales[0], null, options);
+                await saleToEdit.updateAttribute('itemFk', 9, options);
+
+                const result = await models.Sale.canEdit(ctx, sales, options);
+
+                expect(result).toEqual(true);
+
+                await tx.rollback();
+            } catch (e) {
+                await tx.rollback();
+                throw e;
+            }
+        });
+    });
 });

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

@@ -3,7 +3,7 @@ const models = require('vn-loopback/server/server').models;
 describe('sale reserve()', () => {
     const ctx = {
         req: {
-            accessToken: {userId: 9},
+            accessToken: {userId: 1},
             headers: {origin: 'localhost:5000'},
             __: () => {}
         }

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

@@ -2,7 +2,7 @@ const models = require('vn-loopback/server/server').models;
 
 describe('sale updateConcept()', () => {
     const ctx = {req: {accessToken: {userId: 9}}};
-    const saleId = 1;
+    const saleId = 25;
 
     it('should throw if ID was undefined', async() => {
         const tx = await models.Sale.beginTransaction({});

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

@@ -9,32 +9,21 @@ describe('sale updateQuantity()', () => {
         }
     };
 
-    it('should throw an error if the quantity is not a number', async() => {
-        const tx = await models.Sale.beginTransaction({});
-
-        let error;
-        try {
-            const options = {transaction: tx};
-
-            await models.Sale.updateQuantity(ctx, 1, 'wrong quantity!', options);
-
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            error = e;
-        }
-
-        expect(error).toEqual(new Error('The value should be a number'));
-    });
-
     it('should throw an error if the quantity is greater than it should be', async() => {
+        const ctx = {
+            req: {
+                accessToken: {userId: 1},
+                headers: {origin: 'localhost:5000'},
+                __: () => {}
+            }
+        };
         const tx = await models.Sale.beginTransaction({});
 
         let error;
         try {
             const options = {transaction: tx};
 
-            await models.Sale.updateQuantity(ctx, 1, 99, options);
+            await models.Sale.updateQuantity(ctx, 17, 99, options);
 
             await tx.rollback();
         } catch (e) {
@@ -45,21 +34,60 @@ describe('sale updateQuantity()', () => {
         expect(error).toEqual(new Error('The new quantity should be smaller than the old one'));
     });
 
-    it('should update the quantity of a given sale current line', async() => {
+    it('should add quantity if the quantity is greater than it should be and is role advanced', async() => {
         const tx = await models.Sale.beginTransaction({});
+        const saleId = 17;
+        const buyerId = 35;
+        const ctx = {
+            req: {
+                accessToken: {userId: buyerId},
+                headers: {origin: 'localhost:5000'},
+                __: () => {}
+            }
+        };
 
         try {
             const options = {transaction: tx};
 
-            const originalLine = await models.Sale.findOne({where: {id: 1}, fields: ['quantity']}, options);
+            const isRoleAdvanced = await models.Ticket.isRoleAdvanced(ctx, options);
 
-            expect(originalLine.quantity).toEqual(5);
+            expect(isRoleAdvanced).toEqual(true);
 
-            await models.Sale.updateQuantity(ctx, 1, 4, options);
+            const originalLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
 
-            const modifiedLine = await models.Sale.findOne({where: {id: 1}, fields: ['quantity']}, options);
+            expect(originalLine.quantity).toEqual(30);
 
-            expect(modifiedLine.quantity).toEqual(4);
+            const newQuantity = originalLine.quantity + 1;
+            await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
+
+            const modifiedLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
+
+            expect(modifiedLine.quantity).toEqual(newQuantity);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should update the quantity of a given sale current line', async() => {
+        const tx = await models.Sale.beginTransaction({});
+        const saleId = 25;
+        const newQuantity = 4;
+
+        try {
+            const options = {transaction: tx};
+
+            const originalLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
+
+            expect(originalLine.quantity).toEqual(20);
+
+            await models.Sale.updateQuantity(ctx, saleId, newQuantity, options);
+
+            const modifiedLine = await models.Sale.findOne({where: {id: saleId}, fields: ['quantity']}, options);
+
+            expect(modifiedLine.quantity).toEqual(newQuantity);
 
             await tx.rollback();
         } catch (e) {

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

@@ -66,12 +66,7 @@ module.exports = Self => {
 
             const sale = await models.Sale.findById(id, filter, myOptions);
 
-            const isEditable = await models.Ticket.isEditable(ctx, sale.ticketFk, myOptions);
-            if (!isEditable)
-                throw new UserError(`The sales of this ticket can't be modified`);
-
             const canEditSale = await models.Sale.canEdit(ctx, [id], myOptions);
-
             if (!canEditSale)
                 throw new UserError(`Sale(s) blocked, please contact production`);
 

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

@@ -42,13 +42,9 @@ module.exports = Self => {
 
         try {
             const canEditSale = await models.Sale.canEdit(ctx, [id], myOptions);
-
             if (!canEditSale)
                 throw new UserError(`Sale(s) blocked, please contact production`);
 
-            if (isNaN(newQuantity))
-                throw new UserError(`The value should be a number`);
-
             const filter = {
                 include: {
                     relation: 'ticket',
@@ -70,7 +66,8 @@ module.exports = Self => {
 
             const sale = await models.Sale.findById(id, filter, myOptions);
 
-            if (newQuantity > sale.quantity)
+            const isRoleAdvanced = await models.Ticket.isRoleAdvanced(ctx, myOptions);
+            if (newQuantity > sale.quantity && !isRoleAdvanced)
                 throw new UserError('The new quantity should be smaller than the old one');
 
             const oldQuantity = sale.quantity;

modules/ticket/back/methods/ticket-future/getTicketsFuture.js

@@ -0,0 +1,224 @@
+const ParameterizedSQL = require('loopback-connector').ParameterizedSQL;
+const buildFilter = require('vn-loopback/util/filter').buildFilter;
+const mergeFilters = require('vn-loopback/util/filter').mergeFilters;
+const UserError = require('vn-loopback/util/user-error');
+
+module.exports = Self => {
+    Self.remoteMethodCtx('getTicketsFuture', {
+        description: 'Find all tickets that can be moved to the future',
+        accessType: 'READ',
+        accepts: [
+            {
+                arg: 'originDated',
+                type: 'date',
+                description: 'The date in question',
+                required: true
+            },
+            {
+                arg: 'futureDated',
+                type: 'date',
+                description: 'The date to probe',
+                required: true
+            },
+            {
+                arg: 'litersMax',
+                type: 'number',
+                description: 'Maximum volume of tickets to catapult',
+                required: true
+            },
+            {
+                arg: 'linesMax',
+                type: 'number',
+                description: 'Maximum number of lines of tickets to catapult',
+                required: true
+            },
+            {
+                arg: 'warehouseFk',
+                type: 'number',
+                description: 'Warehouse identifier',
+                required: true
+            },
+            {
+                arg: 'shipped',
+                type: 'date',
+                description: 'Origin shipped',
+                required: false
+            },
+            {
+                arg: 'tfShipped',
+                type: 'date',
+                description: 'Destination shipped',
+                required: false
+            },
+            {
+                arg: 'ipt',
+                type: 'string',
+                description: 'Origin Item Packaging Type',
+                required: false
+            },
+            {
+                arg: 'tfIpt',
+                type: 'string',
+                description: 'Destination Item Packaging Type',
+                required: false
+            },
+            {
+                arg: 'id',
+                type: 'number',
+                description: 'Origin id',
+                required: false
+            },
+            {
+                arg: 'tfId',
+                type: 'number',
+                description: 'Destination id',
+                required: false
+            },
+            {
+                arg: 'state',
+                type: 'string',
+                description: 'Origin state',
+                required: false
+            },
+            {
+                arg: 'tfState',
+                type: 'string',
+                description: 'Destination state',
+                required: false
+            },
+            {
+                arg: 'problems',
+                type: 'boolean',
+                description: `Whether to show only tickets with problems`,
+                required: false
+            },
+            {
+                arg: 'filter',
+                type: 'object',
+                description: `Filter defining where, order, offset, and limit - must be a JSON-encoded string`
+            }
+        ],
+        returns: {
+            type: ['object'],
+            root: true
+        },
+        http: {
+            path: `/getTicketsFuture`,
+            verb: 'GET'
+        }
+    });
+
+    Self.getTicketsFuture = async (ctx, options) => {
+        const args = ctx.args;
+        const conn = Self.dataSource.connector;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const where = buildFilter(ctx.args, (param, value) => {
+            switch (param) {
+                case 'id':
+                    return { 'f.id': value };
+                case 'tfId':
+                    return { 'f.ticketFuture': value };
+                case 'shipped':
+                    return { 'f.shipped': value };
+                case 'tfShipped':
+                    return { 'f.tfShipped': value };
+                case 'ipt':
+                    return { 'f.ipt': value };
+                case 'tfIpt':
+                    return { 'f.tfIpt': value };
+                case 'state':
+                    return { 'f.code': { like: `%${value}%` } };
+                case 'tfState':
+                    return { 'f.tfCode': { like: `%${value}%` } };
+            }
+        });
+
+        let filter = mergeFilters(ctx.args.filter, { where });
+        const stmts = [];
+        let stmt;
+
+        stmt = new ParameterizedSQL(
+            `CALL vn.ticket_canbePostponed(?,?,?,?,?)`,
+            [args.originDated, args.futureDated, args.litersMax, args.linesMax, args.warehouseFk]);
+
+        stmts.push(stmt);
+
+        stmts.push('DROP TEMPORARY TABLE IF EXISTS tmp.sale_getProblems');
+
+        stmt = new ParameterizedSQL(`
+            CREATE TEMPORARY TABLE tmp.sale_getProblems
+            (INDEX (ticketFk))
+            ENGINE = MEMORY
+            SELECT f.id ticketFk, f.clientFk, f.warehouseFk, f.shipped
+            FROM tmp.filter f
+            LEFT JOIN alertLevel al ON al.id = f.alertLevel
+            WHERE (al.code = 'FREE' OR f.alertLevel IS NULL)`);
+        stmts.push(stmt);
+
+        stmts.push('CALL ticket_getProblems(FALSE)');
+
+        stmt = new ParameterizedSQL(`
+            SELECT f.*, tp.*
+            FROM tmp.filter f
+            LEFT JOIN tmp.ticket_problems tp ON tp.ticketFk = f.id`);
+
+        if (args.problems != undefined && (!args.originDated && !args.futureDated))
+            throw new UserError('Choose a date range or days forward');
+
+        let condition;
+        let hasProblem;
+        let range;
+        let hasWhere;
+        switch (args.problems) {
+            case true:
+                condition = `or`;
+                hasProblem = true;
+                range = { neq: null };
+                hasWhere = true;
+                break;
+
+            case false:
+                condition = `and`;
+                hasProblem = null;
+                range = null;
+                hasWhere = true;
+                break;
+        }
+
+        const problems = {
+            [condition]: [
+                { 'tp.isFreezed': hasProblem },
+                { 'tp.risk': hasProblem },
+                { 'tp.hasTicketRequest': hasProblem },
+                { 'tp.itemShortage': range },
+                { 'tp.hasComponentLack': hasProblem },
+                { 'tp.isTooLittle': hasProblem }
+            ]
+        };
+
+        if (hasWhere) {
+            filter = mergeFilters(filter, { where: problems });
+        }
+
+        stmt.merge(conn.makeWhere(filter.where));
+        stmt.merge(conn.makeOrderBy(filter.order));
+        stmt.merge(conn.makeLimit(filter));
+
+        const ticketsIndex = stmts.push(stmt) - 1;
+
+        stmts.push(
+            `DROP TEMPORARY TABLE
+                tmp.filter,
+                tmp.ticket_problems`);
+
+        const sql = ParameterizedSQL.join(stmts, ';');
+
+        const result = await conn.executeStmt(sql, myOptions);
+
+        return result[ticketsIndex];
+    };
+};

modules/ticket/back/methods/ticket-future/spec/getTicketsFuture.spec.js

@@ -0,0 +1,438 @@
+const models = require('vn-loopback/server/server').models;
+
+describe('TicketFuture getTicketsFuture()', () => {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const tomorrow = new Date(today.getDate() + 1);
+
+    it('should return the tickets passing the required data', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(4);
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the problems on true', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                problems: true
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(4);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the problems on false', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                problems: false
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(0);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the problems on null', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                problems: null
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(4);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the correct origin shipped', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                shipped: today
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(4);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the an incorrect origin shipped', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                shipped: tomorrow
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(0);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the correct destination shipped', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                tfShipped: today
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(4);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the an incorrect destination shipped', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                tfShipped: tomorrow
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(0);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the OK State in origin date', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                state: "OK"
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(1);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the OK State in destination date', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                tfState: "OK"
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(4);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the correct IPT in origin date', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                ipt: null
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(4);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the incorrect IPT in origin date', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                ipt: 0
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(0);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the correct IPT in destination date', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                tfIpt: null
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(4);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the incorrect IPT in destination date', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                tfIpt: 0
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(0);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the ID in origin date', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                id: 13
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(1);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+    it('should return the tickets matching the ID in destination date', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+
+            const args = {
+                originDated: today,
+                futureDated: today,
+                litersMax: 9999,
+                linesMax: 9999,
+                warehouseFk: 1,
+                tfId: 12
+            };
+
+            const ctx = { req: { accessToken: { userId: 9 } }, args };
+            const result = await models.Ticket.getTicketsFuture(ctx, options);
+
+            expect(result.length).toEqual(4);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+
+});

modules/ticket/back/methods/ticket-weekly/specs/filter.spec.js

@@ -17,7 +17,7 @@ describe('ticket-weekly filter()', () => {
             const firstRow = result[0];
 
             expect(firstRow.ticketFk).toEqual(1);
-            expect(result.length).toEqual(5);
+            expect(result.length).toEqual(6);
 
             await tx.rollback();
         } catch (e) {

modules/ticket/back/methods/ticket/isEditable.js

@@ -20,24 +20,20 @@ module.exports = Self => {
     });
 
     Self.isEditable = async(ctx, id, options) => {
-        const userId = ctx.req.accessToken.userId;
+        const models = Self.app.models;
         const myOptions = {};
 
         if (typeof options == 'object')
             Object.assign(myOptions, options);
 
-        let state = await Self.app.models.TicketState.findOne({
+        const state = await models.TicketState.findOne({
             where: {ticketFk: id}
         }, myOptions);
 
-        const isSalesAssistant = await Self.app.models.Account.hasRole(userId, 'salesAssistant', myOptions);
+        const isRoleAdvanced = await models.Ticket.isRoleAdvanced(ctx, myOptions);
-        const isDeliveryBoss = await Self.app.models.Account.hasRole(userId, 'deliveryBoss', myOptions);
-        const isBuyer = await Self.app.models.Account.hasRole(userId, 'buyer', myOptions);
 
-        const isValidRole = isSalesAssistant || isDeliveryBoss || isBuyer;
+        const alertLevel = state ? state.alertLevel : null;
-
+        const ticket = await models.Ticket.findById(id, {
-        let alertLevel = state ? state.alertLevel : null;
-        let ticket = await Self.app.models.Ticket.findById(id, {
             fields: ['clientFk'],
             include: [{
                 relation: 'client',
@@ -48,15 +44,17 @@ module.exports = Self => {
                 }
             }]
         }, myOptions);
-        const isLocked = await Self.app.models.Ticket.isLocked(id, myOptions);
+
+        const isLocked = await models.Ticket.isLocked(id, myOptions);
+        const isWeekly = await models.TicketWeekly.findOne({where: {ticketFk: id}}, myOptions);
 
         const alertLevelGreaterThanZero = (alertLevel && alertLevel > 0);
         const isNormalClient = ticket && ticket.client().type().code == 'normal';
-        const validAlertAndRoleNormalClient = (alertLevelGreaterThanZero && isNormalClient && !isValidRole);
+        const isEditable = !(alertLevelGreaterThanZero && isNormalClient);
-
-        if (!ticket || validAlertAndRoleNormalClient || isLocked)
-            return false;
 
+        if (ticket && (isEditable || isRoleAdvanced) && !isLocked && !isWeekly)
             return true;
+
+        return false;
     };
 };

modules/ticket/back/methods/ticket/isRoleAdvanced.js

@@ -0,0 +1,32 @@
+module.exports = Self => {
+    Self.remoteMethodCtx('isRoleAdvanced', {
+        description: 'Check if a ticket is editable',
+        accessType: 'READ',
+        returns: {
+            type: 'boolean',
+            root: true
+        },
+        http: {
+            path: `/isRoleAdvanced`,
+            verb: 'GET'
+        }
+    });
+
+    Self.isRoleAdvanced = async(ctx, options) => {
+        const models = Self.app.models;
+        const userId = ctx.req.accessToken.userId;
+        const myOptions = {};
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        const isSalesAssistant = await models.Account.hasRole(userId, 'salesAssistant', myOptions);
+        const isDeliveryBoss = await models.Account.hasRole(userId, 'deliveryBoss', myOptions);
+        const isBuyer = await models.Account.hasRole(userId, 'buyer', myOptions);
+        const isClaimManager = await models.Account.hasRole(userId, 'claimManager', myOptions);
+
+        const isRoleAdvanced = isSalesAssistant || isDeliveryBoss || isBuyer || isClaimManager;
+
+        return isRoleAdvanced;
+    };
+};

modules/ticket/back/methods/ticket/merge.js

@@ -0,0 +1,65 @@
+const dateUtil = require('vn-loopback/util/date');
+
+module.exports = Self => {
+    Self.remoteMethodCtx('merge', {
+        description: 'Merge one ticket into another',
+        accessType: 'WRITE',
+        accepts: [
+            {
+                arg: 'tickets',
+                type: ['object'],
+                description: 'The array of tickets',
+                required: false
+            }
+        ],
+        returns: {
+            type: 'string',
+            root: true
+        },
+        http: {
+            path: `/merge`,
+            verb: 'POST'
+        }
+    });
+
+    Self.merge = async(ctx, tickets, options) => {
+        const httpRequest = ctx.req;
+        const $t = httpRequest.__;
+        const origin = httpRequest.headers.origin;
+        const models = Self.app.models;
+        const myOptions = {};
+        let tx;
+
+        if (typeof options == 'object')
+            Object.assign(myOptions, options);
+
+        if (!myOptions.transaction) {
+            tx = await Self.beginTransaction({});
+            myOptions.transaction = tx;
+        }
+
+        try {
+            for (let ticket of tickets) {
+                const fullPath = `${origin}/#!/ticket/${ticket.id}/summary`;
+                const fullPathFuture = `${origin}/#!/ticket/${ticket.ticketFuture}/summary`;
+                const message = $t('Ticket merged', {
+                    originDated: dateUtil.toString(new Date(ticket.originETD)),
+                    futureDated: dateUtil.toString(new Date(ticket.destETD)),
+                    id: ticket.id,
+                    tfId: ticket.ticketFuture,
+                    fullPath,
+                    fullPathFuture
+                });
+                if (!ticket.id || !ticket.ticketFuture) continue;
+                await models.Sale.updateAll({ticketFk: ticket.id}, {ticketFk: ticket.ticketFuture}, myOptions);
+                await models.Ticket.setDeleted(ctx, ticket.id, myOptions);
+                await models.Chat.sendCheckingPresence(ctx, ticket.workerFk, message);
+            }
+            if (tx)
+                await tx.commit();
+        } catch (e) {
+            if (tx) await tx.rollback();
+            throw e;
+        }
+    };
+};

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

@@ -1,4 +1,5 @@
 const models = require('vn-loopback/server/server').models;
+const LoopBackContext = require('loopback-context');
 
 describe('ticket componentUpdate()', () => {
     const userID = 1101;
@@ -178,10 +179,15 @@ describe('ticket componentUpdate()', () => {
                     }
                 }
             };
+
+            spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
+                active: ctx.req
+            });
+            const oldTicket = await models.Ticket.findById(ticketID, null, options);
+
             await models.Ticket.componentUpdate(ctx, options);
 
             const [newTicketID] = await models.Ticket.rawSql('SELECT MAX(id) as id FROM ticket', null, options);
-            const oldTicket = await models.Ticket.findById(ticketID, null, options);
             const newTicket = await models.Ticket.findById(newTicketID.id, null, options);
             const newTicketSale = await models.Sale.findOne({where: {ticketFk: args.id}}, options);
 

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

@@ -11,7 +11,7 @@ describe('ticket filter()', () => {
             const filter = {order: 'id DESC'};
             const result = await models.Ticket.filter(ctx, filter, options);
 
-            expect(result.length).toEqual(27);
+            expect(result.length).toBeGreaterThan(25);
 
             await tx.rollback();
         } catch (e) {
@@ -87,7 +87,7 @@ describe('ticket filter()', () => {
             const filter = {};
             const result = await models.Ticket.filter(ctx, filter, options);
 
-            expect(result.length).toEqual(27);
+            expect(result.length).toBeGreaterThan(25);
 
             await tx.rollback();
         } catch (e) {
@@ -130,7 +130,7 @@ describe('ticket filter()', () => {
             const length = result.length;
             const anyResult = result[Math.floor(Math.random() * Math.floor(length))];
 
-            expect(length).toEqual(10);
+            expect(length).toBeGreaterThan(10);
             expect(anyResult.state).toMatch(/(Libre|Arreglar)/);
 
             await tx.rollback();
@@ -175,7 +175,7 @@ describe('ticket filter()', () => {
             const filter = {};
             const result = await models.Ticket.filter(ctx, filter, options);
 
-            expect(result.length).toEqual(23);
+            expect(result.length).toEqual(26);
 
             await tx.rollback();
         } catch (e) {
@@ -232,7 +232,7 @@ describe('ticket filter()', () => {
             const filter = {};
             const result = await models.Ticket.filter(ctx, filter, options);
 
-            expect(result.length).toEqual(22);
+            expect(result.length).toBeGreaterThan(20);
 
             await tx.rollback();
         } catch (e) {
@@ -270,7 +270,7 @@ describe('ticket filter()', () => {
             const filter = {};
             const result = await models.Ticket.filter(ctx, filter, options);
 
-            expect(result.length).toEqual(27);
+            expect(result.length).toBeGreaterThan(25);
 
             await tx.rollback();
         } catch (e) {

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

@@ -134,4 +134,23 @@ describe('ticket isEditable()', () => {
 
         expect(result).toEqual(false);
     });
+
+    it('should not be able to edit if is a ticket weekly', async() => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = {transaction: tx};
+
+            const ctx = {req: {accessToken: {userId: 1}}};
+
+            const result = await models.Ticket.isEditable(ctx, 15, options);
+
+            expect(result).toEqual(false);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
 });

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

@@ -0,0 +1,58 @@
+const models = require('vn-loopback/server/server').models;
+const LoopBackContext = require('loopback-context');
+
+describe('ticket merge()', () => {
+    const tickets = [{
+        id: 13,
+        ticketFuture: 12,
+        workerFk: 1,
+        originETD: new Date(),
+        destETD: new Date()
+    }];
+
+    const activeCtx = {
+        accessToken: { userId: 9 },
+    };
+
+    beforeEach(() => {
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
+            active: activeCtx
+        });
+    });
+
+    const ctx = {
+        req: {
+            accessToken: { userId: 9 },
+            headers: { origin: 'http://localhost:5000' },
+        }
+    };
+    ctx.req.__ = value => {
+        return value;
+    };
+
+    it('should merge two tickets', async () => {
+        const tx = await models.Ticket.beginTransaction({});
+
+        try {
+            const options = { transaction: tx };
+            const chatNotificationBeforeMerge = await models.Chat.find();
+
+            await models.Ticket.merge(ctx, tickets, options);
+
+            const createdTicketLog = await models.TicketLog.find({ where: { originFk: tickets[0].id } }, options);
+            const deletedTicket = await models.Ticket.findOne({ where: { id: tickets[0].id } }, options);
+            const salesTicketFuture = await models.Sale.find({ where: { ticketFk: tickets[0].ticketFuture } }, options);
+            const chatNotificationAfterMerge = await models.Chat.find();
+
+            expect(createdTicketLog.length).toEqual(1);
+            expect(deletedTicket.isDeleted).toEqual(true);
+            expect(salesTicketFuture.length).toEqual(2);
+            expect(chatNotificationBeforeMerge.length).toEqual(chatNotificationAfterMerge.length - 2);
+
+            await tx.rollback();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    });
+});

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

@@ -87,7 +87,7 @@ describe('sale priceDifference()', () => {
             const secondtItem = result.items[1];
 
             expect(firstItem.movable).toEqual(410);
-            expect(secondtItem.movable).toEqual(1870);
+            expect(secondtItem.movable).toEqual(1810);
 
             await tx.rollback();
         } catch (e) {

modules/ticket/back/model-config.json

@@ -35,6 +35,9 @@
     "SaleChecked": {
         "dataSource": "vn"
     },
+    "SaleCloned": {
+        "dataSource": "vn"
+    },
     "SaleComponent": {
         "dataSource": "vn"
     },
@@ -91,5 +94,8 @@
     },
     "TicketConfig": {
         "dataSource": "vn"
+    },
+    "TicketFuture": {
+        "dataSource": "vn"
     }
 }

modules/ticket/back/models/sale-cloned.json

@@ -0,0 +1,26 @@
+{
+    "name": "SaleCloned",
+    "base": "VnModel",
+    "options": {
+      "mysql": {
+        "table": "saleCloned"
+      }
+    },
+    "properties": {
+      "saleClonedFk": {
+          "id": true
+      }
+  },
+  "relations": {
+    "saleOriginal": {
+      "type": "belongsTo",
+      "model": "Sale",
+      "foreignKey": "saleOriginalFk"
+    },
+    "saleCloned": {
+        "type": "belongsTo",
+        "model": "Sale",
+        "foreignKey": "saleClonedFk"
+      }
+  }
+}

modules/ticket/back/models/ticket-future.json

@@ -0,0 +1,12 @@
+{
+    "name": "TicketFuture",
+    "base": "PersistedModel",
+    "acls": [
+      {
+          "accessType": "READ",
+          "principalType": "ROLE",
+          "principalId": "employee",
+          "permission": "ALLOW"
+      }
+    ]
+  }

modules/ticket/back/models/ticket-methods.js

@@ -33,5 +33,8 @@ module.exports = function(Self) {
     require('../methods/ticket/closeByTicket')(Self);
     require('../methods/ticket/closeByAgency')(Self);
     require('../methods/ticket/closeByRoute')(Self);
+    require('../methods/ticket-future/getTicketsFuture')(Self);
+    require('../methods/ticket/merge')(Self);
+    require('../methods/ticket/isRoleAdvanced')(Self);
     require('../methods/ticket/collectionLabel')(Self);
 };

modules/ticket/front/basic-data/step-two/index.js

@@ -76,7 +76,7 @@ class Controller extends Component {
                 haveNotNegatives = true;
         });
 
-        this.ticket.withoutNegatives = false;
+        this.ticket.withoutNegatives = true;
         this.haveNegatives = (haveNegatives && haveNotNegatives && haveDifferences);
     }
 

modules/ticket/front/expedition/index.spec.js

@@ -76,9 +76,10 @@ describe('Ticket', () => {
             it('should make a query and then call to the $state go() method', () => {
                 jest.spyOn(controller.$state, 'go').mockReturnThis();
 
+                const landed = new Date();
                 const ticket = {
                     clientFk: 1101,
-                    landed: new Date(),
+                    landed: landed,
                     addressFk: 121,
                     agencyModeFk: 1,
                     warehouseFk: 1
@@ -90,7 +91,7 @@ describe('Ticket', () => {
 
                 const expectedParams = {
                     clientId: 1101,
-                    landed: new Date(),
+                    landed: landed,
                     warehouseId: 1,
                     addressId: 121,
                     agencyModeId: 1,

modules/ticket/front/future-search-panel/index.html

@@ -0,0 +1,111 @@
+<div class="search-panel">
+    <form id="manifold-form" ng-submit="$ctrl.onSearch()">
+        <vn-horizontal class="vn-px-lg vn-pt-lg">
+            <vn-date-picker
+                vn-one
+                label="Origin date"
+                ng-model="filter.shipped"
+                on-change="$ctrl.from = value">
+            </vn-date-picker>
+            <vn-date-picker
+                vn-one
+                label="Destination date"
+                ng-model="filter.tfShipped">
+            </vn-date-picker>
+        </vn-horizontal>
+        <vn-horizontal class="vn-px-lg">
+            <vn-date-picker
+                vn-one
+                label="Origin ETD"
+                ng-model="filter.originDated"
+                required="true"
+                info="ETD">
+            </vn-date-picker>
+            <vn-date-picker
+                vn-one
+                label="Destination ETD"
+                ng-model="filter.futureDated"
+                required="true"
+                info="ETD">
+            </vn-date-picker>
+        </vn-horizontal>
+        <vn-horizontal class="vn-px-lg">
+            <vn-textfield
+                vn-one
+                label="Max Lines"
+                ng-model="filter.linesMax"
+                required="true">
+            </vn-textfield>
+            <vn-textfield
+                vn-one
+                label="Max Liters"
+                ng-model="filter.litersMax"
+                required="true">
+            </vn-textfield>
+        </vn-horizontal>
+        <vn-horizontal class="vn-px-lg">
+            <vn-autocomplete vn-one
+                data="$ctrl.itemPackingTypes"
+                label="Origin IPT"
+                value-field="code"
+                show-field="name"
+                ng-model="filter.ipt"
+                info="IPT">
+                <tpl-item>
+                    {{name}}
+                </tpl-item>
+            </vn-autocomplete>
+            <vn-autocomplete vn-one
+                data="$ctrl.itemPackingTypes"
+                label="Destination IPT"
+                value-field="code"
+                show-field="name"
+                ng-model="filter.tfIpt"
+                info="IPT">
+                <tpl-item>
+                    {{name}}
+                </tpl-item>
+            </vn-autocomplete>
+        </vn-horizontal>
+        <vn-horizontal class="vn-px-lg">
+            <vn-autocomplete vn-one
+                data="$ctrl.groupedStates"
+                label="Origin Grouped State"
+                value-field="code"
+                show-field="name"
+                ng-model="filter.state">
+                <tpl-item>
+                    {{name}}
+                </tpl-item>
+            </vn-autocomplete>
+            <vn-autocomplete vn-one
+                data="$ctrl.groupedStates"
+                label="Destination Grouped State"
+                value-field="code"
+                show-field="name"
+                ng-model="filter.tfState">
+                <tpl-item>
+                    {{name}}
+                </tpl-item>
+            </vn-autocomplete>
+        </vn-horizontal>
+        <vn-horizontal class="vn-px-lg">
+            <vn-check
+                vn-one
+                label="With problems"
+                ng-model="filter.problems"
+                triple-state="true">
+            </vn-check>
+            <vn-autocomplete
+                vn-one
+                label="Warehouse"
+                ng-model="filter.warehouseFk"
+                url="Warehouses"
+                required="true">
+            </vn-autocomplete>
+        </vn-horizontal>
+        <vn-horizontal class="vn-px-lg vn-pb-lg vn-mt-lg">
+            <vn-submit label="Search"></vn-submit>
+        </vn-horizontal>
+    </form>
+</div>

modules/ticket/front/future-search-panel/index.js

@@ -0,0 +1,44 @@
+import ngModule from '../module';
+import SearchPanel from 'core/components/searchbar/search-panel';
+
+class Controller extends SearchPanel {
+    constructor($, $element) {
+        super($, $element);
+        this.filter = this.$.filter;
+        this.getGroupedStates();
+        this.getItemPackingTypes();
+    }
+
+    getGroupedStates() {
+        let groupedStates = [];
+        this.$http.get('AlertLevels').then(res => {
+            for (let state of res.data) {
+                groupedStates.push({
+                    id: state.id,
+                    code: state.code,
+                    name: this.$t(state.code)
+                });
+            }
+            this.groupedStates = groupedStates;
+        });
+    }
+
+    getItemPackingTypes() {
+        let itemPackingTypes = [];
+        this.$http.get('ItemPackingTypes').then(res => {
+            for (let ipt of res.data) {
+                itemPackingTypes.push({
+                    id: ipt.id,
+                    code: ipt.code,
+                    name: this.$t(ipt.code)
+                });
+            }
+            this.itemPackingTypes = itemPackingTypes;
+        });
+    }
+}
+
+ngModule.vnComponent('vnFutureTicketSearchPanel', {
+    template: require('./index.html'),
+    controller: Controller
+});

modules/ticket/front/future-search-panel/locale/en.yml

@@ -0,0 +1,9 @@
+Future tickets: Tickets a futuro
+FREE: Free
+DELIVERED: Delivered
+ON_PREPARATION: On preparation
+PACKED: Packed
+F: Fruits and vegetables
+V: Vertical
+H: Horizontal
+P: Feed

modules/ticket/front/future-search-panel/locale/es.yml

@@ -0,0 +1,23 @@
+Future tickets: Tickets a futuro
+Origin date: Fecha origen
+Destination date: Fecha destino
+Origin ETD: ETD origen
+Destination ETD: ETD destino
+Max Lines: Líneas máx.
+Max Liters: Litros máx.
+Origin IPT: IPT origen
+Destination IPT: IPT destino
+With problems: Con problemas
+Warehouse: Almacén
+Origin Grouped State: Estado agrupado origen
+Destination Grouped State: Estado agrupado destino
+FREE: Libre
+DELIVERED: Servido
+ON_PREPARATION: En preparacion
+PACKED: Encajado
+F: Frutas y verduras
+V: Vertical
+H: Horizontal
+P: Pienso
+ETD: Tiempo estimado de entrega
+IPT: Encajado

modules/ticket/front/future/index.html

@@ -0,0 +1,174 @@
+<vn-crud-model
+    vn-id="model"
+    url="Tickets/getTicketsFuture"
+    limit="20">
+</vn-crud-model>
+<vn-portal slot="topbar">
+    <vn-searchbar
+        vn-focus
+        panel="vn-future-ticket-search-panel"
+        placeholder="Search tickets"
+        info="Search future tickets by date"
+        suggested-filter="$ctrl.filterParams"
+        auto-state="false"
+        model="model">
+    </vn-searchbar>
+</vn-portal>
+<vn-card>
+    <smart-table
+        model="model"
+        options="$ctrl.smartTableOptions"
+        expr-builder="$ctrl.exprBuilder(param, value)"
+        >
+        <slot-actions>
+            <vn-button disabled="$ctrl.checked.length === 0"
+                icon="keyboard_double_arrow_right"
+                ng-click="moveTicketsFuture.show($event)"
+                vn-tooltip="Future tickets">
+            </vn-button>
+        </slot-actions>
+        <slot-table>
+            <table>
+                <thead>
+                    <tr>
+                        <th shrink>
+                            <vn-multi-check
+                                model="model"
+                                checked="$ctrl.checkAll"
+                                check-field="checked">
+                            </vn-multi-check>
+                        </th>
+                        <th field="problems">
+                            <span translate>Problems</span>
+                        </th>
+                        <th field="id">
+                            <span translate>Origin ID</span>
+                        </th>
+                        <th field="originETD">
+                            <span translate>Origin ETD</span>
+                        </th>
+                        <th field="state">
+                            <span translate>Origin State</span>
+                        </th>
+                        <th field="ipt">
+                            <span>IPT</span>
+                        </th>
+                        <th field="litersMax">
+                            <span translate>Liters</span>
+                        </th>
+                        <th field="linesMax">
+                            <span translate>Available Lines</span>
+                        </th>
+                        <th field="ticketFuture">
+                            <span translate>Destination ID</span>
+                        </th>
+                        <th field="destETD">
+                            <span translate>Destination ETD</span>
+                        </th>
+                        <th field="tfState">
+                            <span translate>Destination State</span>
+                        </th>
+                        <th field="tfIpt">
+                            <span>IPT</span>
+                        </th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr ng-repeat="ticket in model.data">
+                        <td>
+                            <vn-check
+                                ng-model="ticket.checked"
+                                vn-click-stop>
+                            </vn-check>
+                        </td>
+                        <td class="icon-field">
+                            <vn-icon
+                                ng-show="::ticket.isTaxDataChecked === 0"
+                                translate-attr="{title: 'No verified data'}"
+                                class="bright"
+                                icon="icon-no036">
+                            </vn-icon>
+                            <vn-icon
+                                ng-show="::ticket.hasTicketRequest"
+                                translate-attr="{title: 'Purchase request'}"
+                                class="bright"
+                                icon="icon-buyrequest">
+                            </vn-icon>
+                            <vn-icon
+                                ng-show="::ticket.itemShortage"
+                                translate-attr="{title: 'Not visible'}"
+                                class="bright"
+                                icon="icon-unavailable">
+                            </vn-icon>
+                            <vn-icon
+                                ng-show="::ticket.isFreezed"
+                                translate-attr="{title: 'Client frozen'}"
+                                class="bright"
+                                icon="icon-frozen">
+                            </vn-icon>
+                            <vn-icon
+                                ng-show="::ticket.risk"
+                                title="{{::$ctrl.$t('Risk')}}: {{ticket.risk}}"
+                                class="bright"
+                                icon="icon-risk">
+                            </vn-icon>
+                            <vn-icon
+                                ng-show="::ticket.hasComponentLack"
+                                translate-attr="{title: 'Component lack'}"
+                                class="bright"
+                                icon="icon-components">
+                            </vn-icon>
+                        </td>
+                        <td><span
+                            ng-click="ticketDescriptor.show($event, ticket.id)"
+                            class="link">
+                            {{::ticket.id}}
+                        </span></td>
+                        <td shrink-date>
+                            <span class="chip {{$ctrl.compareDate(ticket.originETD)}}">
+                                {{::ticket.originETD | date: 'dd/MM/yyyy'}}
+                            </span>
+                        </td>
+                        <td>
+                            <span
+                            class="chip {{$ctrl.stateColor(ticket.state)}}">
+                                {{::ticket.state}}
+                            </span>
+                        </td>
+                        <td>{{::ticket.ipt}}</td>
+                        <td>{{::ticket.liters}}</td>
+                        <td>{{::ticket.lines}}</td>
+                        <td>
+                            <span
+                            ng-click="ticketDescriptor.show($event, ticket.ticketFuture)"
+                            class="link">
+                                {{::ticket.ticketFuture}}
+                            </span>
+                        </td>
+                        <td shrink-date>
+                            <span class="chip {{$ctrl.compareDate(ticket.destETD)}}">
+                                {{::ticket.destETD | date: 'dd/MM/yyyy'}}
+                            </span>
+                        </td>
+                        <td>
+                            <span
+                            class="chip {{$ctrl.stateColor(ticket.tfState)}}">
+                                {{::ticket.tfState}}
+                            </span>
+                        </td>
+                        <td>{{::ticket.tfIpt}}</td>
+                    </tr>
+                </tbody>
+            </table>
+        </slot-table>
+    </smart-table>
+</vn-card>
+<vn-confirm
+    vn-id="moveTicketsFuture"
+    on-accept="$ctrl.moveTicketsFuture()"
+    question="{{$ctrl.confirmationMessage}}"
+    message="Move tickets">
+</vn-confirm>
+<vn-ticket-descriptor-popover
+    vn-id="ticketDescriptor">
+</vn-ticket-descriptor-popover>

modules/ticket/front/future/index.js

@@ -0,0 +1,147 @@
+import ngModule from '../module';
+import Section from 'salix/components/section';
+
+export default class Controller extends Section {
+    constructor($element, $) {
+        super($element, $);
+        this.$checkAll = false;
+
+        this.smartTableOptions = {
+            activeButtons: {
+                search: true,
+            },
+            columns: [{
+                field: 'problems',
+                searchable: false
+            },
+            {
+                field: 'originETD',
+                searchable: false
+            },
+            {
+                field: 'destETD',
+                searchable: false
+            },
+            {
+                field: 'state',
+                searchable: false
+            },
+            {
+                field: 'tfState',
+                searchable: false
+            },
+            {
+                field: 'ipt',
+                autocomplete: {
+                    url: 'ItemPackingTypes',
+                    showField: 'description',
+                    valueField: 'code'
+                }
+            },
+            {
+                field: 'tfIpt',
+                autocomplete: {
+                    url: 'ItemPackingTypes',
+                    showField: 'description',
+                    valueField: 'code'
+                }
+            },
+            ]
+        };
+        this.setDefaultFilter();
+    }
+
+    setDefaultFilter() {
+        const today = new Date();
+
+        this.filterParams = {
+            originDated: today,
+            futureDated: today,
+            linesMax: '9999',
+            litersMax: '9999',
+            warehouseFk: 1
+        };
+    }
+
+    compareDate(date) {
+        let today = new Date();
+        today.setHours(0, 0, 0, 0);
+        let timeTicket = new Date(date);
+        timeTicket.setHours(0, 0, 0, 0);
+
+        let comparation = today - timeTicket;
+
+        if (comparation == 0)
+            return 'warning';
+        if (comparation < 0)
+            return 'success';
+    }
+
+    get checked() {
+        const tickets = this.$.model.data || [];
+        const checkedLines = [];
+        for (let ticket of tickets) {
+            if (ticket.checked)
+                checkedLines.push(ticket);
+        }
+
+        return checkedLines;
+    }
+
+    stateColor(state) {
+        if (state === 'OK')
+            return 'success';
+        else if (state === 'Libre')
+            return 'notice';
+    }
+
+    dateRange(value) {
+        const minHour = new Date(value);
+        minHour.setHours(0, 0, 0, 0);
+        const maxHour = new Date(value);
+        maxHour.setHours(23, 59, 59, 59);
+
+        return [minHour, maxHour];
+    }
+
+    get confirmationMessage() {
+        if (!this.$.model) return 0;
+
+        return this.$t(`Move confirmation`, {
+            checked: this.checked.length
+        });
+    }
+
+    moveTicketsFuture() {
+        let params = { tickets: this.checked };
+        return this.$http.post('Tickets/merge', params)
+            .then(() => {
+                this.$.model.refresh();
+                this.vnApp.showSuccess(this.$t('Success'));
+            });
+    }
+
+    exprBuilder(param, value) {
+        switch (param) {
+            case 'id':
+                return { 'id': value };
+            case 'ticketFuture':
+                return { 'ticketFuture': value };
+            case 'litersMax':
+                return { 'liters': value };
+            case 'linesMax':
+                return { 'lines': value };
+            case 'ipt':
+                return { 'ipt': value };
+            case 'tfIpt':
+                return { 'tfIpt': value };
+        }
+    }
+}
+
+Controller.$inject = ['$element', '$scope'];
+
+ngModule.vnComponent('vnTicketFuture', {
+    template: require('./index.html'),
+    controller: Controller
+});