Merge branch 'dev' of https://gitea.verdnatura.es/verdnatura/salix into 2692-add_advanced_search_engine2

db/changes/10271-wisemen/00-ACL.sql

@@ -0,0 +1 @@
+INSERT INTO `salix`.`ACL` (`model`, `property`, `accessType`, `permission`, `principalType`, `principalId`) VALUES ('FixedPrice', '*', '*', 'ALLOW', 'ROLE', 'buyer');

e2e/helpers/selectors.js

@@ -250,6 +250,18 @@ export default {
         taxClassCheckbox: '.vn-popover.shown vn-horizontal:nth-child(11) > vn-check',
         saveFieldsButton: '.vn-popover.shown vn-button[label="Save"] > button'
     },
+    itemFixedPrice: {
+        add: 'vn-fixed-price vn-icon[icon="add_circle"]',
+        fourthFixedPrice: 'vn-fixed-price vn-tr:nth-child(4)',
+        fourthItemID: 'vn-fixed-price vn-tr:nth-child(4) vn-autocomplete[ng-model="price.itemFk"]',
+        fourthWarehouse: 'vn-fixed-price vn-tr:nth-child(4) vn-autocomplete[ng-model="price.warehouseFk"]',
+        fourthPPU: 'vn-fixed-price vn-tr:nth-child(4) > vn-td-editable:nth-child(4)',
+        fourthPPP: 'vn-fixed-price vn-tr:nth-child(4) > vn-td-editable:nth-child(5)',
+        fourthMinPrice: 'vn-fixed-price vn-tr:nth-child(4) > vn-td-editable:nth-child(6)',
+        fourthStarted: 'vn-fixed-price vn-tr:nth-child(4) vn-date-picker[ng-model="price.started"]',
+        fourthEnded: 'vn-fixed-price vn-tr:nth-child(4) vn-date-picker[ng-model="price.ended"]',
+        fourthDeleteIcon: 'vn-fixed-price vn-tr:nth-child(4) > vn-td:nth-child(9) > vn-icon-button[icon="delete"]'
+    },
     itemCreateView: {
         temporalName: 'vn-item-create vn-textfield[ng-model="$ctrl.item.provisionalName"]',
         type: 'vn-autocomplete[ng-model="$ctrl.item.typeFk"]',
@@ -793,13 +805,13 @@ export default {
     workerCalendar: {
         year: 'vn-worker-calendar vn-autocomplete[ng-model="$ctrl.year"]',
         totalHolidaysUsed: 'vn-worker-calendar div.totalBox > div',
-        januaryThirtyFirst: 'vn-worker-calendar vn-calendar:nth-child(2) section:nth-child(33) > div',
+        penultimateMondayOfJanuary: 'vn-worker-calendar vn-calendar:nth-child(2) section:nth-child(22) > div',
-        marchTwentyThird: 'vn-worker-calendar vn-calendar:nth-child(4) section:nth-child(29) > div',
+        lastMondayOfMarch: 'vn-worker-calendar vn-calendar:nth-child(4) section:nth-child(29) > div',
-        mayFourth: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(8) > div',
+        fistMondayOfMay: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(8) > div',
-        mayEighth: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(12) > div',
+        secondFridayOfJun: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(12) > div',
-        mayTwelfth: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(16) > div',
+        secondTuesdayOfMay: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(16) > div',
-        mayThirteenth: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(17) > div',
+        secondWednesdayOfMay: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(17) > div',
-        mayFourteenth: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(18) > div',
+        secondThursdayOfMay: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(18) > div',
         holidays: 'vn-worker-calendar > vn-side-menu div:nth-child(3) > vn-chip:nth-child(1)',
         absence: 'vn-worker-calendar > vn-side-menu div:nth-child(3) > vn-chip:nth-child(2)',
         halfHoliday: 'vn-worker-calendar > vn-side-menu div:nth-child(3) > vn-chip:nth-child(3)',
@@ -828,12 +840,13 @@ export default {
     },
     travelIndex: {
         anySearchResult: 'vn-travel-index vn-tbody > a',
-        firstSearchResult: 'vn-travel-index vn-tbody > a:nth-child(1)'
+        firstSearchResult: 'vn-travel-index vn-tbody > a:nth-child(1)',
+        firstTravelAddEntryButton: 'vn-travel-index a:nth-child(1) vn-icon[icon="icon-ticket"]',
     },
     travelExtraCommunity: {
         anySearchResult: 'vn-travel-extra-community > vn-data-viewer div > vn-tbody > vn-tr',
-        firstTravelReference: 'vn-travel-extra-community vn-card:nth-child(1) vn-td-editable[name="reference"]',
+        firstTravelReference: 'vn-travel-extra-community vn-tbody:nth-child(2) vn-td-editable[name="reference"]',
-        firstTravelLockedKg: 'vn-travel-extra-community vn-card:nth-child(1) vn-td-editable[name="lockedKg"]',
+        firstTravelLockedKg: 'vn-travel-extra-community vn-tbody:nth-child(2) vn-td-editable[name="lockedKg"]',
         removeContinentFilter: 'vn-searchbar > form > vn-textfield > div.container > div.prepend > prepend > div > span:nth-child(3) > vn-icon > i'
     },
     travelBasicData: {
@@ -867,6 +880,7 @@ export default {
         dotMenu: 'vn-travel-descriptor vn-icon-button[icon="more_vert"]',
         dotMenuClone: '#clone',
         dotMenuCloneWithEntries: '#cloneWithEntries',
+        dotMenuAddEntry: '[name="addEntry"]',
         acceptClonation: 'tpl-buttons > button[response="accept"]'
     },
     travelCreate: {
@@ -897,6 +911,10 @@ export default {
         volumetric: 'vn-zone-basic-data vn-check[ng-model="$ctrl.zone.isVolumetric"]',
         saveButton: 'vn-zone-basic-data vn-submit > button',
     },
+    entryCreate: {
+        travel: 'vn-entry-create vn-autocomplete[ng-model="$ctrl.entry.travelFk"]',
+        company: 'vn-entry-create vn-autocomplete[ng-model="$ctrl.entry.companyFk"]'
+    },
     entrySummary: {
         header: 'vn-entry-summary > vn-card > h5',
         reference: 'vn-entry-summary vn-label-value[label="Reference"]',

e2e/paths/03-worker/05_calendar.spec.js

@@ -27,31 +27,31 @@ describe('Worker calendar path', () => {
         it('should set two days as holidays on the calendar and check the total holidays increased by 1.5', async() => {
             await page.waitToClick(selectors.workerCalendar.holidays);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.januaryThirtyFirst);
+            await page.waitToClick(selectors.workerCalendar.penultimateMondayOfJanuary);
 
             await page.waitForTimeout(reasonableTimeBetweenClicks);
             await page.waitToClick(selectors.workerCalendar.absence);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.marchTwentyThird);
+            await page.waitToClick(selectors.workerCalendar.lastMondayOfMarch);
 
             await page.waitForTimeout(reasonableTimeBetweenClicks);
             await page.waitToClick(selectors.workerCalendar.halfHoliday);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.mayFourth);
+            await page.waitToClick(selectors.workerCalendar.fistMondayOfMay);
 
             await page.waitForTimeout(reasonableTimeBetweenClicks);
             await page.waitToClick(selectors.workerCalendar.furlough);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.mayTwelfth);
+            await page.waitToClick(selectors.workerCalendar.secondTuesdayOfMay);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.mayThirteenth);
+            await page.waitToClick(selectors.workerCalendar.secondWednesdayOfMay);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.mayFourteenth);
+            await page.waitToClick(selectors.workerCalendar.secondThursdayOfMay);
 
             await page.waitForTimeout(reasonableTimeBetweenClicks);
             await page.waitToClick(selectors.workerCalendar.halfFurlough);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.mayEighth);
+            await page.waitToClick(selectors.workerCalendar.secondFridayOfJun);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
 
             const result = await page.waitToGetProperty(selectors.workerCalendar.totalHolidaysUsed, 'innerText');
@@ -71,31 +71,31 @@ describe('Worker calendar path', () => {
             await page.waitForTimeout(reasonableTimeBetweenClicks);
             await page.waitToClick(selectors.workerCalendar.holidays);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.januaryThirtyFirst);
+            await page.waitToClick(selectors.workerCalendar.penultimateMondayOfJanuary);
 
             await page.waitForTimeout(reasonableTimeBetweenClicks);
             await page.waitToClick(selectors.workerCalendar.absence);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.marchTwentyThird);
+            await page.waitToClick(selectors.workerCalendar.lastMondayOfMarch);
 
             await page.waitForTimeout(reasonableTimeBetweenClicks);
             await page.waitToClick(selectors.workerCalendar.halfHoliday);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.mayFourth);
+            await page.waitToClick(selectors.workerCalendar.fistMondayOfMay);
 
             await page.waitForTimeout(reasonableTimeBetweenClicks);
             await page.waitToClick(selectors.workerCalendar.furlough);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.mayTwelfth);
+            await page.waitToClick(selectors.workerCalendar.secondTuesdayOfMay);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.mayThirteenth);
+            await page.waitToClick(selectors.workerCalendar.secondWednesdayOfMay);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.mayFourteenth);
+            await page.waitToClick(selectors.workerCalendar.secondThursdayOfMay);
 
             await page.waitForTimeout(reasonableTimeBetweenClicks);
             await page.waitToClick(selectors.workerCalendar.halfFurlough);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.mayEighth);
