таски готовы

backend/src/services/reports/normalizer.py

@@ -0,0 +1,152 @@
+# [DEF:backend.src.services.reports.normalizer:Module]
+# @TIER: CRITICAL
+# @SEMANTICS: reports, normalization, tasks, fallback
+# @PURPOSE: Convert task manager task objects into canonical unified TaskReport entities with deterministic fallback behavior.
+# @LAYER: Domain
+# @RELATION: DEPENDS_ON -> backend.src.core.task_manager.models.Task
+# @RELATION: DEPENDS_ON -> backend.src.models.report
+# @RELATION: DEPENDS_ON -> backend.src.services.reports.type_profiles
+# @INVARIANT: Unknown task types and partial payloads remain visible via fallback mapping.
+
+# [SECTION: IMPORTS]
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from ...core.task_manager.models import Task, TaskStatus
+from ...models.report import ErrorContext, ReportStatus, TaskReport
+from .type_profiles import get_type_profile, resolve_task_type
+# [/SECTION]
+
+
+# [DEF:status_to_report_status:Function]
+# @PURPOSE: Normalize internal task status to canonical report status.
+# @PRE: status may be known or unknown string/enum value.
+# @POST: Always returns one of canonical ReportStatus values.
+# @PARAM: status (Any) - Internal task status value.
+# @RETURN: ReportStatus - Canonical report status.
+def status_to_report_status(status: Any) -> ReportStatus:
+    raw = str(status.value if isinstance(status, TaskStatus) else status).upper()
+    if raw == TaskStatus.SUCCESS.value:
+        return ReportStatus.SUCCESS
+    if raw == TaskStatus.FAILED.value:
+        return ReportStatus.FAILED
+    if raw in {TaskStatus.PENDING.value, TaskStatus.RUNNING.value, TaskStatus.AWAITING_INPUT.value, TaskStatus.AWAITING_MAPPING.value}:
+        return ReportStatus.IN_PROGRESS
+    return ReportStatus.PARTIAL
+# [/DEF:status_to_report_status:Function]
+
+
+# [DEF:build_summary:Function]
+# @PURPOSE: Build deterministic user-facing summary from task payload and status.
+# @PRE: report_status is canonical; plugin_id may be unknown.
+# @POST: Returns non-empty summary text.
+# @PARAM: task (Task) - Source task object.
+# @PARAM: report_status (ReportStatus) - Canonical status.
+# @RETURN: str - Normalized summary.
+def build_summary(task: Task, report_status: ReportStatus) -> str:
+    result = task.result
+    if isinstance(result, dict):
+        for key in ("summary", "message", "status_message", "description"):
+            value = result.get(key)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+    if report_status == ReportStatus.SUCCESS:
+        return "Task completed successfully"
+    if report_status == ReportStatus.FAILED:
+        return "Task failed"
+    if report_status == ReportStatus.IN_PROGRESS:
+        return "Task is in progress"
+    return "Task completed with partial data"
+# [/DEF:build_summary:Function]
+
+
+# [DEF:extract_error_context:Function]
+# @PURPOSE: Extract normalized error context and next actions for failed/partial reports.
+# @PRE: task is a valid Task object.
+# @POST: Returns ErrorContext for failed/partial when context exists; otherwise None.
+# @PARAM: task (Task) - Source task.
+# @PARAM: report_status (ReportStatus) - Canonical status.
+# @RETURN: Optional[ErrorContext] - Error context block.
+def extract_error_context(task: Task, report_status: ReportStatus) -> Optional[ErrorContext]:
+    if report_status not in {ReportStatus.FAILED, ReportStatus.PARTIAL}:
+        return None
+
+    result = task.result if isinstance(task.result, dict) else {}
+    message = None
+    code = None
+    next_actions = []
+
+    if isinstance(result.get("error"), dict):
+        error_obj = result.get("error", {})
+        message = error_obj.get("message") or message
+        code = error_obj.get("code") or code
+        actions = error_obj.get("next_actions")
+        if isinstance(actions, list):
+            next_actions = [str(action) for action in actions if str(action).strip()]
+
+    if not message:
+        message = result.get("error_message") if isinstance(result.get("error_message"), str) else None
+
+    if not message:
+        for log in reversed(task.logs):
+            if str(log.level).upper() == "ERROR" and log.message:
+                message = log.message
+                break
+
+    if not message:
+        message = "Not provided"
+
+    if not next_actions:
+        next_actions = ["Review task diagnostics", "Retry the operation"]
+
+    return ErrorContext(code=code, message=message, next_actions=next_actions)
+# [/DEF:extract_error_context:Function]
+
+
+# [DEF:normalize_task_report:Function]
+# @PURPOSE: Convert one Task to canonical TaskReport envelope.
+# @PRE: task has valid id and plugin_id fields.
+# @POST: Returns TaskReport with required fields and deterministic fallback behavior.
+# @PARAM: task (Task) - Source task.
+# @RETURN: TaskReport - Canonical normalized report.
+def normalize_task_report(task: Task) -> TaskReport:
+    task_type = resolve_task_type(task.plugin_id)
+    report_status = status_to_report_status(task.status)
+    profile = get_type_profile(task_type)
+
+    started_at = task.started_at if isinstance(task.started_at, datetime) else None
+    updated_at = task.finished_at if isinstance(task.finished_at, datetime) else None
+    if not updated_at:
+        updated_at = started_at or datetime.utcnow()
+
+    details: Dict[str, Any] = {
+        "profile": {
+            "display_label": profile.get("display_label"),
+            "visual_variant": profile.get("visual_variant"),
+            "icon_token": profile.get("icon_token"),
+            "emphasis_rules": profile.get("emphasis_rules", []),
+        },
+        "result": task.result if task.result is not None else {"note": "Not provided"},
+    }
+
+    source_ref: Dict[str, Any] = {}
+    if isinstance(task.params, dict):
+        for key in ("environment_id", "source_env_id", "target_env_id", "dashboard_id", "dataset_id", "resource_id"):
+            if key in task.params:
+                source_ref[key] = task.params.get(key)
+
+    return TaskReport(
+        report_id=task.id,
+        task_id=task.id,
+        task_type=task_type,
+        status=report_status,
+        started_at=started_at,
+        updated_at=updated_at,
+        summary=build_summary(task, report_status),
+        details=details,
+        error_context=extract_error_context(task, report_status),
+        source_ref=source_ref or None,
+    )
+# [/DEF:normalize_task_report:Function]
+
+# [/DEF:backend.src.services.reports.normalizer:Module]

