388 lines
16 KiB
Python
388 lines
16 KiB
Python
# Copyright (c) 2025 Patrick Motsch
|
|
# All rights reserved.
|
|
"""
|
|
WorkflowAutomation System Component — n8n-style flow automation.
|
|
|
|
System-level orchestration infrastructure (not a feature).
|
|
Provides lifecycle hooks, service hub, and system templates.
|
|
"""
|
|
|
|
import json
|
|
import logging
|
|
import uuid
|
|
from typing import Dict, List, Any, Optional
|
|
|
|
from modules.shared.i18nRegistry import t
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
COMPONENT_CODE = "workflowAutomation"
|
|
|
|
REQUIRED_SERVICES = [
|
|
{"serviceKey": "chat", "meta": {"usage": "Interfaces, RBAC"}},
|
|
{"serviceKey": "utils", "meta": {"usage": "Timestamps, utilities"}},
|
|
{"serviceKey": "ai", "meta": {"usage": "AI nodes"}},
|
|
{"serviceKey": "extraction", "meta": {"usage": "Workflow method actions"}},
|
|
{"serviceKey": "sharepoint", "meta": {"usage": "SharePoint actions"}},
|
|
{"serviceKey": "clickup", "meta": {"usage": "ClickUp actions"}},
|
|
{"serviceKey": "generation", "meta": {"usage": "file.create document rendering"}},
|
|
]
|
|
|
|
|
|
def _getRequiredServiceKeys() -> List[str]:
|
|
"""Return list of service keys this component requires."""
|
|
return [s["serviceKey"] for s in REQUIRED_SERVICES]
|
|
|
|
|
|
def _getWorkflowAutomationServices(
|
|
user,
|
|
mandateId: Optional[str] = None,
|
|
featureInstanceId: Optional[str] = None,
|
|
workflow=None,
|
|
):
|
|
"""
|
|
Get a ServicesBag for WorkflowAutomation using the service center.
|
|
Used for methodDiscovery (I/O nodes) and execution (ActionExecutor).
|
|
"""
|
|
from modules.serviceCenter import getService, ServicesBag
|
|
from modules.serviceCenter.context import ServiceCenterContext
|
|
|
|
_workflow = workflow
|
|
if _workflow is None:
|
|
_workflow = type(
|
|
"_Placeholder",
|
|
(),
|
|
{"featureCode": COMPONENT_CODE, "id": f"transient-{uuid.uuid4().hex[:12]}", "workflowMode": None, "messages": []},
|
|
)()
|
|
|
|
ctx = ServiceCenterContext(
|
|
user=user,
|
|
mandate_id=mandateId,
|
|
feature_instance_id=featureInstanceId,
|
|
workflow=_workflow,
|
|
)
|
|
return ServicesBag(ctx, lambda key: getService(key, ctx))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Lifecycle Hooks
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def onMandateDelete(mandateId: str, instances: list) -> None:
|
|
"""Cascade-delete all AutoWorkflow data for this mandate."""
|
|
from modules.datamodels.datamodelWorkflowAutomation import (
|
|
WORKFLOW_AUTOMATION_DATABASE, AutoWorkflow, AutoVersion, AutoRun, AutoStepLog, AutoTask,
|
|
)
|
|
from modules.connectors.connectorDbPostgre import DatabaseConnector
|
|
from modules.shared.configuration import APP_CONFIG
|
|
|
|
try:
|
|
waDb = DatabaseConnector(
|
|
dbHost=APP_CONFIG.get("DB_HOST", "localhost"),
|
|
dbDatabase=WORKFLOW_AUTOMATION_DATABASE,
|
|
dbUser=APP_CONFIG.get("DB_USER"),
|
|
dbPassword=APP_CONFIG.get("DB_PASSWORD_SECRET") or APP_CONFIG.get("DB_PASSWORD"),
|
|
dbPort=int(APP_CONFIG.get("DB_PORT", 5432)),
|
|
userId=None,
|
|
)
|
|
|
|
if not waDb._ensureTableExists(AutoWorkflow):
|
|
return
|
|
|
|
workflows = waDb.getRecordset(AutoWorkflow, recordFilter={
|
|
"mandateId": mandateId,
|
|
}) or []
|
|
|
|
totalDeleted = 0
|
|
for wf in workflows:
|
|
wfId = wf.get("id")
|
|
if not wfId:
|
|
continue
|
|
|
|
for v in waDb.getRecordset(AutoVersion, recordFilter={"workflowId": wfId}) or []:
|
|
waDb.recordDelete(AutoVersion, v.get("id"))
|
|
|
|
for run in waDb.getRecordset(AutoRun, recordFilter={"workflowId": wfId}) or []:
|
|
runId = run.get("id")
|
|
for sl in waDb.getRecordset(AutoStepLog, recordFilter={"runId": runId}) or []:
|
|
waDb.recordDelete(AutoStepLog, sl.get("id"))
|
|
waDb.recordDelete(AutoRun, runId)
|
|
|
|
for task in waDb.getRecordset(AutoTask, recordFilter={"workflowId": wfId}) or []:
|
|
waDb.recordDelete(AutoTask, task.get("id"))
|
|
|
|
waDb.recordDelete(AutoWorkflow, wfId)
|
|
totalDeleted += 1
|
|
|
|
if totalDeleted:
|
|
logger.info(f"Cascade: deleted {totalDeleted} AutoWorkflow(s) for mandate {mandateId}")
|
|
waDb.close()
|
|
except Exception as e:
|
|
logger.warning(f"Failed to cascade-delete workflow automation data for mandate {mandateId}: {e}")
|
|
|
|
|
|
def _migrateRbacNamespace() -> None:
|
|
"""Migrate legacy AccessRule objectKeys to the canonical workflowAutomation namespace.
|
|
|
|
Idempotent: silently returns when no old-prefix records remain.
|
|
Must NOT crash the boot process — all exceptions are caught and logged.
|
|
"""
|
|
import psycopg2
|
|
from modules.shared.configuration import APP_CONFIG
|
|
|
|
_REPLACEMENTS = [
|
|
("resource.feature.graphicalEditor.", "resource.system.workflowAutomation."),
|
|
("ui.feature.graphicalEditor.", "ui.system.workflowAutomation."),
|
|
("resource.store.graphicalEditor", "resource.store.workflowAutomation"),
|
|
]
|
|
|
|
try:
|
|
conn = psycopg2.connect(
|
|
host=APP_CONFIG.get("DB_HOST", "localhost"),
|
|
port=int(APP_CONFIG.get("DB_PORT", "5432")),
|
|
user=APP_CONFIG.get("DB_USER"),
|
|
password=APP_CONFIG.get("DB_PASSWORD_SECRET") or APP_CONFIG.get("DB_PASSWORD"),
|
|
dbname="poweron_app",
|
|
)
|
|
conn.autocommit = False
|
|
cur = conn.cursor()
|
|
|
|
totalUpdated = 0
|
|
for oldPrefix, newPrefix in _REPLACEMENTS:
|
|
cur.execute(
|
|
'SELECT id, "objectKey" FROM "AccessRule" WHERE "objectKey" LIKE %s',
|
|
(f"{oldPrefix}%",),
|
|
)
|
|
rows = cur.fetchall()
|
|
if not rows:
|
|
continue
|
|
|
|
for rowId, objectKey in rows:
|
|
newKey = objectKey.replace(oldPrefix, newPrefix, 1)
|
|
cur.execute(
|
|
'UPDATE "AccessRule" SET "objectKey" = %s WHERE id = %s',
|
|
(newKey, rowId),
|
|
)
|
|
totalUpdated += 1
|
|
|
|
conn.commit()
|
|
cur.close()
|
|
conn.close()
|
|
|
|
if totalUpdated:
|
|
logger.info(
|
|
f"RBAC namespace migration: updated {totalUpdated} AccessRule record(s) "
|
|
f"from legacy → workflowAutomation"
|
|
)
|
|
except Exception as e:
|
|
logger.warning(f"RBAC namespace migration failed (non-critical): {e}")
|
|
|
|
|
|
def _registerAgentTools() -> None:
|
|
"""Push workflow agent tools into the agent's external tool registry.
|
|
|
|
Inverts the dependency: workflowAutomation -> serviceCenter (push at boot),
|
|
so the agent service never imports workflowAutomation to obtain its tools.
|
|
"""
|
|
try:
|
|
from modules.serviceCenter.services.serviceAgent.externalToolRegistry import registerExternalTools
|
|
from modules.workflowAutomation.agentTools import getWorkflowToolDefinitions, TOOLBOX_ID
|
|
registerExternalTools(TOOLBOX_ID, getWorkflowToolDefinitions())
|
|
except Exception as e:
|
|
logger.warning(f"Could not register workflow agent tools (non-critical): {e}")
|
|
|
|
|
|
def onBootstrap() -> None:
|
|
"""Seed system workflow templates and sync feature template workflows on boot."""
|
|
_migrateRbacNamespace()
|
|
_registerAgentTools()
|
|
|
|
from modules.datamodels.datamodelWorkflowAutomation import WORKFLOW_AUTOMATION_DATABASE, AutoWorkflow
|
|
from modules.connectors.connectorDbPostgre import DatabaseConnector
|
|
from modules.shared.configuration import APP_CONFIG
|
|
|
|
try:
|
|
waDb = DatabaseConnector(
|
|
dbHost=APP_CONFIG.get("DB_HOST", "localhost"),
|
|
dbDatabase=WORKFLOW_AUTOMATION_DATABASE,
|
|
dbUser=APP_CONFIG.get("DB_USER"),
|
|
dbPassword=APP_CONFIG.get("DB_PASSWORD_SECRET") or APP_CONFIG.get("DB_PASSWORD"),
|
|
)
|
|
waDb._ensureTableExists(AutoWorkflow)
|
|
|
|
existing = waDb.getRecordset(AutoWorkflow, recordFilter={
|
|
"isTemplate": True,
|
|
"templateScope": "system",
|
|
})
|
|
existingLabels = {r.get("label") if isinstance(r, dict) else getattr(r, "label", "") for r in (existing or [])}
|
|
|
|
templates = _buildSystemTemplates()
|
|
created = 0
|
|
for tpl in templates:
|
|
if tpl["label"] in existingLabels:
|
|
continue
|
|
tpl["id"] = str(uuid.uuid4())
|
|
waDb.recordCreate(AutoWorkflow, tpl)
|
|
created += 1
|
|
|
|
if created:
|
|
logger.info(f"Bootstrapped {created} system workflow template(s)")
|
|
|
|
from modules.system.registry import loadFeatureMainModules
|
|
|
|
mainModules = loadFeatureMainModules()
|
|
templatesBySourceId: dict = {}
|
|
for featureCode, mod in mainModules.items():
|
|
getTemplateWorkflowsFn = getattr(mod, "getTemplateWorkflows", None)
|
|
if not getTemplateWorkflowsFn:
|
|
continue
|
|
try:
|
|
featureTemplates = getTemplateWorkflowsFn() or []
|
|
except Exception:
|
|
continue
|
|
for tpl in featureTemplates:
|
|
tplId = tpl.get("id")
|
|
if tplId:
|
|
templatesBySourceId[tplId] = tpl
|
|
|
|
if templatesBySourceId:
|
|
updated = 0
|
|
for sourceId, tpl in templatesBySourceId.items():
|
|
instances = waDb.getRecordset(AutoWorkflow, recordFilter={
|
|
"templateSourceId": sourceId,
|
|
"isTemplate": False,
|
|
})
|
|
if not instances:
|
|
continue
|
|
|
|
canonicalGraph = tpl.get("graph", {})
|
|
for inst in instances:
|
|
instId = inst.get("id") if isinstance(inst, dict) else getattr(inst, "id", None)
|
|
targetInstanceId = (
|
|
inst.get("targetFeatureInstanceId") if isinstance(inst, dict)
|
|
else getattr(inst, "targetFeatureInstanceId", None)
|
|
) or ""
|
|
|
|
graphJson = json.dumps(canonicalGraph)
|
|
graphJson = graphJson.replace("{{featureInstanceId}}", targetInstanceId)
|
|
newGraph = json.loads(graphJson)
|
|
|
|
existingGraph = inst.get("graph") if isinstance(inst, dict) else getattr(inst, "graph", None)
|
|
if isinstance(existingGraph, str):
|
|
try:
|
|
existingGraph = json.loads(existingGraph)
|
|
except Exception:
|
|
existingGraph = None
|
|
|
|
if existingGraph == newGraph:
|
|
continue
|
|
waDb.recordModify(AutoWorkflow, instId, {"graph": newGraph})
|
|
updated += 1
|
|
|
|
if updated:
|
|
logger.info(f"Synced {updated} workflow(s) with current feature templates")
|
|
|
|
waDb.close()
|
|
except Exception as e:
|
|
logger.warning(f"WorkflowAutomation bootstrap failed: {e}")
|
|
|
|
|
|
def onInstanceCreate(mandateId: str, instanceId: str, featureCode: str, templateWorkflows: list) -> int:
|
|
"""Create workflow instances from template definitions when a feature instance is created."""
|
|
from modules.interfaces.interfaceWorkflowAutomation import _getWorkflowAutomationInterface
|
|
from modules.security.rootAccess import getRootUser
|
|
from modules.shared.i18nRegistry import resolveText
|
|
|
|
rootUser = getRootUser()
|
|
waInterface = _getWorkflowAutomationInterface(rootUser, mandateId, instanceId)
|
|
|
|
copied = 0
|
|
for template in templateWorkflows:
|
|
templateId = template.get("id", "<no-id>")
|
|
try:
|
|
graphJson = json.dumps(template.get("graph", {}))
|
|
graphJson = graphJson.replace("{{featureInstanceId}}", instanceId)
|
|
graph = json.loads(graphJson)
|
|
|
|
label = resolveText(template.get("label"))
|
|
|
|
waInterface.createWorkflow({
|
|
"label": label,
|
|
"graph": graph,
|
|
"tags": template.get("tags", [f"feature:{featureCode}"]),
|
|
"isTemplate": False,
|
|
"templateSourceId": templateId,
|
|
"templateScope": "instance",
|
|
"active": True,
|
|
"targetFeatureInstanceId": instanceId,
|
|
"invocations": template.get("invocations", []),
|
|
})
|
|
copied += 1
|
|
except Exception as e:
|
|
logger.error(f"onInstanceCreate: failed to copy template '{templateId}': {e}")
|
|
|
|
return copied
|
|
|
|
|
|
def _buildSystemTemplates():
|
|
"""Build the graph definitions for platform system templates."""
|
|
return [
|
|
{
|
|
"label": t("Personal Assistant: E-Mail-Antwort-Drafting"),
|
|
"mandateId": None,
|
|
"featureInstanceId": None,
|
|
"isTemplate": True,
|
|
"templateScope": "system",
|
|
"sharedReadOnly": True,
|
|
"active": False,
|
|
"graph": {
|
|
"nodes": [
|
|
{"id": "n1", "type": "trigger.schedule", "x": 50, "y": 200, "title": "Täglicher Check", "parameters": {}},
|
|
{"id": "n2", "type": "email.checkEmail", "x": 300, "y": 200, "title": "Mailbox prüfen", "parameters": {}},
|
|
{"id": "n3", "type": "flow.loop", "x": 550, "y": 200, "title": "Pro E-Mail", "parameters": {"items": {"type": "ref", "nodeId": "n2", "path": ["emails"]}, "concurrency": 1}},
|
|
{"id": "n4", "type": "ai.prompt", "x": 800, "y": 200, "title": "Analyse: Antwort nötig?", "parameters": {}},
|
|
{"id": "n5", "type": "flow.ifElse", "x": 1050, "y": 200, "title": "Antwort nötig?", "parameters": {}},
|
|
{"id": "n6", "type": "ai.prompt", "x": 1300, "y": 100, "title": "Kontext abrufen & Antwort formulieren", "parameters": {}},
|
|
{"id": "n7", "type": "email.draftEmail", "x": 1550, "y": 100, "title": "Draft erstellen", "parameters": {}},
|
|
],
|
|
"connections": [
|
|
{"source": "n1", "target": "n2", "sourceOutput": 0, "targetInput": 0},
|
|
{"source": "n2", "target": "n3", "sourceOutput": 0, "targetInput": 0},
|
|
{"source": "n3", "target": "n4", "sourceOutput": 0, "targetInput": 0},
|
|
{"source": "n4", "target": "n5", "sourceOutput": 0, "targetInput": 0},
|
|
{"source": "n5", "target": "n6", "sourceOutput": 0, "targetInput": 0},
|
|
{"source": "n6", "target": "n7", "sourceOutput": 0, "targetInput": 0},
|
|
],
|
|
},
|
|
"invocations": [{"type": "schedule", "cronExpression": "0 8 * * 1-5"}],
|
|
},
|
|
{
|
|
"label": t("Treuhand: PDF-Klassifizierung & Trustee-Import"),
|
|
"mandateId": None,
|
|
"featureInstanceId": None,
|
|
"isTemplate": True,
|
|
"templateScope": "system",
|
|
"sharedReadOnly": True,
|
|
"active": False,
|
|
"graph": {
|
|
"nodes": [
|
|
{"id": "n1", "type": "trigger.schedule", "x": 50, "y": 200, "title": "Geplanter Import", "parameters": {}},
|
|
{"id": "n2", "type": "sharepoint.listFiles", "x": 300, "y": 200, "title": "SharePoint Ordner lesen", "parameters": {}},
|
|
{"id": "n3", "type": "flow.loop", "x": 550, "y": 200, "title": "Pro Dokument", "parameters": {"items": {"type": "ref", "nodeId": "n2", "path": ["files"]}, "concurrency": 1}},
|
|
{"id": "n4", "type": "sharepoint.readFile", "x": 800, "y": 200, "title": "PDF-Inhalt lesen", "parameters": {}},
|
|
{"id": "n5", "type": "ai.prompt", "x": 1050, "y": 200, "title": "Typ klassifizieren (Rechnung, Beleg, Bankauszug, Vertrag, etc.)", "parameters": {}},
|
|
{"id": "n6", "type": "trustee.extractFromFiles", "x": 1300, "y": 200, "title": "Dokument extrahieren", "parameters": {}},
|
|
{"id": "n7", "type": "trustee.processDocuments", "x": 1550, "y": 200, "title": "In Trustee einlesen", "parameters": {}},
|
|
],
|
|
"connections": [
|
|
{"source": "n1", "target": "n2", "sourceOutput": 0, "targetInput": 0},
|
|
{"source": "n2", "target": "n3", "sourceOutput": 0, "targetInput": 0},
|
|
{"source": "n3", "target": "n4", "sourceOutput": 0, "targetInput": 0},
|
|
{"source": "n4", "target": "n5", "sourceOutput": 0, "targetInput": 0},
|
|
{"source": "n5", "target": "n6", "sourceOutput": 0, "targetInput": 0},
|
|
{"source": "n6", "target": "n7", "sourceOutput": 0, "targetInput": 0},
|
|
],
|
|
},
|
|
"invocations": [{"type": "schedule", "cronExpression": "0 7 * * 1-5"}],
|
|
},
|
|
]
|