wiki/implementation/rbac_access_umsetzungskonzept done.md

Umsetzungskonzept RBAC Access (separat, schrittweise)

Ziel

Das RBAC-Konzept aus concept_rbac_access_pending.md technisch umsetzen, inkl.:

• Feature-Containerisierung (plug&play)
• Bootstrap auf System-RBAC reduzieren
• Feature-Services in Container integrieren
• aicore in aichat integrieren
• dynamisches Laden von Routes und Services
• striktes Import-Regelwerk ohne Abhaengigkeiten zwischen Feature-Containern

Import-Regelwerk (Zielzustand)

• Kein Import zwischen Feature-Containern.
• Feature-Container duerfen zentrale Module importieren (modules/interfaces, modules/datamodels, modules/services, modules/aicore, modules/shared, modules/connectors, modules/security, modules/auth).
• Umgekehrt darf zentraler Code keine Feature-Container importieren.

Wichtige konzeptionelle und architektonische Hinweise

• Jeder Feature-Container ist vollstaendig eigenstaendig (Code, Datamodelle, Interfaces, Routes, Services), darf aber zentrale Module nutzen.
• Zentrale Pfade bleiben Plattform-Schnittstellen und duerfen von Features genutzt werden; umgekehrt keine Feature-Imports aus zentralem Code.
• System-RBAC und Feature-RBAC sind strikt getrennt: Bootstrap initialisiert nur System-RBAC, Feature-RBAC entsteht durch Feature-Container.
• Der RBAC-Katalog fuer UI/RESOURCE liegt in gateway/modules/security/rbacCatalog/ und ist persistent; Feature-Container muessen nur registrieren, nicht speichern.
• UI/RESOURCE-Objekte werden rein im Backend definiert und persistiert, keine UI-Abhaengigkeit.
• Datenobjekte werden dynamisch abgeleitet, sind aber nicht auf Features beschraenkt (System- und Feature-Tabellen sind sichtbar).
• Strikte Importregel erzeugt harte Grenzen: Shared-Module muessen in den Feature-Container verschoben oder repliziert werden.
• Zentraler Workflow (geplant unter gateway/modules/workflows/automation/) darf aus Features nicht direkt importiert werden; Zugriff nur ueber feature-interne Adapter/Entry-Points oder durch Verlagerung der benoetigten Teile in die Feature-Container.

Schrittfolge mit Dateiaenderungen und Referenz-Checkliste

Schritt 1: Bootstrap auf System-RBAC reduzieren

Datei: gateway/modules/interfaces/interfaceBootstrap.py

• Entfernen in initBootstrap():
  • initFeatures(db)
  • _initFeatureTemplateRoleAccessRules(db)
• Entfernen:
  • _initFeatureTemplateRoles(db) (Funktion + Call-Sites)
  • _initFeatureTemplateRoleAccessRules(db) (Funktion + Call-Sites)
• Beibehalten: initRoles(db), initRbacRules(db)
• Checkliste Referenzen:
  • Keine Feature-Initialisierung in Bootstrap
  • Keine Feature-Template-Rollen
  • Keine Feature-Template-AccessRules

Schritt 2: Feature-Container-Struktur anlegen

Neue Ordner:

• gateway/modules/features/trustee/
• gateway/modules/features/chatbot/ (existiert)
• gateway/modules/features/aichat/ (neu)
• gateway/modules/features/neutralizer/ (rename)
• gateway/modules/features/realestate/ (neu)
• gateway/modules/features/automation/ (neu)

Pflichtdateien je Feature:

• datamodelFeatureXxx.py
• interfaceFeatureXxx.py
• routeFeatureXxx.py
• mainXxx.py (RBAC UI/RESOURCE Registry)

Struktur-Vorgaben (Soll):

• Jeder Container enthaelt alle benoetigten Submodule, inkl. Services und Helfer.
• Zentrale Module duerfen genutzt werden; keine Feature-zu-Feature-Imports.
• Service-Subfolder bleiben erhalten, liegen aber direkt im Container (serviceXxx/).

Calling-Referenzen (allgemein):

• gateway/app.py registriert alle Feature-Router dynamisch.
• Feature-Container registrieren ihre RBAC-Objekte im Katalog (z.B. via mainXxx.py als Entry-Point).
• Systemcode greift nicht auf Feature-Implementierung zu, sondern nur auf deren registrierte Router/Services.

