.gitea/ISSUE_TEMPLATE/feature_request.md aktualisiert

Reviewed-on: #62

.gitea/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,19 @@
+---
+name: 🐛 Bug Report
+about: Erstelle einen Bericht, um uns zu helfen, das Projekt zu verbessern.
+title: '[BUG] '
+labels: Problem
+assignees: ''
+
+---
+
+**Beschreibung**
+
+
+**Reproduktion**
+
+
+**Screenshots**
+
+
+**Achtung: Achte bitte auf Datenschutz deiner Daten sowie der Daten deiner Kunden. Sollten ein Screenshot nur mit Daten möglich sein, schwärze diese bitte vor dem Upload.**

.gitea/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: ✨ Feature Request
+about: Schlage eine Idee für dieses Projekt vor.
+title: '[FEATURE] '
+labels: Funktionswunsch
+assignees: ''
+
+---
+
+**Ist dein Feature-Wunsch mit einem Problem verbunden?**
+
+
+**Lösungsvorschlag**
+
+
+**Alternativen**
+

.gitea/workflows/build-push.yaml

@@ -0,0 +1,77 @@
+name: Build and Push Docker Images
+run-name: Build Backend & Frontend by @${{ github.actor }}
+
+on: [push]
+
+env:
+  # Passe dies an deine Registry an.
+  # Wenn du die Gitea-interne Registry nutzt, ist es meist einfach der Hostname deiner Gitea-Instanz.
+  # Beispiel: gitea.deine-domain.de
+  REGISTRY_HOST: git.federspiel.tech
+  # Der Name des Repos (z.B. user/repo)
+  IMAGE_NAME: ${{ github.repository }}
+  ACTOR: flfeders
+
+jobs:
+  build-backend:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v3
+
+      - name: Log in to Docker Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.REGISTRY_HOST }}
+          # Gitea stellt secrets.GITHUB_TOKEN automatisch bereit (wie GitLab CI_JOB_TOKEN)
+          username: ${{ env.ACTOR }}
+          password: ${{ vars.CI_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Backend
+        id: meta-backend
+        uses: docker/metadata-action@v4
+        with:
+          images: ${{ env.REGISTRY_HOST }}/${{ env.IMAGE_NAME }}/backend
+          tags: |
+            type=ref,event=branch
+            type=ref,event=tag
+            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }}
+
+      - name: Build and push Backend
+        uses: docker/build-push-action@v4
+        with:
+          context: ./backend # Hier wird der Ordner gewechselt (wie 'cd backend')
+          push: true
+          tags: ${{ steps.meta-backend.outputs.tags }}
+          labels: ${{ steps.meta-backend.outputs.labels }}
+
+  build-frontend:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v3
+
+      - name: Log in to Docker Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.REGISTRY_HOST }}
+          username: ${{ env.ACTOR }}
+          password: ${{ vars.CI_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Frontend
+        id: meta-frontend
+        uses: docker/metadata-action@v4
+        with:
+          images: ${{ env.REGISTRY_HOST }}/${{ env.IMAGE_NAME }}/frontend
+          tags: |
+            type=ref,event=branch
+            type=ref,event=tag
+            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }}
+
+      - name: Build and push Frontend
+        uses: docker/build-push-action@v4
+        with:
+          context: ./frontend # Hier wird der Ordner gewechselt (wie 'cd frontend')
+          push: true
+          tags: ${{ steps.meta-frontend.outputs.tags }}
+          labels: ${{ steps.meta-frontend.outputs.labels }}

README.md

@@ -1 +1,109 @@
-TEST
+
+
+
+# Docker Compose Setup
+
+## ENV Vars
+
+- DOMAIN
+- PDF_LICENSE
+- DB_PASS
+- DB_USER
+- CONTACT_EMAIL
+
+## Docker Compose File
+~~~
+services:
+    frontend:
+        image: git.federspiel.tech/flfeders/fedeo/frontend:main
+        restart: always
+        environment:
+            - NUXT_PUBLIC_API_BASE=https://${DOMAIN}/backend
+            - NUXT_PUBLIC_PDF_LICENSE=${PDF_LICENSE}
+        networks:
+            - traefik
+        labels:
+            - "traefik.enable=true"
+            - "traefik.docker.network=traefik"
+            - "traefik.port=3000"
+            # Middlewares
+            - "traefik.http.middlewares.fedeo-frontend-redirect-web-secure.redirectscheme.scheme=https"
+            # Web Entrypoint
+            - "traefik.http.routers.fedeo-frontend.middlewares=fedeo-frontend-redirect-web-secure"
+            - "traefik.http.routers.fedeo-frontend.rule=Host(`${DOMAIN}`) && PathPrefix(`/`)"
+            - "traefik.http.routers.fedeo-frontend.entrypoints=web"
+            # Web Secure Entrypoint
+            - "traefik.http.routers.fedeo-frontend-secure.rule=Host(`${DOMAIN}`) && PathPrefix(`/`)"
+            - "traefik.http.routers.fedeo-frontend-secure.entrypoints=web-secured" #
+            - "traefik.http.routers.fedeo-frontend-secure.tls.certresolver=mytlschallenge"
+    backend:
+        image: git.federspiel.tech/flfeders/fedeo/backend:main
+        restart: always
+        environment:
+            - INFISICAL_CLIENT_ID=
+            - INFISICAL_CLIENT_SECRET=
+            - NODE_ENV=production
+        networks:
+            - traefik
+        labels:
+            - "traefik.enable=true"
+            - "traefik.docker.network=traefik"
+            - "traefik.port=3100"
+            # Middlewares
+            - "traefik.http.middlewares.fedeo-backend-redirect-web-secure.redirectscheme.scheme=https"
+            - "traefik.http.middlewares.fedeo-backend-strip.stripprefix.prefixes=/backend"
+            # Web Entrypoint
+            - "traefik.http.routers.fedeo-backend.middlewares=fedeo-backend-redirect-web-secure"
+            - "traefik.http.routers.fedeo-backend.rule=Host(`${DOMAIN}`) && PathPrefix(`/backend`)"
+            - "traefik.http.routers.fedeo-backend.entrypoints=web"
+            # Web Secure Entrypoint
+            - "traefik.http.routers.fedeo-backend-secure.rule=Host(`${DOMAIN}`) && PathPrefix(`/backend`)"
+            - "traefik.http.routers.fedeo-backend-secure.entrypoints=web-secured" #
+            - "traefik.http.routers.fedeo-backend-secure.tls.certresolver=mytlschallenge"
+            - "traefik.http.routers.fedeo-backend-secure.middlewares=fedeo-backend-strip"
+    #  db:
+    #    image: postgres
+    #    restart: always
+    #    shm_size: 128mb
+    #    environment:
+    #      POSTGRES_PASSWORD: 
+    #      POSTGRES_USER: 
+    #      POSTGRES_DB: 
+    #    volumes:
+    #      - ./pg-data:/var/lib/postgresql/data
+    #    ports:
+    #      - "5432:5432"
+    traefik:
+        image: traefik:v2.11
+        restart: unless-stopped
+        container_name: traefik
+        command:
+            - "--api.insecure=false"
+            - "--api.dashboard=false"
+            - "--api.debug=false"
+            - "--providers.docker=true"
+            - "--providers.docker.exposedbydefault=false"
+            - "--providers.docker.network=traefik"
+            - "--entrypoints.web.address=:80"
+            - "--entrypoints.web-secured.address=:443"
+            - "--accesslog=true"
+            - "--accesslog.filepath=/logs/access.log"
+            - "--accesslog.bufferingsize=5000"
+            - "--accesslog.fields.defaultMode=keep"
+            - "--accesslog.fields.headers.defaultMode=keep"
+            - "--certificatesresolvers.mytlschallenge.acme.tlschallenge=true" #
+            - "--certificatesresolvers.mytlschallenge.acme.email=${CONTACT_EMAIL}"
+            - "--certificatesresolvers.mytlschallenge.acme.storage=/letsencrypt/acme.json"
+        ports:
+            - 80:80
+            - 443:443
+        volumes:
+            - "./traefik/letsencrypt:/letsencrypt" # <== Volume for certs (TLS)
+            - "/var/run/docker.sock:/var/run/docker.sock:ro"
+            - "./traefik/logs:/logs"
+        networks:
+            - traefik
+networks:
+    traefik:
+        external: false
+~~~

backend/.gitignore

@@ -0,0 +1,5 @@
+node_modules
+# Keep environment variables out of version control
+.env
+
+/src/generated/prisma

backend/.gitlab-ci.yml

@@ -0,0 +1,18 @@
+before_script:
+  - docker info
+
+stages:
+  - build
+
+build-backend:
+  stage: build
+  tags:
+    - shell
+    - docker-daemon
+  variables:
+    IMAGE_TAG: $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG
+  script:
+    - echo $IMAGE_TAG
+    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+    - docker build -t $IMAGE_TAG  .
+    - docker push $IMAGE_TAG

backend/Dockerfile

@@ -0,0 +1,20 @@
+FROM node:20-alpine
+WORKDIR /usr/src/app
+
+# Package-Dateien
+COPY package*.json ./
+
+# Dev + Prod Dependencies (für TS-Build nötig)
+RUN npm install
+
+# Restlicher Sourcecode
+COPY . .
+
+# TypeScript Build
+RUN npm run build
+
+# Port freigeben
+EXPOSE 3100
+
+# Start der App
+CMD ["node", "dist/src/index.js"]

backend/TODO.md

@@ -0,0 +1,32 @@
+# Projekt To-Do Liste
+
+## ✅ Erledigt
+- JWT-basierte Authentifizierung mit Cookie
+- Prefix für Auth-Tabellen (`auth_users`, `auth_roles`, …)
+- `/me` liefert User + Rechte (via `auth_get_user_permissions`)
+- Basis-Seed für Standardrollen + Rechte eingespielt
+- Auth Middleware im Frontend korrigiert (Login-Redirects)
+- Nuxt API Plugin unterstützt JWT im Header
+- Login-Seite an Nuxt UI Pro (v2) anpassen
+- `usePermission()` Composable im Frontend vorbereitet
+
+---
+
+## 🔄 Offene Punkte
+
+### Backend
+- [ ] `/me` erweitern: Rollen + deren Rechte strukturiert zurückgeben (`{ role: "manager", permissions: [...] }`)
+- [ ] Loading Flag im Auth-Flow berücksichtigen (damit `me` nicht doppelt feuert)
+- [ ] Gemeinsames Schema für Entities (Backend stellt per Endpoint bereit)
+- [ ] Soft Delete vereinheitlichen (`archived = true` statt DELETE)
+- [ ] Swagger-Doku verbessern (Schemas, Beispiele)
+
+### Frontend
+- [ ] Loading Flag in Middleware/Store einbauen
+- [ ] Einheitliches Laden des Schemas beim Start
+- [ ] Pinia-Store für Auth/User/Tenant konsolidieren
+- [ ] Composable `usePermission(key)` implementieren, um Rechte einfach im Template zu prüfen
+- [ ] Entity-Seiten schrittweise auf API-Routen umstellen
+- [ ] Page Guards für Routen einbauen (z. B. `/projects/create` nur bei `projects-create`)
+
+---

backend/db/index.ts

@@ -0,0 +1,13 @@
+import { drizzle } from "drizzle-orm/node-postgres"
+import { Pool } from "pg"
+import {secrets} from "../src/utils/secrets";
+import * as schema from "./schema"
+
+
+
+export const pool = new Pool({
+    connectionString: secrets.DATABASE_URL,
+    max: 10, // je nach Last
+})
+
+export const db = drizzle(pool , {schema})

backend/db/migrations/0001_medical_big_bertha.sql

@@ -0,0 +1,32 @@
+CREATE TABLE "time_events" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"tenant_id" bigint NOT NULL,
+	"user_id" uuid NOT NULL,
+	"actor_type" text NOT NULL,
+	"actor_user_id" uuid,
+	"event_time" timestamp with time zone NOT NULL,
+	"event_type" text NOT NULL,
+	"source" text NOT NULL,
+	"invalidates_event_id" uuid,
+	"metadata" jsonb,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	CONSTRAINT "time_events_actor_user_check" CHECK (
+        (actor_type = 'system' AND actor_user_id IS NULL)
+        OR
+        (actor_type = 'user' AND actor_user_id IS NOT NULL)
+      )
+);
+--> statement-breakpoint
+ALTER TABLE "bankstatements" DROP CONSTRAINT "bankstatements_incomingInvoice_incominginvoices_id_fk";
+--> statement-breakpoint
+ALTER TABLE "bankstatements" DROP CONSTRAINT "bankstatements_createdDocument_createddocuments_id_fk";
+--> statement-breakpoint
+ALTER TABLE "time_events" ADD CONSTRAINT "time_events_tenant_id_tenants_id_fk" FOREIGN KEY ("tenant_id") REFERENCES "public"."tenants"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "time_events" ADD CONSTRAINT "time_events_user_id_auth_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."auth_users"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "time_events" ADD CONSTRAINT "time_events_actor_user_id_auth_users_id_fk" FOREIGN KEY ("actor_user_id") REFERENCES "public"."auth_users"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "time_events" ADD CONSTRAINT "time_events_invalidates_event_id_time_events_id_fk" FOREIGN KEY ("invalidates_event_id") REFERENCES "public"."time_events"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "idx_time_events_tenant_user_time" ON "time_events" USING btree ("tenant_id","user_id","event_time");--> statement-breakpoint
+CREATE INDEX "idx_time_events_created_at" ON "time_events" USING btree ("created_at");--> statement-breakpoint
+CREATE INDEX "idx_time_events_invalidates" ON "time_events" USING btree ("invalidates_event_id");--> statement-breakpoint
+ALTER TABLE "bankstatements" DROP COLUMN "incomingInvoice";--> statement-breakpoint
+ALTER TABLE "bankstatements" DROP COLUMN "createdDocument";

backend/db/migrations/0002_silent_christian_walker.sql

@@ -0,0 +1,13 @@
+ALTER TABLE "time_events" RENAME TO "staff_time_events";--> statement-breakpoint
+ALTER TABLE "staff_time_events" DROP CONSTRAINT "time_events_tenant_id_tenants_id_fk";
+--> statement-breakpoint
+ALTER TABLE "staff_time_events" DROP CONSTRAINT "time_events_user_id_auth_users_id_fk";
+--> statement-breakpoint
+ALTER TABLE "staff_time_events" DROP CONSTRAINT "time_events_actor_user_id_auth_users_id_fk";
+--> statement-breakpoint
+ALTER TABLE "staff_time_events" DROP CONSTRAINT "time_events_invalidates_event_id_time_events_id_fk";
+--> statement-breakpoint
+ALTER TABLE "staff_time_events" ADD CONSTRAINT "staff_time_events_tenant_id_tenants_id_fk" FOREIGN KEY ("tenant_id") REFERENCES "public"."tenants"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "staff_time_events" ADD CONSTRAINT "staff_time_events_user_id_auth_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."auth_users"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "staff_time_events" ADD CONSTRAINT "staff_time_events_actor_user_id_auth_users_id_fk" FOREIGN KEY ("actor_user_id") REFERENCES "public"."auth_users"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "staff_time_events" ADD CONSTRAINT "staff_time_events_invalidates_event_id_staff_time_events_id_fk" FOREIGN KEY ("invalidates_event_id") REFERENCES "public"."staff_time_events"("id") ON DELETE no action ON UPDATE no action;

backend/db/migrations/meta/_journal.json

@@ -0,0 +1,41 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1764947303113,
+      "tag": "0000_brief_dark_beast",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1765641431341,
+      "tag": "0001_medical_big_bertha",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "7",
+      "when": 1765642446738,
+      "tag": "0002_silent_christian_walker",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "7",
+      "when": 1765716484200,
+      "tag": "0003_woozy_adam_destine",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "7",
+      "when": 1765716877146,
+      "tag": "0004_stormy_onslaught",
+      "breakpoints": true
+    }
+  ]
+}

backend/db/schema/accounts.ts

@@ -0,0 +1,24 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+} from "drizzle-orm/pg-core"
+
+export const accounts = pgTable("accounts", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    number: text("number").notNull(),
+    label: text("label").notNull(),
+
+    description: text("description"),
+})
+
+export type Account = typeof accounts.$inferSelect
+export type NewAccount = typeof accounts.$inferInsert

backend/db/schema/auth_profiles.ts

