1188 lines
37 KiB
JavaScript
1188 lines
37 KiB
JavaScript
import {defineStore} from 'pinia'
|
|
import dayjs from "dayjs"
|
|
import {typeOf} from "uri-js/dist/esnext/util";
|
|
import {useNumberRange} from "~/composables/useNumberRange.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 router = useRouter()
|
|
|
|
const dataTypes = {
|
|
tasks: {
|
|
label: "Aufgaben",
|
|
labelSingle: "Aufgabe",
|
|
redirect: true
|
|
},
|
|
customers: {
|
|
label: "Kunden",
|
|
labelSingle: "Kunde",
|
|
redirect:true,
|
|
numberRangeHolder: "customerNumber"
|
|
},
|
|
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,
|
|
numberRangeHolder: "vendorNumber"
|
|
},
|
|
messages: {
|
|
label: "Nachrichten",
|
|
labelSingle: "Nachricht"
|
|
},
|
|
spaces: {
|
|
label: "Lagerplätze",
|
|
labelSingle: "Lagerplatz",
|
|
redirect: true,
|
|
numberRangeHolder: "spaceNumber"
|
|
},
|
|
users: {
|
|
label: "Benutzer",
|
|
labelSingle: "Benutzer"
|
|
},
|
|
createddocuments: {
|
|
label: "Dokumente",
|
|
labelSingle: "Dokument"
|
|
},
|
|
incominginvoices: {
|
|
label: "Eingangsrechnungen",
|
|
labelSingle: "Eingangsrechnung"
|
|
},
|
|
inventoryitems: {
|
|
label: "Inventarartikel",
|
|
labelSingle: "Inventarartikel",
|
|
redirect: true
|
|
},
|
|
services: {
|
|
label: "Leistungen",
|
|
labelSingle: "Leistung",
|
|
redirect: true
|
|
},
|
|
events: {
|
|
label: "Termine",
|
|
labelSingle: "Termin"
|
|
},
|
|
profiles: {
|
|
label: "Mitarbeiter",
|
|
labelSingle: "Mitarbeiter",
|
|
redirect: true
|
|
}
|
|
}
|
|
|
|
const documentTypesForCreation = ref({
|
|
invoices: {
|
|
label: "Rechnungen",
|
|
labelSingle: "Rechnung",
|
|
|
|
},
|
|
quotes: {
|
|
label: "Angebote",
|
|
labelSingle: "Angebot"
|
|
},
|
|
deliveryNotes: {
|
|
label: "Lieferscheine",
|
|
labelSingle: "Lieferschein"
|
|
}
|
|
})
|
|
|
|
|
|
const loaded = ref(false)
|
|
const ownTenant = ref({
|
|
calendarConfig: {
|
|
eventTypes: []
|
|
},
|
|
timeConfig: {
|
|
timeTypes: []
|
|
},
|
|
tags: {
|
|
documents: [] ,
|
|
products: []
|
|
},
|
|
measures: []
|
|
})
|
|
|
|
|
|
const profiles = ref([])
|
|
const currentTenant = ref(null)
|
|
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([])
|
|
const createddocuments = ref([])
|
|
const workingtimes = ref([])
|
|
const phasesTemplates = ref([])
|
|
const emailAccounts = ref([])
|
|
const texttemplates =ref([])
|
|
const services =ref([])
|
|
const serviceCategories =ref([])
|
|
|
|
|
|
const rights = ref({
|
|
createUser: {label: "Benutzer erstellen"},
|
|
modifyUser: {label: "Benutzer bearbeiten"},
|
|
deactivateUser: {label: "Benutzer sperren"},
|
|
createProject: {label: "Projekt erstellen"},
|
|
viewOwnProjects: {label: "Eigene Projekte sehen"},
|
|
viewAllProjects: {label: "Alle Projekte sehen"},
|
|
createTask: {label: "Aufgabe erstellen"},
|
|
viewOwnTasks: {label:"Eigene Aufgaben sehen"},
|
|
viewAllTasks: {label: "Alle Aufgaben sehen"},
|
|
trackOwnTime: {label:"Eigene Zeite erfassen"},
|
|
createOwnTime: {label:"Eigene Zeiten erstellen"},
|
|
createTime: {label:"Zeiten erstellen"},
|
|
viewOwnTimes: {label:"Eigene Zeiten anzeigen"},
|
|
viewTimes: {label:"Zeiten anzeigen"},
|
|
})
|
|
|
|
const roles = ref([
|
|
{
|
|
key: "tenantAdmin",
|
|
label: "Firmenadministrator",
|
|
rights: [
|
|
...Object.keys(rights.value)
|
|
]
|
|
},
|
|
{
|
|
key:"worker",
|
|
label: "Monteur",
|
|
rights: [
|
|
"viewOwnProjects",
|
|
"createTasks",
|
|
"viewOwnTasks",
|
|
"viewOwnTimes",
|
|
"createOwnTime"
|
|
]
|
|
},
|
|
{
|
|
key:"manager",
|
|
label: "Vorarbeiter",
|
|
rights: [
|
|
"createProjects",
|
|
"viewOwnProjects",
|
|
"createTasks",
|
|
"viewOwnTasks",
|
|
]
|
|
},
|
|
{
|
|
key:"booker",
|
|
label: "Buchhalter",
|
|
rights: [
|
|
"createTasks",
|
|
"viewOwnTasks",
|
|
"createTime",
|
|
"viewAllTimes"
|
|
]
|
|
}
|
|
])
|
|
|
|
async function initializeData (userId) {
|
|
let profile = (await supabase.from("profiles").select().eq("user",userId).single()).data
|
|
|
|
currentTenant.value = profile.tenant
|
|
|
|
await fetchData()
|
|
|
|
}
|
|
|
|
async function changeTenant() {
|
|
loaded.value = false
|
|
await clearStore()
|
|
await fetchData()
|
|
router.push("/")
|
|
loaded.value = true
|
|
|
|
}
|
|
|
|
async function fetchData () {
|
|
await fetchProfiles()
|
|
await fetchDocuments()
|
|
await fetchOwnTenant()
|
|
await fetchEvents()
|
|
await fetchTasks()
|
|
await fetchProjects()
|
|
await fetchTimes()
|
|
await fetchCustomers()
|
|
await fetchContracts()
|
|
await fetchContacts()
|
|
await fetchForms()
|
|
await fetchFormSubmits()
|
|
await fetchProducts()
|
|
await fetchUnits()
|
|
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()
|
|
await fetchCreatedDocuments()
|
|
await fetchWorkingTimes()
|
|
await fetchPhasesTemplates()
|
|
await fetchEmailAccounts()
|
|
await fetchTextTemplates()
|
|
await fetchServices()
|
|
await fetchServiceCategories()
|
|
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 = []
|
|
createddocuments.value = []
|
|
workingtimes.value = []
|
|
phasesTemplates.value = []
|
|
emailAccounts.value = []
|
|
texttemplates.value = []
|
|
services.value = []
|
|
serviceCategories.value = []
|
|
}
|
|
|
|
function hasRight (right) {
|
|
const role = profiles.value.find(i => i.id === user.value.id).role
|
|
const grantedRights = roles.value.find(i => i.key === role).rights
|
|
|
|
if(grantedRights.includes(right)){
|
|
return true
|
|
} else return false
|
|
|
|
}
|
|
|
|
|
|
//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,data){
|
|
if(typeOf(data) === 'object') {
|
|
data = {...data, tenant: currentTenant.value}
|
|
} else if(typeOf(data) === 'array') {
|
|
data.map(i => {
|
|
return {
|
|
...i,
|
|
tenant: currentTenant.value
|
|
}
|
|
})
|
|
}
|
|
|
|
|
|
|
|
//console.log(dataType)
|
|
if(dataTypes[dataType].numberRangeHolder) {
|
|
|
|
const numberRange = useNumberRange(dataType)
|
|
if(!dataTypes[dataType].numberRangeHolder) {
|
|
data[dataTypes[dataType].numberRangeHolder] = await numberRange.useNextNumber()
|
|
}
|
|
|
|
|
|
} else if(dataType === "createddocuments") {
|
|
console.log(data.type)
|
|
const numberRange = useNumberRange(data.type)
|
|
data.documentNumber = await numberRange.useNextNumber()
|
|
|
|
}
|
|
|
|
const {data:supabaseData,error:supabaseError} = await supabase
|
|
.from(dataType)
|
|
.insert(data)
|
|
.select()
|
|
|
|
if(supabaseError) {
|
|
console.log(supabaseError)
|
|
toast.add({title: "Es ist ein Fehler bei der Erstellung aufgetreten", color: "rose"})
|
|
} 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}`)
|
|
return supabaseData
|
|
}
|
|
}
|
|
|
|
async function updateItem (dataType, data) {
|
|
|
|
const {tenants, ...newData} = data
|
|
|
|
|
|
|
|
|
|
const {data:supabaseData,error: supabaseError} = await supabase
|
|
.from(dataType)
|
|
.update(newData)
|
|
.eq('id',newData.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]))
|
|
if(dataType === 'profiles') await fetchProfiles()
|
|
toast.add({title: `${dataTypes[dataType].labelSingle} gespeichert`})
|
|
if(dataTypes[dataType].redirect) await router.push(`/${dataType}/show/${data.id}`)
|
|
return supabaseData
|
|
}
|
|
}
|
|
|
|
const uploadFiles = async (formData, files, upsert) => {
|
|
console.log(files)
|
|
console.log(formData)
|
|
let documentsToInsert = []
|
|
|
|
const uploadSingleFile = async (file) => {
|
|
|
|
const {data, error} = await supabase
|
|
.storage
|
|
.from("files")
|
|
.upload(`${currentTenant.value}/${file.name}`, file, {upsert: upsert})
|
|
|
|
if (error) {
|
|
console.log(error)
|
|
console.log(error.statusCode)
|
|
|
|
if(error.statusCode === '400') {
|
|
console.log("is 400")
|
|
toast.add({title: "Hochladen fehlgeschlagen", description: "Die Datei enthält ungültige Zeichen", icon: "i-heroicons-x-circle", color: "rose", timeout: 10000})
|
|
} else if(error.statusCode === '409') {
|
|
console.log("is 409")
|
|
toast.add({title: "Hochladen fehlgeschlagen", description: "Es existiert bereits eine Datei mit diesem Namen", icon: "i-heroicons-x-circle", color: "rose", timeout: 10000})
|
|
} else {
|
|
toast.add({title: "Hochladen fehlgeschlagen", icon: "i-heroicons-x-circle", color: "rose", timeout: 10000})
|
|
|
|
}
|
|
|
|
} else if (data) {
|
|
const returnPath = data.path
|
|
|
|
documentsToInsert.push({...formData, path: returnPath, tenant: currentTenant.value})
|
|
}
|
|
|
|
console.log(data)
|
|
}
|
|
|
|
//uploadInProgress.value = true
|
|
|
|
|
|
if(files.length === 1) {
|
|
await uploadSingleFile(files[0])
|
|
} else if( files.length > 1) {
|
|
|
|
for(let i = 0; i < files.length; i++){
|
|
await uploadSingleFile(files[i])
|
|
}
|
|
|
|
}
|
|
|
|
console.log(documentsToInsert)
|
|
|
|
const {data, error} = await supabase
|
|
.from("documents")
|
|
.insert(documentsToInsert)
|
|
.select()
|
|
if(error) console.log(error)
|
|
else {
|
|
console.log(data)
|
|
|
|
await fetchDocuments()
|
|
|
|
//documents.value.push(...data)
|
|
}
|
|
//uploadModalOpen.value = false;
|
|
//uploadInProgress.value = false;
|
|
|
|
|
|
}
|
|
|
|
async function fetchOwnTenant () {
|
|
ownTenant.value = (await supabase.from("tenants").select().eq('id', currentTenant.value)).data[0]
|
|
}
|
|
|
|
async function fetchProfiles () {
|
|
profiles.value = (await supabase.from("profiles").select('* , tenants (id, name)').eq("tenant", currentTenant.value).order("fullName")).data
|
|
}
|
|
async function fetchBankAccounts () {
|
|
bankAccounts.value = (await supabase.from("bankaccounts").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchBankStatements () {
|
|
bankStatements.value = (await supabase.from("bankstatements").select().eq('tenant', currentTenant.value).order("date", {ascending:false})).data
|
|
}
|
|
async function fetchEvents () {
|
|
events.value = (await supabase.from("events").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchContracts () {
|
|
contracts.value = (await supabase.from("contracts").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchContacts () {
|
|
contacts.value = (await supabase.from("contacts").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchCustomers () {
|
|
customers.value = (await supabase.from("customers").select().eq('tenant', currentTenant.value).order("customerNumber", {ascending:true})).data
|
|
}
|
|
async function fetchTasks () {
|
|
tasks.value = (await supabase.from("tasks").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchForms () {
|
|
forms.value = (await supabase.from("forms").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchFormSubmits () {
|
|
formSubmits.value = (await supabase.from("formSubmits").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchProducts () {
|
|
products.value = (await supabase.from("products").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchUnits () {
|
|
units.value = (await supabase.from("units").select()).data
|
|
}
|
|
async function fetchProjects () {
|
|
projects.value = (await supabase.from("projects").select().eq("tenant",currentTenant.value)).data
|
|
}
|
|
async function fetchSpaces () {
|
|
spaces.value = (await supabase.from("spaces").select().eq('tenant', currentTenant.value).order("spaceNumber", {ascending:true})).data
|
|
}
|
|
async function fetchMovements () {
|
|
movements.value = (await supabase.from("movements").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchVehicles () {
|
|
vehicles.value = (await supabase.from("vehicles").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchTimes () {
|
|
times.value = (await supabase.from("times").select().eq('tenant', currentTenant.value).order("start", {ascending:false})).data
|
|
}
|
|
async function fetchHistoryItems () {
|
|
|
|
historyItems.value = (await supabase.from("historyitems").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchVendors () {
|
|
vendors.value = (await supabase.from("vendors").select().eq('tenant', currentTenant.value).order("vendorNumber", {ascending:true})).data
|
|
}
|
|
async function fetchIncomingInvoices () {
|
|
incominginvoices.value = (await supabase.from("incominginvoices").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchNumberRanges () {
|
|
numberRanges.value = (await supabase.from("numberranges").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchNotifications () {
|
|
notifications.value = (await supabase.from("notifications").select().eq('tenant', currentTenant.value).order("created_at", {ascending: false})).data
|
|
}
|
|
async function fetchAbsenceRequests () {
|
|
absenceRequests.value = (await supabase.from("absencerequests").select().eq('tenant', currentTenant.value)).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().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchInventoryItems () {
|
|
inventoryitems.value = (await supabase.from("inventoryitems").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
async function fetchChats() {
|
|
chats.value = (await supabase.from("chats").select()).data
|
|
}
|
|
async function fetchMessages() {
|
|
messages.value = (await supabase.from("messages").select().eq('tenant', currentTenant.value).order('created_at', {ascending:true})).data
|
|
}
|
|
async function fetchCreatedDocuments() {
|
|
createddocuments.value = (await supabase.from("createddocuments").select().eq('tenant', currentTenant.value).order('created_at', {ascending:true})).data
|
|
}
|
|
|
|
async function fetchWorkingTimes() {
|
|
workingtimes.value = (await supabase.from("workingtimes").select().eq('tenant', currentTenant.value).order('created_at', {ascending:true})).data
|
|
}
|
|
|
|
async function fetchPhasesTemplates() {
|
|
phasesTemplates.value = (await supabase.from("phasesTemplates").select().eq('tenant', currentTenant.value).order('created_at', {ascending:true})).data
|
|
}
|
|
|
|
async function fetchEmailAccounts() {
|
|
emailAccounts.value = (await supabase.from("emailAccounts").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
|
|
async function fetchTextTemplates() {
|
|
texttemplates.value = (await supabase.from("textTemplates").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
|
|
async function fetchServices() {
|
|
services.value = (await supabase.from("services").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
|
|
async function fetchServiceCategories() {
|
|
serviceCategories.value = (await supabase.from("serviceCategories").select().eq('tenant', currentTenant.value)).data
|
|
}
|
|
|
|
async function fetchDocuments () {
|
|
let tempDocuments = (await supabase.from("documents").select().eq('tenant', currentTenant.value)).data
|
|
|
|
if(tempDocuments.length > 0){
|
|
let paths = []
|
|
tempDocuments.forEach(doc => {
|
|
paths.push(doc.path)
|
|
})
|
|
|
|
const {data,error} = await supabase.storage.from('files').createSignedUrls(paths,3600)
|
|
|
|
tempDocuments = tempDocuments.map((doc,index) => {
|
|
|
|
return {
|
|
...doc,
|
|
url: data[index].signedUrl
|
|
}
|
|
})
|
|
|
|
documents.value = tempDocuments
|
|
} else {
|
|
documents.value = []
|
|
}
|
|
|
|
|
|
}
|
|
|
|
async function addHistoryItem(text, user, elementId, resourceType) {
|
|
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 getOwnProfile = computed(() => {
|
|
return profiles.value.find(i => i.id === user.value.id)
|
|
|
|
})
|
|
|
|
const getMovementsBySpace = computed(() => (spaceId) => {
|
|
return movements.value.filter(movement => movement.spaceId === spaceId)
|
|
})
|
|
|
|
const getContactsByCustomerId = computed(() => (customerId) => {
|
|
return contacts.value.filter(item => item.customer === customerId)
|
|
})
|
|
|
|
const getProjectsByCustomerId = computed(() => (customerId) => {
|
|
return projects.value.filter(item => item.customer === customerId)
|
|
})
|
|
|
|
const getPlantsByCustomerId = computed(() => (customerId) => {
|
|
return plants.value.filter(item => item.customer === customerId)
|
|
})
|
|
|
|
const getContractsByCustomerId = computed(() => (customerId) => {
|
|
return contracts.value.filter(item => item.customer === customerId)
|
|
})
|
|
|
|
const getContactsByVendorId = computed(() => (vendorId) => {
|
|
return contacts.value.filter(item => item.vendor === vendorId)
|
|
})
|
|
|
|
const getDocumentsByProjectId = computed(() => (projectId) => {
|
|
return documents.value.filter(item => item.project === projectId && !item.tags.includes("Archiviert"))
|
|
})
|
|
|
|
const getDocumentsByPlantId = computed(() => (itemId) => {
|
|
return documents.value.filter(item => item.plant === itemId && !item.tags.includes("Archiviert"))
|
|
})
|
|
|
|
const getDocumentsByContractId = computed(() => (itemId) => {
|
|
return documents.value.filter(item => item.contract === itemId && !item.tags.includes("Archiviert"))
|
|
})
|
|
|
|
const getDocumentsByVehicleId = computed(() => (itemId) => {
|
|
return documents.value.filter(item => item.vehicle === itemId && !item.tags.includes("Archiviert"))
|
|
})
|
|
|
|
const getDocumentsByProductId = computed(() => (itemId) => {
|
|
return documents.value.filter(item => item.product === itemId && !item.tags.includes("Archiviert"))
|
|
})
|
|
|
|
const getDocumentsByVendorId = computed(() => (itemId) => {
|
|
return documents.value.filter(item => item.vendor === itemId && !item.tags.includes("Archiviert"))
|
|
})
|
|
|
|
const getEventsByProjectId = computed(() => (projectId) => {
|
|
return events.value.filter(item => item.project === projectId)
|
|
})
|
|
|
|
const getTimesByProjectId = computed(() => (projectId) => {
|
|
return times.value.filter(time => time.projectId === projectId)
|
|
})
|
|
|
|
const getTasksByProjectId = computed(() => (projectId) => {
|
|
return tasks.value.filter(item => item.project === projectId)
|
|
})
|
|
|
|
const getTasksByPlantId = computed(() => (plantId) => {
|
|
return tasks.value.filter(item => item.plant === plantId)
|
|
})
|
|
|
|
const getProjectsByPlantId = computed(() => (plantId) => {
|
|
return projects.value.filter(item => item.plant === plantId)
|
|
})
|
|
|
|
const getIncomingInvoicesByVehicleId = computed(() => (vehicleId) => {
|
|
return incominginvoices.value.filter(i => i.accounts.find(a => a.costCentre === vehicleId))
|
|
})
|
|
|
|
const getMovementsBySpaceId = computed(() => (spaceId) => {
|
|
return movements.value.filter(movement => movement.spaceId === spaceId)
|
|
})
|
|
|
|
const getMessagesByChatId = computed(() => (chatId) => {
|
|
return messages.value.filter(i => i.destination === chatId)
|
|
})
|
|
|
|
const getTextTemplatesByDocumentType = computed(() => (documentType) => {
|
|
return texttemplates.value.filter(i => i.documentType === documentType)
|
|
})
|
|
|
|
const getCreatedDocumentsByProject = computed(() => (project) => {
|
|
return createddocuments.value.filter(i => i.project === project)
|
|
})
|
|
|
|
const getWorkingTimesByProfileId = computed(() => (profileId) => {
|
|
return workingtimes.value.filter(i => i.profile === profileId)
|
|
})
|
|
|
|
const getStockByProductId = computed(() => (productId) => {
|
|
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.filter(i => i.tenant === currentTenant.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) => {
|
|
return products.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getServiceById = computed(() => (itemId) => {
|
|
return services.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getVendorById = computed(() => (itemId) => {
|
|
return vendors.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getIncomingInvoiceById = computed(() => (itemId) => {
|
|
return incominginvoices.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getContractById = computed(() => (itemId) => {
|
|
return contracts.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getContactById = computed(() => (itemId) => {
|
|
return contacts.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getVehicleById = computed(() => (itemId) => {
|
|
return vehicles.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getDocumentById = computed(() => (itemId) => {
|
|
return documents.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getSpaceById = computed(() => (itemId) => {
|
|
return spaces.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getCustomerById = computed(() => (itemId) => {
|
|
return customers.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getTaskById = computed(() => (itemId) => {
|
|
return tasks.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getAbsenceRequestById = computed(() => (itemId) => {
|
|
return absenceRequests.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getProfileById = computed(() => (itemId) => {
|
|
return profiles.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getAccountById = computed(() => (accountId) => {
|
|
return accounts.value.find(item => item.id === accountId)
|
|
})
|
|
|
|
const getPlantById = computed(() => (plantId) => {
|
|
return plants.value.find(item => item.id === plantId)
|
|
})
|
|
|
|
const getCreatedDocumentById = computed(() => (documentId) => {
|
|
return createddocuments.value.find(item => item.id === documentId)
|
|
})
|
|
|
|
const getInventoryItemById = computed(() => (itemId) => {
|
|
return inventoryitems.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getProjectById = computed(() => (itemId) => {
|
|
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 {
|
|
//General
|
|
currentTenant,
|
|
loaded,
|
|
ownTenant,
|
|
initializeData,
|
|
changeTenant,
|
|
uploadFiles,
|
|
hasRight,
|
|
|
|
//Data
|
|
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,
|
|
createddocuments,
|
|
workingtimes,
|
|
phasesTemplates,
|
|
emailAccounts,
|
|
texttemplates,
|
|
services,
|
|
serviceCategories,
|
|
documentTypesForCreation,
|
|
|
|
//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,
|
|
fetchWorkingTimes,
|
|
addHistoryItem,
|
|
//Getters
|
|
getOpenTasksCount,
|
|
getOwnProfile,
|
|
getMovementsBySpace,
|
|
getContactsByCustomerId,
|
|
getProjectsByCustomerId,
|
|
getPlantsByCustomerId,
|
|
getContractsByCustomerId,
|
|
getContactsByVendorId,
|
|
getDocumentsByProjectId,
|
|
getDocumentsByPlantId,
|
|
getDocumentsByContractId,
|
|
getDocumentsByVehicleId,
|
|
getDocumentsByProductId,
|
|
getDocumentsByVendorId,
|
|
getEventsByProjectId,
|
|
getTimesByProjectId,
|
|
getTasksByProjectId,
|
|
getTasksByPlantId,
|
|
getProjectsByPlantId,
|
|
getMovementsBySpaceId,
|
|
getMessagesByChatId,
|
|
getTextTemplatesByDocumentType,
|
|
getCreatedDocumentsByProject,
|
|
getWorkingTimesByProfileId,
|
|
getStockByProductId,
|
|
getIncomingInvoicesByVehicleId,
|
|
getEventTypes,
|
|
getTimeTypes,
|
|
getDocumentTags,
|
|
getMeasures,
|
|
getResources,
|
|
getEvents,
|
|
getEventsByResource,
|
|
getCostCentresComposed,
|
|
getProductById,
|
|
getServiceById,
|
|
getVendorById,
|
|
getIncomingInvoiceById,
|
|
getContractById,
|
|
getContactById,
|
|
getVehicleById,
|
|
getDocumentById,
|
|
getSpaceById,
|
|
getCustomerById,
|
|
getTaskById,
|
|
getAbsenceRequestById,
|
|
getProjectById,
|
|
getProfileById,
|
|
getAccountById,
|
|
getPlantById,
|
|
getCreatedDocumentById,
|
|
getInventoryItemById,
|
|
}
|
|
|
|
|
|
}) |