Schritt 3: Trustee verschieben

Move:

• gateway/modules/routes/routeFeatureTrustee.py -> gateway/modules/features/trustee/routeFeatureTrustee.py
• gateway/modules/interfaces/interfaceDbTrustee.py -> gateway/modules/features/trustee/interfaceFeatureTrustee.py
• gateway/modules/datamodels/datamodelTrustee.py -> gateway/modules/features/trustee/datamodelFeatureTrustee.py Add:
• gateway/modules/features/trustee/mainTrustee.py (RBAC Katalog)

Referenzen anpassen (Checkliste):

• Alle Imports auf routeFeatureTrustee.py neu
• Alle Imports auf interfaceDbTrustee.py neu
• Alle Imports auf datamodelTrustee.py neu
• app.py Router-Registrierung auf neuen Pfad Calling-Referenzen (Suche):
• rg -n "routeFeatureTrustee|interfaceDbTrustee|datamodelTrustee" gateway/

Schritt 4: Chatbot verschieben

Move:

• gateway/modules/routes/routeFeatureChatbot.py -> gateway/modules/features/chatbot/routeFeatureChatbot.py
• gateway/modules/interfaces/interfaceDbChatbot.py -> gateway/modules/features/chatbot/interfaceFeatureChatbot.py
• gateway/modules/datamodels/datamodelChatbot.py -> gateway/modules/features/chatbot/datamodelFeatureChatbot.py Keep:
• gateway/modules/features/chatbot/mainChatbot.py + Helpers Add:
• gateway/modules/features/chatbot/mainChatbotCatalog.py (oder in mainChatbot)

Referenzen anpassen:

• Imports fuer interfaceDbChatbot/datamodelChatbot/routeFeatureChatbot
• app.py Router-Registrierung Calling-Referenzen (Suche):
• rg -n "routeFeatureChatbot|interfaceDbChatbot|datamodelChatbot" gateway/

Schritt 5: AIChat (chatworkflow) verschieben

Move:

• gateway/modules/routes/routeFeatureChatDynamic.py -> gateway/modules/features/aichat/routeFeatureAiChat.py
• gateway/modules/interfaces/interfaceDbChat.py -> gateway/modules/features/aichat/interfaceFeatureAiChat.py
• gateway/modules/datamodels/datamodelChat.py -> gateway/modules/features/aichat/datamodelFeatureAiChat.py Add:
• gateway/modules/features/aichat/mainAiChat.py (RBAC Katalog) Keep:
• gateway/modules/features/workflow/mainWorkflow.py (falls reine Workflow-Logik)

Referenzen anpassen:

• Alle Imports auf routeFeatureChatDynamic.py
• Alle Imports auf interfaceDbChat.py
• Alle Imports auf datamodelChat.py
• app.py Router-Registrierung Calling-Referenzen (Suche):
• rg -n "routeFeatureChatDynamic|interfaceDbChat|datamodelChat" gateway/

Schritt 6: Neutralizer verschieben und Ordner umbenennen

Rename:

• gateway/modules/features/neutralizePlayground/ -> gateway/modules/features/neutralizer/ Move:
• gateway/modules/routes/routeFeatureNeutralization.py -> gateway/modules/features/neutralizer/routeFeatureNeutralizer.py
• gateway/modules/datamodels/datamodelNeutralizer.py -> gateway/modules/features/neutralizer/datamodelFeatureNeutralizer.py Add:
• gateway/modules/features/neutralizer/mainNeutralizer.py (RBAC Katalog)

Referenzen anpassen:

• Alle Imports auf neutralizePlayground
• Alle Imports auf routeFeatureNeutralization.py
• app.py Router-Registrierung Calling-Referenzen (Suche):
• rg -n "neutralizePlayground|routeFeatureNeutralization|datamodelNeutralizer" gateway/

Schritt 7: RealEstate verschieben

Move:

• gateway/modules/routes/routeFeatureRealEstate.py -> gateway/modules/features/realestate/routeFeatureRealEstate.py
• gateway/modules/interfaces/interfaceDbRealestate.py -> gateway/modules/features/realestate/interfaceFeatureRealEstate.py
• gateway/modules/datamodels/datamodelRealEstate.py -> gateway/modules/features/realestate/datamodelFeatureRealEstate.py Keep:
• gateway/modules/features/realEstate/mainRealEstate.py Add:
• gateway/modules/features/realestate/mainRealEstateCatalog.py (oder in mainRealEstate)