+            await page.waitToClick(selectors.workerCalendar.secondFridayOfJun);
         });
 
         it('should check the total holidays used are back to what it was', async() => {
@@ -116,7 +116,7 @@ describe('Worker calendar path', () => {
             await page.waitForTimeout(reasonableTimeBetweenClicks);
             await page.waitToClick(selectors.workerCalendar.holidays);
             await page.waitForTimeout(reasonableTimeBetweenClicks);
-            await page.waitToClick(selectors.workerCalendar.januaryThirtyFirst);
+            await page.waitToClick(selectors.workerCalendar.penultimateMondayOfJanuary);
         });
 
         it('should check the total holidays used are now the initial ones', async() => {

e2e/paths/04-item/14_fixedPrice.spec.js

@@ -0,0 +1,61 @@
+import selectors from '../../helpers/selectors.js';
+import getBrowser from '../../helpers/puppeteer';
+
+describe('Item fixed prices path', () => {
+    let browser;
+    let page;
+    beforeAll(async() => {
+        browser = await getBrowser();
+        page = browser.page;
+        await page.loginAndModule('buyer', 'item');
+        await page.accessToSection('item.fixedPrice');
+    });
+
+    afterAll(async() => {
+        await browser.close();
+    });
+
+    it('should click on the add new foxed price button', async() => {
+        await page.waitToClick(selectors.itemFixedPrice.add);
+        await page.waitForSelector(selectors.itemFixedPrice.fourthFixedPrice);
+    });
+
+    it('should fill the fixed price data', async() => {
+        const now = new Date();
+        const searchValue = 'Chest ammo box';
+        await page.waitToClick(selectors.itemFixedPrice.fourthItemID);
+        await page.write('body > div > div > div.content > div.filter.ng-scope > vn-textfield', searchValue);
+        try {
+            await page.waitForFunction(searchValue => {
+                const element = document.querySelector('li.active');
+                if (element)
+                    return element.innerText.toLowerCase().includes(searchValue.toLowerCase());
+            }, {}, searchValue);
+        } catch (error) {
+            const builtSelector = await page.selectorFormater(selectors.ticketSales.moreMenuState);
+            const inputValue = await page.evaluate(() => {
+                return document.querySelector('.vn-drop-down.shown vn-textfield input').value;
+            });
+            throw new Error(`${builtSelector} value is ${inputValue}! ${error}`);
+        }
+        await page.keyboard.press('Enter');
+        await page.autocompleteSearch(selectors.itemFixedPrice.fourthWarehouse, 'Warehouse one');
+        await page.writeOnEditableTD(selectors.itemFixedPrice.fourthPPU, '20');
+        await page.writeOnEditableTD(selectors.itemFixedPrice.fourthPPP, '10');
+        await page.writeOnEditableTD(selectors.itemFixedPrice.fourthMinPrice, '5');
+        await page.pickDate(selectors.itemFixedPrice.fourthStarted, now);
+        await page.pickDate(selectors.itemFixedPrice.fourthEnded, now);
+        await page.waitForTimeout(1000);
+        const message = await page.waitForSnackbar();
+
+        expect(message.text).toContain('Data saved!');
+    });
+
+    it('should reload the section and check the created price has the expected ID', async() => {
+        await page.accessToSection('item.index');
+        await page.accessToSection('item.fixedPrice');
+        const result = await page.getProperty('vn-fixed-price > div > vn-card > vn-table > div > vn-tbody > vn-tr:nth-child(4) > vn-td:nth-child(1) > span', 'innerText');
+
+        expect(result).toContain('13');
+    });
+});

e2e/paths/10-travel/03_descriptor.spec.js

@@ -33,6 +33,61 @@ describe('Travel descriptor path', () => {
         expect(state).toBe('travel.card.summary');
     });
 
+    it('should be redirected to the create entry view', async() => {
+        await page.waitToClick(selectors.travelDescriptor.dotMenu);
+        await page.waitToClick(selectors.travelDescriptor.dotMenuAddEntry);
+        await page.waitForState('entry.create');
+        const state = await page.getState();
+
+        expect(state).toBe('entry.create');
+    });
+
+    it('should check some data was imported from the travel', async() => {
+        const travel = await page.waitToGetProperty(selectors.entryCreate.travel, 'value');
+        const campany = await page.waitToGetProperty(selectors.entryCreate.company, 'value');
+
+        expect(travel).toContain('Warehouse');
+        expect(campany).toContain('VNL');
+    });
+
+    it('should navigate back to the travel index', async() => {
+        await page.waitToClick('.cancel');
+        await page.waitToClick(selectors.globalItems.homeButton);
+        await page.selectModule('travel');
+        await page.waitForState('travel.index');
+        const state = await page.getState();
+
+        expect(state).toBe('travel.index');
+    });
+
+    it('should click on the add entry button of the third result to be redirected to create entry', async() => {
+        await page.keyboard.press('Enter');
+        await page.waitToClick(selectors.travelIndex.firstTravelAddEntryButton);
+        await page.waitForState('entry.create');
+        const state = await page.getState();
+
+        expect(state).toBe('entry.create');
+    });
+
+    it('should check again some data was imported from the travel', async() => {
+        const travel = await page.waitToGetProperty(selectors.entryCreate.travel, 'value');
+        const campany = await page.waitToGetProperty(selectors.entryCreate.company, 'value');
+
+        expect(travel).toContain('Warehouse');
+        expect(campany).toContain('VNL');
+    });
+
+    it('should navigate to the travel summary of a given travel', async() => {
+        await page.waitToClick('.cancel');
+        await page.waitToClick(selectors.globalItems.homeButton);
+        await page.selectModule('travel');
+        await page.accessToSearchResult('3');
+        await page.waitForState('travel.card.summary');
+        const state = await page.getState();
+
+        expect(state).toBe('travel.card.summary');
+    });
+
     it('should be redirected to the create travel when using the clone option of the dot menu', async() => {
         await page.waitToClick(selectors.travelDescriptor.dotMenu);
         await page.waitToClick(selectors.travelDescriptor.dotMenuClone);

e2e/paths/10-travel/04_extra_community.spec.js

@@ -21,6 +21,7 @@ describe('Travel extra community path', () => {
         await page.waitForSpinnerLoad();
         await page.writeOnEditableTD(selectors.travelExtraCommunity.firstTravelReference, 'edited reference');
         await page.writeOnEditableTD(selectors.travelExtraCommunity.firstTravelLockedKg, '1500');
+        await page.waitForTimeout(1000);
     });
 
     it('should reload the index and confirm the reference and locked kg were edited', async() => {

front/salix/components/descriptor/style.scss

@@ -11,8 +11,8 @@ vn-descriptor-content {
         & > img[ng-src] {
             min-height: 16em;
             display: block;
-            height: 100%;
+            width: 256px;
-            width: 100%;
+            height: 256px;
         }
 
         vn-float-button {

loopback/locale/es.json

@@ -166,5 +166,6 @@
 	"The selected ticket is not suitable for this route": "El ticket seleccionado no es apto para esta ruta",
 	"Sorts whole route": "Reordena ruta entera",
 	"New ticket request has been created with price": "Se ha creado una nueva petición de compra '{{description}}' para el día <strong>{{shipped}}</strong>, con una cantidad de <strong>{{quantity}}</strong> y un precio de <strong>{{price}} €</strong>",
-	"New ticket request has been created": "Se ha creado una nueva petición de compra '{{description}}' para el día <strong>{{shipped}}</strong>, con una cantidad de <strong>{{quantity}}</strong>"
+	"New ticket request has been created": "Se ha creado una nueva petición de compra '{{description}}' para el día <strong>{{shipped}}</strong>, con una cantidad de <strong>{{quantity}}</strong>",
+	"That item doesn't exists": "Ese artículo no existe"
 }

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

@@ -5,7 +5,7 @@ module.exports = function(Self) {
         description: 'Updates a client address updating default address',
         accepts: [{
             arg: 'ctx',
-            type: 'Object',
+            type: 'object',
             http: {source: 'context'}
         },
         {
@@ -70,7 +70,7 @@ module.exports = function(Self) {
         }],
         returns: {
             root: true,
-            type: 'Object'
+            type: 'object'
         },
         http: {
             verb: 'patch',

modules/item/back/methods/fixed-price/filter.js

@@ -0,0 +1,192 @@
+
+const ParameterizedSQL = require('loopback-connector').ParameterizedSQL;
+const buildFilter = require('vn-loopback/util/filter').buildFilter;
+const mergeFilters = require('vn-loopback/util/filter').mergeFilters;
+
+module.exports = Self => {
+    Self.remoteMethodCtx('filter', {
+        description: 'Find all instances of the model matched by filter from the data source.',
+        accessType: 'READ',
+        accepts: [
+            {
+                arg: 'filter',
+                type: 'object',
+                description: 'Filter defining where, order, offset, and limit - must be a JSON-encoded string',
+            },
+            {
+                arg: 'search',
+                type: 'string',
+                description: `If it's and integer searchs by itemFk, otherwise it searchs by the itemType code`,
+            },
+            {
+                arg: 'itemFk',
+                type: 'integer',
+                description: 'The item id',
+            },
+            {
+                arg: 'typeFk',
+                type: 'integer',
+                description: 'The item type id',
+            },
+            {
+                arg: 'categoryFk',
+                type: 'integer',
+                description: 'The item category id',
+            },
+            {
+                arg: 'warehouseFk',
+                type: 'integer',
+                description: 'The warehouse id',
+            },
+            {
+                arg: 'buyerFk',
+                type: 'integer',
+                description: 'The buyer id',
+            },
+            {
+                arg: 'rate2',
+                type: 'integer',
+                description: 'The price per unit',
+            },
+            {
+                arg: 'rate3',
+                type: 'integer',
+                description: 'The price per package',
+            },
+            {
+                arg: 'minPrice',
+                type: 'integer',
+                description: 'The minimum price of the item',
+            },
+            {
+                arg: 'hasMinPrice',
+                type: 'boolean',
+                description: 'whether a minimum price has been defined for the  item',
+            },
+            {
+                arg: 'started',
+                type: 'date',
+                description: 'Price validity start date',
+            },
+            {
+                arg: 'ended',
+                type: 'date',
+                description: 'Price validity end date',
+            },
+            {
+                arg: 'tags',
+                type: ['object'],
+                description: 'List of tags to filter with',
+            },
+            {
+                arg: 'mine',
+                type: 'Boolean',
+                description: `Search requests attended by the current user`
+            }
+        ],
+        returns: {
+            type: ['Object'],
+            root: true
+        },
+        http: {
+            path: `/filter`,
+            verb: 'GET'
+        }
+    });
+
+    Self.filter = async(ctx, filter) => {
+        const conn = Self.dataSource.connector;
+        let userId = ctx.req.accessToken.userId;
+
+        if (ctx.args.mine)
+            ctx.args.buyerFk = userId;
+
+        const where = buildFilter(ctx.args, (param, value) => {
+            switch (param) {
+            case 'search':
+                return /^\d+$/.test(value)
+                    ? {'fp.itemFk': {inq: value}}
+                    : {'it.code': {like: `%${value}%`}};
+            case 'categoryFk':
+                return {'it.categoryFk': value};
+            case 'buyerFk':
+                return {'it.workerFk': value};
+            case 'warehouseFk':
+            case 'rate2':
+            case 'rate3':
+            case 'started':
+            case 'ended':
+                param = `fp.${param}`;
+                return {[param]: value};
+            case 'minPrice':
+            case 'hasMinPrice':
+            case 'typeFk':
+                param = `i.${param}`;
+                return {[param]: value};
+            }
+        });
+        filter = mergeFilters(filter, {where});
+
+        const stmts = [];
+        let stmt;
+
+        stmt = new ParameterizedSQL(
+            `SELECT fp.id,
+                    fp.itemFk,
+                    fp.warehouseFk,
+                    fp.rate2,
+                    fp.rate3,
+                    fp.started,
+                    fp.ended,
+                    i.minPrice,
+                    i.hasMinPrice,
+                    i.name,
+                    i.subName,
+                    i.tag5,
+                    i.value5,
+                    i.tag6,
+                    i.value6,
+                    i.tag7,
+                    i.value7,
+                    i.tag8,
+                    i.value8,
+                    i.tag9,
+                    i.value9,
+                    i.tag10,
+                    i.value10
+                FROM priceFixed fp
+                JOIN item i ON i.id = fp.itemFk
+                JOIN itemType it ON it.id = i.typeFk`
+        );
+
+        if (ctx.args.tags) {
+            let i = 1;
+            for (const tag of ctx.args.tags) {
+                const tAlias = `it${i++}`;
+
+                if (tag.tagFk) {
+                    stmt.merge({
+                        sql: `JOIN vn.itemTag ${tAlias} ON ${tAlias}.itemFk = i.id
+                            AND ${tAlias}.tagFk = ?
+                            AND ${tAlias}.value LIKE ?`,
+                        params: [tag.tagFk, `%${tag.value}%`],
+                    });
+                } else {
+                    stmt.merge({
+                        sql: `JOIN vn.itemTag ${tAlias} ON ${tAlias}.itemFk = i.id
+                            AND ${tAlias}.value LIKE ?`,
+                        params: [`%${tag.value}%`],
+                    });
+                }
+            }
+        }
+
+        stmt.merge(conn.makeWhere(filter.where));
+        stmt.merge(conn.makePagination(filter));
+
+        const fixedPriceIndex = stmts.push(stmt) - 1;
+        const sql = ParameterizedSQL.join(stmts, ';');
+        const result = await conn.executeStmt(sql);
+        return fixedPriceIndex === 0 ? result : result[fixedPriceIndex];
+    };
+};

modules/item/back/methods/fixed-price/specs/filter.spec.js

@@ -0,0 +1,86 @@
+const app = require('vn-loopback/server/server');
+
+describe('fixed price filter()', () => {
+    it('should return 1 result filtering by item ID', async() => {
+        const itemID = 3;
+        const ctx = {
+            req: {accessToken: {userId: 1}},
+            args: {
+                search: itemID
+            }
+        };
+        const result = await app.models.FixedPrice.filter(ctx);
+
+        expect(result.length).toEqual(1);
+        expect(result[0].id).toEqual(2);
+        expect(result[0].itemFk).toEqual(itemID);
+    });
+
+    it('should return 1 result filtering by item type code', async() => {
+        const itemCode = 'CRI';
+        const ctx = {
+            req: {accessToken: {userId: 1}},
+            args: {
+                search: itemCode
+            }
+        };
+        const itemType = await app.models.ItemType.findOne({
+            where: {code: itemCode},
+            fields: ['id']
+        });
+        const items = await app.models.Item.find({
+            where: {typeFk: itemType.id},
+            fields: ['id']
+        });
+        const IDs = items.map(item => {
+            return item.id;
+        });
+
+        const result = await app.models.FixedPrice.filter(ctx);
+        const firstResult = result[0];
+
+        expect(result.length).toEqual(1);
+        expect(firstResult.id).toEqual(2);
+        expect(IDs).toContain(firstResult.itemFk);
+    });
+
+    it('should return 2 results filtering by warehouse', async() => {
+        const warehouseID = 1;
+        const ctx = {
+            req: {accessToken: {userId: 1}},
+            args: {
+                warehouseFk: warehouseID
+            }
+        };
+        const result = await app.models.FixedPrice.filter(ctx);
+        const length = result.length;
+        const anyResult = result[Math.floor(Math.random() * Math.floor(length))];
+
+        expect(result.length).toEqual(2);
+        expect(anyResult.warehouseFk).toEqual(warehouseID);
+    });
+
+    it('should return no results filtering by hasMinPrice', async() => {
+        const ctx = {
+            req: {accessToken: {userId: 1}},
+            args: {
+                hasMinPrice: true
+            }
+        };
+        const result = await app.models.FixedPrice.filter(ctx);
+
+        expect(result.length).toEqual(0);
+    });
+
+    it('should return no results filtering by typeFk', async() => {
+        const ctx = {
+            req: {accessToken: {userId: 1}},
+            args: {
+                typeFk: 1
+            }
+        };
+        const result = await app.models.FixedPrice.filter(ctx);
+
+        expect(result.length).toEqual(1);
+    });
+});

modules/item/back/methods/fixed-price/specs/upsertFixedPrice.spec.js

@@ -0,0 +1,62 @@
+const app = require('vn-loopback/server/server');
+
+describe('upsertFixedPrice()', () => {
+    const now = new Date();
+    const fixedPriceId = 1;
+    let originalFixedPrice;
+    let originalItem;
+
+    beforeAll(async() => {
+        originalFixedPrice = await app.models.FixedPrice.findById(fixedPriceId);
+        originalItem = await app.models.Item.findById(originalFixedPrice.itemFk);
+    });
+
+    afterAll(async() => {
+        await originalFixedPrice.save();
+        await originalItem.save();
+    });
+
+    it(`should toggle the hasMinPrice boolean if there's a minPrice and update the rest of the data`, async() => {
+        const ctx = {args: {
+            id: fixedPriceId,
+            itemFk: originalFixedPrice.itemFk,
+            warehouseFk: 1,
+            rate2: 100,
+            rate3: 300,
+            started: now,
+            ended: now,
+            minPrice: 100,
+            hasMinPrice: false
+        }};
+
+        const result = await app.models.FixedPrice.upsertFixedPrice(ctx, ctx.args.id);
+
+        delete ctx.args.started;
+        delete ctx.args.ended;
+        ctx.args.hasMinPrice = true;
+
+        expect(result).toEqual(jasmine.objectContaining(ctx.args));
+    });
+
+    it(`should toggle the hasMinPrice boolean if there's no minPrice and update the rest of the data`, async() => {
+        const ctx = {args: {
+            id: fixedPriceId,
+            itemFk: originalFixedPrice.itemFk,
+            warehouseFk: 1,
+            rate2: 2.5,
+            rate3: 2,
+            started: now,
+            ended: now,
+            minPrice: 0,
+            hasMinPrice: true
+        }};
+
+        const result = await app.models.FixedPrice.upsertFixedPrice(ctx, ctx.args.id);
+
+        delete ctx.args.started;
+        delete ctx.args.ended;
+        ctx.args.hasMinPrice = false;
+
+        expect(result).toEqual(jasmine.objectContaining(ctx.args));
+    });
+});

modules/item/back/methods/fixed-price/upsertFixedPrice.js

@@ -0,0 +1,116 @@
+module.exports = Self => {
+    Self.remoteMethod('upsertFixedPrice', {
+        description: 'Inserts or updates a fixed price for an item',
+        accessType: 'WRITE',
+        accepts: [{
+            arg: 'ctx',
+            type: 'object',
+            http: {source: 'context'}
+        },
+        {
+            arg: 'id',
+            type: 'number',
+            description: 'The fixed price id'
+        },
+        {
+            arg: 'itemFk',
+            type: 'number'
+        },
+        {
+            arg: 'warehouseFk',
+            type: 'number'
+        },
+        {
+            arg: 'started',
+            type: 'date'
+        },
+        {
+            arg: 'ended',
+            type: 'date'
+        },
+        {
+            arg: 'rate2',
+            type: 'number'
+        },
+        {
+            arg: 'rate3',
+            type: 'number'
+        },
+        {
+            arg: 'minPrice',
+            type: 'number'
+        },
+        {
+            arg: 'hasMinPrice',
+            type: 'any'
+        }],
+        returns: {
+            type: 'object',
+            root: true
+        },
+        http: {
+            path: `/upsertFixedPrice`,
+            verb: 'PATCH'
+        }
+    });
+
+    Self.upsertFixedPrice = async ctx => {
+        const models = Self.app.models;
+
+        const args = ctx.args;
+        const tx = await models.Address.beginTransaction({});
+        try {
+            const options = {transaction: tx};
+            delete args.ctx; // removed unwanted data
+
+            const fixedPrice = await models.FixedPrice.upsert(args, options);
+            const targetItem = await models.Item.findById(args.itemFk, null, options);
+            await targetItem.updateAttributes({
+                minPrice: args.minPrice,
+                hasMinPrice: args.minPrice ? true : false
+            }, options);
+
+            const itemFields = [
+                'minPrice',
+                'hasMinPrice',
+                'name',
+                'subName',
+                'tag5',
+                'value5',
+                'tag6',
+                'value6',
+                'tag7',
+                'value7',
+                'tag8',
+                'value8',
+                'tag9',
+                'value9',
+                'tag10',
+                'value10'
+            ];
+
+            const fieldsCopy = [].concat(itemFields);
+            const filter = {
+                include: {
+                    relation: 'item',
+                    scope: {
+                        fields: fieldsCopy
+                    }
+                }
+            };
+
+            const result = await models.FixedPrice.findById(fixedPrice.id, filter, options);
+            const item = result.item();
+
+            for (let key of itemFields)
+                result[key] = item[key];
+
+            await tx.commit();
+            return result;
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    };
+};
+

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

@@ -60,7 +60,6 @@ module.exports = Self => {
             query = `SET @isTriggerDisabled = FALSE`;
             await Self.rawSql(query, null, options);
 
-
             query = `CALL vn.itemRefreshTags(?)`;
             await Self.rawSql(query, [item.id], options);
             await tx.commit();

modules/item/back/model-config.json

@@ -76,5 +76,8 @@
     },
     "TaxType": {
         "dataSource": "vn"
+    },
+    "FixedPrice": {
+        "dataSource": "vn"
     }
 }

modules/item/back/models/fixed-price.js

@@ -0,0 +1,4 @@
+module.exports = Self => {
+    require('../methods/fixed-price/filter')(Self);
+    require('../methods/fixed-price/upsertFixedPrice')(Self);
+};

modules/item/back/models/fixed-price.json

@@ -0,0 +1,59 @@
+{
+    "name": "FixedPrice",
+    "base": "VnModel",
+    "options": {
+        "mysql": {
+          	"table": "priceFixed"
+        }
+    },
+    "properties": {
+      	"id": {
+			"type": "number",
+			"id": true,
+			"description": "Identifier"
+      	},
+        "itemFk": {
+            "type": "number",
+            "required": true
+        },
+        "warehouseFk": {
+            "type": "number"
+        },
+        "rate2": {
+            "type": "number",
+            "required": true
+        },
+        "rate3": {
+            "type": "number",
+            "required": true
+        },
+        "started": {
+            "type": "date",
+            "required": true
+        },
+        "ended": {
+            "type": "date",
+            "required": true
+        }
+    },
+    "relations": {
+        "item": {
+            "type": "belongsTo",
+            "model": "Item",
+            "foreignKey": "itemFk"
+        },
+        "warehouse": {
+            "type": "belongsTo",
+            "model": "Warehouse",
+            "foreignKey": "warehouseFk"
+        }
+    },
+    "acls": [
+        {
+            "accessType": "READ",
+            "principalType": "ROLE",
+            "principalId": "buyer",
+            "permission": "ALLOW"
+        }
+    ]
+}

modules/item/back/models/item.json

@@ -12,119 +12,119 @@
     },
     "properties": {
         "id": {
-            "type": "Number",
+            "type": "number",
             "id": true,
             "description": "Id"
         },
         "name": {
-            "type": "String",
+            "type": "string",
             "description": "Name"
         },
         "size": {
-            "type": "Number",
+            "type": "number",
             "description": "Size"
         },
         "category": {
-            "type": "String",
+            "type": "string",
             "description": "Category"
         },
         "typeFk": {
-            "type": "Number",
+            "type": "number",
             "description": "Type",
             "required": true
         },
         "stems": {
-            "type": "Number",
+            "type": "number",
             "description": "Stems"
         },
         "description": {
-            "type": "String",
+            "type": "string",
             "description": "Description"
         },
         "isOnOffer": {
-            "type": "Boolean",
+            "type": "boolean",
             "description": "Offer"
         },
         "isBargain": {
-            "type": "Boolean",
+            "type": "boolean",
             "description": "Bargain"
         },
         "isActive": {
-            "type": "Boolean",
+            "type": "boolean",
             "description": "Active"
         },
         "comment": {
-            "type": "String",
+            "type": "string",
             "description": "Comment"
         },
         "relevancy": {
-            "type": "Number",
+            "type": "number",
             "description": "Relevancy"
         },
         "density": {
-            "type": "Number",
+            "type": "number",
             "description": "Density"
         },
         "stemMultiplier": {
-            "type": "Number",
+            "type": "number",
             "description": "Multiplier"
         },"image": {
-            "type": "String",
+            "type": "string",
             "description": "Image"
         },
         "longName": {
-            "type": "String",
+            "type": "string",
             "description": "Long name"
         },
         "subName": {
-            "type": "String",
+            "type": "string",
             "description": "Subname"
         },
         "tag5": {
-            "type": "String"
+            "type": "string"
         },
         "value5": {
-            "type": "String"
+            "type": "string"
         },
         "tag6": {
-            "type": "String"
+            "type": "string"
         },
         "value6": {
-            "type": "String"
+            "type": "string"
         },
         "tag7": {
-            "type": "String"
+            "type": "string"
         },
         "value7": {
-            "type": "String"
+            "type": "string"
         },
         "tag8": {
-            "type": "String"
+            "type": "string"
         },
         "value8": {
-            "type": "String"
+            "type": "string"
         },
         "tag9": {
-            "type": "String"
+            "type": "string"
         },
         "value9": {
-            "type": "String"
+            "type": "string"
         },
         "tag10": {
-            "type": "String"
+            "type": "string"
         },
         "value10": {
-            "type": "String"
+            "type": "string"
         },
         "compression": {
-            "type": "Number"
+            "type": "number"
         },
         "hasKgPrice": {
-            "type": "Boolean",
+            "type": "boolean",
             "description": "Price per Kg"
         },
         "expenseFk": {
-            "type": "Number",
+            "type": "number",
             "mysql": {
                 "columnName": "expenceFk"
             }
@@ -132,8 +132,11 @@
         "minPrice": {
             "type": "number"
         },
+        "hasMinPrice": {
+            "type": "boolean"
+        },
         "isFragile": {
-            "type": "Boolean"
+            "type": "boolean"
         }
     },
     "relations": {

modules/item/front/fixed-price-search-panel/index.html

@@ -0,0 +1,136 @@
+<vn-crud-model
+    url="Tags"
+    fields="['id','name','isFree', 'sourceTable']"
+    data="tags"
+    auto-load="true">
+</vn-crud-model>
+<div class="search-panel">
+    <form class="vn-pa-lg" ng-submit="$ctrl.onSearch()">
+        <vn-horizontal>
+            <vn-textfield
+                vn-one
+                label="General search"
+                ng-model="filter.search"
+                vn-focus>
+            </vn-textfield>
+        </vn-horizontal>
+        <vn-horizontal>
+            <vn-autocomplete
+                vn-one
+                url="ItemCategories"
+                label="Category"
+                show-field="name"
+                value-field="id"
+                ng-model="filter.categoryFk">
+            </vn-autocomplete>
+            <vn-autocomplete vn-one
+                url="ItemTypes"
+                label="Type"
+                where="{categoryFk: filter.categoryFk}"
+                show-field="name"
+                value-field="id"
+                ng-model="filter.typeFk"
+                fields="['categoryFk']"
+                include="'category'">
+                <tpl-item>
+                    <div>{{name}}</div>
+                    <div class="text-caption text-secondary">
+                        {{category.name}}
+                    </div>
+                </tpl-item>
+            </vn-autocomplete>
+        </vn-horizontal>
+        <vn-horizontal>
+            <vn-autocomplete 
+                vn-one
+                ng-model="filter.buyerFk"
+                url="Clients/activeWorkersWithRole"
+                show-field="nickname"
+                search-function="{firstName: $search}"
+                value-field="id"
+                where="{role: 'buyer'}"
+                label="Buyer">
+            </vn-autocomplete>
+            <vn-autocomplete
+                vn-one
+                label="Warehouse"
+                ng-model="filter.warehouseFk"
+                url="Warehouses">
+            </vn-autocomplete>
+        </vn-horizontal>
+        <vn-horizontal>
+            <vn-date-picker
+                vn-one
+                label="Started"
+                ng-model="filter.started">
+            </vn-date-picker>
+            <vn-date-picker
+                vn-one
+                label="Ended"
+                ng-model="filter.ended">
+            </vn-date-picker>
+        </vn-horizontal>
+        <vn-horizontal>
+            <vn-check vn-one 
+                triple-state="true" 
+                label="For me" 
+                ng-model="filter.mine">
+            </vn-check>
+            <vn-check vn-one 
+                triple-state="true" 
+                label="Minimum price" 
+                ng-model="filter.hasMinPrice">
+            </vn-check>
+        </vn-horizontal>
+        <vn-horizontal class="vn-pt-sm">
+            <vn-one class="text-subtitle1" translate>
+                Tags
+            </vn-one>
+            <vn-icon-button
+                vn-none
+                vn-bind="+"
+                vn-tooltip="Add tag"
+                icon="add_circle"
+                ng-click="filter.tags.push({})">
+            </vn-icon-button>
+        </vn-horizontal>
+        <vn-horizontal ng-repeat="itemTag in filter.tags">
+            <vn-autocomplete vn-two vn-id="tag"
+                label="Tag"
+                initial-data="itemTag.tag"
+                ng-model="itemTag.tagFk"
+                data="tags"
+                show-field="name"
+                on-change="itemTag.value = null"
+                rule>
+            </vn-autocomplete>
+            <vn-textfield vn-three
+                ng-show="tag.selection.isFree || tag.selection.isFree == undefined"
+                vn-id="text"
+                label="Value"
+                ng-model="itemTag.value"
+                rule>
+            </vn-textfield>
+            <vn-autocomplete vn-three
+                ng-show="tag.selection.isFree === false"
+                url="{{'Tags/' + itemTag.tagFk + '/filterValue'}}"
+                search-function="{value: $search}"
+                label="Value"
+                ng-model="itemTag.value"
+                show-field="value"
+                value-field="value"
+                rule>
+            </vn-autocomplete>
+            <vn-icon-button
+                vn-none
+                vn-tooltip="Remove tag"
+                icon="delete"
+                ng-click="filter.tags.splice($index, 1)"
+                tabindex="-1">
+            </vn-icon-button>
+        </vn-horizontal>
+        <vn-horizontal class="vn-mt-lg">
+            <vn-submit label="Search"></vn-submit>
+        </vn-horizontal>
+    </form>
+</div>

modules/item/front/fixed-price-search-panel/index.js

@@ -0,0 +1,19 @@
+import ngModule from '../module';
+import SearchPanel from 'core/components/searchbar/search-panel';
+
+class Controller extends SearchPanel {
+    get filter() {
+        return this.$.filter;
+    }
+
+    set filter(value = {}) {
+        if (!value.tags) value.tags = [{}];
+
+        this.$.filter = value;
+    }
+}
+
+ngModule.vnComponent('vnFixedPriceSearchPanel', {
+    template: require('./index.html'),
+    controller: Controller
+});

modules/item/front/fixed-price-search-panel/locale/es.yml

@@ -0,0 +1,4 @@
+Started: Inicio
+Ended: Fin
+Minimum price: Precio mínimo
+Item ID: ID Artículo

modules/item/front/fixed-price/index.html

@@ -0,0 +1,159 @@
+<vn-crud-model
+    vn-id="model"
+    url="FixedPrices/filter"
+    limit="20"
+    data="prices"
+    auto-load="true"
+    order="itemFk">
+</vn-crud-model>
+<vn-crud-model
+    auto-load="true"
+    url="Warehouses"
+    data="warehouses"
+    order="name">
+</vn-crud-model>
+<vn-portal slot="topbar">
+    <vn-searchbar
+        auto-state="false"
+        panel="vn-fixed-price-search-panel"
+        info="Search prices by item ID or code"
+        placeholder="Search fixed prices"
+        filter="{}"
+        model="model">
+    </vn-searchbar>
+</vn-portal>
+<div class="vn-w-xl">
+    <vn-card>
+        <vn-table model="model">
+            <vn-thead>
+                <vn-tr>
+                    <vn-th field="itemFk">Item ID</vn-th>
+                    <vn-th field="itemFk">Item</vn-th>
+                    <vn-th field="warehouseFk">Warehouse</vn-th>
+                    <vn-th field="rate2">P.P.U.</vn-th>
+                    <vn-th field="rate3">P.P.P.</vn-th>
+                    <vn-th field="minPrice">Min price</vn-th>
+                    <vn-th field="started" style="width: 90px">Started</vn-th>
+                    <vn-th field="ended" style="width: 90px">Ended</vn-th>
+                    <vn-th shrink></vn-th>
+                </vn-tr>
+            </vn-thead>
+            <vn-tbody>
+                <vn-tr ng-repeat="price in prices">
+                    <vn-td>
+                        <span
+                            ng-if="price.itemFk"
+                            ng-click="itemDescriptor.show($event, price.itemFk)"
+                            class="link">
+                            {{price.itemFk}}
+                        </span>
+                        <vn-autocomplete
+                            class="dense"
+                            ng-if="!price.itemFk"
+                            vn-focus
+                            url="Items"
+                            ng-model="price.itemFk"
+                            show-field="name"
+                            value-field="id"
+                            search-function="$ctrl.itemSearchFunc($search)"
+                            on-change="$ctrl.upsertPrice(price)"
+                            order="id DESC"
+                            tabindex="1">
+                            <tpl-item>
+                                {{::id}} - {{::name}}
+                            </tpl-item>
+                        </vn-autocomplete>
+                    </vn-td>
+                    <vn-td expand>
+                        <text>
+                            <vn-fetched-tags
+                                max-length="6"
+                                item="price"
+                                name="price.name"
+                                sub-name="price.subName"
+                                tabindex="-1">
+                            </vn-fetched-tags>
+                        </text>
+                    </vn-td>
+                    <vn-td>
+                        <vn-autocomplete
+                            vn-one
+                            label="Warehouse"
+                            ng-model="price.warehouseFk"
+                            url="Warehouses"
+                            on-change="$ctrl.upsertPrice(price)"
+                            tabindex="2">
+                        </vn-autocomplete>
+                    </vn-td>
+                    <vn-td-editable number>
+                        <text>{{price.rate2 | currency: 'EUR':2}}</text>
+                        <field>
+                            <vn-input-number
+                                class="dense"
+                                vn-focus
+                                ng-model="price.rate2"
+                                on-change="$ctrl.upsertPrice(price)">
+                            </vn-input-number>
+                        </field>
+                    </vn-td-editable>
+                    <vn-td-editable number>
+                        <text>{{price.rate3 | currency: 'EUR':2}}</text>
+                        <field>
+                            <vn-input-number
+                                class="dense"
+                                vn-focus
+                                ng-model="price.rate3"
+                                on-change="$ctrl.upsertPrice(price)">
+                            </vn-input-number>
+                        </field>
+                    </vn-td-editable>
+                    <vn-td-editable number>
+                        <text>{{(price.hasMinPrice ? (price.minPrice | currency: 'EUR':2) : "-")}}</text>
+                        <field>
+                            <vn-input-number
+                                class="dense"
+                                vn-focus
+                                ng-model="price.minPrice"
+                                on-change="$ctrl.upsertPrice(price)">
+                            </vn-input-number>
+                        </field>
+                    </vn-td-editable>
+                    <vn-td>
+                        <vn-date-picker
+                            vn-one
+                            label="Started"
+                            ng-model="price.started"
+                            on-change="$ctrl.upsertPrice(price)">
+                        </vn-date-picker>
+                    </vn-td>
+                    <vn-td>
+                        <vn-date-picker
+                            vn-one
+                            label="Ended"
+                            ng-model="price.ended"
+                            on-change="$ctrl.upsertPrice(price)">
+                        </vn-date-picker>
+                    </vn-td>
+                    <vn-td shrink>
+                        <vn-icon-button
+                            icon="delete"
+                            vn-tooltip="Delete"
+                            ng-click="$ctrl.removePrice($index)">
+                        </vn-icon-button>
+                    </vn-td>
+                </vn-tr>
+            </vn-tbody>
+        </vn-table>
+        <div class="vn-pa-md">
+            <vn-icon-button
+                vn-tooltip="Add fixed price"
+                icon="add_circle"
+                vn-bind="+"
+                ng-click="model.insert()">
+            </vn-icon-button>
+        </div>
+    </vn-card>
+</div>
+<vn-item-descriptor-popover
+    vn-id="itemDescriptor">
+</vn-item-descriptor-popover>

modules/item/front/fixed-price/index.js

@@ -0,0 +1,54 @@
+import ngModule from '../module';
+import Section from 'salix/components/section';
+import './style.scss';
+
+export default class Controller extends Section {
+    constructor($element, $) {
+        super($element, $);
+    }
+
+    /**
+     * Inserts a new instance
+     */
+    add() {
+        this.$.model.insert({});
+    }
+
+    upsertPrice(price) {
+        price.hasMinPrice = price.minPrice ? true : false;
+
+        let requiredFields = ['itemFk', 'started', 'ended', 'rate2', 'rate3'];
+        for (let field of requiredFields)
+            if (price[field] == undefined) return;
+
+        const query = 'FixedPrices/upsertFixedPrice';
+        this.$http.patch(query, price)
+            .then(res => {
+                this.vnApp.showSuccess(this.$t('Data saved!'));
+                Object.assign(price, res.data);
+            });
+    }
+
+    removePrice($index) {
+        const price = this.$.model.data[$index];
+        if (price.id) {
+            this.$http.delete(`FixedPrices/${price.id}`)
+                .then(() => {
+                    this.$.model.remove($index);
+                    this.vnApp.showSuccess(this.$t('Data saved!'));
+                });
+        } else
+            this.$.model.remove($index);
+    }
+
+    itemSearchFunc($search) {
+        return /^\d+$/.test($search)
+            ? {id: $search}
+            : {name: {like: '%' + $search + '%'}};
+    }
+}
+
+ngModule.vnComponent('vnFixedPrice', {
+    template: require('./index.html'),
+    controller: Controller
+});

modules/item/front/fixed-price/index.spec.js

@@ -0,0 +1,87 @@
+import './index';
+
+describe('fixed price', () => {
+    describe('Component vnFixedPrice', () => {
+        let controller;
+        let $httpBackend;
+
+        beforeEach(ngModule('item'));
+
+        beforeEach(inject(($componentController, _$httpBackend_, $rootScope) => {
+            $httpBackend = _$httpBackend_;
+            const $scope = $rootScope.$new();
+            const $element = angular.element('<vn-fixed-price></vn-fixed-price>');
+            controller = $componentController('vnFixedPrice', {$element, $scope});
+        }));
+
+        describe('upsertPrice()', () => {
+            it('should do nothing if one or more required arguments are missing', () => {
+                jest.spyOn(controller.vnApp, 'showSuccess');
+
+                controller.upsertPrice({});
+
+                expect(controller.vnApp.showSuccess).not.toHaveBeenCalled();
+            });
+
+            it('should perform an http request to update the price', () => {
+                const now = new Date();
+                jest.spyOn(controller.vnApp, 'showSuccess');
+
+                $httpBackend.expectPATCH('FixedPrices/upsertFixedPrice').respond();
+                controller.upsertPrice({
+                    itemFk: 1,
+                    started: now,
+                    ended: now,
+                    rate2: 1,
+                    rate3: 2
+                });
+                $httpBackend.flush();
+
+                expect(controller.vnApp.showSuccess).toHaveBeenCalled();
+            });
+        });
+
+        describe('removePrice()', () => {
+            it(`should only remove the created instance by the model as it doesn't have an ID yet`, () => {
+                const $index = 0;
+                controller.$ = {
+                    model: {
+                        remove: () => {},
+                        data: [{
+                            foo: 'bar'
+                        }]
+                    }
+                };
+                jest.spyOn(controller.vnApp, 'showSuccess');
+                jest.spyOn(controller.$.model, 'remove');
+
+                controller.removePrice($index);
+
+                expect(controller.vnApp.showSuccess).not.toHaveBeenCalled();
+                expect(controller.$.model.remove).toHaveBeenCalled();
+            });
+
+            it('should remove the instance performing an delete http request', () => {
+                const $index = 0;
+                controller.$ = {
+                    model: {
+                        remove: () => {},
+                        data: [{
+                            id: '1'
+                        }]
+                    }
+                };
+                jest.spyOn(controller.vnApp, 'showSuccess');
+                jest.spyOn(controller.$.model, 'remove');
+
+                const query = `FixedPrices/${controller.$.model.data[0].id}`;
+                $httpBackend.expectDELETE(query).respond();
+                controller.removePrice($index);
+                $httpBackend.flush();
+
+                expect(controller.vnApp.showSuccess).toHaveBeenCalled();
+                expect(controller.$.model.remove).toHaveBeenCalled();
+            });
+        });
+    });
+});

modules/item/front/fixed-price/locale/es.yml

@@ -0,0 +1,4 @@
+Fixed prices: Precios fijados
+Search prices by item ID or code: Buscar por ID de artículo o código
+Search fixed prices: Buscar precios fijados
+Add fixed price: Añadir precio fijado

modules/item/front/fixed-price/style.scss

@@ -0,0 +1,5 @@
+@import "variables";
+
+vn-table vn-date-picker {
+    max-width: 90px;
+}

modules/item/front/index.js

@@ -21,4 +21,6 @@ import './botanical';
 import './barcode';
 import './summary';
 import './waste';
+import './fixed-price';
+import './fixed-price-search-panel';
 

modules/item/front/routes.json

@@ -8,7 +8,8 @@
         "main": [
             {"state": "item.index", "icon": "icon-item"},
             {"state": "item.request", "icon": "pan_tool"},
-            {"state": "item.waste", "icon": "icon-claims"}
+            {"state": "item.waste", "icon": "icon-claims"},
+            {"state": "item.fixedPrice", "icon": ""}
         ],
         "card": [
             {"state": "item.card.basicData", "icon": "settings"},
@@ -32,22 +33,26 @@
             "abstract": true,
             "description": "Items",
             "component": "vn-items"
-        }, {
+        },
+        {
             "url": "/index?q",
             "state": "item.index",
             "component": "vn-item-index",
             "description": "Items"
-        }, {
+        },
+        {
             "url": "/create",
             "state": "item.create",
             "component": "vn-item-create",
             "description": "New item"
-        }, {
+        },
+        {
             "url": "/:id",
             "state": "item.card",
             "abstract": true,
             "component": "vn-item-card"
-        }, {
+        },
+        {
             "url" : "/basic-data",
             "state": "item.card.basicData",
             "component": "vn-item-basic-data",
@@ -56,7 +61,8 @@
                 "item": "$ctrl.item"
             },
             "acl": ["buyer"]
-        }, {
+        },
+        {
             "url" : "/tags",
             "state": "item.card.tags",
             "component": "vn-item-tags",
@@ -65,13 +71,15 @@
                 "item-tags": "$ctrl.itemTags"
             },
             "acl": ["buyer", "replenisher"]
-        }, {
+        },
+        {
             "url" : "/tax",
             "state": "item.card.tax",
             "component": "vn-item-tax",
             "description": "Tax",
             "acl": ["administrative","buyer"]
-        }, {
+        },
+        {
             "url" : "/niche",
             "state": "item.card.niche",
             "component": "vn-item-niche",
@@ -80,7 +88,8 @@
                 "item": "$ctrl.item"
             },
             "acl": ["buyer","replenisher"]
-        }, {
+        },
+        {
             "url" : "/botanical",
             "state": "item.card.botanical",
             "component": "vn-item-botanical",
@@ -89,7 +98,8 @@
                 "item": "$ctrl.item"
             },
             "acl": ["buyer"]
-        }, {
+        },
+        {
             "url" : "/barcode",
             "state": "item.card.itemBarcode",
             "component": "vn-item-barcode",
@@ -98,7 +108,8 @@
                 "item": "$ctrl.item"
             },
             "acl": ["buyer","replenisher"]
-        }, {
+        },
+        {
             "url" : "/summary",
             "state": "item.card.summary",
             "component": "vn-item-summary",
@@ -106,7 +117,8 @@
             "params": {
                 "item": "$ctrl.item"
             }
-        }, {
+        },
+        {
             "url" : "/diary?warehouseFk&lineFk",
             "state": "item.card.diary",
             "component": "vn-item-diary",
@@ -115,7 +127,8 @@
                 "item": "$ctrl.item"
             },
             "acl": ["employee"]
-        }, {
+        },
+        {
             "url" : "/last-entries",
             "state": "item.card.last-entries",
             "component": "vn-item-last-entries",
@@ -124,12 +137,14 @@
                 "item": "$ctrl.item"
             },
             "acl": ["employee"]
-        }, {
+        },
+        {
             "url" : "/log",
             "state": "item.card.log",
             "component": "vn-item-log",
             "description": "Log"
-        }, {
+        },
+        {
             "url" : "/request?q",
             "state": "item.request",
             "component": "vn-item-request",
@@ -138,12 +153,20 @@
                 "item": "$ctrl.item"
             },
             "acl": ["employee"]
-        }, {
+        },
+        {
             "url" : "/waste",
             "state": "item.waste",
             "component": "vn-item-waste",
             "description": "Waste breakdown",
             "acl": ["buyer"]
+        },
+        {
+            "url" : "/fixed-price",
+            "state": "item.fixedPrice",
+            "component": "vn-fixed-price",
+            "description": "Fixed prices",
+            "acl": ["buyer"]
         }
     ]
 }

modules/item/front/tags/index.html

@@ -27,8 +27,8 @@
                 initial-data="itemTag.tag"
                 ng-model="itemTag.tagFk"
                 data="tags"
-                on-change="$ctrl.getSourceTable(tag)"
                 show-field="name"
+                on-change="itemTag.value = null"
                 rule>
             </vn-autocomplete>
             <vn-textfield vn-three

modules/order/back/methods/order/filter.js

@@ -155,7 +155,8 @@ module.exports = Self => {
                 co.code companyCode,
                 zed.zoneFk,
                 zed.hourTheoretical,
-                zed.hourEffective
+                zed.hourEffective,
+                am.name AS agencyName
             FROM hedera.order o
                 LEFT JOIN address a ON a.id = o.address_id
                 LEFT JOIN agencyMode am ON am.id = o.agency_id

modules/order/front/index/index.html

@@ -15,8 +15,8 @@
                 <vn-th field="isConfirmed" center>Confirmed</vn-th>
                 <vn-th field="created" center expand>Created</vn-th>
                 <vn-th field="landed" default-order="DESC" center expand>Landed</vn-th>
-                <vn-th field="created" center translate-attr="{title: 'Theoretical hour'}">T. Hour</vn-th>
+                <vn-th field="created" center>Hour</vn-th>
-                <vn-th field="created" center>Real hour</vn-th>
+                <vn-th field="agencyName" center>Agency</vn-th>
                 <vn-th center>Total</vn-th>
             </vn-tr>
         </vn-thead>
@@ -52,8 +52,11 @@
                         {{::order.landed | date:'dd/MM/yyyy'}}
                     </span>
                 </vn-td>
-                <vn-td shrink>{{::order.hourTheoretical | date: 'HH:mm' | dashIfEmpty}}</vn-td>
+                <vn-td shrink>{{::(order.hourTheoretical 
-                <vn-td shrink>{{::ticket.hourEffective | date: 'HH:mm' | dashIfEmpty}}</vn-td>
+                        ? order.hourTheoretical
+                        : order.hourEffective) | dashIfEmpty
+                        }}</vn-td>
+                <vn-td expand>{{::order.agencyName}}</vn-td>
                 <vn-td number>{{::order.total | currency: 'EUR': 2 | dashIfEmpty}}</vn-td>
                 <vn-td shrink>
                     <vn-icon-button

modules/route/back/methods/route/specs/updateVolume.spec.js

@@ -1,7 +1,8 @@
 const app = require('vn-loopback/server/server');
 const LoopBackContext = require('loopback-context');
 
-describe('route updateVolume()', () => {
+// #2735 route updateVolume() returns inconsistent values
+xdescribe('route updateVolume()', () => {
     const routeId = 1;
     const userId = 50;
     const activeCtx = {

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

@@ -60,7 +60,8 @@ describe('sale updatePrice()', () => {
         await originalSalesPersonMana.updateAttributes(originalSalesPersonMana);
     });
 
-    it('should set price as a decimal number and check the sale has the mana component changing the salesPersonMana', async() => {
+    // #2736 sale updatePrice() returns inconsistent values
+    xit('should set price as a decimal number and check the sale has the mana component changing the salesPersonMana', async() => {
         let ctx = {req: {accessToken: {userId: 18}}};
         let price = 5.4;
 

modules/ticket/back/methods/ticket-request/filter.js

@@ -30,11 +30,11 @@ module.exports = Self => {
             }, {
                 arg: 'attenderFk',
                 type: 'Number',
-                description: `Search requests atended by the given worker`
+                description: `Search requests attended by a given worker id`
             }, {
                 arg: 'mine',
                 type: 'Boolean',
-                description: `Search requests attended by the connected worker`
+                description: `Search requests attended by the current user`
             }, {
                 arg: 'from',
                 type: 'Date',
@@ -62,10 +62,9 @@ module.exports = Self => {
     Self.filter = async(ctx, filter) => {
         let conn = Self.dataSource.connector;
         let userId = ctx.req.accessToken.userId;
-        let worker = await Self.app.models.Worker.findOne({where: {userFk: userId}});
 
         if (ctx.args.mine)
-            ctx.args.attenderFk = worker.id;
+            ctx.args.attenderFk = userId;
 
         let where = buildFilter(ctx.args, (param, value) => {
             switch (param) {

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

@@ -60,7 +60,8 @@ class Controller extends Section {
                 }
             },
             {relation: 'ship'},
-            {relation: 'stowaway'}]
+            {relation: 'stowaway'},
+            {relation: 'invoiceOut'}]
         };
 
         return this.$http.get(`Tickets/${this.ticketId}`, {filter})

modules/ticket/front/locale/es.yml

@@ -21,7 +21,7 @@ Discount: Descuento
 Employee : Empleado
 Import: Importe
 Is checked: Comprobado
-Item: Articulo
+Item: Artículo
 Landing: Llegada
 Landed: F. entrega
 More: Más

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

@@ -18,6 +18,12 @@
             translate>
             Clone travel and his entries
         </vn-item>
+        <a class="vn-item"
+            ui-sref="entry.create({travelFk: $ctrl.travel.id})"
+            name="addEntry"
+            translate>
+            Add entry
+        </a>
     </vn-list>
 </vn-menu>
 

modules/travel/front/descriptor-menu/locale/es.yml

@@ -1,3 +1,4 @@
 Clone travel: Clonar envío
+Add entry: Añadir entrada
 Clone travel and his entries: Clonar travel y sus entradas
 Do you want to clone this travel and all containing entries?: ¿Quieres clonar este travel y todas las entradas que contiene?

modules/travel/front/index/index.html

@@ -49,6 +49,11 @@
                             vn-tooltip="Clone"
                             icon="icon-clone">
                         </vn-icon-button>
+                        <vn-icon-button 
+                            vn-anchor="::{state: 'entry.create', params: {travelFk: travel.id}}"
+                            vn-tooltip="Add entry"
+                            icon="icon-ticket">
+                        </vn-icon-button>
                         <vn-icon-button
                             vn-click-stop="$ctrl.preview(travel)"
                             vn-tooltip="Preview"

print/core/filters/zerofill.js

@@ -1,4 +1,3 @@
-const {KeyValueModel} = require('loopback');
 const Vue = require('vue');
 
 const zerofill = function(value, pad) {