salix-front/src/pages/Zone/Card/ZoneLocationsTree.vue

<script setup>
import { onMounted, ref, computed, watch } from 'vue';
import { useI18n } from 'vue-i18n';
import { useRoute } from 'vue-router';

import { useState } from 'src/composables/useState';
import axios from 'axios';
import { useArrayData } from 'composables/useArrayData';
import { onUnmounted } from 'vue';

const { t } = useI18n();
const route = useRoute();
const state = useState();

const treeRef = ref();
const expanded = ref([]);

const arrayData = useArrayData('ZoneLocations', {
    url: `Zones/${route.params.id}/getLeaves`,
});
const { store } = arrayData;
const storeData = computed(() => store.data);

const nodes = ref([
    { id: null, name: t('zoneLocations.locations'), sons: true, childs: [{}] },
]);

const previousExpandedNodes = ref(new Set());

const onNodeExpanded = async (nodeKeysArray) => {
    let nodeKeysSet = new Set(nodeKeysArray);
    const lastNodeKey = nodeKeysArray.at(-1);

    if (!nodeKeysSet.has(null)) return;

    const wasExpanded = !previousExpandedNodes.value.has(lastNodeKey);
    if (wasExpanded) await fetchNodeLeaves(lastNodeKey);
    else {
        const difference = new Set(
            [...previousExpandedNodes.value].filter((x) => !nodeKeysSet.has(x))
        );
        const collapsedNode = Array.from(difference).pop();
        const node = treeRef.value?.getNodeByKey(collapsedNode);
        const allNodeIds = getNodeIds(node);
        expanded.value = expanded.value.filter((id) => !allNodeIds.includes(id));
    }
    previousExpandedNodes.value = nodeKeysSet;
};

const formatNodeSelected = (node) => {
    if (node.selected === 1) node.selected = true;
    else if (node.selected === 0) node.selected = false;

    if (node.childs && node.childs.length > 0) {
        expanded.value.push(node.id);

        node.childs.forEach((childNode) => {
            formatNodeSelected(childNode);
        });
    }

    if (node.sons > 0 && !node.childs) node.childs = [{}];
};

const fetchNodeLeaves = async (nodeKey) => {
    try {
        const node = treeRef.value?.getNodeByKey(nodeKey);
        if (!node || node.sons === 0) return;

        const params = { parentId: node.id };
        const response = await axios.get(`Zones/${route.params.id}/getLeaves`, {
            params,
        });
        if (response.data) {
            node.childs = response.data.map((n) => {
                formatNodeSelected(n);
                return n;
            });
        }

        state.set('Tree', node);
    } catch (err) {
        console.error('Error fetching department leaves', err);
        throw new Error();
    }
};

function getNodeIds(node) {
    let ids = [];
    if (node.id) ids.push(node.id);

    if (node.childs)
        node.childs.forEach((child) => {
            ids = ids.concat(getNodeIds(child));
        });
    return ids;
}

watch(storeData, async (val) => {
    // Se triggerea cuando se actualiza el store.data, el cual es el resultado del fetch de la searchbar
    nodes.value[0].childs = [...val];
    const fetchedNodeKeys = val.flatMap(getNodeIds);
    state.set('Tree', [...fetchedNodeKeys]);

    if (store.userParams?.search === '') {
        val.forEach((n) => {
            formatNodeSelected(n);
        });
    } else {
        for (let n of state.get('Tree')) {
            await fetchNodeLeaves(n);
        }
        expanded.value = [null, ...fetchedNodeKeys];
    }
    previousExpandedNodes.value = new Set(expanded.value);
});

onMounted(async () => {
    if (store.userParams?.search) {
        await arrayData.fetch({ append: false });
        return;
    }
    const stateTree = state.get('Tree');
    const tree = stateTree ? [...state.get('Tree')] : [null];
    const lastStateTree = state.get('TreeState');
    if (tree) {
        for (let n of tree) {
            await fetchNodeLeaves(n);
        }

        if (lastStateTree) {
            tree.push(lastStateTree);
            await fetchNodeLeaves(lastStateTree);
        }
    }

    setTimeout(() => {
        if (lastStateTree) {
            document.getElementById(lastStateTree).scrollIntoView();
        }
    }, 1000);

    previousExpandedNodes.value = new Set(expanded.value);
});

onUnmounted(() => {
    state.set('Tree', undefined);
});
</script>

<template>
    <QTree
        ref="treeRef"
        :nodes="nodes"
        node-key="id"
        label-key="name"
        children-key="childs"
        v-model:expanded="expanded"
        @update:expanded="onNodeExpanded($event)"
        :default-expand-all="true"
    >
        <template #default-header="{ node }">
            <div
                :id="node.id"
                class="qtr row justify-between full-width q-pr-md cursor-pointer"
            >
                <span v-if="!node.id">{{ node.name }}</span>
                <slot name="checkbox" :node="node" />
            </div>
        </template>
    </QTree>
</template>