FEDEO/spaces/stores/data.ts

import {defineStore} from 'pinia'
import dayjs from "dayjs"
import {typeOf} from "uri-js/dist/esnext/util";

//const supabase = createClient('https://uwppvcxflrcsibuzsbil.supabase.co','eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InV3cHB2Y3hmbHJjc2lidXpzYmlsIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MDA5MzgxOTQsImV4cCI6MjAxNjUxNDE5NH0.CkxYSQH0uLfwx9GVUlO6AYMU2FMLAxGMrwEKvyPv7Oo')

// @ts-ignore
export const useDataStore = defineStore('data', () => {

    const supabase = useSupabaseClient()
    const user = useSupabaseUser()
    const toast = useToast()
    const router = useRouter()

    const dataTypes = {
        tasks: {
            label: "Aufgaben",
            labelSingle: "Aufgabe",
            redirect: true
        },
        customers: {
            label: "Kunden",
            labelSingle: "Kunde",
            redirect:true
        },
        contacts: {
            label: "Kontakte",
            labelSingle: "Kontakt",
            redirect:true
        },
        contracts: {
            label: "Verträge",
            labelSingle: "Vertrag",
            redirect:true
        },
        absenceRequests: {
            label: "Abwesenheitsanträge",
            labelSingle: "Abwesenheitsantrag",
            redirect:true
        },
        plants: {
            label: "Objekte",
            labelSingle: "Objekte",
            redirect:true
        },
        products: {
            label: "Artikel",
            labelSingle: "Artikel",
            redirect:true
        },
        projects: {
            label: "Projekte",
            labelSingle: "Projekt",
            redirect:true
        },
        vehicles: {
            label: "Fahrzeuge",
            labelSingle: "Fahrzeug",
            redirect:true
        },
        vendors: {
            label: "Lieferanten",
            labelSingle: "Lieferant",
            redirect:true
        },
        messages: {
            label: "Nachrichten",
            labelSingle: "Nachricht"
        },
        spaces: {
            label: "Lagerplätze",
            labelSingle: "Lagerplatz",
            redirect: true
        },
        users: {
            label: "Benutzer",
            labelSingle: "Benutzer"
        }
    }

    const loaded = ref(false)
    const ownTenant = ref({
        calendarConfig: {
            eventTypes: [] as any[]
        },
        timeConfig: {
            timeTypes: [] as any[]
        },
        tags: {
            documents: [] as any[],
                products: [] as any[]
        },
        measures: [] as {name:String, short:String}[]
    })
    const profiles = ref([])
    const events = ref([])
    const customers = ref([])
    const tasks = ref([])
    const projects = ref([])
    const documents = ref([])
    const spaces = ref([])
    const units = ref([])
    const times = ref([])
    const products = ref([])
    const movements = ref([])
    const forms = ref([])
    const contracts = ref([])
    const formSubmits = ref([])
    const contacts = ref([])
    const vehicles = ref([])
    const vendors = ref([])
    const incomingInvoices = ref([])
    const bankAccounts = ref([])
    const bankStatements = ref([])
    const historyItems = ref([])
    const numberRanges = ref([])
    const notifications = ref([])
    const absenceRequests = ref([])
    const accounts = ref([])
    const taxTypes = ref([])
    const plants = ref([])
    const inventoryItems = ref([])
    const chats = ref([])
    const messages = ref([])

    async function fetchData () {
        fetchDocuments()
        await fetchOwnTenant()
        await fetchProfiles()
        await fetchEvents()
        await fetchTasks()
        await fetchProjects()
        await fetchTimes()
        await fetchCustomers()
        await fetchContracts()
        await fetchContacts()
        await fetchForms()
        await fetchFormSubmits()
        await fetchProducts()
        await fetchUnits()
        //await fetchDocuments()
        await fetchMovements()
        await fetchSpaces()
        await fetchVehicles()
        await fetchVendors()
        await fetchIncomingInvoices()
        await fetchBankAccounts()
        await fetchBankStatements()
        await fetchHistoryItems()
        await fetchNumberRanges()
        await fetchNotifications()
        await fetchAbsenceRequests()
        await fetchAccounts()
        await fetchTaxTypes()
        await fetchPlants()
        await fetchInventoryItems()
        await fetchChats()
        await fetchMessages()
        loaded.value = true
    }

    function clearStore () {
        console.log("Clear")
        loaded.value = false
        ownTenant.value =  {}
        profiles.value= []
        events.value= []
        customers.value= []
        tasks.value= []
        projects.value= []
        documents.value= []
        spaces.value= []
        units.value= []
        times.value= []
        products.value= []
        movements.value= []
        forms.value= []
        contracts.value= []
        formSubmits.value= []
        contacts.value= []
        vehicles.value= []
        vendors.value= []
        incomingInvoices.value= []
        bankAccounts.value= []
        bankStatements.value= []
        historyItems.value = []
        numberRanges.value = []
        notifications.value = []
        absenceRequests.value = []
        accounts.value = []
        taxTypes.value = []
        plants.value = []
        inventoryItems.value = []
        chats.value = []
        messages.value = []
    }

    //Realtime Update
    const channelA = supabase
        .channel('schema-db-changes')
        .on(
            'postgres_changes',
            {
                event: '*',
                schema: 'public',
            },
            (payload) => {
                console.log(payload)

                if(payload.eventType === 'INSERT') {
                    const c = payload.table + '.value.push(' + JSON.stringify(payload.new) + ')'
                    eval(c)
                } else if(payload.eventType === 'UPDATE'){
                    const c = payload.table + '.value[' + payload.table + '.value.findIndex(i => i.id === ' + JSON.stringify(payload.old.id) + ')] = ' + JSON.stringify(payload.new)
                    eval(c)
                }
            }
        )
        .subscribe()

    async function createNewItem (dataType:string,data:Array){
        const {data:supabaseData,error:supabaseError} = await supabase
            .from(dataType)
            .insert(typeOf(data) === 'Object' ? [data] : data)
            .select()

        if(supabaseError) {
            console.log(supabaseError)
        } else if (supabaseData) {
            await eval( dataType + '.value.push(' + JSON.stringify(...supabaseData) + ')')
            toast.add({title: `${dataTypes[dataType].labelSingle} hinzugefügt`})
            if(dataTypes[dataType].redirect) await router.push(`/${dataType}/show/${supabaseData[0].id}`)
        }
    }

    async function updateItem (dataType:string, data:Object) {
        const {data:supabaseData,error: supabaseError} = await supabase
            .from(dataType)
            .update(data)
            .eq('id',data.id)
            .select()

        if(supabaseError) {
            console.log(supabaseError)
        } else if(supabaseData) {
            await eval(dataType + '.value[' + dataType + '.value.findIndex(i => i.id === ' + JSON.stringify(data.id) + ')] = ' + JSON.stringify(supabaseData[0]))
            toast.add({title: `${dataTypes[dataType].labelSingle} gespeichert`})
            if(dataTypes[dataType].redirect) await router.push(`/${dataType}/show/${supabaseData[0].id}`)

        }
    }

    async function fetchOwnTenant () {
        ownTenant.value = (await supabase.from("tenants").select().eq('id', user.value?.app_metadata.tenant)).data[0]
    }

    async function fetchProfiles () {
        profiles.value = (await supabase.from("profiles").select()).data
    }
    async function fetchBankAccounts () {
        bankAccounts.value = (await supabase.from("bankAccounts").select()).data
    }
    async function fetchBankStatements () {
        bankStatements.value = (await supabase.from("bankStatements").select().order("date", {ascending:false})).data
    }
    async function fetchEvents () {
        events.value = (await supabase.from("events").select()).data
    }
    async function fetchContracts () {
        contracts.value = (await supabase.from("contracts").select()).data
    }
    async function fetchContacts () {
        contacts.value = (await supabase.from("contacts").select()).data
    }
    async function fetchCustomers () {
        customers.value = (await supabase.from("customers").select().order("customerNumber", {ascending:true})).data
    }
    async function fetchTasks () {
        tasks.value = (await supabase.from("tasks").select()).data
    }
    async function fetchForms () {
        forms.value = (await supabase.from("forms").select()).data
    }
    async function fetchFormSubmits () {
        formSubmits.value = (await supabase.from("formSubmits").select()).data
    }
    async function fetchProducts () {
        products.value = (await supabase.from("products").select()).data
    }
    async function fetchUnits () {
        units.value = (await supabase.from("units").select()).data
    }
    async function fetchProjects () {
        projects.value = (await supabase.from("projects").select()).data
    }
    async function fetchSpaces () {
        spaces.value = (await supabase.from("spaces").select().order("spaceNumber", {ascending:true})).data
    }
    async function fetchMovements () {
        movements.value = (await supabase.from("movements").select()).data
    }
    async function fetchVehicles () {
        vehicles.value = (await supabase.from("vehicles").select()).data
    }
    async function fetchTimes () {
        times.value = (await supabase.from("times").select().order("start", {ascending:false})).data
    }
    async function fetchHistoryItems () {

        historyItems.value = (await supabase.from("historyItems").select()).data
    }
    async function fetchVendors () {
        vendors.value = (await supabase.from("vendors").select().order("vendorNumber", {ascending:true})).data
    }
    async function fetchIncomingInvoices () {
        incomingInvoices.value = (await supabase.from("incomingInvoices").select()).data
    }
    async function fetchNumberRanges () {
        numberRanges.value = (await supabase.from("numberRanges").select()).data
    }
    async function fetchNotifications () {
        notifications.value = (await supabase.from("notifications").select().order("created_at", {ascending: false})).data
    }
    async function fetchAbsenceRequests () {
        absenceRequests.value = (await supabase.from("absenceRequests").select()).data
    }
    async function fetchAccounts () {
        accounts.value = (await supabase.from("accounts").select()).data
    }
    async function fetchTaxTypes () {
        taxTypes.value = (await supabase.from("taxTypes").select()).data
    }
    async function fetchPlants () {
        plants.value = (await supabase.from("plants").select()).data
    }
    async function fetchInventoryItems () {
        inventoryItems.value = (await supabase.from("inventoryItems").select()).data
    }
    async function fetchChats() {
        chats.value = (await supabase.from("chats").select()).data
    }
    async function fetchMessages() {
        messages.value = (await supabase.from("messages").select().order('created_at', {ascending:true})).data
    }

    async function fetchDocuments () {
        documents.value = (await supabase.from("documents").select()).data

        for(const [index,doc] of documents.value.entries()){
            // @ts-ignore
            documents.value[index].url = (await supabase.storage.from('files').createSignedUrl(doc.path, 60 * 60)).data.signedUrl
        }
    }

    async function addHistoryItem(text: String, user: String, elementId: String, resourceType: String) {
        let data = {
            user: user,
            text: text
        }

        if(resourceType === "customers") {
            data.customer = elementId
        }

        const {data:insertData,error:insertError} = await supabase
            .from("historyItems")
            .insert([addHistoryItemData.value])
            .select()

        if(insertError) {
            console.log(insertError)
        } else {
            toast.add({title: "Eintrag erfolgreich erstellt"})
            await fetchHistoryItems()
        }

    }

    //Getters

    const getOpenTasksCount = computed(() => {
        return tasks.value.filter(task => task.categorie != "Erledigt").length
    })

    const getMovementsBySpace = computed(() => (spaceId:string) => {
        return movements.value.filter(movement => movement.spaceId === spaceId)
    })

    const getContactsByCustomerId = computed(() => (customerId:string) => {
        return contacts.value.filter(item => item.customer === customerId)
    })

    const getContactsByVendorId = computed(() => (vendorId:string) => {
        return contacts.value.filter(item => item.vendor === vendorId)
    })

    const getDocumentsByProjectId = computed(() => (projectId:string) => {
        return documents.value.filter(item => item.project === projectId)
    })

    const getEventsByProjectId = computed(() => (projectId:string) => {
        return events.value.filter(item => item.project === projectId)
    })

    const getTimesByProjectId = computed(() => (projectId:string) => {
        return times.value.filter(time => time.projectId === projectId)
    })

    const getTasksByProjectId = computed(() => (projectId:string) => {
        return tasks.value.filter(item => item.project === projectId)
    })

    const getTasksByPlantId = computed(() => (plantId:string) => {
        return tasks.value.filter(item => item.plant === plantId)
    })

    const getProjectsByPlantId = computed(() => (plantId:string) => {
        return projects.value.filter(item => item.plant === plantId)
    })

    const getIncomingInvoicesByVehicleId = computed(() => (vehicleId:string) => {
        return incomingInvoices.value.filter(i => i.accounts.find(a => a.costCentre === vehicleId))
    })

    const getMovementsBySpaceId = computed(() => (spaceId:string) => {
        return movements.value.filter(movement => movement.spaceId === spaceId)
    })

    const getMessagesByChatId = computed(() => (chatId:string) => {
        return messages.value.filter(i => i.destination === chatId)
    })

    const getStockByProductId = computed(() => (productId:string) => {
        let productMovements = movements.value.filter(movement => movement.productId === productId)

        let count = 0

        productMovements.forEach(movement => {
            count += movement.quantity
        })

        return count
    })

    const getEventTypes = computed(() => {
        return ownTenant.value.calendarConfig.eventTypes
    })

    const getTimeTypes = computed(() => {
        return ownTenant.value.timeConfig.timeTypes
    })

    const getDocumentTags = computed(() => {
        return ownTenant.value.tags.documents
    })

    const getMeasures = computed(() => {
        return ownTenant.value.measures
    })

    const getResources = computed(() => {
        return [
            ...profiles.value.map(profile => {
                return {
                    type: 'Mitarbeiter',
                    title: profile.fullName,
                    id: profile.id
                }
            }),
            ...vehicles.value.map(vehicle => {
                return {
                    type: 'Fahrzeug',
                    title: vehicle.licensePlate,
                    id: `F-${vehicle.id}`
                }
            }),
            ...inventoryItems.value.filter(i=> i.usePlanning).map(item => {
                return {
                    type: 'Inventar',
                    title: item.name,
                    id: `I-${item.id}`
                }
            })
        ]
    })

    const getEvents = computed(() => {
        return [
            ...events.value.map(event => {
                let eventColor = ownTenant.value.calendarConfig.eventTypes.find(type => type.label === event.type).color

                let title = ""
                if(event.title) {
                    title = event.title
                } else if(event.project) {
                    projects.value.find(i => i.id === event.project) ? projects.value.find(i => i.id === event.project).name : ""
                }

                return {
                    ...event,
                    title: title,
                    borderColor: eventColor,
                    textColor: eventColor,
                    backgroundColor: "black"
                }
            }),
            ...absenceRequests.value.map(absence => {
                return  {
                    resourceId: absence.user,
                    resourceType: "person",
                    title: absence.reason,
                    start: dayjs(absence.start).toDate(),
                    end: dayjs(absence.end).add(1,'day').toDate(),
                    allDay: true
                }
            })
        ]
    })

    const getEventsByResource = computed(() => {
        let tempEvents = []
        events.value.forEach(event => {
            event.resources.forEach(resource => {
                let eventColor = ownTenant.value.calendarConfig.eventTypes.find(type => type.label === event.type).color

                let title = ""
                if(event.title) {
                    title = event.title
                } else if(event.project) {
                    projects.value.find(i => i.id === event.project) ? projects.value.find(i => i.id === event.project).name : ""
                }



                tempEvents.push({
                    ...event,
                    resourceId: resource.type !== 'Mitarbeiter' ? `${resource.type[0]}-${resource.id}`: resource.id,
                    resourceType: resource.type,
                    title: title,
                    borderColor: eventColor,
                    textColor: eventColor,
                    backgroundColor: "black"
                })


            })
        })



        return [
            ...tempEvents,
            /*...events.value.map(event => {


                let eventColor = ownTenant.value.calendarConfig.eventTypes.find(type => type.label === event.type).color

                return {
                    ...event,
                    title: !event.title ? projects.value.find(i => i.id === event.project).name : event.title,
                    borderColor: eventColor,
                    textColor: eventColor,
                    backgroundColor: "black"
                }
            }),*/
            ...absenceRequests.value.map(absence => {
                return  {
                    resourceId: absence.user,
                    resourceType: "person",
                    title: absence.reason,
                    start: dayjs(absence.start).toDate(),
                    end: dayjs(absence.end).add(1,'day').toDate(),
                    allDay: true
                }
            })
        ]
    })

    const getCostCentresComposed = computed(() => {
        return [
            ...vehicles.value.map(vehicle => {
                return {
                    label: "Fahrzeug - " + vehicle.licensePlate,
                    id: vehicle.id
                }
            }),
            ...projects.value.map(project => {
                return {
                    label: "Projekt - " + project.name,
                    id: project.id
                }
            })
        ]
    })


    //Get Item By Id
    const getProductById = computed(() => (itemId:string) => {
        return products.value.find(item => item.id === itemId)
    })

    const getVendorById = computed(() => (itemId:string) => {
        return vendors.value.find(item => item.id === itemId)
    })

    const getIncomingInvoiceById = computed(() => (itemId:string) => {
        return incomingInvoices.value.find(item => item.id === itemId)
    })

    const getContractById = computed(() => (itemId:string) => {
        return contracts.value.find(item => item.id === itemId)
    })

    const getContactById = computed(() => (itemId:string) => {
        return contacts.value.find(item => item.id === itemId)
    })

    const getVehicleById = computed(() => (itemId:string) => {
        return vehicles.value.find(item => item.id === itemId)
    })

    const getDocumentById = computed(() => (itemId:string) => {
        return documents.value.find(item => item.id === itemId)
    })

    const getSpaceById = computed(() => (itemId:string) => {
        return spaces.value.find(item => item.id === itemId)
    })

    const getCustomerById = computed(() => (itemId:number) => {
        return customers.value.find(item => item.id === itemId)
    })

    const getTaskById = computed(() => (itemId:string) => {
        return tasks.value.find(item => item.id === itemId)
    })

    const getAbsenceRequestById = computed(() => (itemId:string) => {
        return absenceRequests.value.find(item => item.id === itemId)
    })

    const getProfileById = computed(() => (itemId:string) => {
        return profiles.value.find(item => item.id === itemId)
    })

    const getAccountById = computed(() => (accountId:string) => {
        return accounts.value.find(item => item.id === accountId)
    })

    const getPlantById = computed(() => (plantId:string) => {
        return plants.value.find(item => item.id === plantId)
    })

    const getProjectById = computed(() => (itemId:string) => {
        if(projects.value.find(i => i.id === itemId)) {
            let project = projects.value.find(project => project.id === itemId)

            /*let projectHours = 0

            let projectTimes = times.value.filter(time => time.projectId === itemId)
            projectTimes.forEach(time => projectHours += time.duration)

            project.projectHours = projectHours*/

            return project
        } else {
            return null
        }



    })

    return {
        loaded,
        ownTenant,
        profiles,
        events,
        customers,
        tasks,
        projects,
        documents,
        spaces,
        units,
        times,
        products,
        movements,
        forms,
        contracts,
        formSubmits,
        contacts,
        vehicles,
        vendors,
        incomingInvoices,
        bankAccounts,
        bankStatements,
        historyItems,
        numberRanges,
        notifications,
        absenceRequests,
        accounts,
        taxTypes,
        plants,
        inventoryItems,
        chats,
        messages,
        //Functions
        createNewItem,
        updateItem,
        fetchData,
        clearStore,
        fetchOwnTenant,
        fetchProfiles,
        fetchBankAccounts,
        fetchBankStatements,
        fetchEvents,
        fetchContracts,
        fetchContacts,
        fetchCustomers,
        fetchTasks,
        fetchForms,
        fetchFormSubmits,
        fetchProducts,
        fetchUnits,
        fetchProjects,
        fetchSpaces,
        fetchMovements,
        fetchVehicles,
        fetchTimes,
        fetchHistoryItems,
        fetchVendors,
        fetchIncomingInvoices,
        fetchNumberRanges,
        fetchNotifications,
        fetchDocuments,
        fetchAbsenceRequests,
        fetchPlants,
        fetchInventoryItems,
        fetchChats,
        fetchMessages,
        addHistoryItem,
        //Getters
        getOpenTasksCount,
        getMovementsBySpace,
        getContactsByCustomerId,
        getContactsByVendorId,
        getDocumentsByProjectId,
        getEventsByProjectId,
        getTimesByProjectId,
        getTasksByProjectId,
        getTasksByPlantId,
        getProjectsByPlantId,
        getMovementsBySpaceId,
        getMessagesByChatId,
        getStockByProductId,
        getIncomingInvoicesByVehicleId,
        getEventTypes,
        getTimeTypes,
        getDocumentTags,
        getMeasures,
        getResources,
        getEvents,
        getEventsByResource,
        getCostCentresComposed,
        getProductById,
        getVendorById,
        getIncomingInvoiceById,
        getContractById,
        getContactById,
        getVehicleById,
        getDocumentById,
        getSpaceById,
        getCustomerById,
        getTaskById,
        getAbsenceRequestById,
        getProjectById,
        getProfileById,
        getAccountById,
        getPlantById
    }


})