src/stores/products.ts - dev - vdele/app

src/stores/products.ts
198 строк7 KB
Vasilii Polshakov
last fixes for 0.0.1-alpha
02 апр 2025, 12:32
02 апр 2025, 12:32ef3d4ef
import { defineStore } from 'pinia';
import type { IGroup, IServicesGroup, IServiceRecord } from '@/libs/types';
import { computed, ref} from 'vue';
import { openDB } from 'idb';

export const useProductsStore = defineStore('products', () => {
    
    const groupsRecords = ref<IGroup[] | null>(null);
    const servicesRecords = ref<IServiceRecord[] | null>(null); 
    const data = ref<IServicesGroup[]|null>(null);

    const groups = computed(() => groupsRecords.value);
    const services = computed(() => servicesRecords.value);

    return {
        groups,
        services,
        data,
        fetchAll: async () => {
            const initDB = async () => {
                return openDB('MyDatabase', 1);
            }

            const db = await initDB();

            const _groups = await db.getAll('groups') as IGroup[];
            const _service = await db.getAll('services') as IServiceRecord[];

            data.value = _groups.map((group) => ({
                uid: group.uid,
                name: group.name,
                services: _service.filter((service) => service.group === group.uid),
            })) as IServicesGroup[];

            groupsRecords.value = _groups;
            servicesRecords.value = _service;
        },
        //group actions
        createGroup: async (group: IGroup) => {
            const initDB = async () => {
                return openDB('MyDatabase', 1);
            }

            const db = await initDB();

            await db.put('groups', group)
                .then(() => {
                    groupsRecords.value?.push(group);
                    data.value?.push({ ...group, services: []});
                });
        },
        deleteGroup: async (group: IGroup) => {
            const initDB = async () => {
                return openDB('MyDatabase', 1);
            }

            const db = await initDB();

            const tx = db.transaction('services', 'readwrite');

            if(data.value){
                const _group = data.value.find((v) => v.uid === group.uid);

                if(_group){
                    // удаляем связанные услуги
                    Promise.all([
                        ..._group.services.map(service => tx.store.delete(service.uid)),
                        tx.done
                    ]).then(async () => {
                        await db.delete('groups', group.uid)
                            .then(() => {
                                if(groupsRecords.value) {
                                    const idx = groupsRecords.value.findIndex((v) => v.uid === group.uid);
                                
                                    if(idx > -1)
                                        groupsRecords.value.splice(idx, 1);
                                };
            
                                if(data.value) {
                                    const index = data.value.findIndex((v) => v.uid === group.uid);
            
                                    if(index > -1)
                                        data.value.splice(index, 1);
                                };

                                if(servicesRecords.value){
                                    const _idx = servicesRecords.value.findIndex((v) => v.group === group.uid);

                                    if(_idx > -1)
                                        servicesRecords.value.splice(_idx, 1);
                                }
                            });
                    });
                }
            }
        },
        editGroup: async (group: IGroup) => {
            const initDB = async () => {
                return openDB('MyDatabase', 1);
            }

            const db = await initDB();

            await db.put('groups', group)
                .then(() => {
                    if(groupsRecords.value) {
                        const idx = groupsRecords.value.findIndex((v) => v.uid === group.uid);
                    
                        if(idx > -1)
                            groupsRecords.value[idx].name = group.name;
                    };

                    if(data.value) {
                        const index = data.value.findIndex((v) => v.uid === group.uid);

                        if(index > -1)
                            data.value[index].name = group.name;
                    };
                });
        },
        //service actions
        createService: async (service: IServiceRecord) => {
            const initDB = async () => {
                return openDB('MyDatabase', 1);
            }

            const db = await initDB();
            await db.put('services', service)
                .then(() => {
                    if(servicesRecords.value){
                        servicesRecords.value.push(service);
                    };

                    if(data.value) {
                        const index = data.value.findIndex((v) => v.uid === service.group);
                        
                        if(index > -1)
                            data.value[index].services.push(service);
                    };
                });
        },
        deleteService: async (service: IServiceRecord) => {
            const initDB = async () => {
                return openDB('MyDatabase', 1);
            }

            const db = await initDB();

            await db.delete('services', service.uid)
                .then(() => {
                    if(servicesRecords.value){
                        const idx = servicesRecords.value.findIndex((v) => v.uid === service.uid);

                        if(idx > -1)
                            servicesRecords.value.splice(idx, 1);
                    };

                    if(data.value) {
                        const index = data.value.findIndex((v) => v.uid === service.group);
                        
                        if(index > -1){
                            const _idx = data.value[index].services.findIndex((v) => v.uid === service.uid);

                            if(_idx > -1)
                                data.value[index].services.splice(_idx, 1);
                        }
                    };
                });
        },
        editService: async (service: IServiceRecord) => {
            const initDB = async () => {
                return openDB('MyDatabase', 1);
            }

            const db = await initDB();
            await db.put('services', service)
                .then(() => {
                    if(servicesRecords.value){
                        const idx = servicesRecords.value.findIndex((v) => v.uid === service.uid);

                        if(idx > -1)
                            servicesRecords.value[idx] = service;
                    };

                    if(data.value) {
                        const index = data.value.findIndex((v) => v.uid === service.group);
                        
                        if(index > -1){
                            const _idx = data.value[index].services.findIndex((v) => v.uid === service.uid);

                            if(_idx > -1)
                                data.value[index].services[_idx] = service;
                        }
                    };
                });
        },
    };
});