backend/src/services/reports/report_service.py

@@ -0,0 +1,148 @@
+# [DEF:backend.src.services.reports.report_service:Module]
+# @TIER: CRITICAL
+# @SEMANTICS: reports, service, aggregation, filtering, pagination, detail
+# @PURPOSE: Aggregate, normalize, filter, and paginate task reports for unified list/detail API use cases.
+# @LAYER: Domain
+# @RELATION: DEPENDS_ON -> backend.src.core.task_manager.manager.TaskManager
+# @RELATION: DEPENDS_ON -> backend.src.models.report
+# @RELATION: DEPENDS_ON -> backend.src.services.reports.normalizer
+# @INVARIANT: List responses are deterministic and include applied filter echo metadata.
+
+# [SECTION: IMPORTS]
+from datetime import datetime
+from typing import List, Optional
+
+from ...core.task_manager import TaskManager
+from ...models.report import ReportCollection, ReportDetailView, ReportQuery, ReportStatus, TaskReport, TaskType
+from .normalizer import normalize_task_report
+# [/SECTION]
+
+
+# [DEF:ReportsService:Class]
+# @PURPOSE: Service layer for list/detail report retrieval and normalization.
+# @TIER: CRITICAL
+# @PRE: TaskManager dependency is initialized.
+# @POST: Provides deterministic list/detail report responses.
+class ReportsService:
+    # [DEF:__init__:Function]
+    # @PURPOSE: Initialize service with TaskManager dependency.
+    # @PARAM: task_manager (TaskManager) - Task manager providing source task history.
+    def __init__(self, task_manager: TaskManager):
+        self.task_manager = task_manager
+    # [/DEF:__init__:Function]
+
+    # [DEF:_load_normalized_reports:Function]
+    # @PURPOSE: Build normalized reports from all available tasks.
+    # @RETURN: List[TaskReport] - Reports sorted later by list logic.
+    def _load_normalized_reports(self) -> List[TaskReport]:
+        tasks = self.task_manager.get_all_tasks()
+        reports = [normalize_task_report(task) for task in tasks]
+        return reports
+    # [/DEF:_load_normalized_reports:Function]
+
+    # [DEF:_matches_query:Function]
+    # @PURPOSE: Apply query filtering to a report.
+    # @PARAM: report (TaskReport) - Candidate report.
+    # @PARAM: query (ReportQuery) - Applied query.
+    # @RETURN: bool - True if report matches all filters.
+    def _matches_query(self, report: TaskReport, query: ReportQuery) -> bool:
+        if query.task_types and report.task_type not in query.task_types:
+            return False
+        if query.statuses and report.status not in query.statuses:
+            return False
+        if query.time_from and report.updated_at < query.time_from:
+            return False
+        if query.time_to and report.updated_at > query.time_to:
+            return False
+        if query.search:
+            needle = query.search.lower()
+            haystack = f"{report.summary} {report.task_type.value} {report.status.value}".lower()
+            if needle not in haystack:
+                return False
+        return True
+    # [/DEF:_matches_query:Function]
+
+    # [DEF:_sort_reports:Function]
+    # @PURPOSE: Sort reports deterministically according to query settings.
+    # @PARAM: reports (List[TaskReport]) - Filtered reports.
+    # @PARAM: query (ReportQuery) - Sort config.
+    # @RETURN: List[TaskReport] - Sorted reports.
+    def _sort_reports(self, reports: List[TaskReport], query: ReportQuery) -> List[TaskReport]:
+        reverse = query.sort_order == "desc"
+
+        if query.sort_by == "status":
+            reports.sort(key=lambda item: item.status.value, reverse=reverse)
+        elif query.sort_by == "task_type":
+            reports.sort(key=lambda item: item.task_type.value, reverse=reverse)
+        else:
+            reports.sort(key=lambda item: item.updated_at, reverse=reverse)
+
+        return reports
+    # [/DEF:_sort_reports:Function]
+
+    # [DEF:list_reports:Function]
+    # @PURPOSE: Return filtered, sorted, paginated report collection.
+    # @PRE: query has passed schema validation.
+    # @POST: Returns {items,total,page,page_size,has_next,applied_filters}.
+    # @PARAM: query (ReportQuery) - List filters and pagination.
+    # @RETURN: ReportCollection - Paginated unified reports payload.
+    def list_reports(self, query: ReportQuery) -> ReportCollection:
+        reports = self._load_normalized_reports()
+        filtered = [report for report in reports if self._matches_query(report, query)]
+        sorted_reports = self._sort_reports(filtered, query)
+
+        total = len(sorted_reports)
+        start = (query.page - 1) * query.page_size
+        end = start + query.page_size
+        items = sorted_reports[start:end]
+        has_next = end < total
+
+        return ReportCollection(
+            items=items,
+            total=total,
+            page=query.page,
+            page_size=query.page_size,
+            has_next=has_next,
+            applied_filters=query,
+        )
+    # [/DEF:list_reports:Function]
+
+    # [DEF:get_report_detail:Function]
+    # @PURPOSE: Return one normalized report with timeline/diagnostics/next actions.
+    # @PRE: report_id exists in normalized report set.
+    # @POST: Returns normalized detail envelope with diagnostics and next actions where applicable.
+    # @PARAM: report_id (str) - Stable report identifier.
+    # @RETURN: Optional[ReportDetailView] - Detailed report or None if not found.
+    def get_report_detail(self, report_id: str) -> Optional[ReportDetailView]:
+        reports = self._load_normalized_reports()
+        target = next((report for report in reports if report.report_id == report_id), None)
+        if not target:
+            return None
+
+        timeline = []
+        if target.started_at:
+            timeline.append({"event": "started", "at": target.started_at.isoformat()})
+        timeline.append({"event": "updated", "at": target.updated_at.isoformat()})
+
+        diagnostics = target.details or {}
+        if not diagnostics:
+            diagnostics = {"note": "Not provided"}
+        if target.error_context:
+            diagnostics["error_context"] = target.error_context.model_dump()
+
+        next_actions = []
+        if target.error_context and target.error_context.next_actions:
+            next_actions = target.error_context.next_actions
+        elif target.status in {ReportStatus.FAILED, ReportStatus.PARTIAL}:
+            next_actions = ["Review diagnostics", "Retry task if applicable"]
+
+        return ReportDetailView(
+            report=target,
+            timeline=timeline,
+            diagnostics=diagnostics,
+            next_actions=next_actions,
+        )
+    # [/DEF:get_report_detail:Function]
+# [/DEF:ReportsService:Class]
+
+# [/DEF:backend.src.services.reports.report_service:Module]