Referenzen anpassen:

• Imports auf interfaceDbRealestate, datamodelRealEstate, routeFeatureRealEstate
• app.py Router-Registrierung Calling-Referenzen (Suche):
• rg -n "routeFeatureRealEstate|interfaceDbRealestate|datamodelRealEstate" gateway/

Schritt 8: Automation Feature-Container

Move:

• gateway/modules/routes/routeDataAutomation.py -> gateway/modules/features/automation/routeFeatureAutomation.py Add:
• gateway/modules/features/automation/interfaceFeatureAutomation.py
• gateway/modules/features/automation/datamodelFeatureAutomation.py
  • enthaelt AutomationDefinition
• gateway/modules/features/automation/mainAutomation.py (RBAC Katalog)

Referenzen anpassen:

• Alle Imports von routeDataAutomation.py
• Alle AutomationDefinition-Imports auf neuen Pfad
• app.py Router-Registrierung Calling-Referenzen (Suche):
• rg -n "routeDataAutomation|AutomationDefinition" gateway/

Schritt 9: Services in Feature-Container

aichat:

• Move:
  • gateway/modules/aicore/ -> gateway/modules/features/aichat/aicore/
  • gateway/modules/services/serviceAi/ -> gateway/modules/features/aichat/serviceAi/
  • gateway/modules/services/serviceExtraction/ -> gateway/modules/features/aichat/serviceExtraction/
  • gateway/modules/services/serviceGeneration/ -> gateway/modules/features/aichat/serviceGeneration/
  • gateway/modules/services/serviceWeb/ -> gateway/modules/features/aichat/serviceWeb/ neutralizer:
• Move:
  • gateway/modules/services/serviceNeutralization/ -> gateway/modules/features/neutralizer/serviceNeutralization/ Shared Services:
• bleiben in gateway/modules/services

Referenzen anpassen:

• Alle Imports der o.g. Services auf neue Pfade
• AI-Services duerfen keine Imports ausserhalb des aichat-Containers haben
• In Feature-Folders kein Subfolder services; Services liegen direkt als serviceXxx/ Calling-Referenzen (Suche):
• rg -n "modules\\.services\\.service(Ai|Extraction|Generation|Web)|modules\\.aicore" gateway/
• rg -n "serviceNeutralization" gateway/

Code-Struktur (Soll):

• Feature-Services importieren nur Feature-Datamodelle innerhalb des Containers.
• aicore wird komplett unter features/aichat/ verschoben und ist nur dort nutzbar.

Schritt 10: Plug&Play Router Loading

Datei: gateway/app.py

• Ersetze statische Imports aus modules/routes durch dynamische Feature-Discovery.
• Nur existierende Feature-Folder werden registriert.

Referenzen anpassen:

• Alle Router-Registrierungen neu
• Keine Route-Imports aus modules/routes

Konzept Router-Discovery (Soll):

• Scanne gateway/modules/features/*/ nach routeFeature*.py.
• Pro Datei wird ein router-Objekt erwartet und registriert.
• Fehlende Router in einem Feature duerfen den Start nicht abbrechen (log + skip).
• Feature-Status markieren: active, degraded (z.B. Router ok, Service-Load fehlschlaegt).

Schritt 11: Plug&Play Service Loading

Zentraler Loader (shared):

• Ein Service-Registry-Modul laedt pro Feature-Container definierte Services.
• Nur existierende Feature-Folder werden registriert.

Referenzen anpassen:

• Alle Service-Center-Aufrufe auf neuen Loader
• Kein direkter Import aus modules/services/serviceAi etc.

Konzept Service-Discovery (Soll):

• Pro Feature-Container werden vorhandene service*-Ordner als Services erkannt.
• Der Loader scannt gateway/modules/features/<feature>/service*/ und registriert diese Services zentral.
• Services werden nur geladen, wenn der Feature-Container vorhanden ist.
• Registrierungs-Contract analog modules/services/__init__.py:
  • In jedem service*-Ordner existiert mainService*.py mit Service-Klasse.
  • Loader instanziert Service und exponiert ihn via PublicService(...).