@@ -0,0 +1,83 @@
+import {
+    pgTable,
+    uuid,
+    text,
+    timestamp,
+    date,
+    boolean,
+    bigint,
+    doublePrecision,
+    jsonb,
+} from "drizzle-orm/pg-core"
+import { authUsers } from "./auth_users"
+
+export const authProfiles = pgTable("auth_profiles", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    user_id: uuid("user_id").references(() => authUsers.id),
+
+    tenant_id: bigint("tenant_id", { mode: "number" }).notNull(),
+
+    created_at: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    first_name: text("first_name").notNull(),
+    last_name: text("last_name").notNull(),
+
+    full_name: text("full_name").generatedAlwaysAs(
+        `((first_name || ' ') || last_name)`
+    ),
+
+    mobile_tel: text("mobile_tel"),
+    fixed_tel: text("fixed_tel"),
+    salutation: text("salutation"),
+    employee_number: text("employee_number"),
+
+    weekly_working_hours: doublePrecision("weekly_working_hours").default(0),
+    annual_paid_leave_days: bigint("annual_paid_leave_days", { mode: "number" }),
+
+    weekly_regular_working_hours: jsonb("weekly_regular_working_hours").default("{}"),
+
+    clothing_size_top: text("clothing_size_top"),
+    clothing_size_bottom: text("clothing_size_bottom"),
+    clothing_size_shoe: text("clothing_size_shoe"),
+
+    email_signature: text("email_signature").default("<p>Mit freundlichen Grüßen</p>"),
+
+    birthday: date("birthday"),
+    entry_date: date("entry_date").defaultNow(),
+
+    automatic_hour_corrections: jsonb("automatic_hour_corrections").default("[]"),
+
+    recreation_days_compensation: boolean("recreation_days_compensation")
+        .notNull()
+        .default(true),
+
+    customer_for_portal: bigint("customer_for_portal", { mode: "number" }),
+
+    pinned_on_navigation: jsonb("pinned_on_navigation").notNull().default("[]"),
+
+    email: text("email"),
+    token_id: text("token_id"),
+
+    weekly_working_days: doublePrecision("weekly_working_days"),
+
+    old_profile_id: uuid("old_profile_id"),
+    temp_config: jsonb("temp_config"),
+
+    state_code: text("state_code").default("DE-NI"),
+
+    contract_type: text("contract_type"),
+    position: text("position"),
+    qualification: text("qualification"),
+
+    address_street: text("address_street"),
+    address_zip: text("address_zip"),
+    address_city: text("address_city"),
+
+    active: boolean("active").notNull().default(true),
+})
+
+export type AuthProfile = typeof authProfiles.$inferSelect
+export type NewAuthProfile = typeof authProfiles.$inferInsert

backend/db/schema/auth_role_permisssions.ts

@@ -0,0 +1,23 @@
+import { pgTable, uuid, text, timestamp } from "drizzle-orm/pg-core"
+import { authRoles } from "./auth_roles"
+
+export const authRolePermissions = pgTable(
+    "auth_role_permissions",
+    {
+        created_at: timestamp("created_at", { withTimezone: true })
+            .notNull()
+            .defaultNow(),
+
+        role_id: uuid("role_id")
+            .notNull()
+            .references(() => authRoles.id),
+
+        permission: text("permission").notNull(),
+    },
+    (table) => ({
+        primaryKey: [table.role_id, table.permission],
+    })
+)
+
+export type AuthRolePermission = typeof authRolePermissions.$inferSelect
+export type NewAuthRolePermission = typeof authRolePermissions.$inferInsert

backend/db/schema/auth_roles.ts

@@ -0,0 +1,19 @@
+import { pgTable, uuid, text, timestamp, bigint } from "drizzle-orm/pg-core"
+import { authUsers } from "./auth_users"
+
+export const authRoles = pgTable("auth_roles", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    created_at: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+    description: text("description"),
+
+    created_by: uuid("created_by").references(() => authUsers.id),
+    tenant_id: bigint("tenant_id", {mode: "number"}),
+})
+
+export type AuthRole = typeof authRoles.$inferSelect
+export type NewAuthRole = typeof authRoles.$inferInsert

backend/db/schema/auth_tenant_users.ts

@@ -0,0 +1,22 @@
+import { pgTable, uuid, bigint, timestamp } from "drizzle-orm/pg-core"
+import { authUsers } from "./auth_users"
+
+export const authTenantUsers = pgTable(
+    "auth_tenant_users",
+    {
+        created_at: timestamp("created_at", { withTimezone: true })
+            .notNull()
+            .defaultNow(),
+
+        tenant_id: bigint("tenant_id", { mode: "number" }).notNull(),
+        user_id: uuid("user_id").notNull(),
+
+        created_by: uuid("created_by").references(() => authUsers.id),
+    },
+    (table) => ({
+        primaryKey: [table.tenant_id, table.user_id],
+    })
+)
+
+export type AuthTenantUser = typeof authTenantUsers.$inferSelect
+export type NewAuthTenantUser = typeof authTenantUsers.$inferInsert

backend/db/schema/auth_user_roles.ts

@@ -0,0 +1,30 @@
+import { pgTable, uuid, bigint, timestamp } from "drizzle-orm/pg-core"
+import { authUsers } from "./auth_users"
+import { authRoles } from "./auth_roles"
+
+export const authUserRoles = pgTable(
+    "auth_user_roles",
+    {
+        created_at: timestamp("created_at", { withTimezone: true })
+            .notNull()
+            .defaultNow(),
+
+        user_id: uuid("user_id")
+            .notNull()
+            .references(() => authUsers.id),
+
+        role_id: uuid("role_id")
+            .notNull()
+            .references(() => authRoles.id),
+
+        tenant_id: bigint("tenant_id", { mode: "number" }).notNull(),
+
+        created_by: uuid("created_by").references(() => authUsers.id),
+    },
+    (table) => ({
+        primaryKey: [table.user_id, table.role_id, table.tenant_id],
+    })
+)
+
+export type AuthUserRole = typeof authUserRoles.$inferSelect
+export type NewAuthUserRole = typeof authUserRoles.$inferInsert

backend/db/schema/auth_users.ts

@@ -0,0 +1,22 @@
+import { pgTable, uuid, text, boolean, timestamp } from "drizzle-orm/pg-core"
+
+export const authUsers = pgTable("auth_users", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    created_at: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    email: text("email").notNull(),
+    passwordHash: text("password_hash").notNull(),
+
+    multiTenant: boolean("multi_tenant").notNull().default(true),
+    must_change_password: boolean("must_change_password").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+
+    ported: boolean("ported").notNull().default(true),
+})
+
+export type AuthUser = typeof authUsers.$inferSelect
+export type NewAuthUser = typeof authUsers.$inferInsert

backend/db/schema/bankaccounts.ts

