New CustomerInventory,

New Mitgliederverwaltung für Vereine
New Bank Auto Complete

backend/src/routes/banking.ts

@@ -6,6 +6,7 @@ import { secrets } from "../utils/secrets"
 import { insertHistoryItem } from "../utils/history"
 import { decrypt, encrypt } from "../utils/crypt"
 import { DE_BANK_CODE_TO_NAME } from "../utils/deBankCodes"
+import { DE_BANK_CODE_TO_BIC } from "../utils/deBankBics"
 
 import {
     bankrequisitions,
@@ -116,16 +117,20 @@ export default async function bankingRoutes(server: FastifyInstance) {
         return remainder === 1
     }
 
-    const resolveBankInstituteFromIbanLocal = (iban: string) => {
+    const resolveGermanBankDataFromIbanLocal = (iban: string) => {
         const normalized = normalizeIban(iban)
         if (!isValidIbanLocal(normalized)) return null
 
         // Für DE-IBANs kann die BLZ aus Position 5-12 lokal gelesen werden.
         if (normalized.startsWith("DE") && normalized.length === 22) {
             const bankCode = normalized.slice(4, 12)
-            const bankName = DE_BANK_CODE_TO_NAME[bankCode]
-            if (bankName) return bankName
-            return `Unbekannt (BLZ ${bankCode})`
+            const bankName = DE_BANK_CODE_TO_NAME[bankCode] || `Unbekannt (BLZ ${bankCode})`
+            const bic = DE_BANK_CODE_TO_BIC[bankCode] || null
+            return {
+                bankName,
+                bic,
+                bankCode,
+            }
         }
 
         return null
@@ -139,13 +144,14 @@ export default async function bankingRoutes(server: FastifyInstance) {
         const normalizedIban = normalizeIban(iban)
         if (!normalizedIban) return null
 
-        const bankInstitute = resolveBankInstituteFromIbanLocal(normalizedIban)
+        const bankData = resolveGermanBankDataFromIbanLocal(normalizedIban)
 
         const allAccounts = await server.db
             .select({
                 id: entitybankaccounts.id,
                 ibanEncrypted: entitybankaccounts.ibanEncrypted,
                 bankNameEncrypted: entitybankaccounts.bankNameEncrypted,
+                bicEncrypted: entitybankaccounts.bicEncrypted,
             })
             .from(entitybankaccounts)
             .where(eq(entitybankaccounts.tenant, tenantId))
@@ -161,19 +167,28 @@ export default async function bankingRoutes(server: FastifyInstance) {
         })
 
         if (existing?.id) {
-            if (bankInstitute) {
+            if (bankData) {
                 let currentBankName = ""
+                let currentBic = ""
                 try {
                     currentBankName = String(decrypt(existing.bankNameEncrypted as any) || "").trim()
                 } catch {
                     currentBankName = ""
                 }
+                try {
+                    currentBic = String(decrypt((existing as any).bicEncrypted as any) || "").trim()
+                } catch {
+                    currentBic = ""
+                }
 
-                if (currentBankName !== bankInstitute) {
+                const nextBankName = bankData?.bankName || "Unbekannt"
+                const nextBic = bankData?.bic || "UNBEKANNT"
+                if (currentBankName !== nextBankName || currentBic !== nextBic) {
                     await server.db
                         .update(entitybankaccounts)
                         .set({
-                            bankNameEncrypted: encrypt(bankInstitute),
+                            bankNameEncrypted: encrypt(nextBankName),
+                            bicEncrypted: encrypt(nextBic),
                             updatedAt: new Date(),
                             updatedBy: userId,
                         })
@@ -189,8 +204,8 @@ export default async function bankingRoutes(server: FastifyInstance) {
             .values({
                 tenant: tenantId,
                 ibanEncrypted: encrypt(normalizedIban),
-                bicEncrypted: encrypt("UNBEKANNT"),
-                bankNameEncrypted: encrypt(bankInstitute || "Unbekannt"),
+                bicEncrypted: encrypt(bankData?.bic || "UNBEKANNT"),
+                bankNameEncrypted: encrypt(bankData?.bankName || "Unbekannt"),
                 description: "Automatisch aus Bankbuchung übernommen",
                 updatedAt: new Date(),
                 updatedBy: userId,
@@ -200,6 +215,30 @@ export default async function bankingRoutes(server: FastifyInstance) {
         return created?.id ? Number(created.id) : null
     }
 
+    server.get("/banking/iban/:iban", async (req, reply) => {
+        try {
+            const { iban } = req.params as { iban: string }
+            const normalized = normalizeIban(iban)
+            if (!normalized) {
+                return reply.code(400).send({ error: "IBAN missing" })
+            }
+
+            const valid = isValidIbanLocal(normalized)
+            const bankData = resolveGermanBankDataFromIbanLocal(normalized)
+
+            return reply.send({
+                iban: normalized,
+                valid,
+                bic: bankData?.bic || null,
+                bankName: bankData?.bankName || null,
+                bankCode: bankData?.bankCode || null,
+            })
+        } catch (err) {
+            server.log.error(err)
+            return reply.code(500).send({ error: "Failed to resolve IBAN data" })
+        }
+    })
+
     const assignIbanFromStatementToCustomer = async (tenantId: number, userId: string, statementId: number, createdDocumentId?: number) => {
         if (!createdDocumentId) return
 

backend/src/routes/functions.ts

@@ -1,6 +1,6 @@
 import { FastifyInstance } from "fastify";
 import {createInvoicePDF, createTimeSheetPDF} from "../utils/pdf";
-//import {encodeBase64ToNiimbot, generateLabel, useNextNumberRangeNumber} from "../utils/functions";
+import {encodeBase64ToNiimbot, generateLabel, useNextNumberRangeNumber} from "../utils/functions";
 import dayjs from "dayjs";
 //import { ready as zplReady } from 'zpl-renderer-js'
 //import { renderZPL } from "zpl-image";
@@ -15,7 +15,6 @@ import timezone from "dayjs/plugin/timezone.js";
 import {generateTimesEvaluation} from "../modules/time/evaluation.service";
 import {citys} from "../../db/schema";
 import {eq} from "drizzle-orm";
-import {useNextNumberRangeNumber} from "../utils/functions";
 import {executeManualGeneration, finishManualGeneration} from "../modules/serialexecution.service";
 dayjs.extend(customParseFormat)
 dayjs.extend(isoWeek)
@@ -177,44 +176,20 @@ export default async function functionRoutes(server: FastifyInstance) {
         await server.services.dokuboxSync.run()
     })
 
-
-    /*server.post('/print/zpl/preview', async (req, reply) => {
-        const { zpl, widthMm = 50, heightMm = 30, dpmm = 8, asBase64 = false } = req.body as {zpl:string,widthMm:number,heightMm:number,dpmm:number,asBase64:string}
-
-        console.log(widthMm,heightMm,dpmm)
-
-        if (!zpl) {
-            return reply.code(400).send({ error: 'Missing ZPL string' })
-        }
-
-        try {
-            // 1️⃣ Renderer initialisieren
-            const { api } = await zplReady
-
-            // 2️⃣ Rendern (liefert base64-encoded PNG)
-            const base64Png = await api.zplToBase64Async(zpl, widthMm, heightMm, dpmm)
-
-            return await encodeBase64ToNiimbot(base64Png, 'top')
-        } catch (err) {
-            console.error('[ZPL Preview Error]', err)
-            return reply.code(500).send({ error: err.message || 'Failed to render ZPL' })
-        }
-    })
-
     server.post('/print/label', async (req, reply) => {
-        const { context, width=584, heigth=354 } = req.body as {context:any,width:number,heigth:number}
+        const { context, width = 584, height = 354 } = req.body as {context:any,width:number,height:number}
 
         try {
-            const base64 = await generateLabel(context,width,heigth)
+            const base64 = await generateLabel(context,width,height)
 
             return {
                 encoded: await encodeBase64ToNiimbot(base64, 'top'),
                 base64: base64
             }
         } catch (err) {
-            console.error('[ZPL Preview Error]', err)
-            return reply.code(500).send({ error: err.message || 'Failed to render ZPL' })
+            console.error('[Label Render Error]', err)
+            return reply.code(500).send({ error: err.message || 'Failed to render label' })
         }
-    })*/
+    })
 
 }

backend/src/routes/history.ts

@@ -5,6 +5,7 @@ import { authProfiles, historyitems } from "../../db/schema";
 
 const columnMap: Record<string, any> = {
     customers: historyitems.customer,
+    members: historyitems.customer,
     vendors: historyitems.vendor,
     projects: historyitems.project,
     plants: historyitems.plant,
@@ -22,10 +23,14 @@ const columnMap: Record<string, any> = {
     documentboxes: historyitems.documentbox,
     hourrates: historyitems.hourrate,
     services: historyitems.service,
+    customerspaces: historyitems.customerspace,
+    customerinventoryitems: historyitems.customerinventoryitem,
+    memberrelations: historyitems.memberrelation,
 };
 
 const insertFieldMap: Record<string, string> = {
     customers: "customer",
+    members: "customer",
     vendors: "vendor",
     projects: "project",
     plants: "plant",
@@ -43,6 +48,9 @@ const insertFieldMap: Record<string, string> = {
     documentboxes: "documentbox",
     hourrates: "hourrate",
     services: "service",
+    customerspaces: "customerspace",
+    customerinventoryitems: "customerinventoryitem",
+    memberrelations: "memberrelation",
 }
 
 const parseId = (value: string) => {

backend/src/routes/resources/main.ts

@@ -12,7 +12,7 @@ import {
 
 import { resourceConfig } from "../../utils/resource.config";
 import { useNextNumberRangeNumber } from "../../utils/functions";
-import { insertHistoryItem } from "../../utils/history";
+import { getHistoryEntityLabel, insertHistoryItem } from "../../utils/history";
 import { diffObjects } from "../../utils/diff";
 import { recalculateServicePricesForTenant } from "../../modules/service-price-recalculation.service";
 import { decrypt, encrypt } from "../../utils/crypt";
@@ -67,7 +67,8 @@ function getUserVisibleChanges(oldRecord: Record<string, any>, updated: Record<s
 }
 
 function buildFieldUpdateHistoryText(resource: string, label: string, oldValue: any, newValue: any) {
-    return `${resource}: ${label} geändert von "${formatDiffValue(oldValue)}" zu "${formatDiffValue(newValue)}"`
+    const resourceLabel = getHistoryEntityLabel(resource)
+    return `${resourceLabel}: ${label} geändert von "${formatDiffValue(oldValue)}" zu "${formatDiffValue(newValue)}"`
 }
 
 function applyResourceWhereFilters(resource: string, table: any, whereCond: any) {
@@ -525,6 +526,7 @@ export default async function resourceRoutes(server: FastifyInstance) {
 
             if (created) {
                 try {
+                    const resourceLabel = getHistoryEntityLabel(resource)
                     await insertHistoryItem(server, {
                         tenant_id: req.user.tenant_id,
                         created_by: req.user?.user_id || null,
@@ -533,7 +535,7 @@ export default async function resourceRoutes(server: FastifyInstance) {
                         action: "created",
                         oldVal: null,
                         newVal: created,
-                        text: `Neuer Eintrag in ${resource} erstellt`,
+                        text: `Neuer Eintrag in ${resourceLabel} erstellt`,
                     })
                 } catch (historyError) {
                     server.log.warn({ err: historyError, resource }, "Failed to write create history entry")
@@ -608,6 +610,7 @@ export default async function resourceRoutes(server: FastifyInstance) {
 
             if (updated) {
                 try {
+                    const resourceLabel = getHistoryEntityLabel(resource)
                     const changes = oldRecord ? getUserVisibleChanges(oldRecord, updated) : []
                     if (!changes.length) {
                         await insertHistoryItem(server, {
@@ -618,7 +621,7 @@ export default async function resourceRoutes(server: FastifyInstance) {
                             action: "updated",
                             oldVal: oldRecord || null,
                             newVal: updated,
-                            text: `Eintrag in ${resource} geändert`,
+                            text: `Eintrag in ${resourceLabel} geändert`,
                         })
                     } else {
                         for (const change of changes) {

backend/src/routes/wiki.ts

@@ -10,6 +10,8 @@ import {
     plants,
     products,
     inventoryitems,
+    customerinventoryitems,
+    customerspaces,
     // NEU HINZUGEFÜGT (Basierend auf deinem DataStore)
     tasks,
     contacts,
@@ -34,6 +36,8 @@ const ENTITY_CONFIG: Record<string, { table: any, labelField: any, rootLabel: st
     'plants': { table: plants, labelField: plants.name, rootLabel: 'Objekte', idField: 'id' },
     'products': { table: products, labelField: products.name, rootLabel: 'Artikel', idField: 'id' },
     'inventoryitems': { table: inventoryitems, labelField: inventoryitems.name, rootLabel: 'Inventarartikel', idField: 'id' },
+    'customerinventoryitems': { table: customerinventoryitems, labelField: customerinventoryitems.name, rootLabel: 'Kundeninventar', idField: 'id' },
+    'customerspaces': { table: customerspaces, labelField: customerspaces.name, rootLabel: 'Kundenlagerplätze', idField: 'id' },
 
     // --- NEU BASIEREND AUF DATASTORE ---
     'tasks': { table: tasks, labelField: tasks.name, rootLabel: 'Aufgaben', idField: 'id' },
@@ -337,4 +341,4 @@ export default async function wikiRoutes(server: FastifyInstance) {
 
         return { success: true, deletedId: result[0].id }
     })
-}
+}