Merge pull request '#7524 warmfix-useVnTable' (!862) from 7524-warmfix-useVnTable into test

Reviewed-on: verdnatura/salix-front#862
Reviewed-by: Alex Moreno <alexm@verdnatura.es>

src/components/VnTable/VnTable.vue

@@ -457,7 +457,11 @@ function handleScroll() {
                     />
                 </template>
                 <template #header-cell="{ col }">
-                    <QTh v-if="col.visible ?? true">
+                    <QTh
+                        v-if="col.visible ?? true"
+                        :style="col.headerStyle"
+                        :class="col.headerClass"
+                    >
                         <div
                             class="column self-start q-ml-xs ellipsis"
                             :class="`text-${col?.align ?? 'left'}`"

src/pages/Ticket/TicketAdvance.vue

@@ -1,24 +1,20 @@
 <script setup>
-import { onMounted, ref, computed, reactive } from 'vue';
+import { ref, computed, reactive, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
-
 import FetchData from 'components/FetchData.vue';
-import VnInput from 'src/components/common/VnInput.vue';
-import VnSelect from 'src/components/common/VnSelect.vue';
 import TicketDescriptorProxy from 'src/pages/Ticket/Card/TicketDescriptorProxy.vue';
 import VnSubToolbar from 'src/components/ui/VnSubToolbar.vue';
 import VnSearchbar from 'src/components/ui/VnSearchbar.vue';
 import VnProgress from 'src/components/common/VnProgressModal.vue';
 import RightMenu from 'src/components/common/RightMenu.vue';
 import TicketAdvanceFilter from './TicketAdvanceFilter.vue';
-
 import { dashIfEmpty, toCurrency } from 'src/filters';
 import { useVnConfirm } from 'composables/useVnConfirm';
-import { useArrayData } from 'composables/useArrayData';
 import useNotify from 'src/composables/useNotify.js';
 import { useState } from 'src/composables/useState';
 import { toDateFormat } from 'src/filters/date.js';
 import axios from 'axios';
+import VnTable from 'src/components/VnTable/VnTable.vue';
 
 const state = useState();
 const { t } = useI18n();
@@ -29,109 +25,58 @@ const user = state.getUser();
 const itemPackingTypesOptions = ref([]);
 const zonesOptions = ref([]);
 const selectedTickets = ref([]);
-
+const vnTableRef = ref({});
-const exprBuilder = (param, value) => {
+const originElRef = ref(null);
-    switch (param) {
+const destinationElRef = ref(null);
-        case 'id':
+let today = Date.vnNew().toISOString();
-        case 'futureId':
+const tomorrow = new Date(today);
-        case 'liters':
+tomorrow.setDate(tomorrow.getDate() + 1);
-        case 'futureLiters':
+const userParams = reactive({
-        case 'lines':
+    dateFuture: tomorrow,
-        case 'futureLines':
+    dateToAdvance: today,
-        case 'totalWithVat':
+    warehouseFk: user.value.warehouseFk,
-        case 'futureTotalWithVat':
+    ipt: 'H',
-        case 'futureZone':
+    futureIpt: 'H',
-        case 'notMovableLines':
+    isFullMovable: true,
-        case 'futureZoneFk':
-            return { [param]: value };
-        case 'iptColFilter':
-            return { ipt: { like: `%${value}%` } };
-        case 'futureIptColFilter':
-            return { futureIpt: { like: `%${value}%` } };
-    }
-};
-
-const userParams = reactive({});
-
-const arrayData = useArrayData('AdvanceTickets', {
-    url: 'Tickets/getTicketsAdvance',
-    userParams: userParams,
-    exprBuilder: exprBuilder,
-    limit: 0,
 });
-const { store } = arrayData;
-const tickets = computed(() =>
-    (store.data || []).map((ticket, index) => ({ ...ticket, index: index }))
-);
-
-const applyColumnFilter = async (col) => {
-    try {
-        const paramKey = col.columnFilter?.filterParamKey || col.field;
-        userParams[paramKey] = col.columnFilter.filterValue;
-        await arrayData.addFilter({ params: userParams });
-    } catch (err) {
-        console.error('Error applying column filter', err);
-    }
-};
-
-const getInputEvents = (col) => {
-    return col.columnFilter.type === 'select'
-        ? { 'update:modelValue': () => applyColumnFilter(col) }
-        : {
-              'keyup.enter': () => applyColumnFilter(col),
-          };
-};
 
 const ticketColumns = computed(() => [
     {
         label: '',
         name: 'icons',
-        align: 'left',
+        hidden: true,
-        columnFilter: null,
+        headerClass: 'horizontal-separator',
     },
     {
-        label: t('advanceTickets.ticketId'),
-        name: 'ticketId',
         align: 'center',
-        sortable: true,
+        label: t('advanceTickets.ticketId'),
-        columnFilter: {
+        name: 'id',
-            component: VnInput,
+        headerClass: 'horizontal-separator',
-            type: 'text',
-            filterValue: null,
-            filterParamKey: 'id',
-            event: getInputEvents,
-            attrs: {
-                dense: true,
-            },
-        },
     },
     {
+        align: 'left',
         label: t('advanceTickets.ipt'),
         name: 'ipt',
-        field: 'ipt',
-        align: 'left',
-        sortable: true,
         columnFilter: {
-            component: VnSelect,
+            component: 'select',
-            filterParamKey: 'iptColFilter',
-            type: 'select',
-            filterValue: null,
-            event: getInputEvents,
             attrs: {
-                options: itemPackingTypesOptions.value,
+                url: 'itemPackingTypes',
-                'option-value': 'code',
+                fields: ['code', 'description'],
-                'option-label': 'description',
+                where: { isActive: true },
-                dense: true,
+                optionValue: 'code',
+                optionLabel: 'description',
+                inWhere: false,
             },
         },
-        format: (val) => dashIfEmpty(val),
+        format: (row, dashIfEmpty) => dashIfEmpty(row.ipt),
+        headerClass: 'horizontal-separator',
     },
     {
+        align: 'left',
         label: t('advanceTickets.state'),
         name: 'state',
-        align: 'left',
+        headerClass: 'horizontal-separator',
-        sortable: true,
+        hidden: true,
-        columnFilter: null,
     },
     {
         label: t('advanceTickets.preparation'),
@@ -139,171 +84,105 @@ const ticketColumns = computed(() => [
         field: 'preparation',
         align: 'left',
         sortable: true,
-        columnFilter: null,
+        headerClass: 'horizontal-separator',
+        columnFilter: false,
     },
     {
-        label: t('advanceTickets.liters'),
-        name: 'liters',
-        field: 'liters',
         align: 'left',
-        sortable: true,
+        label: t('advanceTickets.liters'),
-        columnFilter: {
+        headerClass: 'horizontal-separator',
-            component: VnInput,
+        name: 'liters',
-            type: 'text',
-            filterValue: null,
-            event: getInputEvents,
-            attrs: {
-                dense: true,
-            },
-        },
     },
     {
+        align: 'left',
         label: t('advanceTickets.lines'),
         name: 'lines',
-        field: 'lines',
+        headerClass: 'horizontal-separator',
-        align: 'left',
+        format: (row, dashIfEmpty) => dashIfEmpty(row.lines),
-        sortable: true,
-        columnFilter: {
-            component: VnInput,
-            type: 'text',
-            filterValue: null,
-            event: getInputEvents,
-            attrs: {
-                dense: true,
-            },
-        },
-        format: (val) => dashIfEmpty(val),
     },
     {
+        align: 'left',
         label: t('advanceTickets.import'),
-        field: 'import',
+        name: 'totalWithVat',
-        name: 'import',
+        hidden: true,
-        align: 'left',
+        headerClass: 'horizontal-separator',
-        sortable: true,
+        format: (row) => toCurrency(row.totalWithVat),
     },
     {
+        align: 'left',
         label: t('advanceTickets.futureId'),
         name: 'futureId',
-        align: 'left',
+        headerClass: 'vertical-separator horizontal-separator',
-        sortable: true,
+        columnClass: 'vertical-separator',
-        columnFilter: {
-            component: VnInput,
-            type: 'text',
-            filterValue: null,
-            filterParamKey: 'futureId',
-            event: getInputEvents,
-            attrs: {
-                dense: true,
-            },
-        },
     },
     {
+        align: 'left',
         label: t('advanceTickets.futureIpt'),
         name: 'futureIpt',
-        field: 'futureIpt',
-        align: 'left',
-        sortable: true,
         columnFilter: {
-            component: VnSelect,
+            component: 'select',
-            filterParamKey: 'futureIptColFilter',
-            type: 'select',
-            filterValue: null,
-            event: getInputEvents,
             attrs: {
-                options: itemPackingTypesOptions.value,
+                url: 'itemPackingTypes',
-                'option-value': 'code',
+                fields: ['code', 'description'],
-                'option-label': 'description',
+                where: { isActive: true },
-                dense: true,
+                optionValue: 'code',
+                optionLabel: 'description',
             },
         },
-        format: (val) => dashIfEmpty(val),
+        headerClass: 'horizontal-separator',
+        format: (row, dashIfEmpty) => dashIfEmpty(row.futureIpt),
     },
     {
+        align: 'left',
         label: t('advanceTickets.futureState'),
         name: 'futureState',
-        align: 'left',
+        headerClass: 'horizontal-separator',
-        sortable: true,
+        hidden: true,
-        columnFilter: null,
-        format: (val) => dashIfEmpty(val),
     },
     {
+        align: 'left',
         label: t('advanceTickets.futureLiters'),
+        headerClass: 'horizontal-separator',
         name: 'futureLiters',
-        field: 'futureLiters',
-        align: 'left',
-        sortable: true,
-        columnFilter: {
-            component: VnInput,
-            type: 'text',
-            filterValue: null,
-            event: getInputEvents,
-            attrs: {
-                dense: true,
-            },
-        },
-        format: (val) => dashIfEmpty(val),
     },
     {
+        align: 'left',
         label: t('advanceTickets.futureZone'),
-        name: 'futureZoneName',
+        name: 'futureZoneFk',
-        field: 'futureZoneName',
+        columnClass: 'expand',
-        align: 'left',
-        sortable: true,
         columnFilter: {
-            component: VnSelect,
+            component: 'select',
-            type: 'select',
+            inWhere: true,
-            filterValue: null,
-            filterParamKey: 'futureZoneFk',
-            event: getInputEvents,
             attrs: {
-                options: zonesOptions.value,
+                url: 'Zones',
-                'option-value': 'id',
+                fields: ['id', 'name'],
-                'option-label': 'name',
-                dense: true,
             },
         },
-        format: (val) => dashIfEmpty(val),
+        columnField: {
+            component: null,
+        },
+        headerClass: 'horizontal-separator',
+        format: (row, dashIfEmpty) => dashIfEmpty(row.futureZoneName),
     },
     {
+        align: 'left',
         label: t('advanceTickets.notMovableLines'),
+        headerClass: 'horizontal-separator',
         name: 'notMovableLines',
-        field: 'notMovableLines',
-        align: 'left',
-        sortable: true,
-        columnFilter: {
-            component: VnInput,
-            type: 'text',
-            filterValue: null,
-            event: getInputEvents,
-            attrs: {
-                dense: true,
-            },
-        },
-        format: (val) => dashIfEmpty(val),
     },
     {
+        align: 'left',
         label: t('advanceTickets.futureLines'),
+        headerClass: 'horizontal-separator',
         name: 'futureLines',
-        field: 'futureLines',
-        align: 'left',
-        sortable: true,
-        columnFilter: {
-            component: VnInput,
-            type: 'text',
-            filterValue: null,
-            event: getInputEvents,
-            attrs: {
-                dense: true,
-            },
-        },
-        format: (val) => dashIfEmpty(val),
     },
     {
-        label: t('advanceTickets.futureImport'),
-        name: 'futureImport',
         align: 'left',
-        sortable: true,
+        label: t('advanceTickets.futureImport'),
-        columnFilter: null,
+        name: 'futureTotalWithVat',
+        hidden: true,
+        headerClass: 'horizontal-separator',
+        format: (row) => toCurrency(row.futureTotalWithVat),
     },
 ]);
 
@@ -329,7 +208,7 @@ const requestComponentUpdate = async (ticket, isWithoutNegatives) => {
     const query = `tickets/${ticket.futureId}/componentUpdate`;
     if (!ticket.landed) {
         const newLanded = await getLanded({
-            shipped: userParams.dateToAdvance,
+            shipped: vnTableRef.value.params.dateToAdvance,
             addressFk: ticket.futureAddressFk,
             agencyModeFk: ticket.agencyModeFk ?? ticket.futureAgencyModeFk,
             warehouseFk: ticket.futureWarehouseFk,
@@ -352,7 +231,7 @@ const requestComponentUpdate = async (ticket, isWithoutNegatives) => {
         zoneFk: ticket.zoneFk ?? ticket.futureZoneFk,
         warehouseFk: ticket.futureWarehouseFk,
         companyFk: ticket.futureCompanyFk,
-        shipped: userParams.dateToAdvance,
+        shipped: vnTableRef.value.params.dateToAdvance,
         landed: ticket.landed,
         isDeleted: false,
         isWithoutNegatives,
@@ -364,7 +243,6 @@ const requestComponentUpdate = async (ticket, isWithoutNegatives) => {
 };
 
 const moveTicketsAdvance = async () => {
-    try {
     let ticketsToMove = [];
     for (const ticket of selectedTickets.value) {
         if (!ticket.id) {
@@ -387,13 +265,9 @@ const moveTicketsAdvance = async () => {
 
     const params = { tickets: ticketsToMove };
     await axios.post('Tickets/merge', params);
-        arrayData.fetch({ append: false });
+    vnTableRef.value.reload();
     selectedTickets.value = [];
-        if (ticketsToMove.length)
+    if (ticketsToMove.length) notify(t('advanceTickets.moveTicketSuccess'), 'positive');
-            notify(t('advanceTickets.moveTicketSuccess'), 'positive');
-    } catch (error) {
-        console.error('Error moving tickets', error);
-    }
 };
 
 const progressLength = ref(0);
@@ -434,10 +308,8 @@ const splitTickets = async () => {
                 progressAdd(ticket.futureId);
             }
         }
-    } catch (error) {
-        console.error('Error splitting tickets', error);
     } finally {
-        arrayData.fetch({ append: false });
+        vnTableRef.value.reload();
     }
 };
 
@@ -455,22 +327,52 @@ const handleCloseProgressDialog = () => {
 
 const handleCancelProgress = () => (cancelProgress.value = true);
 
-onMounted(async () => {
+watch(
-    let today = Date.vnNew();
+    () => vnTableRef.value.tableRef?.$el,
-    const tomorrow = new Date(today);
+    ($el) => {
-    tomorrow.setDate(tomorrow.getDate() + 1);
+        if (!$el) return;
-    userParams.dateFuture = tomorrow;
+        const head = $el.querySelector('thead');
-    userParams.dateToAdvance = today;
+        const firstRow = $el.querySelector('thead > tr');
-    userParams.scopeDays = 1;
-    userParams.warehouseFk = user.value.warehouseFk;
-    userParams.ipt = 'H';
-    userParams.futureIpt = 'H';
-    userParams.isFullMovable = true;
-    const filter = { limit: 0 };
-    await arrayData.addFilter({ filter, userParams });
-});
-</script>
 
+        const newRow = document.createElement('tr');
+        destinationElRef.value = document.createElement('th');
+        originElRef.value = document.createElement('th');
+
+        newRow.classList.add('bg-header');
+        destinationElRef.value.classList.add('text-uppercase', 'color-vn-label');
+        originElRef.value.classList.add('text-uppercase', 'color-vn-label');
+
+        destinationElRef.value.setAttribute('colspan', '7');
+        originElRef.value.setAttribute('colspan', '9');
+
+        destinationElRef.value.textContent = `${t(
+            'advanceTickets.destination'
+        )} ${toDateFormat(vnTableRef.value.params.dateToAdvance)}`;
+        originElRef.value.textContent = `${t('advanceTickets.origin')} ${toDateFormat(
+            vnTableRef.value.params.dateFuture
+        )}`;
+
+        newRow.append(destinationElRef.value, originElRef.value);
+        head.insertBefore(newRow, firstRow);
+    },
+    { once: true, inmmediate: true }
+);
+
+watch(
+    () => vnTableRef.value.params,
+    () => {
+        if (originElRef.value && destinationElRef.value) {
+            destinationElRef.value.textContent = `${t(
+                'advanceTickets.destination'
+            )} ${toDateFormat(vnTableRef.value.params.dateToAdvance)}`;
+            originElRef.value.textContent = `${t('advanceTickets.origin')} ${toDateFormat(
+                vnTableRef.value.params.dateFuture
+            )}`;
+        }
+    },
+    { deep: true }
+);
+</script>
 <template>
     <FetchData
         url="itemPackingTypes"
@@ -491,11 +393,6 @@ onMounted(async () => {
         auto-load
         @on-fetch="(data) => (zonesOptions = data)"
     />
-    <VnSearchbar
-        data-key="WeeklyTickets"
-        :label="t('weeklyTickets.search')"
-        :info="t('weeklyTickets.searchInfo')"
-    />
     <VnSubToolbar>
         <template #st-data>
             <QBtn
@@ -539,79 +436,30 @@ onMounted(async () => {
     </VnSubToolbar>
     <RightMenu>
         <template #right-panel>
-            <TicketAdvanceFilter data-key="AdvanceTickets" />
+            <TicketAdvanceFilter data-key="advanceTickets" />
         </template>
     </RightMenu>
     <QPage class="column items-center q-pa-md">
-        <QTable
+        <VnTable
-            :rows="tickets"
+            data-key="advanceTickets"
+            ref="vnTableRef"
+            url="Tickets/getTicketsAdvance"
+            search-url="advanceTickets"
+            :user-params="userParams"
+            :limit="0"
             :columns="ticketColumns"
-            row-key="index"
+            :table="{
-            selection="multiple"
+                'row-key': '$index',
+                selection: 'multiple',
+            }"
             v-model:selected="selectedTickets"
             :pagination="{ rowsPerPage: 0 }"
             :no-data-label="t('globals.noResults')"
-            style="max-width: 99%"
+            :right-search="false"
+            auto-load
+            :disable-option="{ card: true }"
         >
-            <template #header="props">
+            <template #column-icons="{ row }">
-                {{ userParams.scopeDays }}
-                <QTr :props="props">
-                    <QTh
-                        class="horizontal-separator text-uppercase color-vn-label"
-                        colspan="7"
-                        translate
-                    >
-                        {{ t('advanceTickets.destination') }}
-                        {{ toDateFormat(userParams.dateToAdvance) }}
-                    </QTh>
-                    <QTh
-                        class="horizontal-separator text-uppercase color-vn-label"
-                        colspan="9"
-                        translate
-                    >
-                        {{ t('advanceTickets.origin') }}
-                        {{ toDateFormat(userParams.dateFuture) }}
-                    </QTh>
-                </QTr>
-                <QTr>
-                    <QTh>
-                        <QCheckbox v-model="props.selected" />
-                    </QTh>
-                    <QTh
-                        v-for="(col, index) in ticketColumns"
-                        :key="index"
-                        :class="{ 'vertical-separator': col.name === 'futureId' }"
-                    >
-                        {{ col.label }}
-                    </QTh>
-                </QTr>
-            </template>
-            <template #top-row="{ cols }">
-                <QTr>
-                    <QTd />
-                    <QTd
-                        v-for="(col, index) in cols"
-                        :key="index"
-                        style="max-width: 100px"
-                    >
-                        <component
-                            :is="col.columnFilter.component"
-                            v-if="col.columnFilter"
-                            v-model="col.columnFilter.filterValue"
-                            v-bind="col.columnFilter.attrs"
-                            v-on="col.columnFilter.event(col)"
-                            dense
-                        />
-                    </QTd>
-                </QTr>
-            </template>
-            <template #header-cell-availableLines="{ col }">
-                <QTh class="vertical-separator">
-                    {{ col.label }}
-                </QTh>
-            </template>
-            <template #body-cell-icons="{ row }">
-                <QTd class="q-gutter-x-xs">
                 <QIcon
                     v-if="row.futureAgency !== row.agency && row.agency"
                     color="primary"
@@ -635,19 +483,14 @@ onMounted(async () => {
                         </span>
                     </QTooltip>
                 </QIcon>
-                </QTd>
             </template>
-
+            <template #column-id="{ row }">
-            <template #body-cell-ticketId="{ row }">
-                <QTd>
                 <QBtn flat class="link">
                     {{ row.id }}
                     <TicketDescriptorProxy :id="row.id" />
                 </QBtn>
-                </QTd>
             </template>
-            <template #body-cell-state="{ row }">
+            <template #column-state="{ row }">
-                <QTd>
                 <QBadge
                     v-if="row.state"
                     text-color="black"
@@ -658,10 +501,8 @@ onMounted(async () => {
                     {{ row.state }}
                 </QBadge>
                 <span v-else> {{ dashIfEmpty(row.state) }}</span>
-                </QTd>
             </template>
-            <template #body-cell-import="{ row }">
+            <template #column-import="{ row }">
-                <QTd>
                 <QBadge
                     :text-color="isLessThan50(row.totalWithVat) ? 'black' : 'white'"
                     :color="totalPriceColor(row.totalWithVat)"
@@ -670,18 +511,14 @@ onMounted(async () => {
                 >
                     {{ toCurrency(row.totalWithVat || 0) }}
                 </QBadge>
-                </QTd>
             </template>
-            <template #body-cell-futureId="{ row }">
+            <template #column-futureId="{ row }">
-                <QTd class="vertical-separator">
                 <QBtn flat class="link" dense>
                     {{ row.futureId }}
                     <TicketDescriptorProxy :id="row.futureId" />
                 </QBtn>
-                </QTd>
             </template>
-            <template #body-cell-futureState="{ row }">
+            <template #column-futureState="{ row }">
-                <QTd>
                 <QBadge
                     text-color="black"
                     :color="row.futureClassColor"
@@ -690,23 +527,18 @@ onMounted(async () => {
                 >
                     {{ row.futureState }}
                 </QBadge>
-                </QTd>
             </template>
-            <template #body-cell-futureImport="{ row }">
+            <template #column-futureImport="{ row }">
-                <QTd>
                 <QBadge
-                        :text-color="
+                    :text-color="isLessThan50(row.futureTotalWithVat) ? 'black' : 'white'"
-                            isLessThan50(row.futureTotalWithVat) ? 'black' : 'white'
-                        "
                     :color="totalPriceColor(row.futureTotalWithVat)"
                     class="q-ma-none"
                     dense
                 >
                     {{ toCurrency(row.futureTotalWithVat || 0) }}
                 </QBadge>
-                </QTd>
             </template>
-        </QTable>
+        </VnTable>
         <VnProgress
             :progress="progressPercentage"
             :cancelled="cancelProgress"
@@ -725,11 +557,11 @@ onMounted(async () => {
 </template>
 
 <style scoped lang="scss">
-.vertical-separator {
+:deep(.vertical-separator) {
     border-left: 4px solid white !important;
 }
 
-.horizontal-separator {
+:deep(.horizontal-separator) {
-    border-bottom: 4px solid white !important;
+    border-top: 4px solid white !important;
 }
 </style>

src/pages/Ticket/TicketAdvanceFilter.vue

@@ -58,6 +58,7 @@ onMounted(async () => await getItemPackingTypes());
         auto-load
     />
     <VnFilterPanel
+        search-url="advanceTickets"
         :data-key="props.dataKey"
         :search-button="true"
         :hidden-tags="['search']"
@@ -101,6 +102,7 @@ onMounted(async () => await getItemPackingTypes());
                         dense
                         outlined
                         rounded
+                        :use-like="false"
                     >
                     </VnSelect>
                 </QItemSection>
@@ -118,6 +120,7 @@ onMounted(async () => await getItemPackingTypes());
                         dense
                         outlined
                         rounded
+                        :use-like="false"
                     >
                     </VnSelect>
                 </QItemSection>