@@ -0,0 +1,52 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    doublePrecision,
+    boolean,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const bankaccounts = pgTable("bankaccounts", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name"),
+    iban: text("iban").notNull(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    bankId: text("bankId").notNull(),
+    ownerName: text("ownerName"),
+
+    accountId: text("accountId").notNull(),
+
+    balance: doublePrecision("balance"),
+
+    expired: boolean("expired").notNull().default(false),
+
+    datevNumber: text("datevNumber"),
+
+    syncedAt: timestamp("synced_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+
+    archived: boolean("archived").notNull().default(false),
+})
+
+export type BankAccount = typeof bankaccounts.$inferSelect
+export type NewBankAccount = typeof bankaccounts.$inferInsert

backend/db/schema/bankrequisitions.ts

@@ -0,0 +1,30 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const bankrequisitions = pgTable("bankrequisitions", {
+    id: uuid("id").primaryKey(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    institutionId: text("institutionId"),
+
+    tenant: bigint("tenant", { mode: "number" }).references(() => tenants.id),
+
+    status: text("status"),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type BankRequisition = typeof bankrequisitions.$inferSelect
+export type NewBankRequisition = typeof bankrequisitions.$inferInsert

backend/db/schema/bankstatements.ts

@@ -0,0 +1,62 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    doublePrecision,
+    boolean,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { bankaccounts } from "./bankaccounts"
+import { createddocuments } from "./createddocuments"
+import { tenants } from "./tenants"
+import { incominginvoices } from "./incominginvoices"
+import { contracts } from "./contracts"
+import { authUsers } from "./auth_users"
+
+export const bankstatements = pgTable("bankstatements", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    account: bigint("account", { mode: "number" })
+        .notNull()
+        .references(() => bankaccounts.id),
+
+    date: text("date").notNull(),
+
+    credIban: text("credIban"),
+    credName: text("credName"),
+
+    text: text("text"),
+    amount: doublePrecision("amount").notNull(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    debIban: text("debIban"),
+    debName: text("debName"),
+    gocardlessId: text("gocardlessId"),
+    currency: text("currency"),
+    valueDate: text("valueDate"),
+
+    mandateId: text("mandateId"),
+
+    contract: bigint("contract", { mode: "number" }).references(
+        () => contracts.id
+    ),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type BankStatement = typeof bankstatements.$inferSelect
+export type NewBankStatement = typeof bankstatements.$inferInsert

backend/db/schema/checkexecutions.ts

@@ -0,0 +1,27 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+} from "drizzle-orm/pg-core"
+
+import { checks } from "./checks"
+
+export const checkexecutions = pgTable("checkexecutions", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    check: uuid("check").references(() => checks.id),
+
+    executedAt: timestamp("executed_at"),
+
+    // ❌ executed_by removed (was 0_profiles)
+
+    description: text("description"),
+})
+
+export type CheckExecution = typeof checkexecutions.$inferSelect
+export type NewCheckExecution = typeof checkexecutions.$inferInsert

backend/db/schema/checks.ts

@@ -0,0 +1,52 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    bigint,
+    boolean,
+    jsonb,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { vehicles } from "./vehicles"
+import { inventoryitems } from "./inventoryitems"
+import { authUsers } from "./auth_users"
+
+export const checks = pgTable("checks", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    vehicle: bigint("vehicle", { mode: "number" })
+        .references(() => vehicles.id),
+
+    // ❌ profile removed (old 0_profiles reference)
+
+    inventoryItem: bigint("inventoryitem", { mode: "number" })
+        .references(() => inventoryitems.id),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .references(() => tenants.id),
+
+    name: text("name"),
+    type: text("type"),
+
+    distance: bigint("distance", { mode: "number" }).default(1),
+
+    distanceUnit: text("distanceUnit").default("days"),
+
+    description: text("description"),
+
+    profiles: jsonb("profiles").notNull().default([]),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type Check = typeof checks.$inferSelect
+export type NewCheck = typeof checks.$inferInsert

backend/db/schema/citys.ts

@@ -0,0 +1,32 @@
+import {
+    pgTable,
+    bigint,
+    text,
+    jsonb,
+} from "drizzle-orm/pg-core"
+
+export const citys = pgTable("citys", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    name: text("name"),
+    short: text("short"),
+    long: text("long"),
+
+    geometry: jsonb("geometry"),
+
+    zip: bigint("zip", { mode: "number" }),
+
+    districtCode: bigint("districtCode", { mode: "number" }),
+
+    countryName: text("countryName"),
+    countryCode: bigint("countryCode", { mode: "number" }),
+
+    districtName: text("districtName"),
+
+    geopoint: text("geopoint"),
+})
+
+export type City = typeof citys.$inferSelect
+export type NewCity = typeof citys.$inferInsert

backend/db/schema/contacts.ts

@@ -0,0 +1,66 @@
+import {
+    pgTable,
+    bigint,
+    text,
+    timestamp,
+    boolean,
+    jsonb,
+    date,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { customers } from "./customers"
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const contacts = pgTable(
+    "contacts",
+    {
+        id: bigint("id", { mode: "number" })
+            .primaryKey()
+            .generatedByDefaultAsIdentity(),
+
+        createdAt: timestamp("created_at", { withTimezone: true })
+            .notNull()
+            .defaultNow(),
+
+        firstName: text("firstName"),
+        lastName: text("lastName"),
+        email: text("email"),
+
+        customer: bigint("customer", { mode: "number" }).references(
+            () => customers.id
+        ),
+
+        tenant: bigint("tenant", { mode: "number" }).notNull(),
+
+        phoneMobile: text("phoneMobile"),
+        phoneHome: text("phoneHome"),
+
+        heroId: text("heroId"),
+        role: text("role"),
+
+        fullName: text("fullName"),
+
+        salutation: text("salutation"),
+
+        vendor: bigint("vendor", { mode: "number" }), // vendors folgt separat
+
+        active: boolean("active").notNull().default(true),
+
+        birthday: date("birthday"),
+        notes: text("notes"),
+
+        profiles: jsonb("profiles").notNull().default([]),
+
+        archived: boolean("archived").notNull().default(false),
+
+        title: text("title"),
+
+        updatedAt: timestamp("updated_at", { withTimezone: true }),
+        updatedBy: uuid("updated_by").references(() => authUsers.id),
+    }
+)
+
+export type Contact = typeof contacts.$inferSelect
+export type NewContact = typeof contacts.$inferInsert

backend/db/schema/contracts.ts

@@ -0,0 +1,76 @@
+import {
+    pgTable,
+    bigint,
+    text,
+    timestamp,
+    boolean,
+    jsonb,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { customers } from "./customers"
+import { contacts } from "./contacts"
+import { authUsers } from "./auth_users"
+
+export const contracts = pgTable(
+    "contracts",
+    {
+        id: bigint("id", { mode: "number" })
+            .primaryKey()
+            .generatedByDefaultAsIdentity(),
+
+        createdAt: timestamp("created_at", { withTimezone: true })
+            .notNull()
+            .defaultNow(),
+
+        tenant: bigint("tenant", { mode: "number" }).notNull(),
+
+        name: text("name").notNull(),
+
+        customer: bigint("customer", { mode: "number" })
+            .notNull()
+            .references(() => customers.id),
+
+        notes: text("notes"),
+
+        active: boolean("active").notNull().default(true),
+        recurring: boolean("recurring").notNull().default(false),
+
+        rhythm: jsonb("rhythm"),
+
+        startDate: timestamp("startDate", { withTimezone: true }),
+        endDate: timestamp("endDate", { withTimezone: true }),
+        signDate: timestamp("signDate", { withTimezone: true }),
+
+        duration: text("duration"),
+
+        contact: bigint("contact", { mode: "number" }).references(
+            () => contacts.id
+        ),
+
+        bankingIban: text("bankingIban"),
+        bankingBIC: text("bankingBIC"),
+        bankingName: text("bankingName"),
+        bankingOwner: text("bankingOwner"),
+        sepaRef: text("sepaRef"),
+        sepaDate: timestamp("sepaDate", { withTimezone: true }),
+
+        paymentType: text("paymentType"),
+        invoiceDispatch: text("invoiceDispatch"),
+
+        ownFields: jsonb("ownFields").notNull().default({}),
+        profiles: jsonb("profiles").notNull().default([]),
+
+        archived: boolean("archived").notNull().default(false),
+
+        contractNumber: text("contractNumber"),
+
+        updatedAt: timestamp("updated_at", { withTimezone: true }),
+
+        updatedBy: uuid("updated_by").references(() => authUsers.id),
+    }
+)
+
+export type Contract = typeof contracts.$inferSelect
+export type NewContract = typeof contracts.$inferInsert

backend/db/schema/costcentres.ts

@@ -0,0 +1,50 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    boolean,
+    jsonb,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { inventoryitems } from "./inventoryitems"
+import { projects } from "./projects"
+import { vehicles } from "./vehicles"
+import { authUsers } from "./auth_users"
+
+export const costcentres = pgTable("costcentres", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    number: text("number").notNull(),
+    name: text("name").notNull(),
+
+    vehicle: bigint("vehicle", { mode: "number" }).references(() => vehicles.id),
+
+    project: bigint("project", { mode: "number" }).references(() => projects.id),
+
+    inventoryitem: bigint("inventoryitem", { mode: "number" }).references(
+        () => inventoryitems.id
+    ),
+
+    description: text("description"),
+
+    archived: boolean("archived").notNull().default(false),
+
+    profiles: jsonb("profiles").notNull().default([]),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type CostCentre = typeof costcentres.$inferSelect
+export type NewCostCentre = typeof costcentres.$inferInsert

backend/db/schema/countrys.ts

@@ -0,0 +1,21 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+} from "drizzle-orm/pg-core"
+
+export const countrys = pgTable("countrys", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+})
+
+export type Country = typeof countrys.$inferSelect
+export type NewCountry = typeof countrys.$inferInsert

backend/db/schema/createddocuments.ts

@@ -0,0 +1,124 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    jsonb,
+    boolean,
+    smallint,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { customers } from "./customers"
+import { contacts } from "./contacts"
+import { contracts } from "./contracts"
+import { letterheads } from "./letterheads"
+import { projects } from "./projects"
+import { plants } from "./plants"
+import { authUsers } from "./auth_users"
+import {serialExecutions} from "./serialexecutions";
+
+export const createddocuments = pgTable("createddocuments", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    type: text("type").notNull().default("INVOICE"),
+
+    customer: bigint("customer", { mode: "number" }).references(
+        () => customers.id
+    ),
+
+    contact: bigint("contact", { mode: "number" }).references(
+        () => contacts.id
+    ),
+
+    address: jsonb("address"),
+    project: bigint("project", { mode: "number" }).references(
+        () => projects.id
+    ),
+
+    documentNumber: text("documentNumber"),
+    documentDate: text("documentDate"),
+
+    state: text("state").notNull().default("Entwurf"),
+
+    info: jsonb("info"),
+
+    createdBy: uuid("createdBy").references(() => authUsers.id),
+
+    title: text("title"),
+    description: text("description"),
+
+    startText: text("startText"),
+    endText: text("endText"),
+
+    rows: jsonb("rows").default([]),
+
+    deliveryDateType: text("deliveryDateType"),
+    paymentDays: smallint("paymentDays"),
+    deliveryDate: text("deliveryDate"),
+
+    contactPerson: uuid("contactPerson"),
+
+    serialConfig: jsonb("serialConfig").default({}),
+
+    createddocument: bigint("linkedDocument", { mode: "number" }).references(
+        () => createddocuments.id
+    ),
+
+    agriculture: jsonb("agriculture"),
+
+    letterhead: bigint("letterhead", { mode: "number" }).references(
+        () => letterheads.id
+    ),
+
+    advanceInvoiceResolved: boolean("advanceInvoiceResolved")
+        .notNull()
+        .default(false),
+
+    usedAdvanceInvoices: jsonb("usedAdvanceInvoices").notNull().default([]),
+
+    archived: boolean("archived").notNull().default(false),
+
+    deliveryDateEnd: text("deliveryDateEnd"),
+
+    plant: bigint("plant", { mode: "number" }).references(() => plants.id),
+
+    taxType: text("taxType"),
+
+    customSurchargePercentage: smallint("customSurchargePercentage")
+        .notNull()
+        .default(0),
+
+    report: jsonb("report").notNull().default({}),
+
+    availableInPortal: boolean("availableInPortal")
+        .notNull()
+        .default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+
+    created_by: uuid("created_by").references(() => authUsers.id),
+
+    payment_type: text("payment_type").default("transfer"),
+
+    contract: bigint("contract", { mode: "number" }).references(
+        () => contracts.id
+    ),
+
+    serialexecution: uuid("serialexecution").references(() => serialExecutions.id)
+})
+
+export type CreatedDocument = typeof createddocuments.$inferSelect
+export type NewCreatedDocument = typeof createddocuments.$inferInsert

backend/db/schema/createdletters.ts

@@ -0,0 +1,43 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    bigint,
+    text,
+    jsonb,
+    boolean,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { customers } from "./customers"
+import { vendors } from "./vendors"
+import { authUsers } from "./auth_users"
+
+export const createdletters = pgTable("createdletters", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" }).references(() => tenants.id),
+
+    customer: bigint("customer", { mode: "number" }).references(
+        () => customers.id
+    ),
+
+    vendor: bigint("vendor", { mode: "number" }).references(() => vendors.id),
+
+    contentJson: jsonb("content_json").default([]),
+
+    contentText: text("content_text"),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+
+    archived: boolean("archived").notNull().default(false),
+})
+
+export type CreatedLetter = typeof createdletters.$inferSelect
+export type NewCreatedLetter = typeof createdletters.$inferInsert

backend/db/schema/customers.ts

@@ -0,0 +1,69 @@
+import {
+    pgTable,
+    bigint,
+    text,
+    timestamp,
+    boolean,
+    jsonb,
+    smallint,
+    uuid,
+} from "drizzle-orm/pg-core"
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const customers = pgTable(
+    "customers",
+    {
+        id: bigint("id", { mode: "number" })
+            .primaryKey()
+            .generatedByDefaultAsIdentity(),
+
+        createdAt: timestamp("created_at", { withTimezone: true })
+            .notNull()
+            .defaultNow(),
+
+        customerNumber: text("customerNumber").notNull(),
+        name: text("name").notNull(),
+
+        tenant: bigint("tenant", { mode: "number" }).notNull(),
+
+        infoData: jsonb("infoData").default({}),
+        active: boolean("active").notNull().default(true),
+
+        notes: text("notes"),
+
+        type: text("type").default("Privat"),
+        heroId: text("heroId"),
+
+        isCompany: boolean("isCompany").notNull().default(false),
+
+        profiles: jsonb("profiles").notNull().default([]),
+
+        customPaymentDays: smallint("customPaymentDays"),
+
+        firstname: text("firstname"),
+        lastname: text("lastname"),
+
+        archived: boolean("archived").notNull().default(false),
+
+        customSurchargePercentage: smallint("customSurchargePercentage")
+            .notNull()
+            .default(0),
+
+        salutation: text("salutation"),
+        title: text("title"),
+        nameAddition: text("nameAddition"),
+
+        availableInPortal: boolean("availableInPortal")
+            .notNull()
+            .default(false),
+
+        updatedAt: timestamp("updated_at", { withTimezone: true }),
+        updatedBy: uuid("updated_by").references(() => authUsers.id),
+
+        customPaymentType: text("custom_payment_type"), // ENUM payment_types separat?
+    }
+)
+
+export type Customer = typeof customers.$inferSelect
+export type NewCustomer = typeof customers.$inferInsert

backend/db/schema/devices.ts

@@ -0,0 +1,29 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+
+export const devices = pgTable("devices", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+    type: text("type").notNull(),
+
+    tenant: bigint("tenant", { mode: "number" }).references(() => tenants.id),
+
+    password: text("password"),
+
+    externalId: text("externalId"),
+})
+
+export type Device = typeof devices.$inferSelect
+export type NewDevice = typeof devices.$inferInsert

backend/db/schema/documentboxes.ts

@@ -0,0 +1,28 @@
+import { pgTable, uuid, timestamp, text, boolean, bigint } from "drizzle-orm/pg-core"
+
+import { spaces } from "./spaces"
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const documentboxes = pgTable("documentboxes", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+
+    space: bigint("space", { mode: "number" }).references(() => spaces.id),
+
+    key: text("key").notNull(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type DocumentBox = typeof documentboxes.$inferSelect
+export type NewDocumentBox = typeof documentboxes.$inferInsert

backend/db/schema/enums.ts

@@ -0,0 +1,97 @@
+import { pgEnum } from "drizzle-orm/pg-core"
+
+// public.textTemplatePositions
+export const textTemplatePositionsEnum = pgEnum("texttemplatepositions", [
+    "startText",
+    "endText",
+])
+
+// public.folderFunctions
+export const folderFunctionsEnum = pgEnum("folderfunctions", [
+    "none",
+    "yearSubCategory",
+    "incomingInvoices",
+    "invoices",
+    "quotes",
+    "confirmationOrders",
+    "deliveryNotes",
+    "vehicleData",
+    "reminders",
+    "taxData",
+    "deposit",
+    "timeEvaluations",
+])
+
+// public.locked_tenant
+export const lockedTenantEnum = pgEnum("locked_tenant", [
+    "maintenance_tenant",
+    "maintenance",
+    "general",
+    "no_subscription",
+])
+
+// public.credential_types
+export const credentialTypesEnum = pgEnum("credential_types", [
+    "mail",
+    "m365",
+])
+
+// public.payment_types
+export const paymentTypesEnum = pgEnum("payment_types", [
+    "transfer",
+    "direct_debit",
+])
+
+// public.notification_status
+export const notificationStatusEnum = pgEnum("notification_status", [
+    "queued",
+    "sent",
+    "failed",
+    "read",
+])
+
+// public.notification_channel
+export const notificationChannelEnum = pgEnum("notification_channel", [
+    "email",
+    "inapp",
+    "sms",
+    "push",
+    "webhook",
+])
+
+// public.notification_severity
+export const notificationSeverityEnum = pgEnum("notification_severity", [
+    "info",
+    "success",
+    "warning",
+    "error",
+])
+
+// public.times_state
+export const timesStateEnum = pgEnum("times_state", [
+    "submitted",
+    "approved",
+    "draft",
+])
+
+export const helpdeskStatusEnum = [
+    "open",
+    "in_progress",
+    "waiting_for_customer",
+    "answered",
+    "closed",
+] as const
+
+export const helpdeskPriorityEnum = [
+    "low",
+    "normal",
+    "high",
+] as const
+
+export const helpdeskDirectionEnum = [
+    "incoming",
+    "outgoing",
+    "internal",
+    "system",
+] as const
+

backend/db/schema/events.ts

@@ -0,0 +1,60 @@
+import {
+    pgTable,
+    bigint,
+    text,
+    timestamp,
+    boolean,
+    jsonb,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { customers } from "./customers"
+import { authUsers } from "./auth_users"
+
+export const events = pgTable(
+    "events",
+    {
+        id: bigint("id", { mode: "number" })
+            .primaryKey()
+            .generatedByDefaultAsIdentity(),
+
+        createdAt: timestamp("created_at", { withTimezone: true })
+            .notNull()
+            .defaultNow(),
+
+        tenant: bigint("tenant", { mode: "number" }).notNull(),
+
+        name: text("name").notNull(),
+
+        startDate: timestamp("startDate", { withTimezone: true }).notNull(),
+        endDate: timestamp("endDate", { withTimezone: true }),
+
+        eventtype: text("eventtype").default("Umsetzung"),
+
+        project: bigint("project", { mode: "number" }), // FK follows when projects.ts exists
+
+        resources: jsonb("resources").default([]),
+        notes: text("notes"),
+        link: text("link"),
+
+        profiles: jsonb("profiles").notNull().default([]),
+        archived: boolean("archived").notNull().default(false),
+
+        vehicles: jsonb("vehicles").notNull().default([]),
+        inventoryitems: jsonb("inventoryitems").notNull().default([]),
+        inventoryitemgroups: jsonb("inventoryitemgroups").notNull().default([]),
+
+        customer: bigint("customer", { mode: "number" }).references(
+            () => customers.id
+        ),
+
+        vendor: bigint("vendor", { mode: "number" }), // will link once vendors.ts is created
+
+        updatedAt: timestamp("updated_at", { withTimezone: true }),
+        updatedBy: uuid("updated_by").references(() => authUsers.id),
+    }
+)
+
+export type Event = typeof events.$inferSelect
+export type NewEvent = typeof events.$inferInsert

backend/db/schema/files.ts

@@ -0,0 +1,79 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    boolean,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { projects } from "./projects"
+import { customers } from "./customers"
+import { contracts } from "./contracts"
+import { vendors } from "./vendors"
+import { incominginvoices } from "./incominginvoices"
+import { plants } from "./plants"
+import { createddocuments } from "./createddocuments"
+import { vehicles } from "./vehicles"
+import { products } from "./products"
+import { inventoryitems } from "./inventoryitems"
+import { folders } from "./folders"
+import { filetags } from "./filetags"
+import { authUsers } from "./auth_users"
+import { authProfiles } from "./auth_profiles"
+import { spaces } from "./spaces"
+import { documentboxes } from "./documentboxes"
+import { checks } from "./checks"
+
+export const files = pgTable("files", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    path: text("path"),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    project: bigint("project", { mode: "number" }).references(() => projects.id),
+    customer: bigint("customer", { mode: "number" }).references(() => customers.id),
+    contract: bigint("contract", { mode: "number" }).references(() => contracts.id),
+    vendor: bigint("vendor", { mode: "number" }).references(() => vendors.id),
+    incominginvoice: bigint("incominginvoice", { mode: "number" }).references(() => incominginvoices.id),
+    plant: bigint("plant", { mode: "number" }).references(() => plants.id),
+    createddocument: bigint("createddocument", { mode: "number" }).references(() => createddocuments.id),
+    vehicle: bigint("vehicle", { mode: "number" }).references(() => vehicles.id),
+    product: bigint("product", { mode: "number" }).references(() => products.id),
+
+    check: uuid("check").references(() => checks.id),
+
+    inventoryitem: bigint("inventoryitem", { mode: "number" }).references(() => inventoryitems.id),
+
+    folder: uuid("folder").references(() => folders.id),
+
+    mimeType: text("mimeType"),
+
+    archived: boolean("archived").notNull().default(false),
+
+    space: bigint("space", { mode: "number" }).references(() => spaces.id),
+
+    type: uuid("type").references(() => filetags.id),
+
+    documentbox: uuid("documentbox").references(() => documentboxes.id),
+
+    name: text("name"),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+
+    createdBy: uuid("created_by").references(() => authUsers.id),
+
+    authProfile: uuid("auth_profile").references(() => authProfiles.id),
+})
+
+export type File = typeof files.$inferSelect
+export type NewFile = typeof files.$inferInsert

backend/db/schema/filetags.ts

@@ -0,0 +1,33 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    boolean,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+
+export const filetags = pgTable("filetags", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+    color: text("color"),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    createdDocumentType: text("createddocumenttype").default(""),
+    incomingDocumentType: text("incomingDocumentType"),
+
+    archived: boolean("archived").notNull().default(false),
+})
+
+export type FileTag = typeof filetags.$inferSelect
+export type NewFileTag = typeof filetags.$inferInsert

backend/db/schema/folders.ts

@@ -0,0 +1,51 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    boolean,
+    integer,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+import { filetags } from "./filetags"
+import { folderFunctionsEnum } from "./enums"
+
+export const folders = pgTable("folders", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    name: text("name").notNull(),
+    icon: text("icon"),
+
+    parent: uuid("parent").references(() => folders.id),
+
+    isSystemUsed: boolean("isSystemUsed").notNull().default(false),
+
+    function: folderFunctionsEnum("function"),
+
+    year: integer("year"),
+
+    standardFiletype: uuid("standardFiletype").references(() => filetags.id),
+
+    standardFiletypeIsOptional: boolean("standardFiletypeIsOptional")
+        .notNull()
+        .default(true),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+
+    archived: boolean("archived").notNull().default(false),
+})
+
+export type Folder = typeof folders.$inferSelect
+export type NewFolder = typeof folders.$inferInsert

backend/db/schema/generatedexports.ts

@@ -0,0 +1,35 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+
+export const generatedexports = pgTable("exports", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenantId: bigint("tenant_id", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    startDate: timestamp("start_date", { withTimezone: true }).notNull(),
+    endDate: timestamp("end_date", { withTimezone: true }).notNull(),
+
+    validUntil: timestamp("valid_until", { withTimezone: true }),
+
+    type: text("type").notNull().default("datev"),
+
+    url: text("url").notNull(),
+    filePath: text("file_path"),
+})
+
+export type Export = typeof generatedexports.$inferSelect
+export type NewExport = typeof generatedexports.$inferInsert

backend/db/schema/globalmessages.ts

@@ -0,0 +1,22 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+} from "drizzle-orm/pg-core"
+
+export const globalmessages = pgTable("globalmessages", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    title: text("title"),
+    description: text("description"),
+})
+
+export type GlobalMessage = typeof globalmessages.$inferSelect
+export type NewGlobalMessage = typeof globalmessages.$inferInsert

backend/db/schema/globalmessagesseen.ts