Schritt 12: featuresLifecycle anpassen

Datei: gateway/modules/features/featuresLifecycle.py

• Import der Workflow-Logik aus neuem zentralen Pfad (gateway/modules/workflows/automation/)
• Keine Imports von Feature-Containern

Bemerkung:

• Kein Feature-Discovery notwendig: Modul ist zentraler Scheduler fuer Workflow/Automation.
• Update der Imports: modules.features.workflow -> modules.workflows.automation (nach Auslagerung).
• Workflow-API ist zentral und stabil: Features duerfen nur explizite Entry-Points nutzen (z.B. syncAutomationEvents), keine direkten Imports in interne Workflow-Module.

Schritt 13: Globale Referenzen bereinigen

Checkliste:

• Keine Imports von modules/routes/routeFeature*.py mehr
• interfaceDb*.py und datamodel*.py bleiben fuer System-Module bestehen
• modules/services/service* bleiben fuer System-Services bestehen
• modules/aicore wird verschoben (Feature aichat), keine zentralen Imports mehr

Calling-Referenzen (Suche):

• rg -n "modules\\.routes\\.routeFeature" gateway/

Schritt 14: Tests

• Gateway starten, Router-Registrierung pruefen
• Feature-Folder umbenennen mit z.b. prefix: Route/Service nicht mehr vorhanden
• RBAC Katalog liefert Feature-Objekte
• Bootstrap erzeugt nur System-RBAC
• RBAC Regeln bleiben erhalten, wenn Feature-Ordner entfernt/umbenannt ist (Persistenztest).
• Service-Discovery registriert Services korrekt und markiert degraded bei Teilfehlern.

Referenz-Checkliste (gesamt)

• gateway/app.py Router
• gateway/modules/features/featuresLifecycle.py
• alle routeFeature*.py
• alle interfaceDb*.py
• alle datamodel*.py
• alle main*.py in Feature-Containern
• Service-Center/Service-Loader
• Tests/Fixtures
• RBAC-Katalog Modul in gateway/modules/security/rbacCatalog/
• gateway/modules/interfaces/interfaceBootstrap.py

Import-Analyse (Istzustand, zu verschiebende Module)

Routes (aktueller Stand)

• routeFeatureRealEstate.py:
  • imports: modules.auth, modules.datamodels.*, modules.interfaces.interfaceDbRealestate, modules.features.realEstate.mainRealEstate, modules.connectors, modules.shared
• routeFeatureTrustee.py:
  • imports: modules.auth, modules.interfaces.interfaceDbTrustee, modules.interfaces.interfaceDbApp, modules.interfaces.interfaceFeatures, modules.datamodels.*
• routeFeatureChatDynamic.py:
  • imports: modules.auth, modules.interfaces.interfaceDbChat, modules.datamodels.datamodelChat, modules.features.workflow
• routeFeatureChatbot.py:
  • imports: modules.auth, modules.interfaces.interfaceDbChat, modules.interfaces.interfaceRbac, modules.datamodels.*, modules.features.chatbot, modules.features.workflow, modules.shared
• routeFeatureNeutralization.py:
  • imports: modules.auth, modules.datamodels.datamodelNeutralizer, modules.features.neutralizePlayground
• routeDataAutomation.py:
  • imports: modules.interfaces.interfaceDbChat, modules.auth, modules.datamodels.datamodelChat, modules.features.workflow, modules.shared

Interfaces (aktueller Stand)

• interfaceDbTrustee.py:
  • imports: modules.connectors, modules.shared, modules.interfaces.interfaceRbac, modules.security, modules.datamodels.*
• interfaceDbRealestate.py:
  • imports: modules.datamodels.*, modules.connectors, modules.shared, modules.security, modules.interfaces.interfaceRbac
• interfaceDbChat.py / interfaceDbChatbot.py:
  • imports: modules.security, modules.datamodels.*, modules.connectors, modules.shared, modules.interfaces.interfaceRbac, modules.interfaces.interfaceDbManagement

Feature-Logik (aktueller Stand)

• modules/features/chatbot/mainChatbot.py:
  • imports: modules.datamodels.*, modules.shared, modules.services, modules.workflows, modules.connectors
• modules/features/workflow/mainWorkflow.py:
  • imports: modules.datamodels.*, modules.shared, modules.services, modules.workflows
