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