@@ -0,0 +1,17 @@
+import {
+    pgTable,
+    timestamp,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { globalmessages } from "./globalmessages"
+
+export const globalmessagesseen = pgTable("globalmessagesseen", {
+    message: bigint("message", { mode: "number" })
+        .notNull()
+        .references(() => globalmessages.id),
+
+    seenAt: timestamp("seen_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+})

backend/db/schema/helpdesk_channel_instances.ts

@@ -0,0 +1,44 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    boolean,
+    jsonb,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+import { helpdesk_channel_types } from "./helpdesk_channel_types"
+
+export const helpdesk_channel_instances = pgTable("helpdesk_channel_instances", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    tenantId: bigint("tenant_id", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id, { onDelete: "cascade" }),
+
+    typeId: text("type_id")
+        .notNull()
+        .references(() => helpdesk_channel_types.id),
+
+    name: text("name").notNull(),
+
+    isActive: boolean("is_active").notNull().default(true),
+
+    config: jsonb("config").notNull(),
+    publicConfig: jsonb("public_config").notNull().default({}),
+
+    publicToken: text("public_token").unique(),
+    secretToken: text("secret_token"),
+
+    createdBy: uuid("created_by").references(() => authUsers.id),
+
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+})
+
+export type HelpdeskChannelInstance =
+    typeof helpdesk_channel_instances.$inferSelect
+export type NewHelpdeskChannelInstance =
+    typeof helpdesk_channel_instances.$inferInsert

backend/db/schema/helpdesk_channel_types.ts

@@ -0,0 +1,9 @@
+import { pgTable, text } from "drizzle-orm/pg-core"
+
+export const helpdesk_channel_types = pgTable("helpdesk_channel_types", {
+    id: text("id").primaryKey(),
+    description: text("description").notNull(),
+})
+
+export type HelpdeskChannelType = typeof helpdesk_channel_types.$inferSelect
+export type NewHelpdeskChannelType = typeof helpdesk_channel_types.$inferInsert

backend/db/schema/helpdesk_contacts.ts

@@ -0,0 +1,45 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    jsonb,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { customers } from "./customers"
+import { contacts } from "./contacts"
+import { helpdesk_channel_instances } from "./helpdesk_channel_instances" // placeholder
+
+export const helpdesk_contacts = pgTable("helpdesk_contacts", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    tenantId: bigint("tenant_id", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id, { onDelete: "cascade" }),
+
+    customerId: bigint("customer_id", { mode: "number" })
+        .references(() => customers.id, { onDelete: "set null" }),
+
+    email: text("email"),
+    phone: text("phone"),
+
+    externalRef: jsonb("external_ref"),
+    displayName: text("display_name"),
+
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+
+    sourceChannelId: uuid("source_channel_id").references(
+        () => helpdesk_channel_instances.id,
+        { onDelete: "set null" }
+    ),
+
+    contactId: bigint("contact_id", { mode: "number" }).references(
+        () => contacts.id,
+        { onDelete: "set null" }
+    ),
+})
+
+export type HelpdeskContact = typeof helpdesk_contacts.$inferSelect
+export type NewHelpdeskContact = typeof helpdesk_contacts.$inferInsert

backend/db/schema/helpdesk_conversation_participants.ts

@@ -0,0 +1,34 @@
+import {
+    pgTable,
+    uuid,
+    text,
+} from "drizzle-orm/pg-core"
+
+import { helpdesk_conversations } from "./helpdesk_conversations"
+import { authUsers } from "./auth_users"
+
+export const helpdesk_conversation_participants = pgTable(
+    "helpdesk_conversation_participants",
+    {
+        conversationId: uuid("conversation_id")
+            .notNull()
+            .references(() => helpdesk_conversations.id, { onDelete: "cascade" }),
+
+        userId: uuid("user_id")
+            .notNull()
+            .references(() => authUsers.id, { onDelete: "cascade" }),
+
+        role: text("role"),
+    },
+    (table) => ({
+        pk: {
+            name: "helpdesk_conversation_participants_pkey",
+            columns: [table.conversationId, table.userId],
+        },
+    })
+)
+
+export type HelpdeskConversationParticipant =
+    typeof helpdesk_conversation_participants.$inferSelect
+export type NewHelpdeskConversationParticipant =
+    typeof helpdesk_conversation_participants.$inferInsert

backend/db/schema/helpdesk_conversations.ts

@@ -0,0 +1,59 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { helpdesk_contacts } from "./helpdesk_contacts"
+import { contacts } from "./contacts"
+import { customers } from "./customers"
+import { authUsers } from "./auth_users"
+import { helpdesk_channel_instances } from "./helpdesk_channel_instances"
+
+export const helpdesk_conversations = pgTable("helpdesk_conversations", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    tenantId: bigint("tenant_id", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id, { onDelete: "cascade" }),
+
+    channelInstanceId: uuid("channel_instance_id")
+        .notNull()
+        .references(() => helpdesk_channel_instances.id, { onDelete: "cascade" }),
+
+    contactId: uuid("contact_id").references(() => helpdesk_contacts.id, {
+        onDelete: "set null",
+    }),
+
+    subject: text("subject"),
+
+    status: text("status").notNull().default("open"),
+
+    priority: text("priority").default("normal"),
+
+    assigneeUserId: uuid("assignee_user_id").references(() => authUsers.id),
+
+    lastMessageAt: timestamp("last_message_at", { withTimezone: true }),
+
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+
+    customerId: bigint("customer_id", { mode: "number" }).references(
+        () => customers.id,
+        { onDelete: "set null" }
+    ),
+
+    contactPersonId: bigint("contact_person_id", { mode: "number" }).references(
+        () => contacts.id,
+        { onDelete: "set null" }
+    ),
+
+    ticketNumber: text("ticket_number"),
+})
+
+export type HelpdeskConversation =
+    typeof helpdesk_conversations.$inferSelect
+export type NewHelpdeskConversation =
+    typeof helpdesk_conversations.$inferInsert

backend/db/schema/helpdesk_messages.ts

@@ -0,0 +1,46 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    jsonb,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { helpdesk_contacts } from "./helpdesk_contacts"
+import { helpdesk_conversations } from "./helpdesk_conversations"
+import { authUsers } from "./auth_users"
+
+export const helpdesk_messages = pgTable("helpdesk_messages", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    tenantId: bigint("tenant_id", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id, { onDelete: "cascade" }),
+
+    conversationId: uuid("conversation_id")
+        .notNull()
+        .references(() => helpdesk_conversations.id, { onDelete: "cascade" }),
+
+    direction: text("direction").notNull(),
+
+    authorUserId: uuid("author_user_id").references(() => authUsers.id),
+
+    payload: jsonb("payload").notNull(),
+
+    rawMeta: jsonb("raw_meta"),
+
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+
+    contactId: uuid("contact_id").references(() => helpdesk_contacts.id, {
+        onDelete: "set null",
+    }),
+
+    externalMessageId: text("external_message_id").unique(),
+
+    receivedAt: timestamp("received_at", { withTimezone: true }).defaultNow(),
+})
+
+export type HelpdeskMessage = typeof helpdesk_messages.$inferSelect
+export type NewHelpdeskMessage = typeof helpdesk_messages.$inferInsert

backend/db/schema/helpdesk_routing_rules.ts

@@ -0,0 +1,33 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    jsonb,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const helpdesk_routing_rules = pgTable("helpdesk_routing_rules", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    tenantId: bigint("tenant_id", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id, { onDelete: "cascade" }),
+
+    name: text("name").notNull(),
+
+    condition: jsonb("condition").notNull(),
+    action: jsonb("action").notNull(),
+
+    createdBy: uuid("created_by").references(() => authUsers.id),
+
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+})
+
+export type HelpdeskRoutingRule =
+    typeof helpdesk_routing_rules.$inferSelect
+export type NewHelpdeskRoutingRule =
+    typeof helpdesk_routing_rules.$inferInsert

backend/db/schema/historyitems.ts

@@ -0,0 +1,140 @@
+import {
+    pgTable,
+    bigint,
+    uuid,
+    timestamp,
+    text,
+    jsonb,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { customers } from "./customers"
+import { vendors } from "./vendors"
+import { projects } from "./projects"
+import { plants } from "./plants"
+import { incominginvoices } from "./incominginvoices"
+import { contacts } from "./contacts"
+import { inventoryitems } from "./inventoryitems"
+import { products } from "./products"
+import { tasks } from "./tasks"
+import { vehicles } from "./vehicles"
+import { bankstatements } from "./bankstatements"
+import { spaces } from "./spaces"
+import { costcentres } from "./costcentres"
+import { ownaccounts } from "./ownaccounts"
+import { createddocuments } from "./createddocuments"
+import { documentboxes } from "./documentboxes"
+import { hourrates } from "./hourrates"
+import { projecttypes } from "./projecttypes"
+import { checks } from "./checks"
+import { services } from "./services"
+import { events } from "./events"
+import { inventoryitemgroups } from "./inventoryitemgroups"
+import { authUsers } from "./auth_users"
+import {files} from "./files";
+
+export const historyitems = pgTable("historyitems", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    text: text("text").notNull(),
+
+    customer: bigint("customer", { mode: "number" }).references(
+        () => customers.id,
+        { onDelete: "cascade" }
+    ),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    vendor: bigint("vendor", { mode: "number" }).references(() => vendors.id),
+
+    project: bigint("project", { mode: "number" }).references(
+        () => projects.id,
+        { onDelete: "cascade" }
+    ),
+
+    plant: bigint("plant", { mode: "number" }).references(
+        () => plants.id,
+        { onDelete: "cascade" }
+    ),
+
+    incomingInvoice: bigint("incomingInvoice", { mode: "number" }).references(
+        () => incominginvoices.id,
+        { onDelete: "cascade" }
+    ),
+
+    contact: bigint("contact", { mode: "number" }).references(() => contacts.id, {
+        onDelete: "cascade",
+    }),
+
+    inventoryitem: bigint("inventoryitem", { mode: "number" }).references(
+        () => inventoryitems.id,
+        { onDelete: "cascade" }
+    ),
+
+    product: bigint("product", { mode: "number" }).references(
+        () => products.id,
+        { onDelete: "cascade" }
+    ),
+
+    event: bigint("event", { mode: "number" }).references(() => events.id),
+
+    newVal: text("newVal"),
+    oldVal: text("oldVal"),
+
+    task: bigint("task", { mode: "number" }).references(() => tasks.id),
+
+    vehicle: bigint("vehicle", { mode: "number" }).references(() => vehicles.id),
+
+    bankstatement: bigint("bankstatement", { mode: "number" }).references(
+        () => bankstatements.id
+    ),
+
+    space: bigint("space", { mode: "number" }).references(() => spaces.id),
+
+    config: jsonb("config"),
+
+    projecttype: bigint("projecttype", { mode: "number" }).references(
+        () => projecttypes.id
+    ),
+
+    check: uuid("check").references(() => checks.id),
+
+    service: bigint("service", { mode: "number" }).references(
+        () => services.id
+    ),
+
+    createddocument: bigint("createddocument", { mode: "number" }).references(
+        () => createddocuments.id
+    ),
+
+    file: uuid("file").references(() => files.id),
+
+    inventoryitemgroup: uuid("inventoryitemgroup").references(
+        () => inventoryitemgroups.id
+    ),
+
+    source: text("source").default("Software"),
+
+    costcentre: uuid("costcentre").references(() => costcentres.id),
+
+    ownaccount: uuid("ownaccount").references(() => ownaccounts.id),
+
+    documentbox: uuid("documentbox").references(() => documentboxes.id),
+
+    hourrate: uuid("hourrate").references(() => hourrates.id),
+
+    createdBy: uuid("created_by").references(() => authUsers.id),
+
+    action: text("action"),
+})
+
+export type HistoryItem = typeof historyitems.$inferSelect
+export type NewHistoryItem = typeof historyitems.$inferInsert

backend/db/schema/holidays.ts

@@ -0,0 +1,18 @@
+import { pgTable, bigint, date, text, timestamp } from "drizzle-orm/pg-core"
+
+export const holidays = pgTable("holidays", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedAlwaysAsIdentity(),
+
+    date: date("date").notNull(),
+
+    name: text("name").notNull(),
+
+    state_code: text("state_code").notNull(),
+
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+})
+
+export type Holiday = typeof holidays.$inferSelect
+export type NewHoliday = typeof holidays.$inferInsert

backend/db/schema/hourrates.ts

@@ -0,0 +1,27 @@
+import { pgTable, uuid, timestamp, text, boolean, bigint, doublePrecision } from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const hourrates = pgTable("hourrates", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    name: text("name").notNull(),
+
+    purchasePrice: doublePrecision("purchasePrice").notNull(),
+    sellingPrice: doublePrecision("sellingPrice").notNull(),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type HourRate = typeof hourrates.$inferSelect
+export type NewHourRate = typeof hourrates.$inferInsert

backend/db/schema/incominginvoices.ts

@@ -0,0 +1,63 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    boolean,
+    jsonb,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { vendors } from "./vendors"
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const incominginvoices = pgTable("incominginvoices", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    state: text("state").notNull().default("Entwurf"),
+
+    vendor: bigint("vendor", { mode: "number" }).references(() => vendors.id),
+
+    reference: text("reference"),
+    date: text("date"),
+
+    document: bigint("document", { mode: "number" }),
+
+    dueDate: text("dueDate"),
+
+    description: text("description"),
+
+    paymentType: text("paymentType"),
+
+    accounts: jsonb("accounts").notNull().default([
+        {
+            account: null,
+            taxType: null,
+            amountNet: null,
+            amountTax: 19,
+            costCentre: null,
+        },
+    ]),
+
+    paid: boolean("paid").notNull().default(false),
+    expense: boolean("expense").notNull().default(true),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+
+    archived: boolean("archived").notNull().default(false),
+})
+
+export type IncomingInvoice = typeof incominginvoices.$inferSelect
+export type NewIncomingInvoice = typeof incominginvoices.$inferInsert

backend/db/schema/index.ts

@@ -0,0 +1,74 @@
+export * from "./accounts"
+export * from "./auth_profiles"
+export * from "./auth_role_permisssions"
+export * from "./auth_roles"
+export * from "./auth_tenant_users"
+export * from "./auth_user_roles"
+export * from "./auth_users"
+export * from "./bankaccounts"
+export * from "./bankrequisitions"
+export * from "./bankstatements"
+export * from "./checkexecutions"
+export * from "./checks"
+export * from "./citys"
+export * from "./contacts"
+export * from "./contracts"
+export * from "./costcentres"
+export * from "./countrys"
+export * from "./createddocuments"
+export * from "./createdletters"
+export * from "./customers"
+export * from "./devices"
+export * from "./documentboxes"
+export * from "./enums"
+export * from "./events"
+export * from "./files"
+export * from "./filetags"
+export * from "./folders"
+export * from "./generatedexports"
+export * from "./globalmessages"
+export * from "./globalmessagesseen"
+export * from "./helpdesk_channel_instances"
+export * from "./helpdesk_channel_types"
+export * from "./helpdesk_contacts"
+export * from "./helpdesk_conversation_participants"
+export * from "./helpdesk_conversations"
+export * from "./helpdesk_messages"
+export * from "./helpdesk_routing_rules"
+export * from "./historyitems"
+export * from "./holidays"
+export * from "./hourrates"
+export * from "./incominginvoices"
+export * from "./inventoryitemgroups"
+export * from "./inventoryitems"
+export * from "./letterheads"
+export * from "./movements"
+export * from "./notifications_event_types"
+export * from "./notifications_items"
+export * from "./notifications_preferences"
+export * from "./notifications_preferences_defaults"
+export * from "./ownaccounts"
+export * from "./plants"
+export * from "./productcategories"
+export * from "./products"
+export * from "./projects"
+export * from "./projecttypes"
+export * from "./servicecategories"
+export * from "./services"
+export * from "./spaces"
+export * from "./staff_time_entries"
+export * from "./staff_time_entry_connects"
+export * from "./staff_zeitstromtimestamps"
+export * from "./statementallocations"
+export * from "./tasks"
+export * from "./taxtypes"
+export * from "./tenants"
+export * from "./texttemplates"
+export * from "./units"
+export * from "./user_credentials"
+export * from "./vehicles"
+export * from "./vendors"
+export * from "./staff_time_events"
+export * from "./serialtypes"
+export * from "./serialexecutions"
+export * from "./public_links"

backend/db/schema/inventoryitemgroups.ts

@@ -0,0 +1,39 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    boolean,
+    jsonb, bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const inventoryitemgroups = pgTable("inventoryitemgroups", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" }).notNull().references(() => tenants.id),
+
+    name: text("name").notNull(),
+
+    inventoryitems: jsonb("inventoryitems").notNull().default([]),
+
+    description: text("description"),
+
+    archived: boolean("archived").notNull().default(false),
+
+    profiles: jsonb("profiles").notNull().default([]),
+
+    usePlanning: boolean("usePlanning").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type InventoryItemGroup = typeof inventoryitemgroups.$inferSelect
+export type NewInventoryItemGroup = typeof inventoryitemgroups.$inferInsert

backend/db/schema/inventoryitems.ts

@@ -0,0 +1,68 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    boolean,
+    doublePrecision,
+    uuid,
+    jsonb,
+    date,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { vendors } from "./vendors"
+import { spaces } from "./spaces"
+import { authUsers } from "./auth_users"
+
+export const inventoryitems = pgTable("inventoryitems", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+
+    usePlanning: boolean("usePlanning").notNull().default(false),
+
+    description: text("description"),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    currentSpace: bigint("currentSpace", { mode: "number" }).references(
+        () => spaces.id
+    ),
+
+    articleNumber: text("articleNumber"),
+    serialNumber: text("serialNumber"),
+
+    purchaseDate: date("purchaseDate"),
+
+    vendor: bigint("vendor", { mode: "number" }).references(() => vendors.id),
+
+    quantity: bigint("quantity", { mode: "number" }).notNull().default(0),
+
+    purchasePrice: doublePrecision("purchasePrice").default(0),
+
+    manufacturer: text("manufacturer"),
+    manufacturerNumber: text("manufacturerNumber"),
+
+    currentValue: doublePrecision("currentValue"),
+
+    archived: boolean("archived").notNull().default(false),
+
+    profiles: jsonb("profiles").notNull().default([]),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() =>
+        authUsers.id
+    ),
+})
+
+export type InventoryItem = typeof inventoryitems.$inferSelect
+export type NewInventoryItem = typeof inventoryitems.$inferInsert

backend/db/schema/letterheads.ts

@@ -0,0 +1,39 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    boolean,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const letterheads = pgTable("letterheads", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    name: text("name").default("Standard"),
+
+    path: text("path").notNull(),
+
+    documentTypes: text("documentTypes").array().notNull().default([]),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+
+    archived: boolean("archived").notNull().default(false),
+})
+
+export type Letterhead = typeof letterheads.$inferSelect
+export type NewLetterhead = typeof letterheads.$inferInsert

backend/db/schema/movements.ts