• modules/features/realEstate/mainRealEstate.py:
  • imports: modules.datamodels.*, modules.services, modules.interfaces.interfaceDbRealestate, modules.connectors, externe libs
• modules/features/neutralizePlayground/mainNeutralizePlayground.py:
  • imports: modules.datamodels.*, modules.services

Services / aicore (aktueller Stand)

• modules/services/serviceAi/mainServiceAi.py:
  • imports: modules.datamodels.*, modules.services.serviceExtraction, modules.interfaces.interfaceAiObjects, modules.shared
• modules/services/serviceNeutralization/mainServiceNeutralization.py:
  • imports: modules.datamodels.datamodelNeutralizer, eigene subProcess-* Module
• modules/aicore/*:
  • imports: modules.datamodels.*, modules.security, modules.connectors

Services Submodule-Analyse (Detail)

serviceAi/

• mainServiceAi.py
  • imports: modules.datamodels.datamodelChat, modules.datamodels.datamodelAi, modules.datamodels.datamodelExtraction, modules.datamodels.datamodelWorkflow, modules.datamodels.datamodelDocument, modules.interfaces.interfaceAiObjects, modules.services.serviceExtraction, modules.shared
• subStructureGeneration.py
  • imports: modules.datamodels.datamodelExtraction, modules.datamodels.datamodelAi, modules.workflows.processing.shared.stateTools
• subStructureFilling.py
  • imports: modules.datamodels.datamodelExtraction, modules.datamodels.datamodelAi, modules.workflows.processing.shared.stateTools
• subResponseParsing.py
  • imports: modules.shared.jsonUtils, modules.services.serviceAi.subJsonResponseHandling, modules.datamodels.datamodelAi
• subJsonResponseHandling.py
  • imports: modules.shared.jsonUtils, modules.datamodels.datamodelAi
• subJsonMerger.py
  • imports: modules.shared.jsonUtils
• subDocumentIntents.py
  • imports: modules.datamodels.datamodelChat, modules.datamodels.datamodelExtraction, modules.workflows.processing.shared.stateTools
• subContentExtraction.py
  • imports: modules.datamodels.datamodelChat, modules.datamodels.datamodelExtraction, modules.workflows.processing.shared.stateTools
• subAiCallLooping.py
  • imports: modules.datamodels.datamodelAi, modules.datamodels.datamodelExtraction, modules.services.serviceAi.subJsonResponseHandling, modules.services.serviceAi.subLoopingUseCases, modules.workflows.processing.shared.stateTools, modules.shared.jsonContinuation, modules.shared.jsonUtils
• subLoopingUseCases.py, subJsonResponseHandling.py, subJsonMerger.py (shared utils)
  • imports: modules.shared.* (je nach Datei)

serviceExtraction/

• mainServiceExtraction.py
  • imports: modules.datamodels.datamodelExtraction, modules.datamodels.datamodelChat, modules.datamodels.datamodelAi, modules.aicore.aicoreModelRegistry, modules.aicore.aicoreModelSelector, modules.shared.jsonUtils
• merging/* (mergerText/mergerTable/mergerDefault)
  • imports: modules.datamodels.datamodelExtraction
• extractors/* (Xml/Xlsx/Text/Sql/Pptx/Html/Image/Json/Pdf/Csv/Docx/Binary)
  • imports: modules.datamodels.datamodelExtraction (teilweise ContentExtracted)
• chunking/* (chunkerText/ChunkerTable/ChunkerStructure/ChunkerImage)
  • imports: modules.datamodels.datamodelExtraction
• subRegistry.py
  • imports: modules.datamodels.datamodelExtraction
• subPromptBuilderExtraction.py
  • imports: modules.datamodels.datamodelAi
• subPipeline.py
  • imports: modules.datamodels.datamodelExtraction
• subMerger.py
  • imports: modules.datamodels.datamodelExtraction

serviceGeneration/

• mainServiceGeneration.py
  • imports: modules.datamodels.datamodelDocument, modules.datamodels.datamodelChat, modules.services.serviceGeneration.subDocumentUtility
• renderers/*
  • imports: modules.datamodels.datamodelDocument (alle Renderer)
  • documentRendererBaseTemplate.py imports zusaetzlich: modules.datamodels.datamodelJson, modules.datamodels.datamodelAi
• paths/*
  • imagePath.py: modules.datamodels.datamodelWorkflow, modules.datamodels.datamodelAi
  • documentPath.py: modules.datamodels.datamodelWorkflow, modules.datamodels.datamodelExtraction, modules.datamodels.datamodelAi, modules.datamodels.datamodelDocument, modules.workflows.processing.shared.stateTools
  • codePath.py: modules.datamodels.datamodelWorkflow, modules.datamodels.datamodelExtraction, modules.datamodels.datamodelAi, modules.shared.jsonUtils
• subStructureGenerator.py / subPromptBuilderGeneration.py
  • imports: modules.datamodels.datamodelJson
• subContentGenerator.py
  • imports: modules.services.serviceGeneration.subContentIntegrator, modules.workflows.processing.shared.stateTools

serviceWeb/

• mainServiceWeb.py
  • imports: modules.datamodels.datamodelAi (AiCallOptions, OperationTypeEnum, AiCallPrompt*)

serviceNeutralization/

• mainServiceNeutralization.py
  • imports: modules.datamodels.datamodelNeutralizer, modules.services.serviceNeutralization.subProcess*
• subProcessText.py
  • imports: modules.services.serviceNeutralization.subParseString
• subProcessList.py
  • imports: modules.services.serviceNeutralization.subParseString, modules.services.serviceNeutralization.subPatterns
• subParseString.py
  • imports: modules.services.serviceNeutralization.subPatterns

Compliance-Check gegen Import-Regelwerk (Zielzustand)

Zielkriterium:

• Keine Imports zwischen Feature-Containern.
• Feature-Container duerfen zentrale Module importieren.
• Zentrale Module duerfen keine Feature-Container importieren.

Erwarteter Zustand nach Migration:

• Alle interfaceFeatureXxx.py, routeFeatureXxx.py, datamodelFeatureXxx.py, mainXxx.py liegen im jeweiligen Feature-Container.
• Interne Feature-Imports (z.B. chatbot -> chatbot.eventManager) sind erlaubt.
• Keine Feature-zu-Feature-Imports mehr (z.B. chatbot -> workflow entfaellt durch Auslagerung).

Hinweis zur Validierung:

• Compliance-Check erfolgt nach Abschluss der Verschiebungen und Import-Anpassungen.
• Der Istzustand dient nur als Analysegrundlage und ist nicht compliance-faehig.

Import-Check (Zielzustand, Soll)

Erlaubte Imports innerhalb eines Feature-Containers:

• Relative Imports innerhalb des Containers (z.B. .eventManager, .subModule).
• Absolute Imports innerhalb des eigenen Containers (z.B. modules.features.chatbot.* im Container chatbot).
• Standardbibliothek und externe Libraries.

Nicht erlaubt (muss im Zielzustand eliminiert werden):

• Imports aus anderen Feature-Containern (modules.features.<anderesFeature>.*).
• Zentrale Module importieren Feature-Container (modules.features.*).

Soll-Checkliste je Feature-Container:

• Keine modules.features.<anderesFeature>.* Imports.
• Keine Feature-zu-Feature-Abhaengigkeiten.

Pruefroutine (rg-Patterns, Zielzustand):

• Finde direkte Cross-Feature-Imports:
  • rg -n "modules\\.features\\.(?!<feature>\\.)" gateway/modules/features/<feature>/
• Finde verbotene Feature-Imports aus zentralem Code:
  • rg -n "modules\\.features\\." gateway/modules/(routes|interfaces|datamodels|services|aicore|shared|connectors|security|auth)/

Istzustand (nur Analyse, vor Migration)

Konflikte (heute):

• Alle Routen, Interfaces, Feature-Logiken und Services importieren Module ausserhalb eines Feature-Containers.
• Es bestehen Imports zwischen Features (z.B. routeFeatureChatbot -> modules.features.workflow, im Zielzustand entfaellt da workflow kein Feature mehr ist).

Liste der Imports zwischen Features (Istzustand, Analyse):

• gateway/modules/interfaces/interfaceDbChatbot.py -> modules.features.chatbot.eventManager

Offene Punkte fuer Umsetzung

• Dynamische Feature-Discovery in app.py und Service-Loader designen
• Schrittweise Migration je Feature mit Tests