Redone

src/routes/resources/main.ts

@@ -13,6 +13,8 @@ import {
 
 
 import {resourceConfig} from "../../utils/resource.config";
+import {useNextNumberRangeNumber} from "../../utils/functions";
+import {stafftimeentries} from "../../../db/schema";
 
 // -------------------------------------------------------------
 // SQL Volltextsuche auf mehreren Feldern
@@ -422,4 +424,112 @@ export default async function resourceRoutes(server: FastifyInstance) {
             return reply.code(500).send({ error: "Internal Server Error" })
         }
     })
+
+    // Create
+    server.post("/resource/:resource", async (req, reply) => {
+        if (!req.user?.tenant_id) {
+            return reply.code(400).send({error: "No tenant selected"});
+        }
+
+        const {resource} = req.params as { resource: string };
+        const body = req.body as Record<string, any>;
+
+        const table = resourceConfig[resource].table
+
+        let createData = {
+            ...body,
+            tenant: req.user.tenant_id,
+            archived: false, // Standardwert
+        }
+
+        if (resourceConfig[resource].numberRangeHolder && !body[resourceConfig[resource]]) {
+            const result = await useNextNumberRangeNumber(server, req.user.tenant_id, resource)
+            createData[resourceConfig[resource]] = result.usedNumber
+        }
+
+        const [created] = await server.db
+            .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;
+    });
+
+    // UPDATE (inkl. Soft-Delete/Archive)
+    server.put("/resource/:resource/:id", async (req, reply) => {
+        const {resource, id} = req.params as { resource: string; id: string }
+        const body = req.body as Record<string, any>
+
+        const tenantId = (req.user as any)?.tenant_id
+        const userId = (req.user as any)?.user_id
+
+        if (!tenantId || !userId) {
+            return reply.code(401).send({error: "Unauthorized"})
+        }
+
+        const table = resourceConfig[resource].table
+
+        //TODO: HISTORY
+
+        const normalizeDate = (val: any) => {
+            const d = new Date(val)
+            return isNaN(d.getTime()) ? null : d
+        }
+
+        console.log(body)
+
+        Object.keys(body).forEach((key) => {
+            if(key.includes("_at") || key.includes("At")) {
+                body[key] = normalizeDate(body[key])
+            }
+        })
+
+
+        // vorherige Version für History laden
+        /*const {data: oldItem} = await server.supabase
+            .from(resource)
+            .select("*")
+            .eq("id", id)
+            .eq("tenant", tenantId)
+            .single()*/
+
+        const [updated] = await server.db
+            .update(table)
+            .set({...body, updated_at: new Date().toISOString(), updated_by: userId})
+            .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
+    })
+
 }