@@ -0,0 +1,49 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { products } from "./products"
+import { spaces } from "./spaces"
+import { tenants } from "./tenants"
+import { projects } from "./projects"
+import { authUsers } from "./auth_users"
+
+export const movements = pgTable("movements", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    quantity: bigint("quantity", { mode: "number" }).notNull(),
+
+    productId: bigint("productId", { mode: "number" })
+        .notNull()
+        .references(() => products.id),
+
+    spaceId: bigint("spaceId", { mode: "number" }).references(() => spaces.id),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    projectId: bigint("projectId", { mode: "number" }).references(
+        () => projects.id
+    ),
+
+    notes: text("notes"),
+
+    serials: text("serials").array(),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type Movement = typeof movements.$inferSelect
+export type NewMovement = typeof movements.$inferInsert

backend/db/schema/notifications_event_types.ts

@@ -0,0 +1,34 @@
+import {
+    pgTable,
+    text,
+    jsonb,
+    boolean,
+    timestamp,
+} from "drizzle-orm/pg-core"
+import {notificationSeverityEnum} from "./enums";
+
+
+export const notificationsEventTypes = pgTable("notifications_event_types", {
+    eventKey: text("event_key").primaryKey(),
+
+    displayName: text("display_name").notNull(),
+    description: text("description"),
+    category: text("category"),
+
+    severity: notificationSeverityEnum("severity").notNull().default("info"),
+
+    allowedChannels: jsonb("allowed_channels").notNull().default(["inapp", "email"]),
+
+    payloadSchema: jsonb("payload_schema"),
+
+    isActive: boolean("is_active").notNull().default(true),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+})
+
+export type NotificationsEventType =
+    typeof notificationsEventTypes.$inferSelect
+export type NewNotificationsEventType =
+    typeof notificationsEventTypes.$inferInsert

backend/db/schema/notifications_items.ts

@@ -0,0 +1,54 @@
+import {
+    pgTable,
+    uuid,
+    bigint,
+    text,
+    jsonb,
+    timestamp,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+import { notificationsEventTypes } from "./notifications_event_types"
+import {notificationChannelEnum, notificationStatusEnum} from "./enums";
+
+
+export const notificationsItems = pgTable("notifications_items", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    tenantId: bigint("tenant_id", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id, { onDelete: "cascade", onUpdate: "cascade" }),
+
+    userId: uuid("user_id")
+        .notNull()
+        .references(() => authUsers.id, { onDelete: "cascade", onUpdate: "cascade" }),
+
+    eventType: text("event_type")
+        .notNull()
+        .references(() => notificationsEventTypes.eventKey, {
+            onUpdate: "cascade",
+            onDelete: "restrict",
+        }),
+
+    title: text("title").notNull(),
+    message: text("message").notNull(),
+
+    payload: jsonb("payload"),
+
+    channel: notificationChannelEnum("channel").notNull(),
+
+    status: notificationStatusEnum("status").notNull().default("queued"),
+
+    error: text("error"),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    sentAt: timestamp("sent_at", { withTimezone: true }),
+    readAt: timestamp("read_at", { withTimezone: true }),
+})
+
+export type NotificationItem = typeof notificationsItems.$inferSelect
+export type NewNotificationItem = typeof notificationsItems.$inferInsert

backend/db/schema/notifications_preferences.ts

@@ -0,0 +1,60 @@
+import {
+    pgTable,
+    uuid,
+    bigint,
+    text,
+    boolean,
+    timestamp,
+    uniqueIndex,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+import { notificationsEventTypes } from "./notifications_event_types"
+import {notificationChannelEnum} from "./enums";
+
+export const notificationsPreferences = pgTable(
+    "notifications_preferences",
+    {
+        id: uuid("id").primaryKey().defaultRandom(),
+
+        tenantId: bigint("tenant_id", { mode: "number" })
+            .notNull()
+            .references(() => tenants.id, {
+                onDelete: "cascade",
+                onUpdate: "cascade",
+            }),
+
+        userId: uuid("user_id")
+            .notNull()
+            .references(() => authUsers.id, {
+                onDelete: "cascade",
+                onUpdate: "cascade",
+            }),
+
+        eventType: text("event_type")
+            .notNull()
+            .references(() => notificationsEventTypes.eventKey, {
+                onDelete: "restrict",
+                onUpdate: "cascade",
+            }),
+
+        channel: notificationChannelEnum("channel").notNull(),
+
+        enabled: boolean("enabled").notNull().default(true),
+
+        createdAt: timestamp("created_at", { withTimezone: true })
+            .notNull()
+            .defaultNow(),
+    },
+    (table) => ({
+        uniquePrefs: uniqueIndex(
+            "notifications_preferences_tenant_id_user_id_event_type_chan_key",
+        ).on(table.tenantId, table.userId, table.eventType, table.channel),
+    }),
+)
+
+export type NotificationPreference =
+    typeof notificationsPreferences.$inferSelect
+export type NewNotificationPreference =
+    typeof notificationsPreferences.$inferInsert

backend/db/schema/notifications_preferences_defaults.ts

@@ -0,0 +1,52 @@
+import {
+    pgTable,
+    uuid,
+    bigint,
+    text,
+    boolean,
+    timestamp,
+    uniqueIndex,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { notificationsEventTypes } from "./notifications_event_types"
+import {notificationChannelEnum} from "./enums";
+
+export const notificationsPreferencesDefaults = pgTable(
+    "notifications_preferences_defaults",
+    {
+        id: uuid("id").primaryKey().defaultRandom(),
+
+        tenantId: bigint("tenant_id", { mode: "number" })
+            .notNull()
+            .references(() => tenants.id, {
+                onDelete: "cascade",
+                onUpdate: "cascade",
+            }),
+
+        eventKey: text("event_key")
+            .notNull()
+            .references(() => notificationsEventTypes.eventKey, {
+                onDelete: "restrict",
+                onUpdate: "cascade",
+            }),
+
+        channel: notificationChannelEnum("channel").notNull(),
+
+        enabled: boolean("enabled").notNull().default(true),
+
+        createdAt: timestamp("created_at", { withTimezone: true })
+            .notNull()
+            .defaultNow(),
+    },
+    (table) => ({
+        uniqueDefaults: uniqueIndex(
+            "notifications_preferences_defau_tenant_id_event_key_channel_key",
+        ).on(table.tenantId, table.eventKey, table.channel),
+    }),
+)
+
+export type NotificationPreferenceDefault =
+    typeof notificationsPreferencesDefaults.$inferSelect
+export type NewNotificationPreferenceDefault =
+    typeof notificationsPreferencesDefaults.$inferInsert

backend/db/schema/ownaccounts.ts

@@ -0,0 +1,39 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    text,
+    boolean,
+    jsonb,
+    bigint,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const ownaccounts = pgTable("ownaccounts", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    number: text("number").notNull(),
+    name: text("name").notNull(),
+
+    description: text("description"),
+
+    archived: boolean("archived").notNull().default(false),
+
+    profiles: jsonb("profiles").notNull().default([]),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type OwnAccount = typeof ownaccounts.$inferSelect
+export type NewOwnAccount = typeof ownaccounts.$inferInsert

backend/db/schema/plants.ts

@@ -0,0 +1,56 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    jsonb,
+    boolean,
+    uuid,
+    date,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { customers } from "./customers"
+import { contracts } from "./contracts"
+import { authUsers } from "./auth_users"
+
+export const plants = pgTable("plants", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    name: text("name").notNull(),
+
+    customer: bigint("customer", { mode: "number" }).references(
+        () => customers.id
+    ),
+
+    infoData: jsonb("infoData"),
+    contract: bigint("contract", { mode: "number" }).references(
+        () => contracts.id
+    ),
+
+    description: jsonb("description").default({
+        html: "",
+        json: [],
+        text: "",
+    }),
+
+    archived: boolean("archived").notNull().default(false),
+
+    profiles: jsonb("profiles").notNull().default([]),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type Plant = typeof plants.$inferSelect
+export type NewPlant = typeof plants.$inferInsert

backend/db/schema/productcategories.ts

@@ -0,0 +1,37 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    boolean,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const productcategories = pgTable("productcategories", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    name: text("name").notNull(),
+
+    description: text("description"),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type ProductCategory = typeof productcategories.$inferSelect
+export type NewProductCategory = typeof productcategories.$inferInsert

backend/db/schema/products.ts

@@ -0,0 +1,69 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    doublePrecision,
+    boolean,
+    smallint,
+    uuid,
+    jsonb,
+    json,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { units } from "./units"
+import { authUsers } from "./auth_users"
+
+export const products = pgTable("products", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+    manufacturer: text("manufacturer"),
+
+    unit: bigint("unit", { mode: "number" })
+        .notNull()
+        .references(() => units.id),
+
+    tags: json("tags").notNull().default([]),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    ean: text("ean"),
+    barcode: text("barcode"),
+
+    purchase_price: doublePrecision("purchasePrice"),
+    selling_price: doublePrecision("sellingPrice"),
+
+    description: text("description"),
+
+    manufacturer_number: text("manufacturerNumber"),
+
+    vendor_allocation: jsonb("vendorAllocation").default([]),
+
+    article_number: text("articleNumber"),
+
+    barcodes: text("barcodes").array().notNull().default([]),
+
+    productcategories: jsonb("productcategories").default([]),
+
+    archived: boolean("archived").notNull().default(false),
+
+    tax_percentage: smallint("taxPercentage").notNull().default(19),
+
+    markup_percentage: doublePrecision("markupPercentage"),
+
+    updated_at: timestamp("updated_at", { withTimezone: true }),
+    updated_by: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type Product = typeof products.$inferSelect
+export type NewProduct = typeof products.$inferInsert

backend/db/schema/projects.ts

@@ -0,0 +1,78 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    jsonb,
+    json,
+    boolean,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { customers } from "./customers"
+import { contracts } from "./contracts"
+import { projecttypes } from "./projecttypes"
+import { authUsers } from "./auth_users"
+
+export const projects = pgTable("projects", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    name: text("name").notNull(),
+
+    notes: text("notes"),
+
+    customer: bigint("customer", { mode: "number" }).references(
+        () => customers.id
+    ),
+
+    phases: jsonb("phases").default([]),
+
+    description: json("description"),
+
+    forms: jsonb("forms").default([]),
+
+    heroId: text("heroId"),
+
+    measure: text("measure"),
+
+    material: jsonb("material"),
+
+    plant: bigint("plant", { mode: "number" }),
+
+    profiles: uuid("profiles").array().notNull().default([]),
+
+    projectNumber: text("projectNumber"),
+
+    contract: bigint("contract", { mode: "number" }).references(
+        () => contracts.id
+    ),
+
+    projectType: text("projectType").default("Projekt"),
+
+    projecttype: bigint("projecttype", { mode: "number" }).references(
+        () => projecttypes.id
+    ),
+
+    archived: boolean("archived").notNull().default(false),
+
+    customerRef: text("customerRef"),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+
+    active_phase: text("active_phase").default("Erstkontakt"),
+})
+
+export type Project = typeof projects.$inferSelect
+export type NewProject = typeof projects.$inferInsert

backend/db/schema/projecttypes.ts

@@ -0,0 +1,41 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    jsonb,
+    boolean,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const projecttypes = pgTable("projecttypes", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+
+    initialPhases: jsonb("initialPhases"),
+    addablePhases: jsonb("addablePhases"),
+
+    icon: text("icon"),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type ProjectType = typeof projecttypes.$inferSelect
+export type NewProjectType = typeof projecttypes.$inferInsert

backend/db/schema/public_links.ts

@@ -0,0 +1,30 @@
+import { pgTable, text, integer, boolean, jsonb, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { tenants } from './tenants';
+import { authProfiles } from './auth_profiles';
+
+export const publicLinks = pgTable('public_links', {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    // Der öffentliche Token (z.B. "werkstatt-tablet-01")
+    token: text('token').notNull().unique(),
+
+    // Zuordnung zum Tenant (WICHTIG für die Datentrennung)
+    tenant: integer('tenant').references(() => tenants.id).notNull(),
+
+    defaultProfile: uuid('default_profile').references(() => authProfiles.id),
+
+    // Sicherheit
+    isProtected: boolean('is_protected').default(false).notNull(),
+    pinHash: text('pin_hash'),
+
+    // Konfiguration (JSON)
+    config: jsonb('config').default({}),
+
+    // Metadaten
+    name: text('name').notNull(),
+    description: text('description'),
+
+    active: boolean('active').default(true).notNull(),
+    createdAt: timestamp('created_at').defaultNow(),
+    updatedAt: timestamp('updated_at').defaultNow(),
+});

backend/db/schema/serialexecutions.ts

@@ -0,0 +1,21 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    jsonb,
+    boolean,
+    uuid,
+} from "drizzle-orm/pg-core"
+import {tenants} from "./tenants";
+
+export const serialExecutions = pgTable("serial_executions", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),    executionDate: timestamp("execution_date").notNull(),
+    status: text("status").default("draft"), // 'draft', 'completed'
+    createdBy: text("created_by"), // oder UUID, je nach Auth-System
+    createdAt: timestamp("created_at").defaultNow(),
+    summary: text("summary"), // z.B. "25 Rechnungen erstellt"
+});

backend/db/schema/serialtypes.ts

@@ -0,0 +1,40 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    jsonb,
+    boolean,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const serialtypes = pgTable("serialtypes", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+
+    intervall: text("intervall"),
+
+    icon: text("icon"),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type SerialType = typeof serialtypes.$inferSelect
+export type NewSerialType = typeof serialtypes.$inferInsert

backend/db/schema/servicecategories.ts

@@ -0,0 +1,39 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    doublePrecision,
+    boolean,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const servicecategories = pgTable("servicecategories", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    created_at: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    name: text("name").notNull(),
+    description: text("description"),
+
+    discount: doublePrecision("discount").default(0),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updated_at: timestamp("updated_at", { withTimezone: true }),
+    updated_by: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type ServiceCategory = typeof servicecategories.$inferSelect
+export type NewServiceCategory = typeof servicecategories.$inferInsert

backend/db/schema/services.ts

@@ -0,0 +1,63 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    doublePrecision,
+    jsonb,
+    boolean,
+    smallint,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { units } from "./units"
+import { authUsers } from "./auth_users"
+
+export const services = pgTable("services", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+
+    sellingPrice: doublePrecision("sellingPrice"),
+
+    description: text("description"),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    unit: bigint("unit", { mode: "number" }).references(() => units.id),
+
+    serviceNumber: bigint("serviceNumber", { mode: "number" }),
+
+    tags: jsonb("tags").default([]),
+    servicecategories: jsonb("servicecategories").notNull().default([]),
+
+    archived: boolean("archived").notNull().default(false),
+
+    purchasePriceComposed: jsonb("purchasePriceComposed")
+        .notNull()
+        .default({ total: 0 }),
+
+    sellingPriceComposed: jsonb("sellingPriceComposed")
+        .notNull()
+        .default({ total: 0 }),
+
+    taxPercentage: smallint("taxPercentage").notNull().default(19),
+
+    materialComposition: jsonb("materialComposition").notNull().default([]),
+    personalComposition: jsonb("personalComposition").notNull().default([]),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type Service = typeof services.$inferSelect
+export type NewService = typeof services.$inferInsert

backend/db/schema/spaces.ts

@@ -0,0 +1,49 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    boolean,
+    jsonb,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const spaces = pgTable("spaces", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name"),
+    type: text("type").notNull(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    space_number: text("spaceNumber").notNull(),
+
+    parentSpace: bigint("parentSpace", { mode: "number" }).references(
+        () => spaces.id
+    ),
+
+    info_data: jsonb("infoData")
+        .notNull()
+        .default({ zip: "", city: "", streetNumber: "" }),
+
+    description: text("description"),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type Space = typeof spaces.$inferSelect
+export type NewSpace = typeof spaces.$inferInsert

backend/db/schema/staff_time_entries.ts

@@ -0,0 +1,68 @@
+import {
+    pgTable,
+    uuid,
+    bigint,
+    timestamp,
+    integer,
+    text,
+    boolean,
+    numeric,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+import { timesStateEnum } from "./enums"
+import {sql} from "drizzle-orm";
+
+export const stafftimeentries = pgTable("staff_time_entries", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    tenant_id: bigint("tenant_id", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    user_id: uuid("user_id")
+        .notNull()
+        .references(() => authUsers.id, { onDelete: "cascade" }),
+
+    started_at: timestamp("started_at", { withTimezone: true }).notNull(),
+    stopped_at: timestamp("stopped_at", { withTimezone: true }),
+
+    duration_minutes: integer("duration_minutes").generatedAlwaysAs(
+        sql`CASE 
+      WHEN stopped_at IS NOT NULL 
+      THEN (EXTRACT(epoch FROM (stopped_at - started_at)) / 60)
+      ELSE NULL
+    END`
+    ),
+
+    type: text("type").default("work"),
+
+    description: text("description"),
+
+    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+    updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updated_by: uuid("updated_by").references(() => authUsers.id),
+
+    source: text("source"),
+
+    state: timesStateEnum("state").notNull().default("draft"),
+
+    device: uuid("device"),
+
+    internal_note: text("internal_note"),
+
+    vacation_reason: text("vacation_reason"),
+    vacation_days: numeric("vacation_days", { precision: 5, scale: 2 }),
+
+    approved_by: uuid("approved_by").references(() => authUsers.id),
+    approved_at: timestamp("approved_at", { withTimezone: true }),
+
+    sick_reason: text("sick_reason"),
+})
+
+export type StaffTimeEntry = typeof stafftimeentries.$inferSelect
+export type NewStaffTimeEntry = typeof stafftimeentries.$inferInsert

backend/db/schema/staff_time_entry_connects.ts

@@ -0,0 +1,38 @@
+import {
+    pgTable,
+    uuid,
+    bigint,
+    timestamp,
+    integer,
+    text,
+} from "drizzle-orm/pg-core"
+
+import { stafftimeentries } from "./staff_time_entries"
+import {sql} from "drizzle-orm";
+
+export const stafftimenetryconnects = pgTable("staff_time_entry_connects", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    stafftimeentry: uuid("time_entry_id")
+        .notNull()
+        .references(() => stafftimeentries.id, { onDelete: "cascade" }),
+
+    project_id: bigint("project_id", { mode: "number" }), // referenziert später projects.id
+
+    started_at: timestamp("started_at", { withTimezone: true }).notNull(),
+    stopped_at: timestamp("stopped_at", { withTimezone: true }).notNull(),
+
+    durationMinutes: integer("duration_minutes").generatedAlwaysAs(
+        sql`(EXTRACT(epoch FROM (stopped_at - started_at)) / 60)`
+    ),
+
+    notes: text("notes"),
+
+    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+    updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+})
+
+export type StaffTimeEntryConnect =
+    typeof stafftimenetryconnects.$inferSelect
+export type NewStaffTimeEntryConnect =
+    typeof stafftimenetryconnects.$inferInsert

backend/db/schema/staff_time_events.ts

@@ -0,0 +1,85 @@
+import {
+    pgTable,
+    uuid,
+    bigint,
+    text,
+    timestamp,
+    jsonb,
+    index,
+    check,
+} from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+import {tenants} from "./tenants";
+import {authUsers} from "./auth_users";
+
+export const stafftimeevents = pgTable(
+    "staff_time_events",
+    {
+        id: uuid("id").primaryKey().defaultRandom(),
+
+        tenant_id: bigint("tenant_id", { mode: "number" })
+            .notNull()
+            .references(() => tenants.id),
+
+        user_id: uuid("user_id")
+            .notNull()
+            .references(() => authUsers.id),
+
+        // Akteur
+        actortype: text("actor_type").notNull(), // 'user' | 'system'
+        actoruser_id: uuid("actor_user_id").references(() => authUsers.id),
+
+        // Zeit
+        eventtime: timestamp("event_time", {
+            withTimezone: true,
+        }).notNull(),
+
+        // Fachliche Bedeutung
+        eventtype: text("event_type").notNull(),
+
+        // Quelle
+        source: text("source").notNull(), // web | mobile | terminal | system
+
+        // Entkräftung
+        invalidates_event_id: uuid("invalidates_event_id")
+        .references(() => stafftimeevents.id),
+
+        //Beziehung Approval etc
+        related_event_id: uuid("related_event_id")
+            .references(() => stafftimeevents.id),
+
+        // Zusatzdaten
+        metadata: jsonb("metadata"),
+
+        // Technisch
+        created_at: timestamp("created_at", {
+            withTimezone: true,
+        })
+            .defaultNow()
+            .notNull(),
+    },
+    (table) => ({
+        // Indizes
+        tenantUserTimeIdx: index("idx_time_events_tenant_user_time").on(
+            table.tenant_id,
+            table.user_id,
+            table.eventtime
+        ),
+
+        createdAtIdx: index("idx_time_events_created_at").on(table.created_at),
+
+        invalidatesIdx: index("idx_time_events_invalidates").on(
+            table.invalidates_event_id
+        ),
+
+        // Constraints
+        actorUserCheck: check(
+            "time_events_actor_user_check",
+            sql`
+        (actor_type = 'system' AND actor_user_id IS NULL)
+        OR
+        (actor_type = 'user' AND actor_user_id IS NOT NULL)
+      `
+        ),
+    })
+);

backend/db/schema/staff_zeitstromtimestamps.ts

@@ -0,0 +1,44 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    bigint,
+    text,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authProfiles } from "./auth_profiles"
+import { stafftimeentries } from "./staff_time_entries"
+
+export const staffZeitstromTimestamps = pgTable("staff_zeitstromtimestamps", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    profile: uuid("profile")
+        .notNull()
+        .references(() => authProfiles.id),
+
+    key: text("key").notNull(),
+
+    intent: text("intent").notNull(),
+
+    time: timestamp("time", { withTimezone: true }).notNull(),
+
+    staffTimeEntry: uuid("staff_time_entry").references(
+        () => stafftimeentries.id
+    ),
+
+    internalNote: text("internal_note"),
+})
+
+export type StaffZeitstromTimestamp =
+    typeof staffZeitstromTimestamps.$inferSelect
+export type NewStaffZeitstromTimestamp =
+    typeof staffZeitstromTimestamps.$inferInsert

backend/db/schema/statementallocations.ts

@@ -0,0 +1,69 @@
+import {
+    pgTable,
+    uuid,
+    bigint,
+    integer,
+    text,
+    timestamp,
+    boolean,
+    doublePrecision,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+import { customers } from "./customers"
+import { vendors } from "./vendors"
+import { ownaccounts } from "./ownaccounts"
+import { incominginvoices } from "./incominginvoices"
+import { createddocuments } from "./createddocuments"
+import { bankstatements } from "./bankstatements"
+import { accounts } from "./accounts" // Falls noch nicht erstellt → bitte melden!
+
+export const statementallocations = pgTable("statementallocations", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    // foreign keys
+    bankstatement: integer("bs_id")
+        .notNull()
+        .references(() => bankstatements.id),
+
+    createddocument: integer("cd_id").references(() => createddocuments.id),
+
+    amount: doublePrecision("amount").notNull().default(0),
+
+    incominginvoice: bigint("ii_id", { mode: "number" }).references(
+        () => incominginvoices.id
+    ),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    account: bigint("account", { mode: "number" }).references(
+        () => accounts.id
+    ),
+
+    created_at: timestamp("created_at", {
+        withTimezone: false,
+    }).defaultNow(),
+
+    ownaccount: uuid("ownaccount").references(() => ownaccounts.id),
+
+    description: text("description"),
+
+    customer: bigint("customer", { mode: "number" }).references(
+        () => customers.id
+    ),
+
+    vendor: bigint("vendor", { mode: "number" }).references(() => vendors.id),
+
+    updated_at: timestamp("updated_at", { withTimezone: true }),
+
+    updated_by: uuid("updated_by").references(() => authUsers.id),
+
+    archived: boolean("archived").notNull().default(false),
+})
+
+export type StatementAllocation = typeof statementallocations.$inferSelect
+export type NewStatementAllocation =
+    typeof statementallocations.$inferInsert

backend/db/schema/tasks.ts

@@ -0,0 +1,51 @@
+import {
+    pgTable,
+    bigint,
+    text,
+    timestamp,
+    boolean,
+    jsonb,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+import { customers } from "./customers"
+
+export const tasks = pgTable("tasks", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+    description: text("description"),
+    categorie: text("categorie"),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    // FIXED: user_id statt profile, verweist auf auth_users.id
+    userId: uuid("user_id").references(() => authUsers.id),
+
+    project: bigint("project", { mode: "number" }),
+    plant: bigint("plant", { mode: "number" }),
+
+    customer: bigint("customer", { mode: "number" }).references(
+        () => customers.id
+    ),
+
+    profiles: jsonb("profiles").notNull().default([]),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type Task = typeof tasks.$inferSelect
+export type NewTask = typeof tasks.$inferInsert

backend/db/schema/taxtypes.ts

@@ -0,0 +1,28 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { authUsers } from "./auth_users"
+
+export const taxTypes = pgTable("taxtypes", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    label: text("label").notNull(),
+    percentage: bigint("percentage", { mode: "number" }).notNull(),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type TaxType = typeof taxTypes.$inferSelect
+export type NewTaxType = typeof taxTypes.$inferInsert

backend/db/schema/tenants.ts

@@ -0,0 +1,140 @@
+import {
+    pgTable,
+    bigint,
+    text,
+    timestamp,
+    boolean,
+    jsonb,
+    integer,
+    smallint,
+    date,
+    uuid,
+    pgEnum,
+} from "drizzle-orm/pg-core"
+import { authUsers } from "./auth_users"
+import {lockedTenantEnum} from "./enums";
+
+export const tenants = pgTable(
+    "tenants",
+    {
+        id: bigint("id", { mode: "number" })
+            .primaryKey()
+            .generatedByDefaultAsIdentity(),
+
+        createdAt: timestamp("created_at", { withTimezone: true })
+            .notNull()
+            .defaultNow(),
+
+        name: text("name").notNull(),
+        short: text("short").notNull(),
+
+        calendarConfig: jsonb("calendarConfig").default({
+            eventTypes: [
+                { color: "blue", label: "Büro" },
+                { color: "yellow", label: "Besprechung" },
+                { color: "green", label: "Umsetzung" },
+                { color: "red", label: "Vor Ort Termin" },
+            ],
+        }),
+
+        timeConfig: jsonb("timeConfig").notNull().default({}),
+
+        tags: jsonb("tags").notNull().default({
+            products: [],
+            documents: [],
+        }),
+
+        measures: jsonb("measures")
+            .notNull()
+            .default([
+                { name: "Netzwerktechnik", short: "NWT" },
+                { name: "Elektrotechnik", short: "ELT" },
+                { name: "Photovoltaik", short: "PV" },
+                { name: "Videüberwachung", short: "VÜA" },
+                { name: "Projekt", short: "PRJ" },
+                { name: "Smart Home", short: "SHO" },
+            ]),
+
+        businessInfo: jsonb("businessInfo").default({
+            zip: "",
+            city: "",
+            name: "",
+            street: "",
+        }),
+
+        features: jsonb("features").default({
+            objects: true,
+            calendar: true,
+            contacts: true,
+            projects: true,
+            vehicles: true,
+            contracts: true,
+            inventory: true,
+            accounting: true,
+            timeTracking: true,
+            planningBoard: true,
+            workingTimeTracking: true,
+        }),
+
+        ownFields: jsonb("ownFields"),
+
+        numberRanges: jsonb("numberRanges")
+            .notNull()
+            .default({
+                vendors: { prefix: "", suffix: "", nextNumber: 10000 },
+                customers: { prefix: "", suffix: "", nextNumber: 10000 },
+                products: { prefix: "AT-", suffix: "", nextNumber: 1000 },
+                quotes: { prefix: "AN-", suffix: "", nextNumber: 1000 },
+                confirmationOrders: { prefix: "AB-", suffix: "", nextNumber: 1000 },
+                invoices: { prefix: "RE-", suffix: "", nextNumber: 1000 },
+                spaces: { prefix: "LP-", suffix: "", nextNumber: 1000 },
+                inventoryitems: { prefix: "IA-", suffix: "", nextNumber: 1000 },
+                projects: { prefix: "PRJ-", suffix: "", nextNumber: 1000 },
+                costcentres: { prefix: "KST-", suffix: "", nextNumber: 1000 },
+            }),
+
+        standardEmailForInvoices: text("standardEmailForInvoices"),
+
+        extraModules: jsonb("extraModules").notNull().default([]),
+
+        isInTrial: boolean("isInTrial").default(false),
+        trialEndDate: date("trialEndDate"),
+
+        stripeCustomerId: text("stripeCustomerId"),
+
+        hasActiveLicense: boolean("hasActiveLicense").notNull().default(false),
+
+        userLicenseCount: integer("userLicenseCount")
+            .notNull()
+            .default(0),
+
+        workstationLicenseCount: integer("workstationLicenseCount")
+            .notNull()
+            .default(0),
+
+        standardPaymentDays: smallint("standardPaymentDays")
+            .notNull()
+            .default(14),
+
+        dokuboxEmailAddresses: jsonb("dokuboxEmailAddresses").default([]),
+
+        dokuboxkey: uuid("dokuboxkey").notNull().defaultRandom(),
+
+        autoPrepareIncomingInvoices: boolean("autoPrepareIncomingInvoices")
+            .default(true),
+
+        portalDomain: text("portalDomain"),
+
+        portalConfig: jsonb("portalConfig")
+            .notNull()
+            .default({ primayColor: "#69c350" }),
+
+        updatedAt: timestamp("updated_at", { withTimezone: true }),
+        updatedBy: uuid("updated_by").references(() => authUsers.id),
+
+        locked: lockedTenantEnum("locked"),
+    }
+)
+
+export type Tenant = typeof tenants.$inferSelect
+export type NewTenant = typeof tenants.$inferInsert

backend/db/schema/texttemplates.ts

@@ -0,0 +1,44 @@
+import {
+    pgTable,
+    bigint,
+    text,
+    timestamp,
+    boolean,
+    jsonb,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+import { textTemplatePositionsEnum } from "./enums"
+
+export const texttemplates = pgTable("texttemplates", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    name: text("name").notNull(),
+    text: text("text").notNull(),
+
+    documentType: text("documentType").default(""),
+
+    default: boolean("default").notNull().default(false),
+
+    pos: textTemplatePositionsEnum("pos").notNull(),
+
+    archived: boolean("archived").notNull().default(false),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type TextTemplate = typeof texttemplates.$inferSelect
+export type NewTextTemplate = typeof texttemplates.$inferInsert

backend/db/schema/units.ts

@@ -0,0 +1,27 @@
+import {
+    pgTable,
+    bigint,
+    timestamp,
+    text,
+} from "drizzle-orm/pg-core"
+
+export const units = pgTable("units", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+    single: text("single").notNull(),
+
+    multiple: text("multiple"),
+    short: text("short"),
+
+    step: text("step").notNull().default("1"),
+})
+
+export type Unit = typeof units.$inferSelect
+export type NewUnit = typeof units.$inferInsert

backend/db/schema/user_credentials.ts

@@ -0,0 +1,53 @@
+import {
+    pgTable,
+    uuid,
+    timestamp,
+    bigint,
+    boolean,
+    jsonb,
+    numeric, pgEnum,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+import {credentialTypesEnum} from "./enums";
+
+
+
+export const userCredentials = pgTable("user_credentials", {
+    id: uuid("id").primaryKey().defaultRandom(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    userId: uuid("user_id")
+        .notNull()
+        .references(() => authUsers.id),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+
+    tenantId: bigint("tenant_id", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    smtpPort: numeric("smtp_port"),
+    smtpSsl: boolean("smtp_ssl"),
+
+    type: credentialTypesEnum("type").notNull(),
+
+    imapPort: numeric("imap_port"),
+    imapSsl: boolean("imap_ssl"),
+
+    emailEncrypted: jsonb("email_encrypted"),
+    passwordEncrypted: jsonb("password_encrypted"),
+
+    smtpHostEncrypted: jsonb("smtp_host_encrypted"),
+    imapHostEncrypted: jsonb("imap_host_encrypted"),
+
+    accessTokenEncrypted: jsonb("access_token_encrypted"),
+    refreshTokenEncrypted: jsonb("refresh_token_encrypted"),
+})
+
+export type UserCredential = typeof userCredentials.$inferSelect
+export type NewUserCredential = typeof userCredentials.$inferInsert

backend/db/schema/vehicles.ts

@@ -0,0 +1,57 @@
+import {
+    pgTable,
+    bigint,
+    text,
+    timestamp,
+    boolean,
+    jsonb,
+    uuid,
+    doublePrecision,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const vehicles = pgTable("vehicles", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    created_at: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    license_plate: text("licensePlate"),
+    name: text("name"),
+    type: text("type"),
+
+    active: boolean("active").default(true),
+
+    // FIXED: driver references auth_users.id
+    driver: uuid("driver").references(() => authUsers.id),
+
+    vin: text("vin"),
+
+    tank_size: doublePrecision("tankSize").notNull().default(0),
+
+    archived: boolean("archived").notNull().default(false),
+
+    build_year: text("buildYear"),
+
+    towing_capacity: bigint("towingCapacity", { mode: "number" }),
+    power_in_kw: bigint("powerInKW", { mode: "number" }),
+
+    color: text("color"),
+
+    profiles: jsonb("profiles").notNull().default([]),
+
+    updated_at: timestamp("updated_at", { withTimezone: true }),
+    updated_by: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type Vehicle = typeof vehicles.$inferSelect
+export type NewVehicle = typeof vehicles.$inferInsert

backend/db/schema/vendors.ts

@@ -0,0 +1,45 @@
+import {
+    pgTable,
+    bigint,
+    text,
+    timestamp,
+    boolean,
+    jsonb,
+    uuid,
+} from "drizzle-orm/pg-core"
+
+import { tenants } from "./tenants"
+import { authUsers } from "./auth_users"
+
+export const vendors = pgTable("vendors", {
+    id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+
+    name: text("name").notNull(),
+    vendorNumber: text("vendorNumber").notNull(),
+
+    tenant: bigint("tenant", { mode: "number" })
+        .notNull()
+        .references(() => tenants.id),
+
+    infoData: jsonb("infoData").notNull().default({}),
+    notes: text("notes"),
+
+    hasSEPA: boolean("hasSEPA").notNull().default(false),
+
+    profiles: jsonb("profiles").notNull().default([]),
+    archived: boolean("archived").notNull().default(false),
+
+    defaultPaymentMethod: text("defaultPaymentMethod"),
+
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+    updatedBy: uuid("updated_by").references(() => authUsers.id),
+})
+
+export type Vendor = typeof vendors.$inferSelect
+export type NewVendor = typeof vendors.$inferInsert

backend/drizzle.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "drizzle-kit"
+import {secrets} from "./src/utils/secrets";
+
+export default defineConfig({
+    dialect: "postgresql",
+    schema: "./db/schema",
+    out: "./db/migrations",
+    dbCredentials: {
+        url: secrets.DATABASE_URL,
+    },
+})

backend/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "backend",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/src/index.js",
+    "schema:index": "ts-node scripts/generate-schema-index.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.federspiel.software/fedeo/backend.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.879.0",
+    "@aws-sdk/s3-request-presigner": "^3.879.0",
+    "@fastify/cookie": "^11.0.2",
+    "@fastify/cors": "^11.1.0",
+    "@fastify/multipart": "^9.0.3",
+    "@fastify/swagger": "^9.5.1",
+    "@fastify/swagger-ui": "^5.2.3",
+    "@infisical/sdk": "^4.0.6",
+    "@mmote/niimbluelib": "^0.0.1-alpha.29",
+    "@prisma/client": "^6.15.0",
+    "@supabase/supabase-js": "^2.56.1",
+    "@zip.js/zip.js": "^2.7.73",
+    "archiver": "^7.0.1",
+    "axios": "^1.12.1",
+    "bcrypt": "^6.0.0",
+    "bwip-js": "^4.8.0",
+    "crypto": "^1.0.1",
+    "dayjs": "^1.11.18",
+    "drizzle-orm": "^0.45.0",
+    "fastify": "^5.5.0",
+    "fastify-plugin": "^5.0.1",
+    "handlebars": "^4.7.8",
+    "imapflow": "^1.1.1",
+    "jsonwebtoken": "^9.0.2",
+    "mailparser": "^3.9.0",
+    "nodemailer": "^7.0.6",
+    "openai": "^6.10.0",
+    "pdf-lib": "^1.17.1",
+    "pg": "^8.16.3",
+    "pngjs": "^7.0.0",
+    "sharp": "^0.34.5",
+    "xmlbuilder": "^15.1.1",
+    "zpl-image": "^0.2.0",
+    "zpl-renderer-js": "^2.0.2"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^6.0.0",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^24.3.0",
+    "drizzle-kit": "^0.31.8",
+    "prisma": "^6.15.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2"
+  }
+}

backend/scripts/generate-schema-index.ts

@@ -0,0 +1,16 @@
+import fs from "node:fs"
+import path from "node:path"
+
+const schemaDir = path.resolve("db/schema")
+const indexFile = path.join(schemaDir, "index.ts")
+
+const files = fs
+    .readdirSync(schemaDir)
+    .filter((f) => f.endsWith(".ts") && f !== "index.ts")
+
+const exportsToWrite = files
+    .map((f) => `export * from "./${f.replace(".ts", "")}"`)
+    .join("\n")
+
+fs.writeFileSync(indexFile, exportsToWrite)
+console.log("✓ schema/index.ts generated")

backend/src/index.ts

@@ -0,0 +1,167 @@
+import Fastify from "fastify";
+import swaggerPlugin from "./plugins/swagger"
+import supabasePlugin from "./plugins/supabase";
+import dayjsPlugin from "./plugins/dayjs";
+import healthRoutes from "./routes/health";
+import meRoutes from "./routes/auth/me";
+import tenantRoutes from "./routes/tenant";
+import tenantPlugin from "./plugins/tenant";
+import authRoutes from "./routes/auth/auth";
+import authRoutesAuthenticated from "./routes/auth/auth-authenticated";
+import authPlugin from "./plugins/auth";
+import adminRoutes from "./routes/admin";
+import corsPlugin from "./plugins/cors";
+import queryConfigPlugin from "./plugins/queryconfig";
+import dbPlugin from "./plugins/db";
+import resourceRoutesSpecial from "./routes/resourcesSpecial";
+import fastifyCookie from "@fastify/cookie";
+import historyRoutes from "./routes/history";
+import fileRoutes from "./routes/files";
+import functionRoutes from "./routes/functions";
+import bankingRoutes from "./routes/banking";
+import exportRoutes from "./routes/exports"
+import emailAsUserRoutes from "./routes/emailAsUser";
+import authProfilesRoutes from "./routes/profiles";
+import helpdeskRoutes from "./routes/helpdesk";
+import helpdeskInboundRoutes from "./routes/helpdesk.inbound";
+import notificationsRoutes from "./routes/notifications";
+import staffTimeRoutes from "./routes/staff/time";
+import staffTimeConnectRoutes from "./routes/staff/timeconnects";
+import userRoutes from "./routes/auth/user";
+import publiclinksAuthenticatedRoutes from "./routes/publiclinks/publiclinks-authenticated";
+
+//Public Links
+import publiclinksNonAuthenticatedRoutes from "./routes/publiclinks/publiclinks-non-authenticated";
+
+//Resources
+import resourceRoutes from "./routes/resources/main";
+
+//M2M
+import authM2m from "./plugins/auth.m2m";
+import helpdeskInboundEmailRoutes from "./routes/helpdesk.inbound.email";
+import deviceRoutes from "./routes/internal/devices";
+import tenantRoutesInternal from "./routes/internal/tenant";
+import staffTimeRoutesInternal from "./routes/internal/time";
+
+//Devices
+import devicesRFIDRoutes from "./routes/devices/rfid";
+
+
+import {sendMail} from "./utils/mailer";
+import {loadSecrets, secrets} from "./utils/secrets";
+import {initMailer} from "./utils/mailer"
+import {initS3} from "./utils/s3";
+
+//Services
+import servicesPlugin from "./plugins/services";
+
+async function main() {
+    const app = Fastify({ logger: false });
+    await loadSecrets();
+    await initMailer();
+    await initS3();
+
+
+
+    /*app.addHook("onRequest", (req, reply, done) => {
+        console.log("Incoming:", req.method, req.url, "Headers:", req.headers)
+        done()
+    })*/
+
+    // Plugins Global verfügbar
+    await app.register(swaggerPlugin);
+    await app.register(corsPlugin);
+    await app.register(supabasePlugin);
+    await app.register(tenantPlugin);
+    await app.register(dayjsPlugin);
+    await app.register(dbPlugin);
+    await app.register(servicesPlugin);
+
+    app.addHook('preHandler', (req, reply, done) => {
+        console.log(req.method)
+        console.log('Matched path:', req.routeOptions.url)
+        console.log('Exact URL:', req.url)
+        done()
+    })
+
+    app.get('/health', async (req, res) => {
+        return res.send({ status: 'ok' })
+    })
+
+    //Plugin nur auf bestimmten Routes
+    await app.register(queryConfigPlugin, {
+        routes: ['/api/resource/:resource/paginated']
+    })
+
+    app.register(fastifyCookie, {
+        secret: secrets.COOKIE_SECRET,
+    })
+    // Öffentliche Routes
+    await app.register(authRoutes);
+    await app.register(healthRoutes);
+
+    await app.register(helpdeskInboundRoutes);
+
+    await app.register(publiclinksNonAuthenticatedRoutes)
+
+
+    await app.register(async (m2mApp) => {
+        await m2mApp.register(authM2m)
+        await m2mApp.register(helpdeskInboundEmailRoutes)
+        await m2mApp.register(deviceRoutes)
+        await m2mApp.register(tenantRoutesInternal)
+        await m2mApp.register(staffTimeRoutesInternal)
+    },{prefix: "/internal"})
+
+    await app.register(async (devicesApp) => {
+        await devicesApp.register(devicesRFIDRoutes)
+    },{prefix: "/devices"})
+
+
+    //Geschützte Routes
+
+    await app.register(async (subApp) => {
+        await subApp.register(authPlugin);
+        await subApp.register(authRoutesAuthenticated);
+        await subApp.register(meRoutes);
+        await subApp.register(tenantRoutes);
+        await subApp.register(adminRoutes);
+        await subApp.register(resourceRoutesSpecial);
+        await subApp.register(historyRoutes);
+        await subApp.register(fileRoutes);
+        await subApp.register(functionRoutes);
+        await subApp.register(bankingRoutes);
+        await subApp.register(exportRoutes);
+        await subApp.register(emailAsUserRoutes);
+        await subApp.register(authProfilesRoutes);
+        await subApp.register(helpdeskRoutes);
+        await subApp.register(notificationsRoutes);
+        await subApp.register(staffTimeRoutes);
+        await subApp.register(staffTimeConnectRoutes);
+        await subApp.register(userRoutes);
+        await subApp.register(publiclinksAuthenticatedRoutes);
+        await subApp.register(resourceRoutes);
+
+    },{prefix: "/api"})
+
+    app.ready(async () => {
+        try {
+            console.log("Testing DB Connection:")
+            const result = await app.db.execute("SELECT NOW()");
+            console.log("✓ DB connection OK: " + JSON.stringify(result.rows[0]));
+        } catch (err) {
+            console.log("❌ DB connection failed:", err);
+        }
+    });
+
+    // Start
+    try {
+        await app.listen({ port: secrets.PORT, host: secrets.HOST });
+        console.log(`🚀 Server läuft auf http://${secrets.HOST}:${secrets.PORT}`);
+    } catch (err) {
+        app.log.error(err);
+        process.exit(1);
+    }
+}
+
+main();

backend/src/modules/cron/bankstatementsync.service.ts

@@ -0,0 +1,253 @@
+// /services/bankStatementService.ts
+import axios from "axios"
+import dayjs from "dayjs"
+import utc from "dayjs/plugin/utc.js"
+import {secrets} from "../../utils/secrets"
+import {FastifyInstance} from "fastify"
+
+// Drizzle imports
+import {
+    bankaccounts,
+    bankstatements,
+} from "../../../db/schema"
+
+import {
+    eq,
+    and,
+    isNull,
+} from "drizzle-orm"
+
+dayjs.extend(utc)
+
+interface BalanceAmount {
+    amount: string
+    currency: string
+}
+
+interface BookedTransaction {
+    bookingDate: string
+    valueDate: string
+    internalTransactionId: string
+    transactionAmount: { amount: string; currency: string }
+
+    creditorAccount?: { iban?: string }
+    creditorName?: string
+
+    debtorAccount?: { iban?: string }
+    debtorName?: string
+
+    remittanceInformationUnstructured?: string
+    remittanceInformationStructured?: string
+    remittanceInformationStructuredArray?: string[]
+    additionalInformation?: string
+}
+
+interface TransactionsResponse {
+    transactions: {
+        booked: BookedTransaction[]
+    }
+}
+
+const normalizeDate = (val: any) => {
+    if (!val) return null
+    const d = new Date(val)
+    return isNaN(d.getTime()) ? null : d
+}
+
+export function bankStatementService(server: FastifyInstance) {
+
+    let accessToken: string | null = null
+
+    // -----------------------------------------------
+    // ✔ TOKEN LADEN
+    // -----------------------------------------------
+    const getToken = async () => {
+        console.log("Fetching GoCardless token…")
+
+        const response = await axios.post(
+            `${secrets.GOCARDLESS_BASE_URL}/token/new/`,
+            {
+                secret_id: secrets.GOCARDLESS_SECRET_ID,
+                secret_key: secrets.GOCARDLESS_SECRET_KEY,
+            }
+        )
+
+        accessToken = response.data.access
+    }
+
+    // -----------------------------------------------
+    // ✔ Salden laden
+    // -----------------------------------------------
+    const getBalanceData = async (accountId: string): Promise<any | false> => {
+        try {
+            const {data} = await axios.get(
+                `${secrets.GOCARDLESS_BASE_URL}/accounts/${accountId}/balances`,
+                {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                        Accept: "application/json",
+                    },
+                }
+            )
+
+            return data
+        } catch (err: any) {
+            server.log.error(err.response?.data ?? err)
+
+            const expired =
+                err.response?.data?.summary?.includes("expired") ||
+                err.response?.data?.detail?.includes("expired")
+
+            if (expired) {
+                await server.db
+                    .update(bankaccounts)
+                    .set({expired: true})
+                    .where(eq(bankaccounts.accountId, accountId))
+            }
+
+            return false
+        }
+    }
+
+    // -----------------------------------------------
+    // ✔ Transaktionen laden
+    // -----------------------------------------------
+    const getTransactionData = async (accountId: string) => {
+        try {
+            const {data} = await axios.get<TransactionsResponse>(
+                `${secrets.GOCARDLESS_BASE_URL}/accounts/${accountId}/transactions`,
+                {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                        Accept: "application/json",
+                    },
+                }
+            )
+
+            return data.transactions.booked
+        } catch (err: any) {
+            server.log.error(err.response?.data ?? err)
+            return null
+        }
+    }
+
+    // -----------------------------------------------
+    // ✔ Haupt-Sync-Prozess
+    // -----------------------------------------------
+    const syncAccounts = async (tenantId:number) => {
+        try {
+            console.log("Starting account sync…")
+
+            // 🟦 DB: Aktive Accounts
+            const accounts = await server.db
+                .select()
+                .from(bankaccounts)
+                .where(and(eq(bankaccounts.expired, false),eq(bankaccounts.tenant, tenantId)))
+
+            if (!accounts.length) return
+
+            const allNewTransactions: any[] = []
+
+            for (const account of accounts) {
+
+                // ---------------------------
+                // 1. BALANCE SYNC
+                // ---------------------------
+                const balData = await getBalanceData(account.accountId)
+
+                if (balData === false) break
+
+                if (balData) {
+                    const closing = balData.balances.find(
+                        (i: any) => i.balanceType === "closingBooked"
+                    )
+
+                    const bookedBal = Number(closing.balanceAmount.amount)
+
+                    await server.db
+                        .update(bankaccounts)
+                        .set({balance: bookedBal})
+                        .where(eq(bankaccounts.id, account.id))
+                }
+
+                // ---------------------------
+                // 2. TRANSACTIONS
+                // ---------------------------
+                let transactions = await getTransactionData(account.accountId)
+                if (!transactions) continue
+
+                //@ts-ignore
+                transactions = transactions.map((item) => ({
+                    account: account.id,
+                    date: normalizeDate(item.bookingDate),
+                    credIban: item.creditorAccount?.iban ?? null,
+                    credName: item.creditorName ?? null,
+                    text: `
+                        ${item.remittanceInformationUnstructured ?? ""}
+                        ${item.remittanceInformationStructured ?? ""}
+                        ${item.additionalInformation ?? ""}
+                        ${item.remittanceInformationStructuredArray?.join("") ?? ""}
+                    `.trim(),
+                    amount: Number(item.transactionAmount.amount),
+                    tenant: account.tenant,
+                    debIban: item.debtorAccount?.iban ?? null,
+                    debName: item.debtorName ?? null,
+                    gocardlessId: item.internalTransactionId,
+                    currency: item.transactionAmount.currency,
+                    valueDate: normalizeDate(item.valueDate),
+                }))
+
+                // Existierende Statements laden
+                const existing = await server.db
+                    .select({gocardlessId: bankstatements.gocardlessId})
+                    .from(bankstatements)
+                    .where(eq(bankstatements.tenant, account.tenant))
+
+                const filtered = transactions.filter(
+                    //@ts-ignore
+                    (tx) => !existing.some((x) => x.gocardlessId === tx.gocardlessId)
+                )
+
+                allNewTransactions.push(...filtered)
+            }
+
+            // ---------------------------
+            // 3. NEW TRANSACTIONS → DB
+            // ---------------------------
+            if (allNewTransactions.length > 0) {
+                await server.db.insert(bankstatements).values(allNewTransactions)
+
+                const affectedAccounts = [
+                    ...new Set(allNewTransactions.map((t) => t.account)),
+                ]
+
+                const normalizeDate = (val: any) => {
+                    if (!val) return null
+                    const d = new Date(val)
+                    return isNaN(d.getTime()) ? null : d
+                }
+
+                for (const accId of affectedAccounts) {
+                    await server.db
+                        .update(bankaccounts)
+                        //@ts-ignore
+                        .set({syncedAt: normalizeDate(dayjs())})
+                        .where(eq(bankaccounts.id, accId))
+                }
+            }
+
+            console.log("Bank statement sync completed.")
+        } catch (error) {
+            console.error(error)
+        }
+
+    }
+
+    return {
+        run: async (tenant) => {
+            await getToken()
+            await syncAccounts(tenant)
+            console.log("Service: Bankstatement sync finished")
+        }
+    }
+}

backend/src/modules/cron/dokuboximport.service.ts

@@ -0,0 +1,259 @@
+import axios from "axios"
+import dayjs from "dayjs"
+import { ImapFlow } from "imapflow"
+import { simpleParser } from "mailparser"
+import { FastifyInstance } from "fastify"
+
+import {saveFile} from "../../utils/files";
+import { secrets } from "../../utils/secrets"
+
+// Drizzle Imports
+import {
+    tenants,
+    folders,
+    filetags,
+} from "../../../db/schema"
+
+import {
+    eq,
+    and,
+} from "drizzle-orm"
+
+let badMessageDetected = false
+let badMessageMessageSent = false
+
+let client: ImapFlow | null = null
+
+// -------------------------------------------------------------
+// IMAP CLIENT INITIALIZEN
+// -------------------------------------------------------------
+export async function initDokuboxClient() {
+    client = new ImapFlow({
+        host: secrets.DOKUBOX_IMAP_HOST,
+        port: secrets.DOKUBOX_IMAP_PORT,
+        secure: secrets.DOKUBOX_IMAP_SECURE,
+        auth: {
+            user: secrets.DOKUBOX_IMAP_USER,
+            pass: secrets.DOKUBOX_IMAP_PASSWORD
+        },
+        logger: false
+    })
+
+    console.log("Dokubox E-Mail Client Initialized")
+
+    await client.connect()
+}
+
+
+
+// -------------------------------------------------------------
+// MAIN SYNC FUNCTION (DRIZZLE VERSION)
+// -------------------------------------------------------------
+export const syncDokubox = (server: FastifyInstance) =>
+    async () => {
+
+        console.log("Perform Dokubox Sync")
+
+        await initDokuboxClient()
+
+        if (!client?.usable) {
+            throw new Error("E-Mail Client not usable")
+        }
+
+        // -------------------------------
+        // TENANTS LADEN (DRIZZLE)
+        // -------------------------------
+        const tenantList = await server.db
+            .select({
+                id: tenants.id,
+                name: tenants.name,
+                emailAddresses: tenants.dokuboxEmailAddresses,
+                key: tenants.dokuboxkey
+            })
+            .from(tenants)
+
+        const lock = await client.getMailboxLock("INBOX")
+
+        try {
+
+            for await (let msg of client.fetch({ seen: false }, { envelope: true, source: true })) {
+
+                const parsed = await simpleParser(msg.source)
+
+                const message = {
+                    id: msg.uid,
+                    subject: parsed.subject,
+                    to: parsed.to?.value || [],
+                    cc: parsed.cc?.value || [],
+                    attachments: parsed.attachments || []
+                }
+
+                // -------------------------------------------------
+                // MAPPING / FIND TENANT
+                // -------------------------------------------------
+                const config = await getMessageConfigDrizzle(server, message, tenantList)
+
+                if (!config) {
+                    badMessageDetected = true
+
+                    if (!badMessageMessageSent) {
+                        badMessageMessageSent = true
+                    }
+                    return
+                }
+
+                if (message.attachments.length > 0) {
+                    for (const attachment of message.attachments) {
+                        await saveFile(
+                            server,
+                            config.tenant,
+                            message.id,
+                            attachment,
+                            config.folder,
+                            config.filetype
+                        )
+                    }
+                }
+            }
+
+            if (!badMessageDetected) {
+                badMessageDetected = false
+                badMessageMessageSent = false
+            }
+
+            await client.messageFlagsAdd({ seen: false }, ["\\Seen"])
+            await client.messageDelete({ seen: true })
+
+        } finally {
+            lock.release()
+            client.close()
+        }
+    }
+
+
+
+// -------------------------------------------------------------
+// TENANT ERKENNEN + FOLDER/FILETYPES (DRIZZLE VERSION)
+// -------------------------------------------------------------
+const getMessageConfigDrizzle = async (
+    server: FastifyInstance,
+    message,
+    tenantsList: any[]
+) => {
+
+    let possibleKeys: string[] = []
+
+    if (message.to) {
+        message.to.forEach((item) =>
+            possibleKeys.push(item.address.split("@")[0].toLowerCase())
+        )
+    }
+
+    if (message.cc) {
+        message.cc.forEach((item) =>
+            possibleKeys.push(item.address.split("@")[0].toLowerCase())
+        )
+    }
+
+    // -------------------------------------------
+    // TENANT IDENTIFY
+    // -------------------------------------------
+    let tenant = tenantsList.find((t) => possibleKeys.includes(t.key))
+
+    if (!tenant && message.to?.length) {
+        const address = message.to[0].address.toLowerCase()
+
+        tenant = tenantsList.find((t) =>
+            (t.emailAddresses || []).map((m) => m.toLowerCase()).includes(address)
+        )
+    }
+
+    if (!tenant) return null
+
+    // -------------------------------------------
+    // FOLDER + FILETYPE VIA SUBJECT
+    // -------------------------------------------
+    let folderId = null
+    let filetypeId = null
+
+    // -------------------------------------------
+    // Rechnung / Invoice
+    // -------------------------------------------
+    if (message.subject?.match(/(Rechnung|Beleg|Invoice|Quittung)/gi)) {
+
+        const folder = await server.db
+            .select({ id: folders.id })
+            .from(folders)
+            .where(
+                and(
+                    eq(folders.tenant, tenant.id),
+                    and(
+                    eq(folders.function, "incomingInvoices"),
+                    //@ts-ignore
+                    eq(folders.year, dayjs().format("YYYY"))
+                    )
+                )
+            )
+            .limit(1)
+
+        folderId = folder[0]?.id ?? null
+
+        const tag = await server.db
+            .select({ id: filetags.id })
+            .from(filetags)
+            .where(
+                and(
+                    eq(filetags.tenant, tenant.id),
+                    eq(filetags.incomingDocumentType, "invoices")
+                )
+            )
+            .limit(1)
+
+        filetypeId = tag[0]?.id ?? null
+    }
+
+        // -------------------------------------------
+        // Mahnung
+    // -------------------------------------------
+    else if (message.subject?.match(/(Mahnung|Zahlungsaufforderung|Zahlungsverzug)/gi)) {
+
+        const tag = await server.db
+            .select({ id: filetags.id })
+            .from(filetags)
+            .where(
+                and(
+                    eq(filetags.tenant, tenant.id),
+                    eq(filetags.incomingDocumentType, "reminders")
+                )
+            )
+            .limit(1)
+
+        filetypeId = tag[0]?.id ?? null
+    }
+
+        // -------------------------------------------
+        // Sonstige Dokumente → Deposit Folder
+    // -------------------------------------------
+    else {
+
+        const folder = await server.db
+            .select({ id: folders.id })
+            .from(folders)
+            .where(
+                and(
+                    eq(folders.tenant, tenant.id),
+                    eq(folders.function, "deposit")
+                )
+            )
+            .limit(1)
+
+        folderId = folder[0]?.id ?? null
+    }
+
+
+    return {
+        tenant: tenant.id,
+        folder: folderId,
+        filetype: filetypeId
+    }
+}

backend/src/modules/cron/prepareIncomingInvoices.ts

@@ -0,0 +1,175 @@
+import { FastifyInstance } from "fastify"
+import dayjs from "dayjs"
+import { getInvoiceDataFromGPT } from "../../utils/gpt"
+
+// Drizzle schema
+import {
+    tenants,
+    files,
+    filetags,
+    incominginvoices,
+} from "../../../db/schema"
+
+import { eq, and, isNull, not } from "drizzle-orm"
+
+export function prepareIncomingInvoices(server: FastifyInstance) {
+    const processInvoices = async (tenantId:number) => {
+        console.log("▶ Starting Incoming Invoice Preparation")
+
+        const tenantsRes = await server.db
+            .select()
+            .from(tenants)
+            .where(eq(tenants.id, tenantId))
+            .orderBy(tenants.id)
+
+        if (!tenantsRes.length) {
+            console.log("No tenants with autoPrepareIncomingInvoices = true")
+            return
+        }
+
+        console.log(`Processing tenants: ${tenantsRes.map(t => t.id).join(", ")}`)
+
+        // -------------------------------------------------------------
+        // 2️⃣ Jeden Tenant einzeln verarbeiten
+        // -------------------------------------------------------------
+        for (const tenant of tenantsRes) {
+            const tenantId = tenant.id
+
+            // 2.1 Datei-Tags holen für incoming invoices
+            const tagRes = await server.db
+                .select()
+                .from(filetags)
+                .where(
+                    and(
+                        eq(filetags.tenant, tenantId),
+                        eq(filetags.incomingDocumentType, "invoices")
+                    )
+                )
+                .limit(1)
+
+            const invoiceFileTag = tagRes?.[0]?.id
+            if (!invoiceFileTag) {
+                server.log.error(`❌ Missing filetag 'invoices' for tenant ${tenantId}`)
+                continue
+            }
+
+            // 2.2 Alle Dateien laden, die als Invoice markiert sind aber NOCH keine incominginvoice haben
+            const filesRes = await server.db
+                .select()
+                .from(files)
+                .where(
+                    and(
+                        eq(files.tenant, tenantId),
+                        eq(files.type, invoiceFileTag),
+                        isNull(files.incominginvoice),
+                        eq(files.archived, false),
+                        not(isNull(files.path))
+                    )
+                )
+
+            if (!filesRes.length) {
+                console.log(`No invoice files for tenant ${tenantId}`)
+                continue
+            }
+
+            // -------------------------------------------------------------
+            // 3️⃣ Jede Datei einzeln durch GPT jagen & IncomingInvoice erzeugen
+            // -------------------------------------------------------------
+            for (const file of filesRes) {
+                console.log(`Processing file ${file.id} for tenant ${tenantId}`)
+
+                const data = await getInvoiceDataFromGPT(server,file, tenantId)
+
+                if (!data) {
+                    server.log.warn(`GPT returned no data for file ${file.id}`)
+                    continue
+                }
+
+                // ---------------------------------------------------------
+                // 3.1 IncomingInvoice-Objekt vorbereiten
+                // ---------------------------------------------------------
+                let itemInfo: any = {
+                    tenant: tenantId,
+                    state: "Vorbereitet"
+                }
+
+                if (data.invoice_number) itemInfo.reference = data.invoice_number
+                if (data.invoice_date) itemInfo.date = dayjs(data.invoice_date).toISOString()
+                if (data.issuer?.id) itemInfo.vendor = data.issuer.id
+                if (data.invoice_duedate) itemInfo.dueDate = dayjs(data.invoice_duedate).toISOString()
+
+                // Payment terms mapping
+                const mapPayment: any = {
+                    "Direct Debit": "Einzug",
+                    "Transfer": "Überweisung",
+                    "Credit Card": "Kreditkarte",
+                    "Other": "Sonstiges",
+                }
+                if (data.terms) itemInfo.paymentType = mapPayment[data.terms] ?? data.terms
+
+                // 3.2 Positionszeilen konvertieren
+                if (data.invoice_items?.length > 0) {
+                    itemInfo.accounts = data.invoice_items.map(item => ({
+                        account: item.account_id,
+                        description: item.description,
+                        amountNet: item.total_without_tax,
+                        amountTax: Number((item.total - item.total_without_tax).toFixed(2)),
+                        taxType: String(item.tax_rate),
+                        amountGross: item.total,
+                        costCentre: null,
+                        quantity: item.quantity,
+                    }))
+                }
+
+                // 3.3 Beschreibung generieren
+                let description = ""
+                if (data.delivery_note_number) description += `Lieferschein: ${data.delivery_note_number}\n`
+                if (data.reference) description += `Referenz: ${data.reference}\n`
+                if (data.invoice_items) {
+                    for (const item of data.invoice_items) {
+                        description += `${item.description} - ${item.quantity} ${item.unit} - ${item.total}\n`
+                    }
+                }
+                itemInfo.description = description.trim()
+
+                // ---------------------------------------------------------
+                // 4️⃣ IncomingInvoice erstellen
+                // ---------------------------------------------------------
+                const inserted = await server.db
+                    .insert(incominginvoices)
+                    .values(itemInfo)
+                    .returning()
+
+                const newInvoice = inserted?.[0]
+
+                if (!newInvoice) {
+                    server.log.error(`Failed to insert incoming invoice for file ${file.id}`)
+                    continue
+                }
+
+                // ---------------------------------------------------------
+                // 5️⃣ Datei mit incominginvoice-ID verbinden
+                // ---------------------------------------------------------
+                await server.db
+                    .update(files)
+                    .set({ incominginvoice: newInvoice.id })
+                    .where(eq(files.id, file.id))
+
+                console.log(`IncomingInvoice ${newInvoice.id} created for file ${file.id}`)
+            }
+
+        }
+
+
+        return
+    }
+
+    return {
+        run: async (tenant:number) => {
+            await processInvoices(tenant)
+            console.log("Incoming Invoice Preparation Completed.")
+
+        }
+    }
+
+}

backend/src/modules/helpdesk/helpdesk.contact.service.ts

@@ -0,0 +1,38 @@
+// modules/helpdesk/helpdesk.contact.service.ts
+import { FastifyInstance } from 'fastify'
+
+export async function getOrCreateContact(
+    server: FastifyInstance,
+    tenant_id: number,
+    { email, phone, display_name, customer_id, contact_id }: { email?: string; phone?: string; display_name?: string; customer_id?: number; contact_id?: number }
+) {
+    if (!email && !phone) throw new Error('Contact must have at least an email or phone')
+
+    // Bestehenden Kontakt prüfen
+    const { data: existing, error: findError } = await server.supabase
+        .from('helpdesk_contacts')
+        .select('*')
+        .eq('tenant_id', tenant_id)
+        .or(`email.eq.${email || ''},phone.eq.${phone || ''}`)
+        .maybeSingle()
+
+    if (findError) throw findError
+    if (existing) return existing
+
+    // Anlegen
+    const { data: created, error: insertError } = await server.supabase
+        .from('helpdesk_contacts')
+        .insert({
+            tenant_id,
+            email,
+            phone,
+            display_name,
+            customer_id,
+            contact_id
+        })
+        .select()
+        .single()
+
+    if (insertError) throw insertError
+    return created
+}

backend/src/modules/helpdesk/helpdesk.conversation.service.ts

@@ -0,0 +1,90 @@
+// modules/helpdesk/helpdesk.conversation.service.ts
+import { FastifyInstance } from 'fastify'
+import { getOrCreateContact } from './helpdesk.contact.service.js'
+import {useNextNumberRangeNumber} from "../../utils/functions";
+
+export async function createConversation(
+    server: FastifyInstance,
+    {
+        tenant_id,
+        contact,
+        channel_instance_id,
+        subject,
+        customer_id = null,
+        contact_person_id = null,
+    }: {
+        tenant_id: number
+        contact: { email?: string; phone?: string; display_name?: string }
+        channel_instance_id: string
+        subject?: string,
+        customer_id?: number,
+        contact_person_id?: number
+    }
+) {
+    const contactRecord = await getOrCreateContact(server, tenant_id, contact)
+
+    const {usedNumber } = await useNextNumberRangeNumber(server, tenant_id, "tickets")
+
+    const { data, error } = await server.supabase
+        .from('helpdesk_conversations')
+        .insert({
+            tenant_id,
+            contact_id: contactRecord.id,
+            channel_instance_id,
+            subject: subject || null,
+            status: 'open',
+            created_at: new Date().toISOString(),
+            customer_id,
+            contact_person_id,
+            ticket_number: usedNumber
+        })
+        .select()
+        .single()
+
+    if (error) throw error
+    return data
+}
+
+export async function getConversations(
+    server: FastifyInstance,
+    tenant_id: number,
+    opts?: { status?: string; limit?: number }
+) {
+    const { status, limit = 50 } = opts || {}
+
+    let query = server.supabase.from('helpdesk_conversations').select('*, customer_id(*)').eq('tenant_id', tenant_id)
+
+    if (status) query = query.eq('status', status)
+    query = query.order('last_message_at', { ascending: false }).limit(limit)
+
+    const { data, error } = await query
+    if (error) throw error
+
+    const mappedData = data.map(entry => {
+        return {
+            ...entry,
+            customer: entry.customer_id
+        }
+    })
+
+    return mappedData
+}
+
+export async function updateConversationStatus(
+    server: FastifyInstance,
+    conversation_id: string,
+    status: string
+) {
+    const valid = ['open', 'in_progress', 'waiting_for_customer', 'answered', 'closed']
+    if (!valid.includes(status)) throw new Error('Invalid status')
+
+    const { data, error } = await server.supabase
+        .from('helpdesk_conversations')
+        .update({ status })
+        .eq('id', conversation_id)
+        .select()
+        .single()
+
+    if (error) throw error
+    return data
+}

backend/src/modules/helpdesk/helpdesk.message.service.ts

@@ -0,0 +1,60 @@
+// modules/helpdesk/helpdesk.message.service.ts
+import { FastifyInstance } from 'fastify'
+
+export async function addMessage(
+    server: FastifyInstance,
+    {
+        tenant_id,
+        conversation_id,
+        author_user_id = null,
+        direction = 'incoming',
+        payload,
+        raw_meta = null,
+        external_message_id = null,
+    }: {
+        tenant_id: number
+        conversation_id: string
+        author_user_id?: string | null
+        direction?: 'incoming' | 'outgoing' | 'internal' | 'system'
+        payload: any
+        raw_meta?: any
+        external_message_id?: string
+    }
+) {
+    if (!payload?.text) throw new Error('Message payload requires text content')
+
+    const { data: message, error } = await server.supabase
+        .from('helpdesk_messages')
+        .insert({
+            tenant_id,
+            conversation_id,
+            author_user_id,
+            direction,
+            payload,
+            raw_meta,
+            created_at: new Date().toISOString(),
+        })
+        .select()
+        .single()
+
+    if (error) throw error
+
+    // Letzte Nachricht aktualisieren
+    await server.supabase
+        .from('helpdesk_conversations')
+        .update({ last_message_at: new Date().toISOString() })
+        .eq('id', conversation_id)
+
+    return message
+}
+
+export async function getMessages(server: FastifyInstance, conversation_id: string) {
+    const { data, error } = await server.supabase
+        .from('helpdesk_messages')
+        .select('*')
+        .eq('conversation_id', conversation_id)
+        .order('created_at', { ascending: true })
+
+    if (error) throw error
+    return data
+}