1761 lines
58 KiB
JavaScript
1761 lines
58 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,
|
|
historyItemHolder: "task"
|
|
},
|
|
customers: {
|
|
label: "Kunden",
|
|
labelSingle: "Kunde",
|
|
redirect:true,
|
|
numberRangeHolder: "customerNumber",
|
|
historyItemHolder: "customer"
|
|
},
|
|
contacts: {
|
|
label: "Kontakte",
|
|
labelSingle: "Kontakt",
|
|
redirect:true,
|
|
historyItemHolder: "contact"
|
|
},
|
|
contracts: {
|
|
label: "Verträge",
|
|
labelSingle: "Vertrag",
|
|
redirect:true
|
|
},
|
|
absencerequests: {
|
|
label: "Abwesenheitsanträge",
|
|
labelSingle: "Abwesenheitsantrag",
|
|
redirect:true
|
|
},
|
|
plants: {
|
|
label: "Objekte",
|
|
labelSingle: "Objekte",
|
|
redirect:true,
|
|
historyItemHolder: "plant"
|
|
},
|
|
products: {
|
|
label: "Artikel",
|
|
labelSingle: "Artikel",
|
|
redirect:true
|
|
},
|
|
projects: {
|
|
label: "Projekte",
|
|
labelSingle: "Projekt",
|
|
redirect:true,
|
|
historyItemHolder: "project",
|
|
numberRangeHolder: "projectNumber",
|
|
},
|
|
vehicles: {
|
|
label: "Fahrzeuge",
|
|
labelSingle: "Fahrzeug",
|
|
redirect:true,
|
|
historyItemHolder: "vehicle"
|
|
},
|
|
vendors: {
|
|
label: "Lieferanten",
|
|
labelSingle: "Lieferant",
|
|
redirect:true,
|
|
numberRangeHolder: "vendorNumber",
|
|
historyItemHolder: "vendor"
|
|
},
|
|
messages: {
|
|
label: "Nachrichten",
|
|
labelSingle: "Nachricht"
|
|
},
|
|
spaces: {
|
|
label: "Lagerplätze",
|
|
labelSingle: "Lagerplatz",
|
|
redirect: true,
|
|
numberRangeHolder: "spaceNumber",
|
|
historyItemHolder: "space"
|
|
},
|
|
users: {
|
|
label: "Benutzer",
|
|
labelSingle: "Benutzer"
|
|
},
|
|
createddocuments: {
|
|
label: "Dokumente",
|
|
labelSingle: "Dokument"
|
|
},
|
|
incominginvoices: {
|
|
label: "Eingangsrechnungen",
|
|
labelSingle: "Eingangsrechnung",
|
|
redirect:true
|
|
},
|
|
inventoryitems: {
|
|
label: "Inventarartikel",
|
|
labelSingle: "Inventarartikel",
|
|
redirect: true,
|
|
numberRangeHolder: "articleNumber"
|
|
},
|
|
services: {
|
|
label: "Leistungen",
|
|
labelSingle: "Leistung",
|
|
redirect: true
|
|
},
|
|
events: {
|
|
label: "Termine",
|
|
labelSingle: "Termin",
|
|
historyItemHolder: "event",
|
|
redirect: true
|
|
},
|
|
profiles: {
|
|
label: "Mitarbeiter",
|
|
labelSingle: "Mitarbeiter",
|
|
redirect: true,
|
|
historyItemHolder: "profile"
|
|
},
|
|
workingtimes: {
|
|
label: "Anwesenheiten",
|
|
labelSingle: "Anwesenheit"
|
|
},
|
|
texttemplates: {
|
|
label: "Textvorlagen",
|
|
labelSingle: "Textvorlage"
|
|
},
|
|
bankstatements: {
|
|
label: "Kontobewegungen",
|
|
labelSingle: "Kontobewegung",
|
|
historyItemHolder: "bankStatement",
|
|
},
|
|
statementallocations: {
|
|
label: "Bankzuweisungen",
|
|
labelSingle: "Bankzuweisung"
|
|
},
|
|
productcategories: {
|
|
label: "Artikelkategorien",
|
|
labelSingle: "Artikelkategorie",
|
|
redirect: true
|
|
},
|
|
trackingtrips: {
|
|
label: "Fahrten",
|
|
labelSingle: "Fahrt",
|
|
redirect: true,
|
|
historyItemHolder: "trackingtrip",
|
|
}
|
|
}
|
|
|
|
const documentTypesForCreation = ref({
|
|
invoices: {
|
|
label: "Rechnungen",
|
|
labelSingle: "Rechnung",
|
|
|
|
},
|
|
advanceInvoices: {
|
|
label: "Abschlagsrechnungen",
|
|
labelSingle: "Abschlagsrechnung"
|
|
},
|
|
quotes: {
|
|
label: "Angebote",
|
|
labelSingle: "Angebot"
|
|
},
|
|
deliveryNotes: {
|
|
label: "Lieferscheine",
|
|
labelSingle: "Lieferschein"
|
|
},
|
|
confirmationOrders: {
|
|
label: "Auftragsbestätigungen",
|
|
labelSingle: "Auftragsbestätigung"
|
|
}
|
|
})
|
|
|
|
|
|
const loaded = ref(false)
|
|
const showProfileSelection = ref(false)
|
|
const ownTenant = ref({
|
|
calendarConfig: {
|
|
eventTypes: []
|
|
},
|
|
timeConfig: {
|
|
timeTypes: []
|
|
},
|
|
tags: {
|
|
documents: [] ,
|
|
products: []
|
|
},
|
|
measures: []
|
|
})
|
|
|
|
|
|
const profiles = ref([])
|
|
const ownProfiles = ref([])
|
|
const activeProfile = ref([])
|
|
const tenants = 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 bankrequisitions = 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 resources =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 profileconnections = (await supabase.from("profileconnections").select()).data
|
|
let profiles = (await supabase.from("profiles").select()).data
|
|
let activeProfileConnection = profileconnections.find(i => i.active)
|
|
if(activeProfileConnection) {
|
|
activeProfile.value = profiles.find(i => i.id === activeProfileConnection.profile_id)
|
|
currentTenant.value = activeProfile.value.tenant
|
|
|
|
await fetchData()
|
|
|
|
//loaded.value = true
|
|
|
|
} else {
|
|
await fetchOwnProfiles()
|
|
await fetchTenants()
|
|
showProfileSelection.value = true
|
|
}
|
|
|
|
|
|
}
|
|
|
|
async function changeProfile(newActiveProfileId) {
|
|
loaded.value = false
|
|
|
|
let profileconnections = (await supabase.from("profileconnections").select()).data
|
|
|
|
let oldActiveProfileConnection = profileconnections.find(i => i.active)
|
|
|
|
const {error} = await supabase.from("profileconnections").update({active: true}).eq("profile_id", newActiveProfileId)
|
|
|
|
if(error) {
|
|
console.log(error)
|
|
} else {
|
|
if(oldActiveProfileConnection){
|
|
const {error} = await supabase.from("profileconnections").update({active: false}).eq("profile_id", oldActiveProfileConnection.profile_id)
|
|
}
|
|
|
|
reloadNuxtApp({
|
|
path:"/",
|
|
ttl: 10000
|
|
})
|
|
|
|
/*await clearStore()
|
|
await fetchData()
|
|
router.push("/")
|
|
loaded.value = true*/
|
|
|
|
|
|
}
|
|
}
|
|
|
|
async function fetchData () {
|
|
await fetchOwnProfiles()
|
|
await fetchProfiles()
|
|
|
|
await fetchTenants()
|
|
await fetchOwnTenant()
|
|
|
|
//loaded.value = true
|
|
await fetchDocuments()
|
|
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 fetchBankRequisitions()
|
|
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()
|
|
await fetchResources()
|
|
loaded.value = true
|
|
|
|
|
|
}
|
|
|
|
function clearStore () {
|
|
console.log("Clear")
|
|
loaded.value = false
|
|
ownTenant.value = {}
|
|
profiles.value = []
|
|
ownProfiles.value = []
|
|
tenants.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= []
|
|
bankrequisitions.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 = []
|
|
resources.value = []
|
|
}
|
|
|
|
function hasRight (right) {
|
|
const role = profiles.value.find(i => i.id === activeProfile.value.id).role
|
|
const grantedRights = roles.value.find(i => i.key === role).rights
|
|
|
|
if(grantedRights.includes(right)){
|
|
return true
|
|
} else return false
|
|
|
|
}
|
|
|
|
var deepDiffMapper = function () {
|
|
return {
|
|
VALUE_CREATED: 'created',
|
|
VALUE_UPDATED: 'updated',
|
|
VALUE_DELETED: 'deleted',
|
|
VALUE_UNCHANGED: 'unchanged',
|
|
map: function(obj1, obj2, k = null) {
|
|
if (this.isFunction(obj1) || this.isFunction(obj2)) {
|
|
throw 'Invalid argument. Function given, object expected.';
|
|
}
|
|
if (this.isValue(obj1) || this.isValue(obj2)) {
|
|
return {
|
|
type: this.compareValues(obj1, obj2),
|
|
data: {o: obj1, n: obj2, k: k}//obj1 === undefined ? obj2 : obj1
|
|
};
|
|
}
|
|
|
|
var diff = {};
|
|
for (var key in obj1) {
|
|
if (this.isFunction(obj1[key])) {
|
|
continue;
|
|
}
|
|
|
|
var value2 = undefined;
|
|
if (obj2[key] !== undefined) {
|
|
value2 = obj2[key];
|
|
}
|
|
|
|
diff[key] = this.map(obj1[key], value2,key);
|
|
}
|
|
for (var key in obj2) {
|
|
if (this.isFunction(obj2[key]) || diff[key] !== undefined) {
|
|
continue;
|
|
}
|
|
|
|
diff[key] = this.map(undefined, obj2[key],key);
|
|
}
|
|
|
|
return diff;
|
|
|
|
},
|
|
compareValues: function (value1, value2) {
|
|
if (value1 === value2) {
|
|
return this.VALUE_UNCHANGED;
|
|
}
|
|
if (this.isDate(value1) && this.isDate(value2) && value1.getTime() === value2.getTime()) {
|
|
return this.VALUE_UNCHANGED;
|
|
}
|
|
if (value1 === undefined) {
|
|
return this.VALUE_CREATED;
|
|
}
|
|
if (value2 === undefined) {
|
|
return this.VALUE_DELETED;
|
|
}
|
|
return this.VALUE_UPDATED;
|
|
},
|
|
isFunction: function (x) {
|
|
return Object.prototype.toString.call(x) === '[object Function]';
|
|
},
|
|
isArray: function (x) {
|
|
return Object.prototype.toString.call(x) === '[object Array]';
|
|
},
|
|
isDate: function (x) {
|
|
return Object.prototype.toString.call(x) === '[object Date]';
|
|
},
|
|
isObject: function (x) {
|
|
return Object.prototype.toString.call(x) === '[object Object]';
|
|
},
|
|
isValue: function (x) {
|
|
return !this.isObject(x) && !this.isArray(x);
|
|
}
|
|
}
|
|
}();
|
|
|
|
|
|
|
|
const generateHistoryItems = async (dataType,newData, oldData=null) => {
|
|
//console.log(oldData)
|
|
//console.log(newData)
|
|
|
|
if(dataTypes[dataType].historyItemHolder){
|
|
let itemsToCreate = []
|
|
|
|
const checkPropState = (key,propContent) => {
|
|
//console.log(propContent)
|
|
if(propContent.type && propContent.data){
|
|
if(propContent.type === "updated" ||propContent.type === "created"){
|
|
createHistoryItem(key,propContent)
|
|
}
|
|
} else {
|
|
for (let prop in propContent) {
|
|
checkPropState(prop,propContent[prop])
|
|
}
|
|
}
|
|
}
|
|
|
|
const createHistoryItem = (key,prop) => {
|
|
|
|
//console.log("OLD: " + prop.data.o)
|
|
//console.log("NEW: " + prop.data.n)
|
|
|
|
let name = "" || key
|
|
let oldVal = prop.data.o || "-"
|
|
let newVal = prop.data.n || "-"
|
|
|
|
|
|
|
|
if(key === "project") {
|
|
name = "Projekt"
|
|
oldVal = oldVal !== "-" ? projects.value.find(i => i.id === prop.data.o).name : "-"
|
|
newVal = projects.value.find(i => i.id === prop.data.n).name
|
|
} else if (key === "title") {
|
|
name = "Titel"
|
|
} else if(key === "type") {
|
|
name = "Typ"
|
|
} else if(key === "notes") {
|
|
name = "Notizen"
|
|
} else if(key === "link") {
|
|
name = "Link"
|
|
} else if(key === "start") {
|
|
name = "Start"
|
|
oldVal = dayjs(prop.data.o).format("DD.MM.YYYY HH:mm")
|
|
newVal = dayjs(prop.data.n).format("DD.MM.YYYY HH:mm")
|
|
} else if(key === "end") {
|
|
name = "Ende"
|
|
oldVal = dayjs(prop.data.o).format("DD.MM.YYYY HH:mm")
|
|
newVal = dayjs(prop.data.n).format("DD.MM.YYYY HH:mm")
|
|
} else if(key === "birthday") {
|
|
name = "Geburtstag"
|
|
oldVal = dayjs(prop.data.o).format("DD.MM.YYY")
|
|
newVal = dayjs(prop.data.n).format("DD.MM.YYY")
|
|
} else if(key === "resources") {
|
|
name = "Resourcen"
|
|
oldVal = prop.data.o.map(i => i.title).join(", ")
|
|
newVal = prop.data.n.map(i => i.title).join(", ")
|
|
} else if(key === "customerNumber") {
|
|
name = "Kundennummer"
|
|
} else if(key === "active") {
|
|
name = "Aktiv"
|
|
if(oldVal === true){
|
|
oldVal = "Aktiv"
|
|
newVal = "Gesperrt"
|
|
} else if(oldVal === "-") {
|
|
oldVal = "Gesperrt"
|
|
newVal = "Aktiv"
|
|
}
|
|
} else if(key === "isCompany") {
|
|
name = "Firmenkunde"
|
|
if(oldVal === true){
|
|
oldVal = "Firma"
|
|
newVal = "Privatkunde"
|
|
} else if(oldVal === "-") {
|
|
oldVal = "Privatkunde"
|
|
newVal = "Firma"
|
|
}
|
|
} else if(key === "special") {
|
|
name = "Adresszusatz"
|
|
} else if(key === "street") {
|
|
name = "Straße & Hausnummer"
|
|
} else if(key === "city") {
|
|
name = "Ort"
|
|
} else if(key === "zip") {
|
|
name = "Postleitzahl"
|
|
} else if(key === "country") {
|
|
name = "Land"
|
|
} else if(key === "web") {
|
|
name = "Webseite"
|
|
} else if(key === "email") {
|
|
name = "E-Mail"
|
|
} else if(key === "tel") {
|
|
name = "Telefon"
|
|
} else if(key === "ustid") {
|
|
name = "USt-ID"
|
|
} else if(key === "role") {
|
|
name = "Rolle"
|
|
} else if(key === "phoneHome") {
|
|
name = "Festnetz"
|
|
} else if(key === "phoneMobile") {
|
|
name = "Mobiltelefon"
|
|
} else if(key === "salutation") {
|
|
name = "Anrede"
|
|
} else if(key === "firstName") {
|
|
name = "Vorname"
|
|
} else if(key === "lastName") {
|
|
name = "Nachname"
|
|
} else if(key === "name") {
|
|
name = "Name"
|
|
} else if(key === "customer") {
|
|
name = "Kunde"
|
|
if(prop.data.o) oldVal = customers.value.find(i => i.id === prop.data.o).name
|
|
if(prop.data.o) newVal = customers.value.find(i => i.id === prop.data.n).name
|
|
} else if(key === "vendor") {
|
|
name = "Lieferant"
|
|
if(prop.data.o) oldVal = vendors.value.find(i => i.id === prop.data.o).name
|
|
if(prop.data.o) newVal = vendors.value.find(i => i.id === prop.data.n).name
|
|
|
|
} else if(key === "description") {
|
|
name = "Beschreibung"
|
|
} else if(key === "categorie") {
|
|
name = "Kategorie"
|
|
} else if(key === "profile") {
|
|
name = "Mitarbeiter"
|
|
if(prop.data.o) oldVal = profiles.value.find(i => i.id === prop.data.o).fullName
|
|
if(prop.data.o) newVal = profiles.value.find(i => i.id === prop.data.n).fullName
|
|
} else if(key === "plant") {
|
|
name = "Objekt"
|
|
if(prop.data.o) oldVal = plants.value.find(i => i.id === prop.data.o).name
|
|
if(prop.data.o) newVal = plants.value.find(i => i.id === prop.data.n).name
|
|
} else if(key === "annualPaidLeaveDays") {
|
|
name = "Urlaubstage"
|
|
} else if(key === "employeeNumber") {
|
|
name = "Mitarbeiternummer"
|
|
} else if(key === "weeklyWorkingDays") {
|
|
name = "Wöchentliche Arbeitstage"
|
|
} else if(key === "weeklyWorkingHours") {
|
|
name = "Wöchentliche Arbeitszeit"
|
|
} else if(key === "licensePlate") {
|
|
name = "Kennzeichen"
|
|
} else if(key === "driver") {
|
|
name = "Fahrer"
|
|
if(prop.data.o) oldVal = profiles.value.find(i => i.id === prop.data.o).fullName
|
|
if(prop.data.o) newVal = profiles.value.find(i => i.id === prop.data.n).fullName
|
|
}
|
|
|
|
|
|
|
|
let text = ""
|
|
if(prop.type === "updated" && newVal !== "-" && oldVal !== "-") {
|
|
text = `Gerändert: ${name} von "${oldVal}" zu "${newVal}"`
|
|
} else if(prop.type === "updated" && newVal !== "-" && oldVal === "-") {
|
|
text = `Hinzugefügt: ${name} "${newVal}"`
|
|
} else if(prop.type === "created") {
|
|
text = `Hinzugefügt: ${name} "${newVal}"`
|
|
} else if(prop.type === "updated" && newVal === "-" && oldVal !== "-") {
|
|
text = `Entfernt: ${name} "${oldVal}"`
|
|
}
|
|
|
|
let historyItem = {
|
|
text: text,
|
|
createdBy: activeProfile.value.id,
|
|
oldVal: prop.data.o,
|
|
newVal: prop.data.n,
|
|
tenant: currentTenant.value
|
|
}
|
|
|
|
historyItem[dataTypes[dataType].historyItemHolder] = newData.id
|
|
|
|
|
|
const checkIfNaN = (x) => {
|
|
return typeof x === "number" && x !== x;
|
|
}
|
|
//console.log(key)
|
|
//console.log(checkIfNaN(key))
|
|
|
|
if(key !== "fullName" && key !== "phases") {
|
|
//console.log(historyItem)
|
|
itemsToCreate.push(historyItem)
|
|
}
|
|
|
|
}
|
|
|
|
if(oldData) {
|
|
let result = deepDiffMapper.map(oldData,newData)
|
|
|
|
//console.log(result)
|
|
|
|
for (let prop in result) {
|
|
//console.log(prop)
|
|
checkPropState(prop,result[prop])
|
|
|
|
}
|
|
|
|
} else {
|
|
let historyItem = {
|
|
text: `${dataTypes[dataType].labelSingle} erstellt`,
|
|
createdBy: activeProfile.value.id,
|
|
tenant: currentTenant.value
|
|
}
|
|
|
|
historyItem[dataTypes[dataType].historyItemHolder] = newData.id
|
|
|
|
//console.log(historyItem)
|
|
itemsToCreate.push(historyItem)
|
|
}
|
|
|
|
const {data,error} = await supabase.from("historyitems").insert(itemsToCreate)
|
|
|
|
if(error) {
|
|
console.log(error)
|
|
} else {
|
|
fetchHistoryItems()
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//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(!data[dataTypes[dataType].numberRangeHolder]) {
|
|
data[dataTypes[dataType].numberRangeHolder] = await numberRange.useNextNumber()
|
|
}
|
|
|
|
|
|
} else if(dataType === "createddocuments") {
|
|
console.log(data.type)
|
|
|
|
let type = ""
|
|
if(data.type === "advanceInvoices"){
|
|
type = "invoices"
|
|
} else {
|
|
type = data.type
|
|
}
|
|
|
|
const numberRange = useNumberRange(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) {
|
|
//console.log(supabaseData)
|
|
await generateHistoryItems(dataType, supabaseData[0])
|
|
|
|
if(!["statementallocations", "productcategories"].includes(dataType) ){
|
|
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, oldData = null) {
|
|
//console.log(dataType, data)
|
|
//Temporary Fix TODO: Remove and build Solution
|
|
data = JSON.parse(JSON.stringify(data))
|
|
delete data.users
|
|
|
|
if(oldData) {
|
|
oldData = JSON.parse(JSON.stringify(oldData))
|
|
delete oldData.users
|
|
}
|
|
|
|
const {tenants, ...newData} = data
|
|
|
|
|
|
await generateHistoryItems(dataType,data,oldData)
|
|
|
|
const {data:supabaseData,error: supabaseError} = await supabase
|
|
.from(dataType)
|
|
.update(newData)
|
|
.eq('id',newData.id)
|
|
.select()
|
|
|
|
if(supabaseError) {
|
|
console.log(supabaseError)
|
|
toast.add({title: `Fehler beim Speichern`, color: 'rose'})
|
|
} 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).single()).data
|
|
}
|
|
|
|
async function fetchProfiles () {
|
|
profiles.value = (await supabase.from("profiles").select().eq("tenant",currentTenant.value).order("lastName")).data
|
|
}
|
|
|
|
async function fetchOwnProfiles () {
|
|
let profiles = (await supabase.from("profiles").select().order("fullName")).data
|
|
let conns = (await supabase.from("profileconnections").select()).data.map(i => i.profile_id)
|
|
//console.log(conns)
|
|
//console.log(profiles.filter(i => conns.includes(i.id)))
|
|
ownProfiles.value = profiles.filter(i => conns.includes(i.id))
|
|
}
|
|
|
|
async function fetchTenants () {
|
|
tenants.value = (await supabase.from("tenants").select()).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 fetchBankRequisitions () {
|
|
bankrequisitions.value = (await supabase.from("bankrequisitions").select().eq('status', "LN")).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 fetchResources() {
|
|
resources.value = (await supabase.from("resources").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 getCreatedDocumentsByType = computed(() => (type) => {
|
|
return createddocuments.value.filter(i => i.type === type)
|
|
})
|
|
|
|
const getWorkingTimesByProfileId = computed(() => (profileId) => {
|
|
return workingtimes.value.filter(i => i.profile === profileId)
|
|
})
|
|
|
|
const getStartedWorkingTimes = computed(() => () => {
|
|
return workingtimes.value.filter(i => !i.endDate)
|
|
})
|
|
|
|
const getStockByProductId = computed(() => (productId) => {
|
|
let productMovements = movements.value.filter(movement => movement.productId === productId && movement.projectId === null)
|
|
|
|
let count = 0
|
|
|
|
productMovements.forEach(movement => {
|
|
count += movement.quantity
|
|
})
|
|
|
|
return count
|
|
})
|
|
|
|
const getStocksByProjectId = computed(() => (projectId) => {
|
|
let projectMovements = movements.value.filter(movement => movement.projectId === projectId)
|
|
|
|
let projectProducts = [... new Set(projectMovements.map(i => i.productId))]
|
|
|
|
console.log(projectProducts)
|
|
|
|
let productStocks = []
|
|
|
|
projectProducts.forEach(product => {
|
|
let count = 0
|
|
let productMovements = movements.value.filter(i => i.productId === product && i.projectId && projectId)
|
|
|
|
productMovements.forEach(movement => {
|
|
count += movement.quantity
|
|
})
|
|
|
|
productStocks.push({
|
|
productId: product,
|
|
stock: count
|
|
})
|
|
|
|
})
|
|
|
|
/*let count = 0
|
|
|
|
projectMovements.forEach(movement => {
|
|
count += movement.quantity
|
|
})*/
|
|
|
|
return productStocks
|
|
})
|
|
|
|
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 getResourcesList = 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: vehicle.id
|
|
}
|
|
}),
|
|
...inventoryitems.value.filter(i=> i.usePlanning).map(item => {
|
|
return {
|
|
type: 'Inventar',
|
|
title: item.name,
|
|
id: 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 {
|
|
id: absence.id,
|
|
resourceId: absence.user,
|
|
resourceType: "person",
|
|
title: `Abw.: ${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 => {
|
|
console.log(event)
|
|
event.resources.forEach(resource => {
|
|
console.log(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: "Mitarbeiter",
|
|
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 {
|
|
id: absence.id,
|
|
resourceId: absence.user,
|
|
resourceType: "person",
|
|
title: `Abw.: ${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 getBankAccountById = computed(() => (itemId) => {
|
|
return bankAccounts.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getEventById = computed(() => (itemId) => {
|
|
return events.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
const getWorkingTimeById = computed(() => (itemId) => {
|
|
return workingtimes.value.find(item => item.id === itemId)
|
|
})
|
|
|
|
/*const getOpenDocuments = computed(() => (itemId) => {
|
|
|
|
let items = createddocuments.value.filter(i => i.type === "invoices" || i.type === "advanceInvoices")
|
|
items = items.filter(i => bankstatements.value.filter(x => x.assignments.find(y => y.type === 'createdDocument' && y.id === i.id)).length === 0)
|
|
|
|
/!*let finalItems = []
|
|
items.forEach(item => {
|
|
if(bankstatements.value.filter(i => i.assignments.find(x => x.id === item.id))){
|
|
finalItems.push(item)
|
|
}
|
|
|
|
})
|
|
|
|
return finalItems*!/
|
|
|
|
return items
|
|
|
|
//return createddocuments.value.filter(i => (i.type === "invoices" || i.type === "advanceInvoices") && !bankstatements.value.some(x => x.amount -))
|
|
|
|
})*/
|
|
const getOpenIncomingInvoices = computed(() => (itemId) => {
|
|
|
|
return incominginvoices.value.filter(i => bankstatements.value.filter(x => x.assignments.find(y => y.type === 'incomingInvoice' && y.id === i.id)).length === 0)
|
|
|
|
//return incominginvoices.value.filter(i => !i.paid)
|
|
|
|
})
|
|
|
|
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,
|
|
showProfileSelection,
|
|
ownTenant,
|
|
initializeData,
|
|
changeProfile,
|
|
uploadFiles,
|
|
hasRight,
|
|
generateHistoryItems,
|
|
|
|
//Data
|
|
profiles,
|
|
ownProfiles,
|
|
activeProfile,
|
|
tenants,
|
|
events,
|
|
customers,
|
|
tasks,
|
|
projects,
|
|
documents,
|
|
spaces,
|
|
units,
|
|
times,
|
|
products,
|
|
movements,
|
|
forms,
|
|
contracts,
|
|
formSubmits,
|
|
contacts,
|
|
vehicles,
|
|
vendors,
|
|
incominginvoices,
|
|
bankAccounts,
|
|
bankstatements,
|
|
bankrequisitions,
|
|
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,
|
|
fetchOwnProfiles,
|
|
fetchBankAccounts,
|
|
fetchBankStatements,
|
|
fetchBankRequisitions,
|
|
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,
|
|
getCreatedDocumentsByType,
|
|
getWorkingTimesByProfileId,
|
|
getStartedWorkingTimes,
|
|
getStockByProductId,
|
|
getStocksByProjectId,
|
|
getIncomingInvoicesByVehicleId,
|
|
getEventTypes,
|
|
getTimeTypes,
|
|
getDocumentTags,
|
|
getMeasures,
|
|
getResources,
|
|
getResourcesList,
|
|
getEvents,
|
|
getEventsByResource,
|
|
getCostCentresComposed,
|
|
getProductById,
|
|
getServiceById,
|
|
getVendorById,
|
|
getIncomingInvoiceById,
|
|
getContractById,
|
|
getContactById,
|
|
getVehicleById,
|
|
getDocumentById,
|
|
getSpaceById,
|
|
getCustomerById,
|
|
getTaskById,
|
|
getAbsenceRequestById,
|
|
getProjectById,
|
|
getProfileById,
|
|
getAccountById,
|
|
getPlantById,
|
|
getCreatedDocumentById,
|
|
getInventoryItemById,
|
|
getBankAccountById,
|
|
getEventById,
|
|
getWorkingTimeById,
|
|
//getOpenDocuments,
|
|
getOpenIncomingInvoices
|
|
}
|
|
|
|
|
|
}) |