Storno Fix createddocument link. Added Disable and Tooltip for Storno Button

TODO: Spalten nachpflegen

backend/src/routes/resources/main.ts

@@ -10,30 +10,23 @@ import {
     or
 } from "drizzle-orm"
 
-
+import { resourceConfig } from "../../utils/resource.config";
-
+import { useNextNumberRangeNumber } from "../../utils/functions";
-import {resourceConfig} from "../../utils/resource.config";
-import {useNextNumberRangeNumber} from "../../utils/functions";
-import {stafftimeentries} from "../../../db/schema";
 
 // -------------------------------------------------------------
-// SQL Volltextsuche auf mehreren Feldern
+// SQL Suche auf mehreren Feldern (Haupttabelle + Relationen)
 // -------------------------------------------------------------
-
+function buildSearchCondition(columns: any[], search: string) {
-
-function buildSearchCondition(table: any, columns: string[], search: string) {
     if (!search || !columns.length) return null
 
     const term = `%${search.toLowerCase()}%`
 
     const conditions = columns
-        .map((colName) => table[colName])
         .filter(Boolean)
         .map((col) => ilike(col, term))
 
     if (conditions.length === 0) return null
 
-    // @ts-ignore
     return or(...conditions)
 }
 
@@ -54,96 +47,85 @@ export default async function resourceRoutes(server: FastifyInstance) {
                 asc?: string
             }
 
-            const {resource} = req.params as {resource: string}
+            const { resource } = req.params as { resource: string }
-            const table = resourceConfig[resource].table
+            const config = resourceConfig[resource]
+            const table = config.table
 
-            // WHERE-Basis
             let whereCond: any = eq(table.tenant, tenantId)
+            let q = server.db.select().from(table).$dynamic()
 
-            // 🔍 SQL Search
+            const searchCols: any[] = (config.searchColumns || []).map(c => table[c])
-            if(search) {
-                const searchCond = buildSearchCondition(
-                    table,
-                    resourceConfig[resource].searchColumns,
-                    search.trim()
-                )
 
-                if (searchCond) {
+            if (config.mtoLoad) {
-                    whereCond = and(whereCond, searchCond)
+                config.mtoLoad.forEach(rel => {
-                }
+                    const relConfig = resourceConfig[rel + "s"] || resourceConfig[rel]
+                    if (relConfig) {
+                        const relTable = relConfig.table
+
+                        // FIX: Nur joinen, wenn es keine Self-Reference ist (verhindert ERROR 42712)
+                        if (relTable !== table) {
+                            q = q.leftJoin(relTable, eq(table[rel], relTable.id))
+                            if (relConfig.searchColumns) {
+                                relConfig.searchColumns.forEach(c => {
+                                    if (relTable[c]) searchCols.push(relTable[c])
+                                })
+                            }
+                        }
+                    }
+                })
             }
 
-            // Base Query
+            if (search) {
-            let q = server.db.select().from(table).where(whereCond)
+                const searchCond = buildSearchCondition(searchCols, search.trim())
+                if (searchCond) whereCond = and(whereCond, searchCond)
+            }
+
+            q = q.where(whereCond)
 
-            // Sortierung
             if (sort) {
                 const col = (table as any)[sort]
                 if (col) {
-                    //@ts-ignore
+                    q = ascQuery === "true" ? q.orderBy(asc(col)) : q.orderBy(desc(col))
-                    q = ascQuery === "true"
-                        ? q.orderBy(asc(col))
-                        : q.orderBy(desc(col))
                 }
             }
 
             const queryData = await q
+            // Transformation: Falls Joins genutzt wurden, das Hauptobjekt extrahieren
+            const rows = queryData.map(r => r[resource] || r.table || r);
 
-            // RELATION LOADING (MANY-TO-ONE)
+            // RELATION LOADING
-
+            let data = [...rows]
-            let ids = {}
+            if(config.mtoLoad) {
-            let lists = {}
+                let ids: any = {}
-            let maps = {}
+                let lists: any = {}
-            let data = [...queryData]
+                let maps: any = {}
-
+                config.mtoLoad.forEach(rel => {
-            if(resourceConfig[resource].mtoLoad) {
+                    ids[rel] = [...new Set(rows.map(r => r[rel]).filter(Boolean))];
-                resourceConfig[resource].mtoLoad.forEach(relation => {
-                    ids[relation] = [...new Set(queryData.map(r => r[relation]).filter(Boolean))];
                 })
-
+                for await (const rel of config.mtoLoad) {
-                for await (const relation of resourceConfig[resource].mtoLoad ) {
+                    const relConf = resourceConfig[rel + "s"] || resourceConfig[rel];
-                    console.log(relation)
+                    const relTab = relConf.table
-                    lists[relation] = ids[relation].length ? await server.db.select().from(resourceConfig[relation + "s"].table).where(inArray(resourceConfig[relation + "s"].table.id, ids[relation])) : []
+                    lists[rel] = ids[rel].length ? await server.db.select().from(relTab).where(inArray(relTab.id, ids[rel])) : []
-
+                    maps[rel] = Object.fromEntries(lists[rel].map((i: any) => [i.id, i]));
                 }
-
+                data = rows.map(row => {
-                resourceConfig[resource].mtoLoad.forEach(relation => {
+                    let toReturn = { ...row }
-                    maps[relation] = Object.fromEntries(lists[relation].map(i => [i.id, i]));
+                    config.mtoLoad.forEach(rel => {
-                })
+                        toReturn[rel] = row[rel] ? maps[rel][row[rel]] : null
-
-                data = queryData.map(row => {
-                    let toReturn = {
-                        ...row
-                    }
-
-                    resourceConfig[resource].mtoLoad.forEach(relation => {
-                        toReturn[relation] = row[relation] ? maps[relation][row[relation]] : null
                     })
-
                     return toReturn
                 });
             }
 
-            if(resourceConfig[resource].mtmListLoad) {
+            if(config.mtmListLoad) {
-                for await (const relation of resourceConfig[resource].mtmListLoad) {
+                for await (const relation of config.mtmListLoad) {
-                    console.log(relation)
+                    const relTable = resourceConfig[relation].table
-                    console.log(resource.substring(0,resource.length-1))
+                    const parentKey = resource.substring(0, resource.length - 1)
-
+                    const relationRows = await server.db.select().from(relTable).where(inArray(relTable[parentKey], data.map(i => i.id)))
-                    const relationRows = await server.db.select().from(resourceConfig[relation].table).where(inArray(resourceConfig[relation].table[resource.substring(0,resource.length-1)],data.map(i => i.id)))
+                    data = data.map(row => ({
-
+                        ...row,
-                    console.log(relationRows.length)
+                        [relation]: relationRows.filter(i => i[parentKey] === row.id)
-
+                    }))
-                    data = data.map(row => {
-                        let toReturn = {
-                            ...row
-                        }
-
-                        toReturn[relation] = relationRows.filter(i => i[resource.substring(0,resource.length-1)] === row.id)
-
-                        return toReturn
-                    })
-
-
                 }
             }
 
@@ -155,212 +137,129 @@ export default async function resourceRoutes(server: FastifyInstance) {
         }
     })
 
-
     // -------------------------------------------------------------
     // PAGINATED LIST
     // -------------------------------------------------------------
     server.get("/resource/:resource/paginated", async (req, reply) => {
         try {
             const tenantId = req.user?.tenant_id;
-            if (!tenantId) {
+            if (!tenantId) return reply.code(400).send({ error: "No tenant selected" });
-                return reply.code(400).send({ error: "No tenant selected" });
-            }
 
-            const {resource} = req.params as {resource: string};
+            const { resource } = req.params as { resource: string };
-
+            const config = resourceConfig[resource];
-            const {queryConfig} = req;
+            const table = config.table;
-            const {
-                pagination,
-                sort,
-                filters,
-                paginationDisabled
-            } = queryConfig;
-
-            const { search, distinctColumns } = req.query as {
-                search?: string;
-                distinctColumns?: string;
-            };
-
-
-
-
-            let table = resourceConfig[resource].table
 
+            const { queryConfig } = req;
+            const { pagination, sort, filters } = queryConfig;
+            const { search, distinctColumns } = req.query as { search?: string; distinctColumns?: string; };
 
             let whereCond: any = eq(table.tenant, tenantId);
+            const searchCols: any[] = (config.searchColumns || []).map(c => table[c]);
 
+            let countQuery = server.db.select({ value: count(table.id) }).from(table).$dynamic();
+            let mainQuery = server.db.select().from(table).$dynamic();
 
-            if(search) {
+            if (config.mtoLoad) {
-                const searchCond = buildSearchCondition(
+                config.mtoLoad.forEach(rel => {
-                    table,
+                    const relConfig = resourceConfig[rel + "s"] || resourceConfig[rel];
-                    resourceConfig[resource].searchColumns,
+                    if (relConfig) {
-                    search.trim()
+                        const relTable = relConfig.table;
-                )
 
-                if (searchCond) {
+                        // FIX: Self-Reference Check
-                    whereCond = and(whereCond, searchCond)
+                        if (relTable !== table) {
-                }
+                            countQuery = countQuery.leftJoin(relTable, eq(table[rel], relTable.id));
+                            mainQuery = mainQuery.leftJoin(relTable, eq(table[rel], relTable.id));
+                            if (relConfig.searchColumns) {
+                                relConfig.searchColumns.forEach(c => {
+                                    if (relTable[c]) searchCols.push(relTable[c]);
+                                });
+                            }
+                        }
+                    }
+                });
+            }
+
+            if (search) {
+                const searchCond = buildSearchCondition(searchCols, search.trim());
+                if (searchCond) whereCond = and(whereCond, searchCond);
             }
 
             if (filters) {
                 for (const [key, val] of Object.entries(filters)) {
                     const col = (table as any)[key];
                     if (!col) continue;
-
+                    whereCond = Array.isArray(val) ? and(whereCond, inArray(col, val)) : and(whereCond, eq(col, val as any));
-                    if (Array.isArray(val)) {
-                        whereCond = and(whereCond, inArray(col, val));
-                    } else {
-                        whereCond = and(whereCond, eq(col, val as any));
-                    }
                 }
             }
 
-            // -----------------------------------------------
+            const totalRes = await countQuery.where(whereCond);
-            // COUNT (for pagination)
-            // -----------------------------------------------
-            const totalRes = await server.db
-                .select({ value: count(table.id) })
-                .from(table)
-                .where(whereCond);
-
             const total = Number(totalRes[0]?.value ?? 0);
 
-            // -----------------------------------------------
-            // DISTINCT VALUES (regardless of pagination)
-            // -----------------------------------------------
-            const distinctValues: Record<string, any[]> = {};
-
-            if (distinctColumns) {
-                for (const colName of distinctColumns.split(",").map(c => c.trim())) {
-                    const col = (table as any)[colName];
-                    if (!col) continue;
-
-                    const rows = await server.db
-                        .select({ v: col })
-                        .from(table)
-                        .where(eq(table.tenant, tenantId));
-
-                    const values = rows
-                        .map(r => r.v)
-                        .filter(v => v != null && v !== "");
-
-                    distinctValues[colName] = [...new Set(values)].sort();
-                }
-            }
-
-            // PAGINATION
             const offset = pagination?.offset ?? 0;
             const limit = pagination?.limit ?? 100;
 
-            // SORTING
+            mainQuery = mainQuery.where(whereCond).offset(offset).limit(limit);
-            let orderField: any = null;
-            let direction: "asc" | "desc" = "asc";
 
             if (sort?.length > 0) {
                 const s = sort[0];
                 const col = (table as any)[s.field];
                 if (col) {
-                    orderField = col;
+                    mainQuery = s.direction === "asc" ? mainQuery.orderBy(asc(col)) : mainQuery.orderBy(desc(col));
-                    direction = s.direction === "asc" ? "asc" : "desc";
                 }
             }
 
-            // MAIN QUERY (Paginated)
+            const rawRows = await mainQuery;
-            let q = server.db
+            // Transformation für Drizzle Joins
-                .select()
+            let rows = rawRows.map(r => r[resource] || r.table || r);
-                .from(table)
-                .where(whereCond)
-                .offset(offset)
-                .limit(limit);
-
-            if (orderField) {
-                //@ts-ignore
-                q = direction === "asc"
-                    ? q.orderBy(asc(orderField))
-                    : q.orderBy(desc(orderField));
-            }
-
-            const rows = await q;
-
-            if (!rows.length) {
-                return {
-                    data: [],
-                    queryConfig: {
-                        ...queryConfig,
-                        total,
-                        totalPages: 0,
-                        distinctValues
-                    }
-                };
-            }
-
-
-
-            let data = [...rows]
-            //Many to One
-            if(resourceConfig[resource].mtoLoad) {
-                let ids = {}
-                let lists = {}
-                let maps = {}
-                resourceConfig[resource].mtoLoad.forEach(relation => {
-                    ids[relation] = [...new Set(rows.map(r => r[relation]).filter(Boolean))];
-                })
-
-                for await (const relation of resourceConfig[resource].mtoLoad ) {
-                    lists[relation] = ids[relation].length ? await server.db.select().from(resourceConfig[relation + "s"].table).where(inArray(resourceConfig[relation + "s"].table.id, ids[relation])) : []
 
+            const distinctValues: Record<string, any[]> = {};
+            if (distinctColumns) {
+                for (const colName of distinctColumns.split(",").map(c => c.trim())) {
+                    const col = (table as any)[colName];
+                    if (!col) continue;
+                    const dRows = await server.db.select({ v: col }).from(table).where(eq(table.tenant, tenantId));
+                    distinctValues[colName] = [...new Set(dRows.map(r => r.v).filter(v => v != null && v !== ""))].sort();
                 }
+            }
 
-                resourceConfig[resource].mtoLoad.forEach(relation => {
+            let data = [...rows];
-                    maps[relation] = Object.fromEntries(lists[relation].map(i => [i.id, i]));
+            if (config.mtoLoad) {
-                })
+                let ids: any = {};
-
+                let lists: any = {};
+                let maps: any = {};
+                config.mtoLoad.forEach(rel => {
+                    ids[rel] = [...new Set(rows.map(r => r[rel]).filter(Boolean))];
+                });
+                for await (const rel of config.mtoLoad) {
+                    const relConf = resourceConfig[rel + "s"] || resourceConfig[rel];
+                    const relTab = relConf.table;
+                    lists[rel] = ids[rel].length ? await server.db.select().from(relTab).where(inArray(relTab.id, ids[rel])) : [];
+                    maps[rel] = Object.fromEntries(lists[rel].map((i: any) => [i.id, i]));
+                }
                 data = rows.map(row => {
-                    let toReturn = {
+                    let toReturn = { ...row };
-                        ...row
+                    config.mtoLoad.forEach(rel => {
-                    }
+                        toReturn[rel] = row[rel] ? maps[rel][row[rel]] : null;
-
+                    });
-                    resourceConfig[resource].mtoLoad.forEach(relation => {
+                    return toReturn;
-                        toReturn[relation] = row[relation] ? maps[relation][row[relation]] : null
-                    })
-
-                    return toReturn
                 });
             }
 
-            if(resourceConfig[resource].mtmListLoad) {
+            if (config.mtmListLoad) {
-                for await (const relation of resourceConfig[resource].mtmListLoad) {
+                for await (const relation of config.mtmListLoad) {
-                    console.log(relation)
+                    const relTable = resourceConfig[relation].table;
-
+                    const parentKey = resource.substring(0, resource.length - 1);
-                    const relationRows = await server.db.select().from(resourceConfig[relation].table).where(inArray(resourceConfig[relation].table[resource.substring(0,resource.length-1)],data.map(i => i.id)))
+                    const relationRows = await server.db.select().from(relTable).where(inArray(relTable[parentKey], data.map(i => i.id)));
-
+                    data = data.map(row => ({
-                    console.log(relationRows)
+                        ...row,
-
+                        [relation]: relationRows.filter(i => i[parentKey] === row.id)
-                    data = data.map(row => {
+                    }));
-                        let toReturn = {
-                            ...row
-                        }
-
-                        toReturn[relation] = relationRows.filter(i => i[resource.substring(0,resource.length-1)] === row.id)
-
-                        return toReturn
-                    })
-
-
                 }
             }
 
-            // -----------------------------------------------
-            // RETURN DATA
-            // -----------------------------------------------
             return {
                 data,
-                queryConfig: {
+                queryConfig: { ...queryConfig, total, totalPages: Math.ceil(total / limit), distinctValues }
-                    ...queryConfig,
-                    total,
-                    totalPages: Math.ceil(total / limit),
-                    distinctValues
-                }
             };
 
         } catch (err) {
@@ -369,9 +268,8 @@ export default async function resourceRoutes(server: FastifyInstance) {
         }
     });
 
-
     // -------------------------------------------------------------
-    // DETAIL (mit JOINS)
+    // DETAIL
     // -------------------------------------------------------------
     server.get("/resource/:resource/:id/:no_relations?", async (req, reply) => {
         try {
@@ -379,7 +277,7 @@ export default async function resourceRoutes(server: FastifyInstance) {
             const tenantId = req.user?.tenant_id
             if (!tenantId) return reply.code(400).send({ error: "No tenant selected" })
 
-            const {resource, no_relations} = req.params as { resource: string, no_relations?: boolean }
+            const { resource, no_relations } = req.params as { resource: string, no_relations?: boolean }
             const table = resourceConfig[resource].table
 
             const projRows = await server.db
@@ -391,40 +289,32 @@ export default async function resourceRoutes(server: FastifyInstance) {
             if (!projRows.length)
                 return reply.code(404).send({ error: "Resource not found" })
 
-            // ------------------------------------
+            let data = { ...projRows[0] }
-            // LOAD RELATIONS
-            // ------------------------------------
 
-            let ids = {}
+            if (!no_relations) {
-            let lists = {}
+                if (resourceConfig[resource].mtoLoad) {
-            let maps = {}
+                    for await (const relation of resourceConfig[resource].mtoLoad) {
-            let data = {
+                        if (data[relation]) {
-                ...projRows[0]
+                            const relConf = resourceConfig[relation + "s"] || resourceConfig[relation];
-            }
+                            const relTable = relConf.table
-
+                            const relData = await server.db.select().from(relTable).where(eq(relTable.id, data[relation]))
-            if(!no_relations) {
+                            data[relation] = relData[0] || null
-                if(resourceConfig[resource].mtoLoad) {
-                    for await (const relation of resourceConfig[resource].mtoLoad ) {
-                        if(data[relation]) {
-                            data[relation] = (await server.db.select().from(resourceConfig[relation + "s"].table).where(eq(resourceConfig[relation + "s"].table.id, data[relation])))[0]
                         }
                     }
                 }
 
-                if(resourceConfig[resource].mtmLoad) {
+                if (resourceConfig[resource].mtmLoad) {
-                    for await (const relation of resourceConfig[resource].mtmLoad ) {
+                    for await (const relation of resourceConfig[resource].mtmLoad) {
-                        console.log(relation)
+                        const relTable = resourceConfig[relation].table
-                        data[relation] = await server.db.select().from(resourceConfig[relation].table).where(eq(resourceConfig[relation].table[resource.substring(0,resource.length - 1)],id))
+                        const parentKey = resource.substring(0, resource.length - 1)
+                        data[relation] = await server.db.select().from(relTable).where(eq(relTable[parentKey], id))
                     }
                 }
             }
 
-
-
             return data
-
         } catch (err) {
-            console.error("ERROR /resource/projects/:id", err)
+            console.error("ERROR /resource/:resource/:id", err)
             return reply.code(500).send({ error: "Internal Server Error" })
         }
     })
@@ -432,132 +322,58 @@ export default async function resourceRoutes(server: FastifyInstance) {
     // Create
     server.post("/resource/:resource", async (req, reply) => {
         try {
-            if (!req.user?.tenant_id) {
+            if (!req.user?.tenant_id) return reply.code(400).send({ error: "No tenant selected" });
-                return reply.code(400).send({error: "No tenant selected"});
+            const { resource } = req.params as { resource: string };
-            }
-
-            const {resource} = req.params as { resource: string };
             const body = req.body as Record<string, any>;
+            const config = resourceConfig[resource];
+            const table = config.table;
 
-            const table = resourceConfig[resource].table
+            let createData = { ...body, tenant: req.user.tenant_id, archived: false };
 
-            let createData = {
+            if (config.numberRangeHolder && !body[config.numberRangeHolder]) {
-                ...body,
-                tenant: req.user.tenant_id,
-                archived: false, // Standardwert
-            }
-
-            console.log(resourceConfig[resource].numberRangeHolder)
-
-            if (resourceConfig[resource].numberRangeHolder && !body[resourceConfig[resource]]) {
                 const result = await useNextNumberRangeNumber(server, req.user.tenant_id, resource)
-                console.log(result)
+                createData[config.numberRangeHolder] = result.usedNumber
-                createData[resourceConfig[resource].numberRangeHolder] = result.usedNumber
-            }
-
-            const normalizeDate = (val: any) => {
-                const d = new Date(val)
-                return isNaN(d.getTime()) ? null : d
             }
 
+            const normalizeDate = (val: any) => { const d = new Date(val); return isNaN(d.getTime()) ? null : d; }
             Object.keys(createData).forEach((key) => {
-                if(key.toLowerCase().includes("date") && key !== "deliveryDateType") createData[key] = normalizeDate(createData[key])
+                if (key.toLowerCase().includes("date") && key !== "deliveryDateType") createData[key] = normalizeDate(createData[key])
             })
 
-            const [created] = await server.db
+            const [created] = await server.db.insert(table).values(createData).returning()
-                .insert(table)
-                .values(createData)
-                .returning()
-
-
-            /*await insertHistoryItem(server, {
-                entity: resource,
-                entityId: data.id,
-                action: "created",
-                created_by: req.user.user_id,
-                tenant_id: req.user.tenant_id,
-                oldVal: null,
-                newVal: data,
-                text: `${dataType.labelSingle} erstellt`,
-            });*/
-
             return created;
         } catch (error) {
-            console.log(error)
+            console.error(error);
-            reply.status(500)
+            reply.status(500);
         }
     });
 
-    // UPDATE (inkl. Soft-Delete/Archive)
+    // Update
     server.put("/resource/:resource/:id", async (req, reply) => {
         try {
-            const {resource, id} = req.params as { resource: string; id: string }
+            const { resource, id } = req.params as { resource: string; id: string }
             const body = req.body as Record<string, any>
+            const tenantId = req.user?.tenant_id
+            const userId = req.user?.user_id
 
-            const tenantId = (req.user as any)?.tenant_id
+            if (!tenantId || !userId) return reply.code(401).send({ error: "Unauthorized" })
-            const userId = (req.user as any)?.user_id
-
-            if (!tenantId || !userId) {
-                return reply.code(401).send({error: "Unauthorized"})
-            }
 
             const table = resourceConfig[resource].table
+            const normalizeDate = (val: any) => { const d = new Date(val); return isNaN(d.getTime()) ? null : d; }
 
-            //TODO: HISTORY
+            let data = { ...body, updated_at: new Date().toISOString(), updated_by: userId }
-
+            delete data.updatedBy; delete data.updatedAt;
-            const normalizeDate = (val: any) => {
-                const d = new Date(val)
-                return isNaN(d.getTime()) ? null : d
-            }
-
-            let data = {...body, updated_at: new Date().toISOString(), updated_by: userId}
-
-            //@ts-ignore
-            delete data.updatedBy
-            //@ts-ignore
-            delete data.updatedAt
-
-            console.log(data)
 
             Object.keys(data).forEach((key) => {
-                console.log(key)
+                if ((key.includes("_at") || key.includes("At") || key.toLowerCase().includes("date")) && key !== "deliveryDateType") {
-
-                if((key.includes("_at") || key.includes("At") || key.toLowerCase().includes("date") ) && key !=="deliveryDateType") {
                     data[key] = normalizeDate(data[key])
                 }
             })
 
-            console.log(data)
+            const [updated] = await server.db.update(table).set(data).where(and(eq(table.id, id), eq(table.tenant, tenantId))).returning()
-
-            const [updated] = await server.db
-                .update(table)
-                .set(data)
-                .where(and(
-                    eq(table.id, id),
-                    eq(table.tenant, tenantId)))
-                .returning()
-
-            //const diffs = diffObjects(oldItem, newItem);
-
-
-            /*for (const d of diffs) {
-                await insertHistoryItem(server, {
-                    entity: resource,
-                    entityId: id,
-                    action: d.type,
-                    created_by: userId,
-                    tenant_id: tenantId,
-                    oldVal: d.oldValue ? String(d.oldValue) : null,
-                    newVal: d.newValue ? String(d.newValue) : null,
-                    text: `Feld "${d.label}" ${d.typeLabel}: ${d.oldValue ?? ""} → ${d.newValue ?? ""}`,
-                });
-            }*/
-
             return updated
         } catch (err) {
-            console.log("ERROR /resource/projects/:id", err)
+            console.error(err)
         }
-
     })
-
+}
-}

backend/src/utils/resource.config.ts

@@ -36,7 +36,7 @@ import {
 
 export const resourceConfig = {
     projects: {
-        searchColumns: ["name"],
+        searchColumns: ["name","customerRef","projectNumber","notes"],
         mtoLoad: ["customer","plant","contract","projecttype"],
         mtmLoad: ["tasks", "files","createddocuments"],
         table: projects,
@@ -61,6 +61,7 @@ export const resourceConfig = {
     },
     plants: {
         table: plants,
+        searchColumns: ["name"],
         mtoLoad: ["customer"],
         mtmLoad: ["projects","tasks","files"],
     },

frontend/pages/createDocument/edit/[[id]].vue

@@ -1387,7 +1387,7 @@ const saveDocument = async (state, resetup = false) => {
     endText: itemInfo.value.endText,
     rows: itemInfo.value.rows,
     contactPerson: itemInfo.value.contactPerson,
-    linkedDocument: itemInfo.value.linkedDocument,
+    createddocument: itemInfo.value.createddocument,
     agriculture: itemInfo.value.agriculture,
     letterhead: itemInfo.value.letterhead,
     usedAdvanceInvoices: itemInfo.value.usedAdvanceInvoices,

frontend/pages/createDocument/show/[id].vue

@@ -17,11 +17,18 @@ const dataStore = useDataStore()
 
 const itemInfo = ref({})
 const linkedDocument =ref({})
+const links = ref([])
+
 const setupPage = async () => {
   if(route.params) {
     if(route.params.id) itemInfo.value = await useEntities("createddocuments").selectSingle(route.params.id,"*,files(*),linkedDocument(*), statementallocations(bs_id)")
 
-    console.log(itemInfo.value)
+    if(itemInfo.value.type === "invoices"){
+      const createddocuments = await useEntities("createddocuments").select()
+      console.log(createddocuments)
+      links.value = createddocuments.filter(i => i.createddocument?.id === itemInfo.value.id)
+      console.log(links.value)
+    }
 
     linkedDocument.value = await useFiles().selectDocument(itemInfo.value.files[0].id)
   }
@@ -80,14 +87,20 @@ const openBankstatements = () => {
       >
         E-Mail
       </UButton>
-      <UButton
+      <UTooltip
-          @click="router.push(`/createDocument/edit/?createddocument=${itemInfo.id}&loadMode=storno`)"
-          variant="outline"
-          color="rose"
           v-if="itemInfo.type === 'invoices' || itemInfo.type === 'advanceInvoices'"
+          :text="links.find(i => i.type === 'cancellationInvoices') ? 'Bereits stoniert' : ''"
       >
-        Stornieren
+        <UButton
-      </UButton>
+            @click="router.push(`/createDocument/edit/?createddocument=${itemInfo.id}&loadMode=storno`)"
+            variant="outline"
+            color="rose"
+            :disabled="links.find(i => i.type === 'cancellationInvoices')"
+        >
+          Stornieren
+        </UButton>
+      </UTooltip>
+
       <UButton
           v-if="itemInfo.project"
           @click="router.push(`/standardEntity/projects/show/${itemInfo.project?.id}`)"