Merge branch 'dev' of https://gitea.verdnatura.es/verdnatura/salix-front into 7790_formFocus_mixin

src/boot/axios.js

@@ -39,7 +39,37 @@ const onResponse = (response) => {
 const onResponseError = (error) => {
     stateQuery.remove(error.config);
 
-    if (session.isLoggedIn() && error.response?.status === 401) {
+    let message = '';
+
+    const response = error.response;
+    const responseData = response && response.data;
+    const responseError = responseData && response.data.error;
+    if (responseError) {
+        message = responseError.message;
+    }
+
+    switch (response?.status) {
+        case 422:
+            if (error.name == 'ValidationError')
+                message +=
+                    ' "' +
+                    responseError.details.context +
+                    '.' +
+                    Object.keys(responseError.details.codes).join(',') +
+                    '"';
+            break;
+        case 500:
+            message = 'errors.statusInternalServerError';
+            break;
+        case 502:
+            message = 'errors.statusBadGateway';
+            break;
+        case 504:
+            message = 'errors.statusGatewayTimeout';
+            break;
+    }
+
+    if (session.isLoggedIn() && response?.status === 401) {
         session.destroy(false);
         const hash = window.location.hash;
         const url = hash.slice(1);
@@ -48,6 +78,8 @@ const onResponseError = (error) => {
         return Promise.reject(error);
     }
 
+    notify(message, 'negative');
+
     return Promise.reject(error);
 };
 

src/boot/qFormEnterEvent.js

@@ -0,0 +1,27 @@
+import { getCurrentInstance } from 'vue';
+
+export default {
+    mounted: function () {
+        const vm = getCurrentInstance();
+        if (vm.type.name === 'QForm') {
+            const that = this;
+            this.$el.addEventListener('keyup', function (evt) {
+                if (evt.key === 'Enter') {
+                    const input = evt.target;
+                    if (input.type == 'textarea' && evt.shiftKey) {
+                        evt.preventDefault();
+                        let { selectionStart, selectionEnd } = input;
+                        input.value =
+                            input.value.substring(0, selectionStart) +
+                            '\n' +
+                            input.value.substring(selectionEnd);
+                        selectionStart = selectionEnd = selectionStart + 1;
+                        return;
+                    }
+                    evt.preventDefault();
+                    that.onSubmit();
+                }
+            });
+        }
+    },
+};

src/boot/qFormFocus.js

@@ -0,0 +1,54 @@
+export default {
+    mounted: function () {
+        // func
+        const observer = new MutationObserver((mutations, observerInstance) => {
+            try {
+                // Login
+                const inputsFormCard = document.querySelectorAll(
+                    'form.formCard input:not([disabled]):not([type="checkbox"])'
+                );
+                if (inputsFormCard.length) {
+                    // .focus();
+                    // observerInstance.disconnect();
+                    // return;
+                    focusFirstInput(inputsFormCard[0], observerInstance);
+                }
+                // VnNotes
+                const textareas = document.querySelectorAll(
+                    'textarea:not([disabled]), [contenteditable]:not([disabled])'
+                );
+                if (textareas.length) {
+                    // textareas[textareas.length - 1].focus();
+                    // observerInstance.disconnect();
+                    // return;
+                    focusFirstInput(textareas[textareas.length - 1], observerInstance);
+                }
+                // if (!inputs || inputs.length === 0) return;
+                const inputs = document.querySelectorAll(
+                    'form#formModel input:not([disabled]):not([type="checkbox"])'
+                );
+                const input = inputs[0];
+                if (!input) return;
+                // if (input.type === 'textarea' || input.form) {
+                // AUTOFOCUS
+
+                focusFirstInput(input, observerInstance);
+                //             input.focus();
+                // observerInstance.disconnect();
+            } catch (error) {
+                console.error(error);
+            }
+        });
+
+        observer.observe(this.$el, {
+            childList: true,
+            subtree: false,
+        });
+    },
+};
+
+function focusFirstInput(input, observerInstance) {
+    input.focus();
+    observerInstance.disconnect();
+    return;
+}

src/boot/qformMixin.js

@@ -1,30 +0,0 @@
-import { getCurrentInstance } from 'vue';
-
-export default {
-    mounted: function () {
-        const vm = getCurrentInstance();
-        if (vm.type.name === 'QForm') {
-            if (!['searchbarForm', 'filterPanelForm'].includes(this.$el?.id)) {
-                // TODO: AUTOFOCUS IS NOT FOCUSING
-                const that = this;
-                this.$el.addEventListener('keyup', function (evt) {
-                    if (evt.key === 'Enter') {
-                        const input = evt.target;
-                        if (input.type == 'textarea' && evt.shiftKey) {
-                            evt.preventDefault();
-                            let { selectionStart, selectionEnd } = input;
-                            input.value =
-                                input.value.substring(0, selectionStart) +
-                                '\n' +
-                                input.value.substring(selectionEnd);
-                            selectionStart = selectionEnd = selectionStart + 1;
-                            return;
-                        }
-                        evt.preventDefault();
-                        that.onSubmit();
-                    }
-                });
-            }
-        }
-    },
-};

src/boot/quasar.js

@@ -1,53 +1,18 @@
 import { boot } from 'quasar/wrappers';
-import qFormMixin from './qformMixin';
+import qFormEnterEvent from './qFormEnterEvent';
+import qFormFocus from './qFormFocus';
 import mainShortcutMixin from './mainShortcutMixin';
 import keyShortcut from './keyShortcut';
 import useNotify from 'src/composables/useNotify.js';
-import { CanceledError } from 'axios';
-
 const { notify } = useNotify();
 
 export default boot(({ app }) => {
-    app.mixin(qFormMixin);
+    app.mixin(qFormEnterEvent);
+    app.mixin(qFormFocus);
     app.mixin(mainShortcutMixin);
     app.directive('shortcut', keyShortcut);
-    app.config.errorHandler = (error) => {
+    app.config.errorHandler = function (err) {
-        let message;
+        console.error(err);
-        const response = error.response;
+        notify('globals.error', 'negative', 'error');
-        const responseData = response?.data;
-        const responseError = responseData && response.data.error;
-        if (responseError) {
-            message = responseError.message;
-        }
-
-        switch (response?.status) {
-            case 422:
-                if (error.name == 'ValidationError')
-                    message +=
-                        ' "' +
-                        responseError.details.context +
-                        '.' +
-                        Object.keys(responseError.details.codes).join(',') +
-                        '"';
-                break;
-            case 500:
-                message = 'errors.statusInternalServerError';
-                break;
-            case 502:
-                message = 'errors.statusBadGateway';
-                break;
-            case 504:
-                message = 'errors.statusGatewayTimeout';
-                break;
-        }
-
-        console.error(error);
-        if (error instanceof CanceledError) {
-            const env = process.env.NODE_ENV;
-            if (env && env !== 'development') return;
-            message = 'Duplicate request';
-        }
-
-        notify(message ?? 'globals.error', 'negative', 'error');
     };
 });

src/components/FormModel.vue

@@ -217,6 +217,9 @@ async function save() {
         updateAndEmit('onDataSaved', formData.value, response?.data);
         if ($props.reload) await arrayData.fetch({});
         hasChanges.value = false;
+    } catch (err) {
+        console.error(err);
+        notify('errors.writeRequest', 'negative');
     } finally {
         isLoading.value = false;
     }

src/components/FormModelPopup.vue

@@ -61,7 +61,6 @@ defineExpose({
                     :loading="isLoading"
                     @click="emit('onDataCanceled')"
                     v-close-popup
-                    data-cy="FormModelPopup_cancel"
                 />
                 <QBtn
                     :label="t('globals.save')"
@@ -71,7 +70,6 @@ defineExpose({
                     class="q-ml-sm"
                     :disabled="isLoading"
                     :loading="isLoading"
-                    data-cy="FormModelPopup_save"
                 />
             </div>
         </template>

src/components/VnTable/VnTable.vue

@@ -457,11 +457,7 @@ function handleScroll() {
                     />
                 </template>
                 <template #header-cell="{ col }">
-                    <QTh
+                    <QTh v-if="col.visible ?? true">
-                        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/components/common/VnProgressModal.vue

@@ -9,6 +9,10 @@ const $props = defineProps({
         type: Number, //Progress value (1.0 > x > 0.0)
         required: true,
     },
+    showDialog: {
+        type: Boolean,
+        required: true,
+    },
     cancelled: {
         type: Boolean,
         required: false,
@@ -20,22 +24,30 @@ const emit = defineEmits(['cancel', 'close']);
 
 const dialogRef = ref(null);
 
-const showDialog = defineModel('showDialog', {
+const _showDialog = computed({
-    type: Boolean,
+    get: () => $props.showDialog,
-    default: false,
+    set: (value) => {
+        if (value) dialogRef.value.show();
+    },
 });
 
 const _progress = computed(() => $props.progress);
+
 const progressLabel = computed(() => `${Math.round($props.progress * 100)}%`);
+
+const cancel = () => {
+    dialogRef.value.hide();
+    emit('cancel');
+};
 </script>
 
 <template>
-    <QDialog ref="dialogRef" v-model="showDialog" @hide="emit('close')">
+    <QDialog ref="dialogRef" v-model="_showDialog" @hide="onDialogHide">
         <QCard class="full-width dialog">
             <QCardSection class="row">
                 <span class="text-h6">{{ t('Progress') }}</span>
                 <QSpace />
-                <QBtn icon="close" flat round dense v-close-popup />
+                <QBtn icon="close" flat round dense @click="emit('close')" />
             </QCardSection>
             <QCardSection>
                 <div class="column">
@@ -68,7 +80,7 @@ const progressLabel = computed(() => `${Math.round($props.progress * 100)}%`);
                     type="button"
                     flat
                     class="text-primary"
-                    v-close-popup
+                    @click="cancel()"
                 >
                     {{ t('globals.cancel') }}
                 </QBtn>

src/pages/Account/Alias/Card/AliasUsers.vue

@@ -46,9 +46,13 @@ const columns = computed(() => [
 ]);
 
 const deleteAlias = async (row) => {
+    try {
         await axios.delete(`${urlPath.value}/${row.id}`);
         notify(t('User removed'), 'positive');
         fetchAliases();
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 watch(

src/pages/Account/Card/AccountMailAlias.vue

@@ -61,15 +61,23 @@ const fetchAccountExistence = async () => {
 };
 
 const deleteMailAlias = async (row) => {
+    try {
         await axios.delete(`${urlPath}/${row.id}`);
         fetchMailAliases();
         notify(t('Unsubscribed from alias!'), 'positive');
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const createMailAlias = async (mailAliasFormData) => {
+    try {
         await axios.post(urlPath, mailAliasFormData);
         notify(t('Subscribed to alias!'), 'positive');
         fetchMailAliases();
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const fetchMailAliases = async () => {

src/pages/Account/Role/Card/SubRoles.vue

@@ -46,15 +46,29 @@ const columns = computed(() => [
 ]);
 
 const deleteSubRole = async (row) => {
+    try {
         await axios.delete(`${urlPath.value}/${row.id}`);
         fetchSubRoles();
-    notify(t('Role removed. Changes will take a while to fully propagate.'), 'positive');
+        notify(
+            t('Role removed. Changes will take a while to fully propagate.'),
+            'positive'
+        );
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const createSubRole = async (subRoleFormData) => {
+    try {
         await axios.post(urlPath.value, subRoleFormData);
-    notify(t('Role added! Changes will take a while to fully propagate.'), 'positive');
+        notify(
+            t('Role added! Changes will take a while to fully propagate.'),
+            'positive'
+        );
         fetchSubRoles();
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 watch(

src/pages/Ticket/Card/BasicData/TicketBasicDataForm.vue

@@ -112,20 +112,32 @@ const getShipped = async (params) => {
 };
 
 const onChangeZone = async (zoneId) => {
+    try {
         formData.value.agencyModeFk = null;
         const { data } = await axios.get(`Zones/${zoneId}`);
         formData.value.agencyModeFk = data.agencyModeFk;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const onChangeAddress = async (addressId) => {
+    try {
         formData.value.nickname = null;
         const { data } = await axios.get(`Addresses/${addressId}`);
         formData.value.nickname = data.nickname;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const getClientDefaultAddress = async (clientId) => {
+    try {
         const { data } = await axios.get(`Clients/${clientId}`);
         if (data) addressId.value = data.defaultAddressFk;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const clientAddressesList = async (value) => {

src/pages/Ticket/Card/BasicData/TicketBasicDataView.vue

@@ -70,6 +70,7 @@ const isFormInvalid = () => {
 };
 
 const getPriceDifference = async () => {
+    try {
         const params = {
             landed: formData.value.landed,
             addressId: formData.value.addressFk,
@@ -83,10 +84,15 @@ const getPriceDifference = async () => {
             params
         );
         formData.value.sale = data;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const submit = async () => {
-    if (!formData.value.option) return notify(t('basicData.chooseAnOption'), 'negative');
+    try {
+        if (!formData.value.option)
+            return notify(t('basicData.chooseAnOption'), 'negative');
 
         const params = {
             clientFk: formData.value.clientFk,
@@ -115,6 +121,9 @@ const submit = async () => {
         const ticketToMove = data.id;
         notify(t('basicData.unroutedTicket'), 'positive');
         router.push({ name: 'TicketSummary', params: { id: ticketToMove } });
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const submitWithNegatives = async () => {

src/pages/Ticket/Card/ExpeditionNewTicket.vue

@@ -34,7 +34,10 @@ const newTicketFormData = reactive({});
 const date = new Date();
 
 const createTicket = async () => {
-    const expeditionIds = $props.selectedExpeditions.map((expedition) => expedition.id);
+    try {
+        const expeditionIds = $props.selectedExpeditions.map(
+            (expedition) => expedition.id
+        );
         const params = {
             clientId: $props.ticket.clientFk,
             landed: newTicketFormData.landed,
@@ -48,6 +51,9 @@ const createTicket = async () => {
         const { data } = await axios.post('Expeditions/moveExpeditions', params);
         notify(t('globals.dataSaved'), 'positive');
         router.push({ name: 'TicketSummary', params: { id: data.id } });
+    } catch (error) {
+        console.error(error);
+    }
 };
 </script>
 

src/pages/Ticket/Card/TicketComponents.vue

@@ -150,19 +150,31 @@ const getTotal = computed(() => {
 });
 
 const getComponentsSum = async () => {
+    try {
         const { data } = await axios.get(`Tickets/${route.params.id}/getComponentsSum`);
         componentsList.value = data;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const getTheoricalCost = async () => {
+    try {
         const { data } = await axios.get(`Tickets/${route.params.id}/freightCost`);
         theoricalCost.value = data;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const getTicketVolume = async () => {
+    try {
         if (!ticketData.value) return;
         const { data } = await axios.get(`Tickets/${ticketData.value.id}/getVolume`);
         ticketVolume.value = data[0].volume;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 onMounted(() => {

src/pages/Ticket/Card/TicketExpedition.vue

@@ -163,12 +163,16 @@ const showNewTicketDialog = (withRoute = false) => {
 };
 
 const deleteExpedition = async () => {
+    try {
         const expeditionIds = selectedRows.value.map((expedition) => expedition.id);
         const params = { expeditionIds };
         await axios.post('Expeditions/deleteExpeditions', params);
         vnTableRef.value.reload();
         selectedExpeditions.value = [];
         notify(t('expedition.expeditionRemoved'), 'positive');
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const showLog = async (expedition) => {
@@ -177,6 +181,7 @@ const showLog = async (expedition) => {
 };
 
 const getExpeditionState = async (expedition) => {
+    try {
         const filter = {
             where: { expeditionFk: expedition.id },
             order: ['created DESC'],
@@ -190,6 +195,9 @@ const getExpeditionState = async (expedition) => {
             ...state,
             isScanned: !!state.isScanned,
         }));
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 onMounted(async () => {

src/pages/Ticket/Card/TicketSaleMoreActions.vue

@@ -165,10 +165,14 @@ const createRefund = async (withWarehouse) => {
         negative: true,
     };
 
+    try {
         const { data } = await axios.post('Tickets/cloneAll', params);
         const [refundTicket] = data;
         notify(t('refundTicketCreated', { ticketId: refundTicket.id }), 'positive');
         push({ name: 'TicketSale', params: { id: refundTicket.id } });
+    } catch (error) {
+        console.error(error);
+    }
 };
 </script>
 

src/pages/Ticket/Card/TicketSaleTracking.vue

@@ -150,6 +150,7 @@ const shelvingsTableColumns = computed(() => [
 ]);
 
 const getSaleTrackings = async (sale) => {
+    try {
         const filter = {
             where: { saleFk: sale.saleFk },
             order: ['itemFk DESC'],
@@ -158,6 +159,9 @@ const getSaleTrackings = async (sale) => {
             params: { filter: JSON.stringify(filter) },
         });
         saleTrackings.value = data;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const showLog = async (sale) => {
@@ -166,6 +170,7 @@ const showLog = async (sale) => {
 };
 
 const getItemShelvingSales = async (sale) => {
+    try {
         const filter = {
             where: { saleFk: sale.saleFk },
         };
@@ -173,6 +178,9 @@ const getItemShelvingSales = async (sale) => {
             params: { filter: JSON.stringify(filter) },
         });
         itemShelvingsSales.value = data;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const showShelving = async (sale) => {
@@ -181,15 +189,20 @@ const showShelving = async (sale) => {
 };
 
 const updateQuantity = async (sale) => {
+    try {
         if (oldQuantity.value === sale.quantity) return;
         const params = {
             quantity: sale.quantity,
         };
         await axios.patch(`ItemShelvingSales/${sale.id}`, params);
         oldQuantity.value = null;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const updateParking = async (sale) => {
+    try {
         const filter = {
             fields: ['id'],
             where: {
@@ -203,6 +216,9 @@ const updateParking = async (sale) => {
             parkingFk: sale.parkingFk,
         };
         await axios.patch(`Shelvings/${data.id}`, params);
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const updateShelving = async (sale) => {
@@ -225,6 +241,7 @@ const updateShelving = async (sale) => {
 };
 
 const saleTrackingNew = async (sale, stateCode, isChecked) => {
+    try {
         const params = {
             saleFk: sale.saleFk,
             isChecked,
@@ -233,33 +250,52 @@ const saleTrackingNew = async (sale, stateCode, isChecked) => {
         };
         await axios.post(`SaleTrackings/new`, params);
         notify(t('globals.dataSaved'), 'positive');
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const saleTrackingDel = async ({ saleFk }, stateCode) => {
+    try {
         const params = {
             saleFk,
             stateCodes: [stateCode],
         };
         await axios.post(`SaleTrackings/delete`, params);
         notify(t('globals.dataSaved'), 'positive');
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const clickSaleGroupDetail = async (sale) => {
+    try {
         if (!sale.saleGroupDetailFk) return;
 
         await axios.delete(`SaleGroupDetails/${sale.saleGroupDetailFk}`);
         sale.hasSaleGroupDetail = false;
         notify(t('globals.dataSaved'), 'positive');
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const clickPreviousSelected = (sale) => {
+    try {
         qCheckBoxController(sale, 'isPreviousSelected');
         if (!sale.isPreviousSelected) sale.isPrevious = false;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const clickPrevious = (sale) => {
+    try {
         qCheckBoxController(sale, 'isPrevious');
         if (sale.isPrevious) sale.isPreviousSelected = true;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const qCheckBoxController = (sale, action) => {
@@ -270,6 +306,7 @@ const qCheckBoxController = (sale, action) => {
         isPreviousSelected: 'PREVIOUS_PREPARATION',
     };
     const stateCode = STATE_CODES[action];
+    try {
         if (!sale[action]) {
             saleTrackingNew(sale, stateCode, true);
             sale[action] = true;
@@ -277,6 +314,9 @@ const qCheckBoxController = (sale, action) => {
             saleTrackingDel(sale, stateCode);
             sale[action] = false;
         }
+    } catch (error) {
+        console.error(error);
+    }
 };
 </script>
 

src/pages/Ticket/Card/TicketService.vue

@@ -46,6 +46,7 @@ watch(
 onMounted(async () => await getDefaultTaxClass());
 
 const createRefund = async () => {
+    try {
         if (!selected.value.length) return;
 
         const params = {
@@ -62,9 +63,13 @@ const createRefund = async () => {
             'positive'
         );
         router.push({ name: 'TicketSale', params: { id: refundTicket.id } });
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const getDefaultTaxClass = async () => {
+    try {
         let filter = {
             where: { code: 'G' },
         };
@@ -72,6 +77,9 @@ const getDefaultTaxClass = async () => {
             params: { filter: JSON.stringify(filter) },
         });
         defaultTaxClass.value = data;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const columns = computed(() => [

src/pages/Ticket/Card/TicketVolume.vue

@@ -75,6 +75,7 @@ const columns = computed(() => [
 ]);
 
 const applyVolumes = async (salesData) => {
+    try {
         if (!salesData.length) return;
 
         sales.value = salesData;
@@ -87,6 +88,9 @@ const applyVolumes = async (salesData) => {
         });
 
         packingTypeVolume.value = data.packingTypeVolume;
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 onMounted(() => (stateStore.rightDrawer = true));

src/pages/Ticket/TicketAdvance.vue

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

src/pages/Ticket/TicketAdvanceFilter.vue

@@ -27,6 +27,7 @@ const warehousesOptions = ref([]);
 const itemPackingTypes = ref([]);
 
 const getItemPackingTypes = async () => {
+    try {
         const filter = {
             where: { isActive: true },
         };
@@ -37,6 +38,9 @@ const getItemPackingTypes = async () => {
             description: t(ipt.description),
             code: ipt.code,
         }));
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const getLocale = (val) => {
@@ -54,7 +58,6 @@ onMounted(async () => await getItemPackingTypes());
         auto-load
     />
     <VnFilterPanel
-        search-url="advanceTickets"
         :data-key="props.dataKey"
         :search-button="true"
         :hidden-tags="['search']"
@@ -98,7 +101,6 @@ onMounted(async () => await getItemPackingTypes());
                         dense
                         outlined
                         rounded
-                        :use-like="false"
                     >
                     </VnSelect>
                 </QItemSection>
@@ -116,7 +118,6 @@ onMounted(async () => await getItemPackingTypes());
                         dense
                         outlined
                         rounded
-                        :use-like="false"
                     >
                     </VnSelect>
                 </QItemSection>

src/pages/Ticket/TicketFutureFilter.vue

@@ -24,6 +24,7 @@ const itemPackingTypes = ref([]);
 const stateOptions = ref([]);
 
 const getItemPackingTypes = async () => {
+    try {
         const filter = {
             where: { isActive: true },
         };
@@ -34,15 +35,22 @@ const getItemPackingTypes = async () => {
             description: t(ipt.description),
             code: ipt.code,
         }));
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const getGroupedStates = async () => {
+    try {
         const { data } = await axios.get('AlertLevels');
         stateOptions.value = data.map((state) => ({
             id: state.id,
             name: t(`futureTickets.${state.code}`),
             code: state.code,
         }));
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 onMounted(async () => {

src/pages/Worker/Card/WorkerDescriptor.vue

@@ -17,11 +17,6 @@ const $props = defineProps({
         required: false,
         default: null,
     },
-    dataKey: {
-        type: String,
-        required: false,
-        default: 'workerData',
-    },
 });
 const image = ref(null);
 
@@ -70,7 +65,7 @@ const handlePhotoUpdated = (evt = false) => {
     <CardDescriptor
         ref="cardDescriptorRef"
         module="Worker"
-        :data-key="dataKey"
+        data-key="workerData"
         url="Workers/descriptor"
         :filter="{ where: { id: entityId } }"
         title="user.nickname"

src/pages/Worker/Card/WorkerDescriptorProxy.vue

@@ -12,11 +12,6 @@ const $props = defineProps({
 
 <template>
     <QPopupProxy>
-        <WorkerDescriptor
+        <WorkerDescriptor v-if="$props.id" :id="$props.id" :summary="WorkerSummary" />
-            v-if="$props.id"
-            :id="$props.id"
-            :summary="WorkerSummary"
-            data-key="workerDescriptorProxy"
-        />
     </QPopupProxy>
 </template>

src/pages/Worker/Card/WorkerNotificationsManager.vue

@@ -44,9 +44,8 @@ async function toggleNotification(notification) {
                 `worker.notificationsManager.${notification.active ? '' : 'un'}subscribed`
             ),
         });
-    } catch (e) {
+    } catch {
         notification.active = !notification.active;
-        throw e;
     }
 }
 

src/pages/Zone/Card/ZoneWarehouses.vue

@@ -34,13 +34,21 @@ const columns = computed(() => [
 ]);
 
 const deleteWarehouse = async (row) => {
+    try {
         await axios.delete(`${urlPath.value}/${row.id}`);
         fetchWarehouses();
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 const createZoneWarehouse = async (ZoneWarehouseFormData) => {
+    try {
         await axios.post(urlPath.value, ZoneWarehouseFormData);
         fetchWarehouses();
+    } catch (error) {
+        console.error(error);
+    }
 };
 
 watch(

test/cypress/integration/outLogin/logout.spec.js

@@ -13,7 +13,7 @@ describe('Logout', () => {
     });
     describe('not user', () => {
         beforeEach(() => {
-            cy.intercept('GET', '**DefaultViewConfigs**', {
+            cy.intercept('GET', '**/VnUsers/acl', {
                 statusCode: 401,
                 body: {
                     error: {
@@ -24,11 +24,10 @@ describe('Logout', () => {
                     },
                 },
                 statusMessage: 'AUTHORIZATION_REQUIRED',
+            }).as('someRoute');
         });
-        });
-
         it('when token not exists', () => {
-            cy.get('.q-list > [href="#/item"]').click();
+            cy.reload();
             cy.get('.q-notification__message').should(
                 'have.text',
                 'Authorization Required'

test/cypress/integration/route/agency/agencyWorkCenter.spec.js

@@ -7,20 +7,31 @@ describe('AgencyWorkCenter', () => {
     const createButton = '.q-page-sticky > div > .q-btn > .q-btn__content > .q-icon';
     const workCenterCombobox = 'input[role="combobox"]';
 
-    it('check workCenter crud', () => {
+    it('assign workCenter', () => {
-        // create
         cy.get(createButton).click();
         cy.get(workCenterCombobox).type('workCenterOne{enter}');
-        cy.hasNotify('Data created');
+        cy.get('.q-notification__message').should('have.text', 'Data created');
+    });
 
-        // expect error when duplicate
+    it('delete workCenter', () => {
-        cy.get(createButton).click();
-        cy.get('[data-cy="FormModelPopup_save"]').click();
-        cy.hasNotify('This workCenter is already assigned to this agency');
-        cy.get('[data-cy="FormModelPopup_cancel"]').click();
-
-        // delete
         cy.get('.q-item__section--side > .q-btn > .q-btn__content > .q-icon').click();
-        cy.hasNotify('WorkCenter removed successfully');
+        cy.get('.q-notification__message').should(
+            'have.text',
+            'WorkCenter removed successfully'
+        );
+    });
+
+    it('error on duplicate workCenter', () => {
+        cy.get(createButton).click();
+        cy.get(workCenterCombobox).type('workCenterOne{enter}');
+        cy.get('.q-notification__message').should('have.text', 'Data created');
+        cy.get(createButton).click();
+        cy.get(
+            '.vn-row > .q-field > .q-field__inner > .q-field__control > .q-field__control-container'
+        ).type('workCenterOne{enter}');
+
+        cy.get(
+            ':nth-child(2) > .q-notification__wrapper > .q-notification__content > .q-notification__message'
+        ).should('have.text', 'This workCenter is already assigned to this agency');
     });
 });

test/cypress/integration/worker/workerNotificationsManager.spec.js

@@ -17,7 +17,10 @@ describe('WorkerNotificationsManager', () => {
         cy.login('developer');
         cy.visit(`/#/worker/${salesPersonId}/notifications`);
         cy.get(firstAvailableNotification).click();
-        cy.hasNotify('The notification subscription of this worker cant be modified');
+        cy.notificationHas(
+            '.q-notification__message',
+            'The notification subscription of this worker cant be modified'
+        );
     });
 
     it('should active a notification that is yours', () => {

test/cypress/support/commands.js

@@ -262,14 +262,3 @@ Cypress.Commands.add('openUserPanel', () => {
         '.column > .q-avatar > .q-avatar__content > .q-img > .q-img__container > .q-img__image'
     ).click();
 });
-
-Cypress.Commands.add('hasNotify', (text) => {
-    //last
-    cy.get('.q-notification')
-        .should('be.visible')
-        .last()
-        .then(($lastNotification) => {
-            if (!Cypress.$($lastNotification).text().includes(text))
-                throw new Error(`Notification not found: "${text}"`);
-        });
-});

test/vitest/__tests__/boot/axios.spec.js

@@ -36,6 +36,8 @@ describe('Axios boot', () => {
 
     describe('onResponseError()', async () => {
         it('should call to the Notify plugin with a message error for an status code "500"', async () => {
+            Notify.create = vi.fn();
+
             const error = {
                 response: {
                     status: 500,
@@ -43,10 +45,19 @@ describe('Axios boot', () => {
             };
 
             const result = onResponseError(error);
+
             expect(result).rejects.toEqual(expect.objectContaining(error));
+            expect(Notify.create).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    message: 'An internal server error has ocurred',
+                    type: 'negative',
+                })
+            );
         });
 
         it('should call to the Notify plugin with a message from the response property', async () => {
+            Notify.create = vi.fn();
+
             const error = {
                 response: {
                     status: 401,
@@ -59,7 +70,14 @@ describe('Axios boot', () => {
             };
 
             const result = onResponseError(error);
+
             expect(result).rejects.toEqual(expect.objectContaining(error));
+            expect(Notify.create).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    message: 'Invalid user or password',
+                    type: 'negative',
+                })
+            );
         });
     });
 });