425 lines
13 KiB
TypeScript
425 lines
13 KiB
TypeScript
import {defineStore} from 'pinia'
|
|
|
|
import {createClient} from '@supabase/supabase-js'
|
|
|
|
//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 loaded = ref(false)
|
|
const ownTenant = ref({
|
|
calendarConfig: {
|
|
eventTypes: [] as any[]
|
|
},
|
|
timeConfig: {
|
|
timeTypes: [] as any[]
|
|
},
|
|
tags: {
|
|
documents: [] as any[],
|
|
products: [] as any[]
|
|
}
|
|
})
|
|
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 jobs = ref([])
|
|
const formSubmits = ref([])
|
|
const contacts = ref([])
|
|
const vehicles = ref([])
|
|
const vendors = ref([])
|
|
const vendorInvoices = ref([])
|
|
const bankAccounts = ref([])
|
|
const bankStatements = ref([])
|
|
const historyItems = ref([])
|
|
const numberRanges = ref([])
|
|
|
|
async function fetchData () {
|
|
fetchDocuments()
|
|
await fetchOwnTenant()
|
|
await fetchProfiles()
|
|
await fetchEvents()
|
|
await fetchTasks()
|
|
await fetchProjects()
|
|
await fetchTimes()
|
|
await fetchJobs()
|
|
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 fetchVendorInvoices()
|
|
await fetchBankAccounts()
|
|
await fetchBankStatements()
|
|
await fetchHistoryItems()
|
|
await fetchNumberRanges()
|
|
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= []
|
|
jobs.value= []
|
|
formSubmits.value= []
|
|
contacts.value= []
|
|
vehicles.value= []
|
|
vendors.value= []
|
|
vendorInvoices.value= []
|
|
bankAccounts.value= []
|
|
bankStatements.value= []
|
|
historyItems.value = []
|
|
numberRanges.value = []
|
|
}
|
|
|
|
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()).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()).data
|
|
}
|
|
async function fetchJobs () {
|
|
jobs.value = (await supabase.from("jobs").select()).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 fetchVendorInvoices () {
|
|
vendorInvoices.value = (await supabase.from("vendorInvoices").select()).data
|
|
}
|
|
async function fetchNumberRanges () {
|
|
numberRanges.value = (await supabase.from("numberRanges").select()).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 getDocumentsByProjectId = computed(() => (projectId:string) => {
|
|
return documents.value.filter(item => item.project === projectId)
|
|
})
|
|
|
|
const getTimesByProjectId = computed(() => (projectId:string) => {
|
|
return times.value.filter(time => time.projectId === projectId)
|
|
})
|
|
|
|
const getHistoryItemsByCustomer = computed(() => (customerId:string) => {
|
|
return historyItems.value.filter(item => item.customer === customerId)
|
|
})
|
|
|
|
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 getResources = computed(() => {
|
|
return [
|
|
...profiles.value.map(profile => {
|
|
return {
|
|
type: 'person',
|
|
title: profile.fullName,
|
|
id: profile.id
|
|
}
|
|
}),
|
|
...vehicles.value.map(vehicle => {
|
|
return {
|
|
type: 'vehicle',
|
|
title: vehicle.licensePlate,
|
|
id: vehicle.licensePlate
|
|
}
|
|
})
|
|
]
|
|
})
|
|
|
|
const getEvents = computed(() => {
|
|
return [
|
|
...events.value.map(event => {
|
|
let eventColor = ownTenant.value.calendarConfig.eventTypes.find(type => type.label === event.type).color
|
|
|
|
return {
|
|
...event,
|
|
borderColor: eventColor,
|
|
textColor: eventColor,
|
|
backgroundColor: "black"
|
|
}
|
|
}),
|
|
]
|
|
})
|
|
|
|
|
|
//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 getVendorInvoiceById = computed(() => (itemId:string) => {
|
|
return vendorInvoices.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 getVehiclesById = 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 getJobById = computed(() => (itemId:string) => {
|
|
return jobs.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getProfileById = computed(() => (itemId:string) => {
|
|
return profiles.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getProjectById = computed(() => (itemId:string) => {
|
|
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
|
|
})
|
|
|
|
return {
|
|
loaded,
|
|
ownTenant,
|
|
profiles,
|
|
events,
|
|
customers,
|
|
tasks,
|
|
projects,
|
|
documents,
|
|
spaces,
|
|
units,
|
|
times,
|
|
products,
|
|
movements,
|
|
forms,
|
|
contracts,
|
|
jobs,
|
|
formSubmits,
|
|
contacts,
|
|
vehicles,
|
|
vendors,
|
|
vendorInvoices,
|
|
bankAccounts,
|
|
bankStatements,
|
|
historyItems,
|
|
numberRanges,
|
|
//Functions
|
|
fetchData,
|
|
clearStore,
|
|
fetchOwnTenant,
|
|
fetchProfiles,
|
|
fetchBankAccounts,
|
|
fetchBankStatements,
|
|
fetchEvents,
|
|
fetchContracts,
|
|
fetchContacts,
|
|
fetchCustomers,
|
|
fetchTasks,
|
|
fetchForms,
|
|
fetchFormSubmits,
|
|
fetchProducts,
|
|
fetchUnits,
|
|
fetchProjects,
|
|
fetchSpaces,
|
|
fetchMovements,
|
|
fetchVehicles,
|
|
fetchTimes,
|
|
fetchJobs,
|
|
fetchHistoryItems,
|
|
fetchVendors,
|
|
fetchVendorInvoices,
|
|
fetchNumberRanges,
|
|
fetchDocuments,
|
|
addHistoryItem,
|
|
//Getters
|
|
getOpenTasksCount,
|
|
getMovementsBySpace,
|
|
getContactsByCustomerId,
|
|
getDocumentsByProjectId,
|
|
getTimesByProjectId,
|
|
getHistoryItemsByCustomer,
|
|
getEventTypes,
|
|
getTimeTypes,
|
|
getDocumentTags,
|
|
getResources,
|
|
getEvents,
|
|
getProductById,
|
|
getVendorById,
|
|
getVendorInvoiceById,
|
|
getContractById,
|
|
getContactById,
|
|
getVehiclesById,
|
|
getDocumentById,
|
|
getSpaceById,
|
|
getCustomerById,
|
|
getJobById,
|
|
getProjectById,
|
|
getProfileById
|
|
}
|
|
|
|
|
|
}) |