backend/src/services/reports/type_profiles.py

@@ -0,0 +1,91 @@
+# [DEF:backend.src.services.reports.type_profiles:Module]
+# @TIER: CRITICAL
+# @SEMANTICS: reports, type_profiles, normalization, fallback
+# @PURPOSE: Deterministic mapping of plugin/task identifiers to canonical report task types and fallback profile metadata.
+# @LAYER: Domain
+# @RELATION: DEPENDS_ON -> backend.src.models.report.TaskType
+# @INVARIANT: Unknown input always resolves to TaskType.UNKNOWN with a single fallback profile.
+
+# [SECTION: IMPORTS]
+from typing import Any, Dict, Optional
+
+from ...models.report import TaskType
+# [/SECTION]
+
+# [DEF:PLUGIN_TO_TASK_TYPE:Data]
+# @PURPOSE: Maps plugin identifiers to normalized report task types.
+PLUGIN_TO_TASK_TYPE: Dict[str, TaskType] = {
+    "llm_dashboard_validation": TaskType.LLM_VERIFICATION,
+    "superset-backup": TaskType.BACKUP,
+    "superset-migration": TaskType.MIGRATION,
+    "documentation": TaskType.DOCUMENTATION,
+}
+# [/DEF:PLUGIN_TO_TASK_TYPE:Data]
+
+# [DEF:TASK_TYPE_PROFILES:Data]
+# @PURPOSE: Profile metadata registry for each normalized task type.
+TASK_TYPE_PROFILES: Dict[TaskType, Dict[str, Any]] = {
+    TaskType.LLM_VERIFICATION: {
+        "display_label": "LLM Verification",
+        "visual_variant": "llm",
+        "icon_token": "sparkles",
+        "emphasis_rules": ["summary", "status", "next_actions"],
+        "fallback": False,
+    },
+    TaskType.BACKUP: {
+        "display_label": "Backup",
+        "visual_variant": "backup",
+        "icon_token": "archive",
+        "emphasis_rules": ["summary", "status", "updated_at"],
+        "fallback": False,
+    },
+    TaskType.MIGRATION: {
+        "display_label": "Migration",
+        "visual_variant": "migration",
+        "icon_token": "shuffle",
+        "emphasis_rules": ["summary", "status", "error_context"],
+        "fallback": False,
+    },
+    TaskType.DOCUMENTATION: {
+        "display_label": "Documentation",
+        "visual_variant": "documentation",
+        "icon_token": "file-text",
+        "emphasis_rules": ["summary", "status", "details"],
+        "fallback": False,
+    },
+    TaskType.UNKNOWN: {
+        "display_label": "Other / Unknown",
+        "visual_variant": "unknown",
+        "icon_token": "help-circle",
+        "emphasis_rules": ["summary", "status"],
+        "fallback": True,
+    },
+}
+# [/DEF:TASK_TYPE_PROFILES:Data]
+
+
+# [DEF:resolve_task_type:Function]
+# @PURPOSE: Resolve canonical task type from plugin/task identifier with guaranteed fallback.
+# @PRE: plugin_id may be None or unknown.
+# @POST: Always returns one of TaskType enum values.
+# @PARAM: plugin_id (Optional[str]) - Source plugin/task identifier from task record.
+# @RETURN: TaskType - Resolved canonical type or UNKNOWN fallback.
+def resolve_task_type(plugin_id: Optional[str]) -> TaskType:
+    normalized = (plugin_id or "").strip()
+    if not normalized:
+        return TaskType.UNKNOWN
+    return PLUGIN_TO_TASK_TYPE.get(normalized, TaskType.UNKNOWN)
+# [/DEF:resolve_task_type:Function]
+
+
+# [DEF:get_type_profile:Function]
+# @PURPOSE: Return deterministic profile metadata for a task type.
+# @PRE: task_type may be known or unknown.
+# @POST: Returns a profile dict and never raises for unknown types.
+# @PARAM: task_type (TaskType) - Canonical task type.
+# @RETURN: Dict[str, Any] - Profile metadata used by normalization and UI contracts.
+def get_type_profile(task_type: TaskType) -> Dict[str, Any]:
+    return TASK_TYPE_PROFILES.get(task_type, TASK_TYPE_PROFILES[TaskType.UNKNOWN])
+# [/DEF:get_type_profile:Function]
+
+# [/DEF:backend.src.services.reports.type_profiles:Module]