import logging import os import shutil import json import re import hashlib import base64 import html import math from pathlib import Path from datetime import datetime, timedelta, timezone from typing import Any, List, Optional, Dict from uuid import uuid4 from fastapi import APIRouter, HTTPException, Query, UploadFile, File, Request, Form, Response, Body, Depends from fastapi.responses import FileResponse, HTMLResponse from pydantic import BaseModel, Field from app.core.database import execute_query, execute_query_single, execute_update, table_has_column, get_db_connection, release_db_connection from psycopg2.extras import RealDictCursor from app.models.schemas import TodoStep, TodoStepCreate, TodoStepUpdate, QuickCreateAnalysis from app.core.config import settings from app.core.auth_dependencies import get_current_user, require_any_permission from app.services.email_service import EmailService from app.services.case_analysis_service import CaseAnalysisService from app.services.ollama_service import ollama_service from app.services.brother_label_print_service import BrotherLabelPrintService, LabelJob try: import extract_msg except ImportError: extract_msg = None import email from email.header import decode_header logger = logging.getLogger(__name__) case_read_access = require_any_permission("cases.view", "tickets.view") case_create_access = require_any_permission("cases.create", "tickets.create") case_edit_access = require_any_permission("cases.edit", "tickets.edit") case_delete_access = require_any_permission("cases.delete", "tickets.delete") async def case_route_access(request: Request, current_user: dict = Depends(get_current_user)) -> dict: """Apply read/create/edit/delete access consistently to every case route.""" if current_user.get("is_superadmin"): return current_user method = request.method.upper() normalized_path = request.url.path.rstrip("/") if method in {"GET", "HEAD", "OPTIONS"}: required = {"cases.view", "tickets.view"} elif method == "POST" and normalized_path == "/api/v1/sag": required = {"cases.create", "tickets.create"} elif method == "DELETE" and re.fullmatch(r"/api/v1/sag/\d+", normalized_path): required = {"cases.delete", "tickets.delete"} else: required = {"cases.edit", "tickets.edit"} available = set(current_user.get("permissions") or []) if available.intersection(required): return current_user raise HTTPException( status_code=403, detail=f"Missing required permission. Need one of: {', '.join(sorted(required))}", ) router = APIRouter(dependencies=[Depends(case_route_access)]) def _table_exists(table_name: str) -> bool: row = execute_query_single("SELECT to_regclass(%s) AS table_name", (f"public.{table_name}",)) return bool(row and row.get("table_name")) def _get_user_id_from_request(request: Request) -> int: user_id = getattr(request.state, "user_id", None) if user_id is not None: try: return int(user_id) except ValueError: raise HTTPException(status_code=400, detail="Invalid user_id format") user_id = request.query_params.get("user_id") if user_id: try: return int(user_id) except ValueError: raise HTTPException(status_code=400, detail="Invalid user_id format") raise HTTPException(status_code=401, detail="User not authenticated - provide user_id query parameter") def _ensure_case_internet_connection_tag(sag_id: int) -> None: """Mark a case as internet-related without creating duplicate tags.""" existing = execute_query_single( """SELECT id FROM sag_tags WHERE sag_id = %s AND deleted_at IS NULL AND LOWER(TRIM(tag_navn)) = 'internet forbindelse' LIMIT 1""", (sag_id,), ) if not existing: execute_query( "INSERT INTO sag_tags (sag_id, tag_navn) VALUES (%s, 'internet forbindelse')", (sag_id,), fetch=False, ) def _normalize_case_status(status_value: Optional[str]) -> str: canonical = { "ny": "Ny", "tildelt": "Tildelt", "igangværende": "Igangværende", "afventer": "Afventer", "løst": "Løst", "kunde svaret": "Kunde svaret", "lukket": "Lukket", } legacy_aliases = { "åben": "Ny", "open": "Ny", "under behandling": "Igangværende", "i_gang": "Igangværende", "in progress": "Igangværende", "on_hold": "Afventer", "resolved": "Løst", "closed": "Lukket", "afsluttet": "Lukket", "done": "Lukket", } normalized = str(status_value or "Ny").strip().lower() if normalized in canonical: return canonical[normalized] if normalized in legacy_aliases: return legacy_aliases[normalized] raise HTTPException(status_code=400, detail="Ugyldig status. Vælg en af de faste sagsstatuser.") def _normalize_optional_timestamp(value: Optional[str], field_name: str) -> Optional[str]: if value is None: return None if isinstance(value, datetime): return value.strftime("%Y-%m-%d %H:%M:%S") text = str(value).strip() if not text: return None try: parsed = datetime.fromisoformat(text.replace("Z", "+00:00")) if parsed.tzinfo is not None: parsed = parsed.astimezone(timezone.utc).replace(tzinfo=None) return parsed.strftime("%Y-%m-%d %H:%M:%S") except ValueError: raise HTTPException(status_code=400, detail=f"Invalid datetime format for {field_name}") def _coerce_optional_int(value: Optional[object], field_name: str) -> Optional[int]: if value is None or value == "": return None try: return int(value) except (TypeError, ValueError): raise HTTPException(status_code=400, detail=f"Invalid {field_name}") def _validate_user_id(user_id: Optional[int], field_name: str = "ansvarlig_bruger_id") -> None: if user_id is None: return exists = execute_query("SELECT 1 FROM users WHERE user_id = %s", (user_id,)) if not exists: raise HTTPException(status_code=400, detail=f"Invalid {field_name}") def _validate_group_id(group_id: Optional[int], field_name: str = "assigned_group_id") -> None: if group_id is None: return exists = execute_query("SELECT 1 FROM groups WHERE id = %s", (group_id,)) if not exists: raise HTTPException(status_code=400, detail=f"Invalid {field_name}") def _validate_customer_id(customer_id: Optional[int], field_name: str = "customer_id") -> None: if customer_id is None: return exists = execute_query("SELECT 1 FROM customers WHERE id = %s", (customer_id,)) if not exists: raise HTTPException(status_code=400, detail=f"Invalid {field_name}") def _normalize_deferred_statuses(value: Optional[object]) -> Optional[str]: if value is None: return None raw_items: List[str] = [] if isinstance(value, (list, tuple, set)): raw_items = [str(v or "") for v in value] else: raw_items = re.split(r"[,;\n]", str(value or "")) cleaned: List[str] = [] seen = set() for item in raw_items: token = str(item or "").strip() if not token: continue key = token.lower() if key in seen: continue seen.add(key) cleaned.append(token) if not cleaned: return None return ", ".join(cleaned) def _normalize_relation_input(sag_id: int, data: dict) -> tuple[int, str]: try: target_id = int(data.get("målsag_id")) except (AttributeError, TypeError, ValueError): raise HTTPException(status_code=400, detail="målsag_id must be an integer") raw_relation_type = str(data.get("relationstype") or "").strip() relation_aliases = { "relateret til": "Relateret til", "relateret_til": "Relateret til", "afledt af": "Afledt af", "afledt_af": "Afledt af", "årsag til": "Årsag til", "årsag_til": "Årsag til", "blokkerer": "Blokkerer", "afhænger af": "afhænger af", "afhænger_af": "afhænger af", "undersag": "undersag", "duplikat": "duplikat", "forælder": "forælder", "barn": "barn", "udfører for": "udfører_for", "udfører_for": "udfører_for", } relation_type = relation_aliases.get(raw_relation_type.casefold()) if not relation_type: raise HTTPException(status_code=400, detail="Invalid relationstype") if sag_id == target_id: raise HTTPException(status_code=400, detail="A case cannot be related to itself") return target_id, relation_type def _deferred_status_matches( deferred_until_status: Optional[str], previous_status: Optional[str], new_status: Optional[str], ) -> bool: normalized_new = str(new_status or "").strip().lower() normalized_prev = str(previous_status or "").strip().lower() if not normalized_new: return False status_values = [ str(part or "").strip().lower() for part in re.split(r"[,;\n]", str(deferred_until_status or "")) if str(part or "").strip() ] if not status_values: return False if "__any_change__" in status_values and normalized_prev and normalized_prev != normalized_new: return True return normalized_new in status_values def _activate_waiting_cases_by_status( trigger_case_id: int, previous_status: Optional[str], new_status: Optional[str], ) -> None: """Set start_date for waiting cases when their status dependency is met.""" normalized_status = str(new_status or "").strip() if not normalized_status: return try: waiting_rows = execute_query( """ SELECT id, deferred_until_status FROM sag_sager WHERE deleted_at IS NULL AND deferred_until_case_id = %s AND deferred_until_status IS NOT NULL AND start_date IS NULL """, (trigger_case_id,), ) or [] matching_ids = [ int(row["id"]) for row in waiting_rows if _deferred_status_matches(row.get("deferred_until_status"), previous_status, normalized_status) ] if not matching_ids: return placeholders = ",".join(["%s"] * len(matching_ids)) updated_rows = execute_query( f""" UPDATE sag_sager SET start_date = NOW(), updated_at = NOW() WHERE id IN ({placeholders}) RETURNING id """, tuple(matching_ids), ) or [] if updated_rows: logger.info( "✅ Activated %s waiting case(s) from trigger case %s with status '%s'", len(updated_rows), trigger_case_id, normalized_status, ) except Exception as exc: logger.warning( "⚠️ Could not activate waiting cases for trigger case %s and status '%s': %s", trigger_case_id, normalized_status, exc, ) # ============================================================================ # QUICKCREATE AI ANALYSIS # ============================================================================ class QuickCreateRequest(BaseModel): text: str = Field(..., min_length=1, max_length=5000) user_id: int class RewriteTextRequest(BaseModel): text: str = Field(..., min_length=1, max_length=10000) context: Optional[str] = Field(default="case") class RewriteTextResponse(BaseModel): rewritten_text: str model: Optional[str] = None endpoint: Optional[str] = None context: Optional[str] = None class CaseCreateRewriteRequest(BaseModel): title: str = Field(default="", max_length=500) description: str = Field(..., min_length=1, max_length=10000) class CaseCreateRewriteResponse(BaseModel): title: str description: str model: Optional[str] = None class SagSendEmailRequest(BaseModel): to: List[str] subject: str = Field(..., min_length=1, max_length=998) body_text: str = Field(..., min_length=1) cc: List[str] = Field(default_factory=list) bcc: List[str] = Field(default_factory=list) body_html: Optional[str] = None attachment_file_ids: List[int] = Field(default_factory=list) thread_email_id: Optional[int] = None thread_key: Optional[str] = None class SignatureCanvasRequest(BaseModel): data_url: str = Field(..., min_length=32) class DirectPrintOverrideRequest(BaseModel): printer_host: Optional[str] = None printer_port: Optional[int] = None printer_model: Optional[str] = None label_size: Optional[str] = None hardware_id: Optional[int] = None class SagBuzzwordCreateRequest(BaseModel): buzzword: str = Field(..., min_length=1, max_length=120) class SagBuzzwordSelectionRequest(BaseModel): selected_text: str = Field(..., min_length=1, max_length=2000) class SagListPreferencesUpdate(BaseModel): type_filters: Optional[List[str]] = None column_order: Optional[List[str]] = None hidden_columns: Optional[List[str]] = None class CaseAssignmentsUpdate(BaseModel): group_id: Optional[int] = None user_ids: List[int] = Field(default_factory=list) primary_user_id: Optional[int] = None class CaseAssignmentWithReason(BaseModel): group_id: int = Field(gt=0) primary_user_id: Optional[int] = Field(default=None, gt=0) reason: str = Field(min_length=1, max_length=2000) content: str = Field(min_length=1, max_length=20000) SAG_LIST_COLUMN_KEYS = ( "id", "company", "contact", "description", "type", "priority", "status", "owner", "group", "next_todo", "created", "start", "deferred", "deadline", ) def _normalize_email_list(values: List[str], field_name: str) -> List[str]: cleaned: List[str] = [] for value in values or []: candidate = str(value or "").strip() if not candidate: continue if "@" not in candidate or "." not in candidate.split("@")[-1]: raise HTTPException(status_code=400, detail=f"Invalid email in {field_name}: {candidate}") cleaned.append(candidate) return list(dict.fromkeys(cleaned)) def _normalize_message_id_token(value: Optional[str]) -> Optional[str]: if not value: return None normalized = str(value).strip().strip("<>").lower() normalized = "".join(normalized.split()) return normalized or None def _assert_sag_exists(sag_id: int) -> None: exists = execute_query_single( "SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,), ) if not exists: raise HTTPException(status_code=404, detail="Case not found") def _normalize_buzzword_text(value: Optional[str]) -> str: raw = str(value or "") normalized = " ".join(raw.strip().lower().split()) if not normalized: raise HTTPException(status_code=400, detail="buzzword is required") if len(normalized) > 120: raise HTTPException(status_code=400, detail="buzzword is too long") return normalized def _ensure_buzzword(normalized_word: str) -> dict: existing = execute_query_single( "SELECT id, word FROM buzzwords WHERE word = %s AND deleted_at IS NULL", (normalized_word,), ) if existing: return existing revived = execute_query( """ UPDATE buzzwords SET deleted_at = NULL, created_at = NOW() WHERE id = ( SELECT id FROM buzzwords WHERE word = %s AND deleted_at IS NOT NULL ORDER BY deleted_at DESC NULLS LAST, id DESC LIMIT 1 ) RETURNING id, word """, (normalized_word,), ) if revived: return revived[0] inserted = execute_query( "INSERT INTO buzzwords (word) VALUES (%s) RETURNING id, word", (normalized_word,), ) if not inserted: raise HTTPException(status_code=500, detail="Failed to create buzzword") return inserted[0] def _ensure_sag_buzzword_link(sag_id: int, buzzword_id: int) -> tuple[dict, str]: active = execute_query_single( """ SELECT id, sag_id, buzzword_id, created_at FROM sag_buzzwords WHERE sag_id = %s AND buzzword_id = %s AND deleted_at IS NULL """, (sag_id, buzzword_id), ) if active: return active, "existing" revived = execute_query( """ UPDATE sag_buzzwords SET deleted_at = NULL, created_at = NOW() WHERE id = ( SELECT id FROM sag_buzzwords WHERE sag_id = %s AND buzzword_id = %s AND deleted_at IS NOT NULL ORDER BY deleted_at DESC NULLS LAST, id DESC LIMIT 1 ) RETURNING id, sag_id, buzzword_id, created_at """, (sag_id, buzzword_id), ) if revived: return revived[0], "reactivated" created = execute_query( """ INSERT INTO sag_buzzwords (sag_id, buzzword_id) VALUES (%s, %s) RETURNING id, sag_id, buzzword_id, created_at """, (sag_id, buzzword_id), ) if not created: raise HTTPException(status_code=500, detail="Failed to link buzzword") return created[0], "created" def _derive_thread_key_for_outbound( payload_thread_key: Optional[str], in_reply_to_header: Optional[str], references_header: Optional[str], generated_message_id: Optional[str], ) -> Optional[str]: provided = _normalize_message_id_token(payload_thread_key) if provided: return provided if references_header: for token in re.split(r"[\s,]+", references_header.strip()): normalized = _normalize_message_id_token(token) if normalized: return normalized reply_to = _normalize_message_id_token(in_reply_to_header) if reply_to: return reply_to return _normalize_message_id_token(generated_message_id) def _generate_local_thread_key_for_new_outbound(sag_id: int) -> str: """Generate a stable local thread key for brand-new case emails. This prevents fallback BMCid tags like sXXt001 that cannot be mapped back to a concrete thread later. """ nonce = uuid4().hex[:10] return f"sag{sag_id}-{int(datetime.now().timestamp())}-{nonce}@bmchub.local" def _build_scan_token(sag_id: int, token_type: str) -> str: if token_type == "work_order": return f"BMCSCAN-WO-S{sag_id}-{uuid4().hex[:10].upper()}" # Keep hardware label tokens shorter so Code39 labels stay physically compact. return f"BMCSCAN-HW-{sag_id}-{uuid4().hex[:6].upper()}" def _create_document_token( sag_id: int, token_type: str, user_id: Optional[int] = None, hardware_id: Optional[int] = None, ) -> str: token = _build_scan_token(sag_id, token_type) expires_at = datetime.now() + timedelta(days=30) execute_query( """ INSERT INTO sag_document_tokens ( sag_id, token, token_type, hardware_id, created_by_user_id, expires_at ) VALUES (%s, %s, %s, %s, %s, %s) """, (sag_id, token, token_type, hardware_id, user_id, expires_at), ) return token def _get_setting_value(key: str, fallback: Optional[str] = None) -> Optional[str]: row = execute_query_single("SELECT value FROM settings WHERE key = %s", (key,)) if not row: return fallback value = row.get("value") if value is None: return fallback return str(value) _CODE39_PATTERNS: Dict[str, str] = { "0": "nnnwwnwnn", "1": "wnnwnnnnw", "2": "nnwwnnnnw", "3": "wnwwnnnnn", "4": "nnnwwnnnw", "5": "wnnwwnnnn", "6": "nnwwwnnnn", "7": "nnnwnnwnw", "8": "wnnwnnwnn", "9": "nnwwnnwnn", "A": "wnnnnwnnw", "B": "nnwnnwnnw", "C": "wnwnnwnnn", "D": "nnnnwwnnw", "E": "wnnnwwnnn", "F": "nnwnwwnnn", "G": "nnnnnwwnw", "H": "wnnnnwwnn", "I": "nnwnnwwnn", "J": "nnnnwwwnn", "K": "wnnnnnnww", "L": "nnwnnnnww", "M": "wnwnnnnwn", "N": "nnnnwnnww", "O": "wnnnwnnwn", "P": "nnwnwnnwn", "Q": "nnnnnnwww", "R": "wnnnnnwwn", "S": "nnwnnnwwn", "T": "nnnnwnwwn", "U": "wwnnnnnnw", "V": "nwwnnnnnw", "W": "wwwnnnnnn", "X": "nwnnwnnnw", "Y": "wwnnwnnnn", "Z": "nwwnwnnnn", "-": "nwnnnnwnw", ".": "wwnnnnwnn", " ": "nwwnnnwnn", "$": "nwnwnwnnn", "/": "nwnwnnnwn", "+": "nwnnnwnwn", "%": "nnnwnwnwn", "*": "nwnnwnwnn", } def _render_code39_svg( value: str, height: int = 48, narrow: int = 2, wide: int = 5, gap: int = 2, font_size: int = 11, include_text: bool = True, ) -> str: safe_value = "".join(ch for ch in (value or "").upper() if ch in _CODE39_PATTERNS and ch != "*") if not safe_value: safe_value = "EMPTY" sequence = f"*{safe_value}*" total_width = 12 for ch in sequence: pattern = _CODE39_PATTERNS[ch] for idx, code in enumerate(pattern): stroke = wide if code == "w" else narrow total_width += stroke if idx < len(pattern) - 1: total_width += gap total_width += gap x = 6 bars = [] for ch in sequence: pattern = _CODE39_PATTERNS[ch] for idx, code in enumerate(pattern): stroke = wide if code == "w" else narrow if idx % 2 == 0: bars.append(f'') x += stroke if idx < len(pattern) - 1: x += gap x += gap text_block = "" svg_height = height if include_text: svg_height = height + 20 text_block = ( f'{html.escape(safe_value)}' ) return ( f'' f"{''.join(bars)}" f"{text_block}" f"" ) def _get_signature_template() -> str: default_template = ( "{full_name}\n" "{title}\n" "{company_name}\n" "Telefon: {company_phone}\n" "Email: {email}\n" "Web: {company_website}\n" "Adresse: {company_address}\n" "BMCid: {bmc_id_tag}" ) row = execute_query_single( "SELECT value FROM settings WHERE key = %s", ("email_default_signature_template",), ) value = (row or {}).get("value") if row else None return (value or default_template).strip() def _build_case_bmc_id_tag(sag_id: int, thread_key: Optional[str] = None) -> str: """Build a case+thread marker used in signatures for helpdesk routing hints. Example: s53t472193 - s53 => case id 53 - t472193 => deterministic per-thread suffix (or 001 when unknown) """ if not thread_key: return f"s{sag_id}t001" normalized = re.sub(r"[^a-z0-9]+", "", str(thread_key).lower()) if not normalized: return f"s{sag_id}t001" digest = hashlib.sha1(normalized.encode("utf-8")).hexdigest() thread_suffix = (int(digest[:8], 16) % 900000) + 100000 return f"s{sag_id}t{thread_suffix}" def _render_signature_for_case_email(user_id: int, sag_id: int, thread_key: Optional[str] = None) -> str: user = execute_query_single( "SELECT full_name, email FROM users WHERE user_id = %s", (user_id,), ) or {} company_rows = execute_query( "SELECT key, value FROM settings WHERE key IN ('company_name', 'company_phone', 'company_address', 'company_email', 'company_website')", (), ) or [] company = {row.get("key"): row.get("value") for row in company_rows} context = { "full_name": (user.get("full_name") or "BMC Hub").strip(), "title": "IT-Supporter", "email": (user.get("email") or company.get("company_email") or "").strip(), "company_name": (company.get("company_name") or "BMC Networks ApS").strip(), "company_phone": (company.get("company_phone") or "").strip(), "company_website": (company.get("company_website") or "https://bmcnetworks.dk").strip(), "company_address": (company.get("company_address") or "").strip(), "bmc_id_tag": _build_case_bmc_id_tag(sag_id, thread_key), } template = _get_signature_template() signature = template for key, value in context.items(): signature = signature.replace(f"{{{key}}}", value) if "BMCid:" not in signature: signature = f"{signature}\nBMCid: {context['bmc_id_tag']}" return signature.strip() def _append_signature_to_body(body_text: str, signature: str) -> str: clean_body = (body_text or "").rstrip() clean_signature = (signature or "").strip() if not clean_signature: return clean_body return f"{clean_body}\n\n--\n{clean_signature}" if clean_body else clean_signature def _append_signature_to_html(body_html: Optional[str], signature: str) -> Optional[str]: clean_signature = (signature or "").strip() if not clean_signature: return body_html # If original message is plain text, do not synthesize an HTML-only body. # That can cause clients/providers to display only the signature. if not body_html or not body_html.strip(): return None signature_html = clean_signature.replace("&", "&").replace("<", "<").replace(">", ">").replace("\n", "
") signature_block = ( "
" f"{signature_html}" "
" ) return f"{body_html}{signature_block}" @router.post("/sag/analyze-quick-create", response_model=QuickCreateAnalysis) async def analyze_quick_create(request: QuickCreateRequest): """ Analyze case description text using AI for QuickCreate feature. Returns structured suggestions for customer, technician, priority, tags, etc. """ try: logger.info(f"🔍 QuickCreate analysis requested by user {request.user_id}, text length: {len(request.text)}") # Initialize service and analyze service = CaseAnalysisService() analysis = await service.analyze_case_text(request.text, request.user_id) logger.info(f"✅ QuickCreate analysis complete: confidence={analysis.confidence}, priority={analysis.suggested_priority}") return analysis except Exception as e: logger.error(f"❌ QuickCreate analysis failed: {str(e)}", exc_info=True) raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}") @router.post("/sag/rewrite-case-create", response_model=CaseCreateRewriteResponse) async def rewrite_case_create(request: CaseCreateRewriteRequest): """Return a fact-preserving title and description suggestion for a new case.""" result = await ollama_service.rewrite_case_creation(request.title, request.description) if not result or result.get("error"): raise HTTPException(status_code=502, detail=(result or {}).get("error") or "Could not rewrite case") return CaseCreateRewriteResponse( title=result.get("title", ""), description=result.get("description", ""), model=result.get("model"), ) @router.post("/sag/rewrite-text", response_model=RewriteTextResponse) async def rewrite_sag_text(request: RewriteTextRequest): """Rewrite case/email text using Ollama with configurable prompt.""" try: result = await ollama_service.rewrite_text(request.text, request.context or "case") if not result or result.get("error"): detail = (result or {}).get("error") or "Could not rewrite text" raise HTTPException(status_code=502, detail=detail) return RewriteTextResponse( rewritten_text=result.get("rewritten_text", ""), model=result.get("model"), endpoint=result.get("endpoint"), context=result.get("context"), ) except HTTPException: raise except Exception as e: logger.error("❌ Rewrite text failed: %s", e) raise HTTPException(status_code=500, detail="Failed to rewrite text") @router.post("/rewrite-text", response_model=RewriteTextResponse) async def rewrite_text_global(request: RewriteTextRequest): """Global rewrite alias used by UI flows that should avoid feature-specific route conflicts.""" try: result = await ollama_service.rewrite_text(request.text, request.context or "case") if not result or result.get("error"): detail = (result or {}).get("error") or "Could not rewrite text" raise HTTPException(status_code=502, detail=detail) return RewriteTextResponse( rewritten_text=result.get("rewritten_text", ""), model=result.get("model"), endpoint=result.get("endpoint"), context=result.get("context"), ) except HTTPException: raise except Exception as e: logger.error("❌ Global rewrite text failed: %s", e) raise HTTPException(status_code=500, detail="Failed to rewrite text") # ============================================================================ # SAGER - CRUD Operations # ============================================================================ @router.get("/sag") async def list_sager( status: Optional[str] = Query(None), tag: Optional[str] = Query(None), customer_id: Optional[int] = Query(None), ansvarlig_bruger_id: Optional[int] = Query(None), assigned_group_id: Optional[int] = Query(None), include_deferred: bool = Query(False), q: Optional[str] = Query(None), limit: Optional[int] = Query(None, ge=1, le=200), offset: int = Query(0, ge=0), ): """List all cases with optional filtering.""" try: query = """ SELECT s.*, COALESCE(u.full_name, u.username) AS ansvarlig_navn, g.name AS assigned_group_name FROM sag_sager s LEFT JOIN users u ON u.user_id = s.ansvarlig_bruger_id LEFT JOIN groups g ON g.id = s.assigned_group_id WHERE s.deleted_at IS NULL """ params = [] if not include_deferred: query += " AND (deferred_until IS NULL OR deferred_until <= NOW())" query += " AND (start_date IS NULL OR start_date <= NOW())" if status: query += " AND s.status = %s" params.append(status) if customer_id: query += " AND s.customer_id = %s" params.append(customer_id) if ansvarlig_bruger_id: query += " AND s.ansvarlig_bruger_id = %s" params.append(ansvarlig_bruger_id) if assigned_group_id: query += " AND s.assigned_group_id = %s" params.append(assigned_group_id) if q: query += " AND (LOWER(s.titel) LIKE %s OR CAST(s.id AS TEXT) LIKE %s)" q_like = f"%{q.lower()}%" params.extend([q_like, q_like]) query += " ORDER BY s.created_at DESC" if limit is not None: query += " LIMIT %s OFFSET %s" params.extend([limit, offset]) cases = execute_query(query, tuple(params)) # If tag filter, filter in Python after fetch if tag: case_ids = [case["id"] for case in cases] if case_ids: tag_query = "SELECT sag_id FROM sag_tags WHERE tag_navn = %s AND deleted_at IS NULL" tagged_cases = execute_query(tag_query, (tag,)) tagged_ids = set(t["sag_id"] for t in tagged_cases) cases = [c for c in cases if c["id"] in tagged_ids] return cases except Exception: logger.exception("❌ Error listing cases") raise HTTPException(status_code=500, detail="Failed to list cases") @router.get("/sag/sale-items/all") async def list_all_sale_items( type: Optional[str] = Query(None), status: Optional[str] = Query(None), q: Optional[str] = Query(None), customer_id: Optional[int] = Query(None), sag_id: Optional[int] = Query(None), date_from: Optional[str] = Query(None), date_to: Optional[str] = Query(None), ): """List all sale items across cases (orders overview).""" try: if not _table_exists("sag_salgsvarer"): logger.warning("⚠️ sag_salgsvarer table missing - returning empty sale items list") return [] query = """ SELECT si.*, s.titel AS sag_titel, s.customer_id, c.name AS customer_name FROM sag_salgsvarer si JOIN sag_sager s ON s.id = si.sag_id LEFT JOIN customers c ON c.id = s.customer_id WHERE s.deleted_at IS NULL """ params = [] if type: query += " AND LOWER(si.type) = %s" params.append(type.lower()) if status: query += " AND LOWER(si.status) = %s" params.append(status.lower()) if q: query += " AND (LOWER(si.description) LIKE %s OR LOWER(si.external_ref) LIKE %s OR LOWER(s.titel) LIKE %s OR LOWER(c.name) LIKE %s)" like = f"%{q.lower()}%" params.extend([like, like, like, like]) if customer_id: query += " AND s.customer_id = %s" params.append(customer_id) if sag_id: query += " AND s.id = %s" params.append(sag_id) if date_from: query += " AND si.line_date >= %s" params.append(date_from) if date_to: query += " AND si.line_date <= %s" params.append(date_to) query += " ORDER BY si.line_date DESC NULLS LAST, si.id DESC" return execute_query(query, tuple(params)) or [] except Exception as e: logger.error("❌ Error listing sale items: %s", e) raise HTTPException(status_code=500, detail="Failed to list sale items") @router.post("/sag", dependencies=[Depends(case_create_access)]) async def create_sag(request: Request, data: dict): """Create a case and its optional pipeline/order data atomically.""" try: if not data.get("titel"): raise HTTPException(status_code=400, detail="titel is required") case_type = str(data.get("template_key") or data.get("type", "ticket")).strip().lower() or "ticket" customer_required_types = {"ticket", "salg", "bogholderi", "projekt", "bug_report", "service", "pipeline", "ordre", "opgave", "abonnement"} if case_type == "intern_ticket": # Internal work always belongs to BMC Networks and is owned by its creator. data["customer_id"] = 8 data["customer_id"] = _coerce_optional_int(data.get("customer_id"), "customer_id") if case_type in customer_required_types and not data.get("customer_id"): raise HTTPException(status_code=400, detail="customer_id is required") _validate_customer_id(data.get("customer_id")) status = _normalize_case_status(data.get("status")) deadline = _normalize_optional_timestamp(data.get("deadline"), "deadline") deferred_until = _normalize_optional_timestamp(data.get("deferred_until"), "deferred_until") current_user_id = _get_user_id_from_request(request) raw_responsible = data.get("ansvarlig_bruger_id") if "ansvarlig_bruger_id" in data else current_user_id if case_type == "intern_ticket": raw_responsible = current_user_id ansvarlig_bruger_id = _coerce_optional_int(raw_responsible, "ansvarlig_bruger_id") assigned_group_id = _coerce_optional_int(data.get("assigned_group_id"), "assigned_group_id") _validate_user_id(ansvarlig_bruger_id) _validate_group_id(assigned_group_id) pipeline = data.get("pipeline") order_items = data.get("order_items", []) type_details = data.get("type_details") or {} if not isinstance(type_details, dict): raise HTTPException(status_code=400, detail="type_details skal være et objekt") if len(type_details) > 20: raise HTTPException(status_code=400, detail="For mange typefelter") normalized_type_details = {} for key, value in type_details.items(): if not re.fullmatch(r"[a-z][a-z0-9_]{0,63}", str(key)): raise HTTPException(status_code=400, detail="Ugyldigt typefeltnavn") if value is None: continue if not isinstance(value, (str, int, float, bool)): raise HTTPException(status_code=400, detail="Ugyldig værdi i typefelt") normalized = str(value).strip() if len(normalized) > 10000: raise HTTPException(status_code=400, detail="Et typefelt er for langt") if normalized: normalized_type_details[str(key)] = normalized raw_contact_ids = data.get("contact_ids") or [] if not isinstance(raw_contact_ids, list): raise HTTPException(status_code=400, detail="contact_ids skal være en liste") contact_ids = [] for raw_contact_id in raw_contact_ids: contact_id = _coerce_optional_int(raw_contact_id, "contact_id") if contact_id and contact_id not in contact_ids: contact_ids.append(contact_id) telefoni_opkald_id = _coerce_optional_int(data.get("telefoni_opkald_id"), "telefoni_opkald_id") raw_connection_ids = data.get("internet_connection_ids") or [] if not isinstance(raw_connection_ids, list): raise HTTPException(status_code=400, detail="internet_connection_ids skal være en liste") internet_connection_ids = [] for raw_connection_id in raw_connection_ids: connection_id = _coerce_optional_int(raw_connection_id, "internet_connection_id") if connection_id and connection_id not in internet_connection_ids: internet_connection_ids.append(connection_id) if pipeline is not None and not isinstance(pipeline, dict): raise HTTPException(status_code=400, detail="pipeline skal være et objekt") if not isinstance(order_items, list): raise HTTPException(status_code=400, detail="order_items skal være en liste") conn = get_db_connection() try: with conn.cursor(cursor_factory=RealDictCursor) as cursor: pipeline_values = {"amount": None, "probability": None, "stage_id": None, "description": None} if pipeline: pipeline_values.update({key: pipeline.get(key) for key in pipeline_values}) if pipeline_values["amount"] not in (None, ""): try: pipeline_values["amount"] = float(pipeline_values["amount"]) if not math.isfinite(pipeline_values["amount"]) or pipeline_values["amount"] < 0: raise ValueError("Invalid amount") except (TypeError, ValueError) as exc: raise HTTPException(status_code=400, detail="Pipeline-beløb skal være et tal") from exc else: pipeline_values["amount"] = None if pipeline_values["probability"] not in (None, ""): try: pipeline_values["probability"] = int(pipeline_values["probability"]) except (TypeError, ValueError) as exc: raise HTTPException(status_code=400, detail="Pipeline-sandsynlighed skal være et helt tal") from exc if not 0 <= pipeline_values["probability"] <= 100: raise HTTPException(status_code=400, detail="Pipeline-sandsynlighed skal være mellem 0 og 100") else: pipeline_values["probability"] = None if pipeline_values["stage_id"] not in (None, ""): try: pipeline_values["stage_id"] = int(pipeline_values["stage_id"]) except (TypeError, ValueError) as exc: raise HTTPException(status_code=400, detail="Ugyldig pipeline-stage") from exc cursor.execute("SELECT id FROM pipeline_stages WHERE id = %s", (pipeline_values["stage_id"],)) if not cursor.fetchone(): raise HTTPException(status_code=400, detail="Ugyldig pipeline-stage") else: pipeline_values["stage_id"] = None normalized_items = [] for item in order_items: if not isinstance(item, dict): raise HTTPException(status_code=400, detail="Ugyldig ordrelinje") description = str(item.get("description") or "").strip() item_type = str(item.get("type") or "sale").lower() if not description: raise HTTPException(status_code=400, detail="Ordrelinjens beskrivelse er påkrævet") if item_type not in ("sale", "purchase"): raise HTTPException(status_code=400, detail="Ordrelinjetype skal være køb eller salg") if item.get("amount") in (None, ""): raise HTTPException(status_code=400, detail="Ordrelinjens beløb er påkrævet") try: normalized_items.append({ "type": item_type, "description": description, "quantity": float(item["quantity"]) if item.get("quantity") not in (None, "") else None, "unit": item.get("unit") or None, "unit_price": float(item["unit_price"]) if item.get("unit_price") not in (None, "") else None, "amount": float(item["amount"]), "currency": str(item.get("currency") or "DKK").upper(), "status": str(item.get("status") or "draft").lower(), "line_date": item.get("line_date") or None, "external_ref": item.get("external_ref") or None, "purchase_purpose": _normalize_purchase_purpose(item.get("purchase_purpose"), item_type), }) except (TypeError, ValueError) as exc: raise HTTPException(status_code=400, detail="Ordrelinjens talfelter er ugyldige") from exc if normalized_items[-1]["status"] not in ("draft", "confirmed", "cancelled"): raise HTTPException(status_code=400, detail="Ugyldig ordrelinjestatus") if any(value is not None and (not math.isfinite(value) or value < 0) for value in (normalized_items[-1][key] for key in ("quantity", "unit_price", "amount"))): raise HTTPException(status_code=400, detail="Ordrelinjens tal skal være endelige og mindst nul") cursor.execute( """ INSERT INTO sag_sager (titel, beskrivelse, template_key, type, status, customer_id, ansvarlig_bruger_id, assigned_group_id, created_by_user_id, deadline, deferred_until, deferred_until_case_id, deferred_until_status, pipeline_amount, pipeline_probability, pipeline_stage_id, pipeline_description) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) RETURNING * """, (data.get("titel"), data.get("beskrivelse", ""), case_type, case_type, status, data.get("customer_id"), ansvarlig_bruger_id, assigned_group_id, current_user_id, deadline, deferred_until, data.get("deferred_until_case_id"), data.get("deferred_until_status"), pipeline_values["amount"], pipeline_values["probability"], pipeline_values["stage_id"], pipeline_values["description"]), ) result = cursor.fetchone() if not result: raise HTTPException(status_code=500, detail="Failed to create case") if normalized_type_details: cursor.execute( """INSERT INTO sag_case_details (sag_id, details, created_by_user_id, updated_by_user_id) VALUES (%s, %s::jsonb, %s, %s)""", (result["id"], json.dumps(normalized_type_details), current_user_id, current_user_id), ) anydesk_id = normalized_type_details.get("anydesk_id") if case_type == "ticket" and anydesk_id: if len(anydesk_id) > 64 or not re.fullmatch(r"[0-9][0-9 .-]*", anydesk_id): raise HTTPException(status_code=400, detail="Ugyldigt AnyDesk-ID") cursor.execute( """INSERT INTO sag_anydesk_ids (sag_id, anydesk_id, is_primary, created_by_user_id) VALUES (%s, %s, TRUE, %s) ON CONFLICT (sag_id, anydesk_id) DO UPDATE SET deleted_at=NULL, is_primary=TRUE, updated_at=NOW()""", (result["id"], anydesk_id, current_user_id), ) cursor.execute("UPDATE sag_anydesk_ids SET is_primary=FALSE WHERE sag_id=%s AND anydesk_id<>%s AND deleted_at IS NULL", (result["id"], anydesk_id)) solution = normalized_type_details.get("solution") if case_type == "ticket" and solution: cursor.execute( """INSERT INTO sag_solutions (sag_id, title, description, solution_type, result, created_by_user_id) VALUES (%s, %s, %s, %s, %s, %s) ON CONFLICT (sag_id) DO NOTHING""", (result["id"], data.get("titel"), solution, "case_solution", "draft", current_user_id), ) if contact_ids: cursor.execute("SELECT id FROM contacts WHERE id = ANY(%s)", (contact_ids,)) existing_contact_ids = {int(row["id"]) for row in cursor.fetchall()} missing_contact_ids = [contact_id for contact_id in contact_ids if contact_id not in existing_contact_ids] if missing_contact_ids: raise HTTPException(status_code=400, detail=f"Ugyldig kontakt: {missing_contact_ids[0]}") for index, contact_id in enumerate(contact_ids): cursor.execute( """INSERT INTO sag_kontakter (sag_id, contact_id, role, is_primary) VALUES (%s, %s, 'Kontakt', %s)""", (result["id"], contact_id, index == 0), ) cursor.execute( """INSERT INTO contact_companies (contact_id, customer_id, is_primary, role) VALUES (%s, %s, FALSE, 'Kontakt') ON CONFLICT (contact_id, customer_id) DO NOTHING""", (contact_id, data.get("customer_id")), ) if internet_connection_ids: cursor.execute( """SELECT id FROM internet_connections_connections WHERE id = ANY(%s) AND deleted_at IS NULL""", (internet_connection_ids,), ) existing_connection_ids = {int(row["id"]) for row in cursor.fetchall()} missing_connection_ids = [item for item in internet_connection_ids if item not in existing_connection_ids] if missing_connection_ids: raise HTTPException(status_code=400, detail=f"Internetforbindelsen findes ikke: {missing_connection_ids[0]}") for connection_id in internet_connection_ids: cursor.execute( """INSERT INTO sag_internet_connections (sag_id, connection_id, linked_by_user_id) VALUES (%s,%s,%s) ON CONFLICT DO NOTHING""", (result["id"], connection_id, current_user_id), ) cursor.execute( """INSERT INTO sag_tags (sag_id, tag_navn) SELECT %s, 'internet forbindelse' WHERE NOT EXISTS ( SELECT 1 FROM sag_tags WHERE sag_id = %s AND deleted_at IS NULL AND LOWER(TRIM(tag_navn)) = 'internet forbindelse' )""", (result["id"], result["id"]), ) if telefoni_opkald_id: cursor.execute( """UPDATE telefoni_opkald SET sag_id = %s, kontakt_id = COALESCE(%s, kontakt_id) WHERE id = %s RETURNING id""", (result["id"], contact_ids[0] if contact_ids else None, telefoni_opkald_id), ) if not cursor.fetchone(): raise HTTPException(status_code=400, detail="Det valgte opkald findes ikke") has_purchase_columns = table_has_column("sag_salgsvarer", "purchase_purpose") for item in normalized_items: if has_purchase_columns: cursor.execute( """INSERT INTO sag_salgsvarer (sag_id, type, description, quantity, unit, unit_price, amount, currency, status, line_date, external_ref, purchase_purpose) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""", (result["id"], item["type"], item["description"], item["quantity"], item["unit"], item["unit_price"], item["amount"], item["currency"], item["status"], item["line_date"], item["external_ref"], item["purchase_purpose"]), ) else: cursor.execute( """INSERT INTO sag_salgsvarer (sag_id, type, description, quantity, unit, unit_price, amount, currency, status, line_date, external_ref) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""", (result["id"], item["type"], item["description"], item["quantity"], item["unit"], item["unit_price"], item["amount"], item["currency"], item["status"], item["line_date"], item["external_ref"]), ) from app.modules.sag.backend.create_support import attach_create_relations tag_actions = attach_create_relations(cursor, result["id"], data, current_user_id) conn.commit() result = dict(result) result["tag_actions"] = tag_actions logger.info("✅ Case created: %s", result["id"]) return dict(result) except Exception: conn.rollback() raise finally: release_db_connection(conn) except HTTPException: raise except Exception as e: logger.error("❌ Error creating case: %s", e) raise HTTPException(status_code=500, detail="Failed to create case") @router.get("/sag/{sag_id}/internet-connections") async def list_sag_internet_connections(sag_id: int): return execute_query( """SELECT link.connection_id,link.created_at,ic.name,ic.circuit_number,ic.provider_reference, ic.address,ic.customer_id FROM sag_internet_connections link JOIN internet_connections_connections ic ON ic.id=link.connection_id AND ic.deleted_at IS NULL WHERE link.sag_id=%s ORDER BY link.created_at DESC""", (sag_id,), ) or [] @router.post("/sag/{sag_id}/internet-connections", dependencies=[Depends(case_edit_access)]) async def link_sag_internet_connection(sag_id: int, request: Request, data: dict): connection_id = _coerce_optional_int(data.get("connection_id"), "connection_id") if not connection_id: raise HTTPException(status_code=400, detail="connection_id er påkrævet") if not execute_query_single("SELECT id FROM sag_sager WHERE id=%s AND deleted_at IS NULL", (sag_id,)): raise HTTPException(status_code=404, detail="Sagen findes ikke") if not execute_query_single( "SELECT id FROM internet_connections_connections WHERE id=%s AND deleted_at IS NULL", (connection_id,), ): raise HTTPException(status_code=404, detail="Internetforbindelsen findes ikke") execute_query( """INSERT INTO sag_internet_connections (sag_id,connection_id,linked_by_user_id) VALUES (%s,%s,%s) ON CONFLICT DO NOTHING""", (sag_id, connection_id, _get_user_id_from_request(request)), fetch=False, ) _ensure_case_internet_connection_tag(sag_id) return {"linked": True, "sag_id": sag_id, "connection_id": connection_id} @router.delete("/sag/{sag_id}/internet-connections/{connection_id}", dependencies=[Depends(case_edit_access)]) async def unlink_sag_internet_connection(sag_id: int, connection_id: int): execute_query( "DELETE FROM sag_internet_connections WHERE sag_id=%s AND connection_id=%s", (sag_id, connection_id), fetch=False, ) return {"unlinked": True} @router.get("/sag/{sag_id:int}") async def get_sag(sag_id: int): """Get a specific case.""" try: query = """ SELECT s.*, COALESCE(u.full_name, u.username) AS ansvarlig_navn, g.name AS assigned_group_name FROM sag_sager s LEFT JOIN users u ON u.user_id = s.ansvarlig_bruger_id LEFT JOIN groups g ON g.id = s.assigned_group_id WHERE s.id = %s AND s.deleted_at IS NULL """ result = execute_query(query, (sag_id,)) if not result: raise HTTPException(status_code=404, detail="Case not found") return result[0] except HTTPException: raise except Exception as e: logger.error("❌ Error getting case: %s", e) raise HTTPException(status_code=500, detail="Failed to get case") @router.post("/sag/recent/open/{sag_id:int}") async def mark_sag_recent_open(sag_id: int, request: Request): """Persist that authenticated user opened a case (deduped, newest-first, max 10).""" user_id = _get_user_id_from_request(request) try: case_row = execute_query_single( """ SELECT id, titel FROM sag_sager WHERE id = %s AND deleted_at IS NULL """, (sag_id,), ) if not case_row: raise HTTPException(status_code=404, detail="Case not found") if not _table_exists("sag_recent_cases"): logger.warning("⚠️ sag_recent_cases table missing; skipping recent-open persistence") return { "sag_id": sag_id, "titel": case_row.get("titel"), "opened_at": None, } upserted = execute_query( """ INSERT INTO sag_recent_cases (user_id, sag_id, opened_at) VALUES (%s, %s, NOW()) ON CONFLICT (user_id, sag_id) DO UPDATE SET opened_at = EXCLUDED.opened_at RETURNING user_id, sag_id, opened_at """, (user_id, sag_id), ) execute_query( """ DELETE FROM sag_recent_cases WHERE user_id = %s AND id IN ( SELECT id FROM sag_recent_cases WHERE user_id = %s ORDER BY opened_at DESC, id DESC OFFSET 10 ) """, (user_id, user_id), ) row = (upserted or [{}])[0] return { "sag_id": row.get("sag_id", sag_id), "titel": case_row.get("titel"), "opened_at": row.get("opened_at"), } except HTTPException: raise except Exception as e: logger.error("❌ Error persisting recent case open for user %s and case %s: %s", user_id, sag_id, e) raise HTTPException(status_code=500, detail="Failed to persist recent case open") @router.get("/sag/recent") async def list_recent_sager(request: Request, limit: int = Query(10, ge=1, le=10)): """List authenticated user's recently opened cases (newest first).""" user_id = _get_user_id_from_request(request) try: if not _table_exists("sag_recent_cases"): logger.warning("⚠️ sag_recent_cases table missing; returning empty recent cases") return [] rows = execute_query( """ SELECT r.sag_id, s.titel, r.opened_at FROM sag_recent_cases r JOIN sag_sager s ON s.id = r.sag_id WHERE r.user_id = %s AND s.deleted_at IS NULL ORDER BY r.opened_at DESC, r.id DESC LIMIT %s """, (user_id, limit), ) or [] return [ { "sag_id": row.get("sag_id"), "titel": row.get("titel"), "opened_at": row.get("opened_at"), } for row in rows ] except Exception as e: logger.error("❌ Error listing recent cases for user %s: %s", user_id, e) raise HTTPException(status_code=500, detail="Failed to list recent cases") @router.get("/sag/me/list-preferences") async def get_my_sag_list_preferences(request: Request): user_id = _get_user_id_from_request(request) try: has_columns = table_has_column("user_sag_list_preferences", "column_order") select_fields = "type_filters, column_order, hidden_columns" if has_columns else "type_filters" rows = execute_query( f"SELECT {select_fields} FROM user_sag_list_preferences WHERE user_id = %s", (user_id,), ) or [] if not rows: return {"type_filters": [], "column_order": list(SAG_LIST_COLUMN_KEYS), "hidden_columns": []} raw = rows[0].get("type_filters") parsed = [] if isinstance(raw, list): parsed = raw elif isinstance(raw, str): try: payload = json.loads(raw) if isinstance(payload, list): parsed = payload except Exception: parsed = [] normalized = [] seen = set() for value in parsed: item = str(value or "").strip().lower() if not item or item in seen: continue seen.add(item) normalized.append(item) raw_order = rows[0].get("column_order") if has_columns else None raw_hidden = rows[0].get("hidden_columns") if has_columns else None if isinstance(raw_order, str): try: raw_order = json.loads(raw_order) except Exception: raw_order = [] if isinstance(raw_hidden, str): try: raw_hidden = json.loads(raw_hidden) except Exception: raw_hidden = [] order = [str(key) for key in (raw_order or []) if str(key) in SAG_LIST_COLUMN_KEYS] order.extend(key for key in SAG_LIST_COLUMN_KEYS if key not in order) hidden = [str(key) for key in (raw_hidden or []) if str(key) in SAG_LIST_COLUMN_KEYS] return {"type_filters": normalized, "column_order": order, "hidden_columns": hidden} except Exception as e: if "user_sag_list_preferences" in str(e): return {"type_filters": [], "column_order": list(SAG_LIST_COLUMN_KEYS), "hidden_columns": []} logger.error("❌ Could not load sag list preferences for user %s: %s", user_id, e) raise HTTPException(status_code=500, detail="Failed to load list preferences") @router.get("/sag/me/quick-filter-context") async def get_my_sag_quick_filter_context(request: Request): """Return the authenticated employee and their groups for list quick filters.""" user_id = _get_user_id_from_request(request) rows = execute_query( "SELECT group_id FROM user_groups WHERE user_id = %s ORDER BY group_id", (user_id,), ) or [] return {"user_id": user_id, "group_ids": [row["group_id"] for row in rows]} @router.patch("/sag/me/list-preferences") async def update_my_sag_list_preferences(request: Request, payload: SagListPreferencesUpdate): user_id = _get_user_id_from_request(request) try: normalized = [] seen = set() existing = await get_my_sag_list_preferences(request) for value in (payload.type_filters if payload.type_filters is not None else existing["type_filters"]): item = str(value or "").strip().lower() if not item or item in seen: continue if len(item) > 80: continue seen.add(item) normalized.append(item) requested_order = payload.column_order if payload.column_order is not None else existing["column_order"] column_order = [str(key) for key in requested_order if str(key) in SAG_LIST_COLUMN_KEYS] column_order.extend(key for key in SAG_LIST_COLUMN_KEYS if key not in column_order) requested_hidden = payload.hidden_columns if payload.hidden_columns is not None else existing["hidden_columns"] hidden_columns = list(dict.fromkeys(str(key) for key in requested_hidden if str(key) in SAG_LIST_COLUMN_KEYS)) if not table_has_column("user_sag_list_preferences", "column_order"): raise HTTPException(status_code=503, detail="Kolonnepræferencer kræver den nyeste databasemigration") execute_query( """ INSERT INTO user_sag_list_preferences (user_id, type_filters, column_order, hidden_columns, updated_at) VALUES (%s, %s::jsonb, %s::jsonb, %s::jsonb, NOW()) ON CONFLICT (user_id) DO UPDATE SET type_filters = EXCLUDED.type_filters, column_order = EXCLUDED.column_order, hidden_columns = EXCLUDED.hidden_columns, updated_at = NOW() """, (user_id, json.dumps(normalized), json.dumps(column_order), json.dumps(hidden_columns)), ) return {"type_filters": normalized, "column_order": column_order, "hidden_columns": hidden_columns} except HTTPException: raise except Exception as e: logger.error("❌ Could not update sag list preferences for user %s: %s", user_id, e) raise HTTPException(status_code=500, detail="Failed to save list preferences") @router.get("/sag/{sag_id}/modules") async def get_case_module_prefs(sag_id: int, current_user: dict = Depends(get_current_user)): """Get module visibility preferences for the current user on a case.""" try: user_id = int(current_user["id"]) query = """ SELECT module_key, is_enabled FROM sag_module_prefs WHERE sag_id = %s AND module_key <> 'buzzwords' UNION ALL SELECT module_key, is_enabled FROM user_sag_module_prefs WHERE sag_id = %s AND user_id = %s """ prefs = execute_query(query, (sag_id, sag_id, user_id)) return prefs or [] except Exception as e: logger.error("❌ Error getting module prefs: %s", e) raise HTTPException(status_code=500, detail="Failed to get module prefs") @router.post("/sag/{sag_id}/modules") async def set_case_module_pref( sag_id: int, data: dict, current_user: dict = Depends(get_current_user), ): """Set a module visibility preference, scoped per user for Buzzwords.""" try: module_key = data.get("module_key") is_enabled = data.get("is_enabled") if not module_key or is_enabled is None: raise HTTPException(status_code=400, detail="module_key and is_enabled are required") if module_key == "buzzwords": if not _table_exists("user_sag_module_prefs"): raise HTTPException(status_code=409, detail="Buzzwords-indstillingen er ikke klar. Kør migration 1042 først.") query = """ INSERT INTO user_sag_module_prefs (user_id, sag_id, module_key, is_enabled) VALUES (%s, %s, %s, %s) ON CONFLICT (user_id, sag_id, module_key) DO UPDATE SET is_enabled = EXCLUDED.is_enabled RETURNING module_key, is_enabled """ result = execute_query(query, (int(current_user["id"]), sag_id, module_key, bool(is_enabled))) else: query = """ INSERT INTO sag_module_prefs (sag_id, module_key, is_enabled) VALUES (%s, %s, %s) ON CONFLICT (sag_id, module_key) DO UPDATE SET is_enabled = EXCLUDED.is_enabled RETURNING module_key, is_enabled """ result = execute_query(query, (sag_id, module_key, bool(is_enabled))) return result[0] if result else {"module_key": module_key, "is_enabled": bool(is_enabled)} except HTTPException: raise except Exception as e: logger.error("❌ Error setting module pref: %s", e) raise HTTPException(status_code=500, detail="Failed to set module pref") # ========================================================================= # SAG TODO STEPS # ========================================================================= @router.get("/sag/{sag_id}/assignments", dependencies=[Depends(case_edit_access)]) async def get_case_assignments(sag_id: int, group_id: Optional[int] = Query(None)): """Return selected employees and, when a group is chosen, its available members.""" case_row = execute_query_single( "SELECT id, assigned_group_id, ansvarlig_bruger_id FROM sag_sager WHERE id=%s AND deleted_at IS NULL", (sag_id,), ) if not case_row: raise HTTPException(status_code=404, detail="Case not found") effective_group_id = group_id if group_id is not None else case_row.get("assigned_group_id") selected = execute_query( """ SELECT u.user_id, COALESCE(NULLIF(TRIM(u.full_name), ''), u.username) AS display_name FROM sag_case_assignees a JOIN users u ON u.user_id=a.user_id WHERE a.sag_id=%s ORDER BY display_name """, (sag_id,), ) or [] members = [] if effective_group_id: _validate_group_id(effective_group_id) members = execute_query( """ SELECT u.user_id, COALESCE(NULLIF(TRIM(u.full_name), ''), u.username) AS display_name FROM user_groups ug JOIN users u ON u.user_id=ug.user_id WHERE ug.group_id=%s AND u.is_active=true ORDER BY display_name """, (effective_group_id,), ) or [] return { "group_id": effective_group_id, "primary_user_id": case_row.get("ansvarlig_bruger_id"), "selected_user_ids": [row["user_id"] for row in selected], "members": members, } @router.put("/sag/{sag_id}/assignments", dependencies=[Depends(case_edit_access)]) async def save_case_assignments(sag_id: int, payload: CaseAssignmentsUpdate, request: Request): """Persist every selected employee as its own assignment row.""" case_row = execute_query_single("SELECT id FROM sag_sager WHERE id=%s AND deleted_at IS NULL", (sag_id,)) if not case_row: raise HTTPException(status_code=404, detail="Case not found") user_ids = list(dict.fromkeys(payload.user_ids)) if payload.group_id is None: if user_ids: raise HTTPException(status_code=400, detail="Vælg en gruppe før medarbejdere tildeles") else: _validate_group_id(payload.group_id) group_members = execute_query( "SELECT user_id FROM user_groups WHERE group_id=%s", (payload.group_id,) ) or [] permitted_user_ids = {row["user_id"] for row in group_members} invalid_user_ids = [user_id for user_id in user_ids if user_id not in permitted_user_ids] if invalid_user_ids: raise HTTPException(status_code=400, detail="Alle valgte medarbejdere skal være medlem af den valgte gruppe") primary_user_id = payload.primary_user_id if primary_user_id is not None and primary_user_id not in user_ids: raise HTTPException(status_code=400, detail="Primær ansvarlig skal være blandt de valgte medarbejdere") if primary_user_id is None and user_ids: primary_user_id = user_ids[0] user_id = _get_user_id_from_request(request) execute_query("DELETE FROM sag_case_assignees WHERE sag_id=%s", (sag_id,)) for assignee_id in user_ids: execute_query( "INSERT INTO sag_case_assignees (sag_id, user_id, assigned_by_user_id) VALUES (%s, %s, %s)", (sag_id, assignee_id, user_id), ) execute_query( "UPDATE sag_sager SET assigned_group_id=%s, ansvarlig_bruger_id=%s WHERE id=%s", (payload.group_id, primary_user_id, sag_id), ) return await get_case_assignments(sag_id, payload.group_id) @router.post("/sag/{sag_id}/assign-with-reason", dependencies=[Depends(case_edit_access)]) async def assign_case_with_reason(sag_id: int, payload: CaseAssignmentWithReason, request: Request, current_user: dict = Depends(get_current_user)): """V5: save assignment and its internal explanation in one transaction.""" reason, content = payload.reason.strip(), payload.content.strip() if not reason or not content: raise HTTPException(status_code=400, detail="Kommentar og begrundelse skal udfyldes") if not table_has_column("sag_kommentarer", "er_intern"): raise HTTPException(status_code=409, detail="Interne kommentarer skal være understøttet før tildeling med begrundelse") actor_id = int(current_user["id"]) conn = get_db_connection() try: with conn.cursor(cursor_factory=RealDictCursor) as cursor: cursor.execute("SELECT id, ansvarlig_bruger_id, assigned_group_id FROM sag_sager WHERE id=%s AND deleted_at IS NULL FOR UPDATE", (sag_id,)) previous = cursor.fetchone() if not previous: raise HTTPException(status_code=404, detail="Case not found") cursor.execute("SELECT name FROM groups WHERE id=%s", (payload.group_id,)) group = cursor.fetchone() if not group: raise HTTPException(status_code=400, detail="Gruppen findes ikke") target_name = "Ingen primær ansvarlig" if payload.primary_user_id is not None: cursor.execute("""SELECT COALESCE(NULLIF(TRIM(u.full_name), ''), u.username) AS name FROM users u JOIN user_groups ug ON ug.user_id=u.user_id WHERE u.user_id=%s AND ug.group_id=%s AND u.is_active=true""", (payload.primary_user_id, payload.group_id)) target = cursor.fetchone() if not target: raise HTTPException(status_code=400, detail="Medarbejderen skal være aktiv og medlem af gruppen") target_name = target["name"] cursor.execute("SELECT COALESCE(NULLIF(TRIM(full_name), ''), username) AS name FROM users WHERE user_id=%s", (actor_id,)) actor = cursor.fetchone() if not actor: raise HTTPException(status_code=403, detail="Brugeren findes ikke") cursor.execute("SELECT COALESCE(NULLIF(TRIM(full_name), ''), username) AS name FROM users WHERE user_id=%s", (previous["ansvarlig_bruger_id"],)) old_user = cursor.fetchone() cursor.execute("SELECT name FROM groups WHERE id=%s", (previous["assigned_group_id"],)) old_group = cursor.fetchone() note = (f"{content}\n\nTildeling: {old_user['name'] if old_user else 'Ingen ansvarlig'} → {target_name}" f"\nGruppe: {old_group['name'] if old_group else 'Ingen gruppe'} → {group['name']}" f"\nBegrundelse: {reason}") # V4 displays stored comment HTML. V5 assignment notes are plain # text, including user-entered reasons and employee/group names. note = html.escape(note) # Keep other employees in the chosen group; remove incompatible rows # on a group change rather than discarding all existing colleagues. cursor.execute("""DELETE FROM sag_case_assignees a WHERE a.sag_id=%s AND NOT EXISTS (SELECT 1 FROM user_groups ug WHERE ug.user_id=a.user_id AND ug.group_id=%s)""", (sag_id, payload.group_id)) if payload.primary_user_id is not None: cursor.execute("""INSERT INTO sag_case_assignees (sag_id, user_id, assigned_by_user_id) VALUES (%s, %s, %s) ON CONFLICT (sag_id, user_id) DO NOTHING""", (sag_id, payload.primary_user_id, actor_id)) cursor.execute("UPDATE sag_sager SET assigned_group_id=%s, ansvarlig_bruger_id=%s WHERE id=%s", (payload.group_id, payload.primary_user_id, sag_id)) cursor.execute("""INSERT INTO sag_kommentarer (sag_id, forfatter, indhold, er_system_besked, er_intern) VALUES (%s, %s, %s, false, true) RETURNING *""", (sag_id, actor["name"], note)) comment = dict(cursor.fetchone()) conn.commit() return {"comment": comment, "group_id": payload.group_id, "primary_user_id": payload.primary_user_id} except HTTPException: conn.rollback() raise except Exception: conn.rollback() logger.exception("Could not save assignment with reason for case %s", sag_id) raise HTTPException(status_code=500, detail="Tildeling og kommentar blev ikke gemt") finally: release_db_connection(conn) @router.get("/sag/{sag_id}/todo-steps", response_model=List[TodoStep]) async def list_todo_steps(sag_id: int): try: query = """ SELECT t.*, COALESCE(u_created.full_name, u_created.username) AS created_by_name, COALESCE(u_completed.full_name, u_completed.username) AS completed_by_name FROM sag_todo_steps t LEFT JOIN users u_created ON u_created.user_id = t.created_by_user_id LEFT JOIN users u_completed ON u_completed.user_id = t.completed_by_user_id WHERE t.sag_id = %s AND t.deleted_at IS NULL ORDER BY t.is_done ASC, t.is_next DESC, t.due_date NULLS LAST, t.created_at DESC """ return execute_query(query, (sag_id,)) or [] except Exception as e: logger.error("❌ Error listing todo steps: %s", e) raise HTTPException(status_code=500, detail="Failed to list todo steps") @router.post("/sag/{sag_id}/todo-steps", response_model=TodoStep) async def create_todo_step(sag_id: int, request: Request, data: TodoStepCreate): try: user_id = _get_user_id_from_request(request) if not data.title: raise HTTPException(status_code=400, detail="title is required") insert_query = """ INSERT INTO sag_todo_steps (sag_id, title, description, due_date, created_by_user_id) VALUES (%s, %s, %s, %s, %s) RETURNING id """ result = execute_query(insert_query, ( sag_id, data.title, data.description, data.due_date, user_id )) if not result: raise HTTPException(status_code=500, detail="Failed to create todo step") step_id = result[0]["id"] return execute_query( """ SELECT t.*, COALESCE(u_created.full_name, u_created.username) AS created_by_name, COALESCE(u_completed.full_name, u_completed.username) AS completed_by_name FROM sag_todo_steps t LEFT JOIN users u_created ON u_created.user_id = t.created_by_user_id LEFT JOIN users u_completed ON u_completed.user_id = t.completed_by_user_id WHERE t.id = %s """, (step_id,) )[0] except HTTPException: raise except Exception as e: logger.error("❌ Error creating todo step: %s", e) raise HTTPException(status_code=500, detail="Failed to create todo step") @router.patch("/sag/todo-steps/{step_id}", response_model=TodoStep) async def update_todo_step(step_id: int, request: Request, data: TodoStepUpdate): try: if data.is_done is None and data.is_next is None: raise HTTPException(status_code=400, detail="Provide is_done or is_next") step_row = execute_query_single( "SELECT id, sag_id, is_done FROM sag_todo_steps WHERE id = %s AND deleted_at IS NULL", (step_id,) ) if not step_row: raise HTTPException(status_code=404, detail="Todo step not found") if data.is_done is not None: user_id = _get_user_id_from_request(request) if data.is_done: update_query = """ UPDATE sag_todo_steps SET is_done = TRUE, is_next = FALSE, completed_by_user_id = %s, completed_at = CURRENT_TIMESTAMP WHERE id = %s AND deleted_at IS NULL RETURNING id """ execute_query(update_query, (user_id, step_id)) else: update_query = """ UPDATE sag_todo_steps SET is_done = FALSE, completed_by_user_id = NULL, completed_at = NULL WHERE id = %s AND deleted_at IS NULL RETURNING id """ execute_query(update_query, (step_id,)) if data.is_next is not None: if step_row.get("is_done") and data.is_next: raise HTTPException(status_code=400, detail="Completed todo cannot be marked as next") if data.is_next: execute_query( """ UPDATE sag_todo_steps SET is_next = FALSE WHERE sag_id = %s AND deleted_at IS NULL """, (step_row["sag_id"],) ) execute_query( """ UPDATE sag_todo_steps SET is_next = %s WHERE id = %s AND deleted_at IS NULL """, (bool(data.is_next), step_id) ) return execute_query( """ SELECT t.*, COALESCE(u_created.full_name, u_created.username) AS created_by_name, COALESCE(u_completed.full_name, u_completed.username) AS completed_by_name FROM sag_todo_steps t LEFT JOIN users u_created ON u_created.user_id = t.created_by_user_id LEFT JOIN users u_completed ON u_completed.user_id = t.completed_by_user_id WHERE t.id = %s """, (step_id,) )[0] except HTTPException: raise except Exception as e: logger.error("❌ Error updating todo step: %s", e) raise HTTPException(status_code=500, detail="Failed to update todo step") @router.delete("/sag/todo-steps/{step_id}") async def delete_todo_step(step_id: int): try: result = execute_query( """ UPDATE sag_todo_steps SET deleted_at = CURRENT_TIMESTAMP WHERE id = %s AND deleted_at IS NULL RETURNING id """, (step_id,) ) if not result: raise HTTPException(status_code=404, detail="Todo step not found") return {"status": "deleted"} except HTTPException: raise except Exception as e: logger.error("❌ Error deleting todo step: %s", e) raise HTTPException(status_code=500, detail="Failed to delete todo step") @router.patch("/sag/{sag_id:int}", dependencies=[Depends(case_edit_access)]) async def update_sag(sag_id: int, request: Request, updates: dict = Body(...)): """Update a case.""" try: confirm_close_without_time = updates.pop("confirm_close_without_time", False) is True awaiting_todo = updates.pop("awaiting_todo", None) # Check if case exists check = execute_query( """ SELECT * FROM sag_sager WHERE id = %s AND deleted_at IS NULL """, (sag_id,), ) if not check: raise HTTPException(status_code=404, detail="Case not found") previous_row = check[0] or {} previous_status = str(previous_row.get("status") or "").strip().lower() # Backwards compatibility: frontend sends "type", DB stores "template_key" if "type" in updates and "template_key" not in updates: updates["template_key"] = updates.get("type") if "template_key" in updates: updates["type"] = updates["template_key"] if str(updates.get("template_key") or "").strip().lower() == "intern_ticket": # Keep the same invariant when an existing case is changed to Internal ticket. updates["customer_id"] = 8 updates["ansvarlig_bruger_id"] = _get_user_id_from_request(request) if "status" in updates: updates["status"] = _normalize_case_status(updates.get("status")) closing_statuses = {"lukket"} new_status = str(updates.get("status") or "").strip().lower() case_type = str(previous_row.get("template_key") or "").strip().lower() is_support_case = case_type in {"", "support", "ticket", "quickcreate", "service"} if new_status in closing_statuses and previous_status not in closing_statuses: unfinished_time = execute_query_single( """ SELECT COUNT(*)::int AS count FROM tmodule_times WHERE sag_id = %s AND ( slut_tid IS NULL OR COALESCE( entry_status, CASE WHEN status IN ('approved', 'billed') THEN 'godkendt' ELSE 'afventer' END ) <> 'godkendt' ) """, (sag_id,), ) or {} unfinished_count = int(unfinished_time.get("count") or 0) if unfinished_count: raise HTTPException( status_code=409, detail={ "code": "case_close_blocked_unfinished_time", "message": f"Sagen kan ikke lukkes, fordi {unfinished_count} tidsregistrering(er) stadig er aktive, i kladde eller afventer godkendelse.", }, ) if new_status in closing_statuses and previous_status not in closing_statuses and is_support_case: has_registered_time = execute_query_single( "SELECT EXISTS(SELECT 1 FROM tmodule_times WHERE sag_id = %s) AS has_time", (sag_id,), ) or {} if not bool(has_registered_time.get("has_time")) and not confirm_close_without_time: raise HTTPException( status_code=409, detail={ "code": "close_without_time_confirmation_required", "message": "Der er ikke registreret tid på supportsagen. Bekræft at den skal lukkes uden tid.", }, ) is_awaiting_transition = new_status.startswith("afventer") and not previous_status.startswith("afventer") if is_awaiting_transition: if not isinstance(awaiting_todo, dict): raise HTTPException( status_code=400, detail="En TODO med hvad der afventes er påkrævet, før sagen kan sættes til Afventer", ) todo_title = str(awaiting_todo.get("title") or "").strip() if len(todo_title) < 3: raise HTTPException( status_code=400, detail="TODO-titlen skal beskrive, hvad der afventes", ) awaiting_todo = { "title": todo_title, "description": str(awaiting_todo.get("description") or "").strip() or None, "due_date": awaiting_todo.get("due_date") or None, } else: is_awaiting_transition = False if "deadline" in updates: updates["deadline"] = _normalize_optional_timestamp(updates.get("deadline"), "deadline") if "start_date" in updates: updates["start_date"] = _normalize_optional_timestamp(updates.get("start_date"), "start_date") if "deferred_until" in updates: updates["deferred_until"] = _normalize_optional_timestamp(updates.get("deferred_until"), "deferred_until") if "deferred_until_status" in updates: updates["deferred_until_status"] = _normalize_deferred_statuses(updates.get("deferred_until_status")) if "priority" in updates: updates["priority"] = (str(updates.get("priority") or "").strip().lower() or "normal") if "ansvarlig_bruger_id" in updates: updates["ansvarlig_bruger_id"] = _coerce_optional_int(updates.get("ansvarlig_bruger_id"), "ansvarlig_bruger_id") _validate_user_id(updates["ansvarlig_bruger_id"]) if "assigned_group_id" in updates: updates["assigned_group_id"] = _coerce_optional_int(updates.get("assigned_group_id"), "assigned_group_id") _validate_group_id(updates["assigned_group_id"]) if "customer_id" in updates: updates["customer_id"] = _coerce_optional_int(updates.get("customer_id"), "customer_id") _validate_customer_id(updates["customer_id"]) if "supplier_flow_type" in updates: flow_type = str(updates.get("supplier_flow_type") or "").strip().lower() if flow_type and flow_type not in {"varekob", "ydelse"}: raise HTTPException(status_code=400, detail="supplier_flow_type must be varekob or ydelse") updates["supplier_flow_type"] = flow_type or None if "supplier_flow_confidence" in updates: conf = updates.get("supplier_flow_confidence") if conf in (None, ""): updates["supplier_flow_confidence"] = None else: try: conf_num = float(conf) except (TypeError, ValueError): raise HTTPException(status_code=400, detail="supplier_flow_confidence must be a number between 0 and 1") if conf_num < 0 or conf_num > 1: raise HTTPException(status_code=400, detail="supplier_flow_confidence must be between 0 and 1") updates["supplier_flow_confidence"] = conf_num # Build dynamic update query allowed_fields = [ "titel", "beskrivelse", "template_key", "type", "status", "customer_id", "ansvarlig_bruger_id", "assigned_group_id", "priority", "start_date", "deadline", "deferred_until", "deferred_until_case_id", "deferred_until_status", "supplier_flow_type", "supplier_flow_confidence", ] set_clauses = [] params = [] for field in allowed_fields: if field in updates: set_clauses.append(f"{field} = %s") params.append(updates[field]) if not set_clauses: raise HTTPException(status_code=400, detail="No valid fields to update") params.append(sag_id) set_sql = ", ".join(set_clauses) query = f"UPDATE sag_sager SET {set_sql} WHERE id = %s RETURNING *" # Create the follow-up before changing status: an awaiting case must never # be persisted without its required next action. if is_awaiting_transition and awaiting_todo: try: todo_user_id = _get_user_id_from_request(request) execute_query( """ INSERT INTO sag_todo_steps (sag_id, title, description, due_date, created_by_user_id, is_next) VALUES (%s, %s, %s, %s, %s, true) """, ( sag_id, awaiting_todo["title"], awaiting_todo["description"], awaiting_todo["due_date"], todo_user_id, ), ) except Exception as todo_error: logger.error("Could not create mandatory awaiting TODO for case %s: %s", sag_id, todo_error) raise HTTPException(status_code=500, detail="TODO kunne ikke oprettes; status er ikke ændret") result = execute_query(query, tuple(params)) if result: updated_row = result[0] or {} if "status" in updates: new_status = str(updated_row.get("status") or "").strip().lower() if new_status and new_status != previous_status: _activate_waiting_cases_by_status(sag_id, previous_status, new_status) try: def _norm(value: Optional[object]) -> str: return str(value or "").strip() def _resolve_user_name(user_id: Optional[object]) -> str: if user_id in (None, ""): return "Ingen" row = execute_query_single( """ SELECT COALESCE(NULLIF(TRIM(full_name), ''), NULLIF(TRIM(username), ''), CONCAT('Bruger #', user_id::text)) AS name FROM users WHERE user_id = %s """, (int(user_id),), ) return str((row or {}).get("name") or f"Bruger #{int(user_id)}") def _resolve_group_name(group_id: Optional[object]) -> str: if group_id in (None, ""): return "Ingen" row = execute_query_single( "SELECT COALESCE(NULLIF(TRIM(name), ''), CONCAT('Gruppe #', id::text)) AS name FROM groups WHERE id = %s", (int(group_id),), ) return str((row or {}).get("name") or f"Gruppe #{int(group_id)}") type_labels = { "ticket": "Ticket", "salg": "Salg", "bogholderi": "Bogholderi", "admin": "Admin", "postit": "Post-it", "intern_ticket": "Intern ticket", "bug_report": "Bug_report", "pipeline": "Pipeline", "opgave": "Opgave", "ordre": "Ordre", "projekt": "Projekt", "service": "Service", } change_messages: List[str] = [] changed_by = "System" try: acting_user_id = _get_user_id_from_request(request) acting_user = execute_query_single( """SELECT COALESCE(NULLIF(TRIM(full_name), ''), NULLIF(TRIM(username), ''), CONCAT('Bruger #', user_id::text)) AS name FROM users WHERE user_id = %s""", (acting_user_id,), ) changed_by = str((acting_user or {}).get("name") or f"Bruger #{acting_user_id}") except Exception: pass if "status" in updates: old_value = _norm(previous_row.get("status")) or "-" new_value = _norm(updated_row.get("status")) or "-" if old_value.lower() != new_value.lower(): change_messages.append(f"🔄 Status ændret: {old_value} → {new_value}") if "template_key" in updates or "type" in updates: old_type_key = _norm(previous_row.get("template_key")).lower() or "ticket" new_type_key = _norm(updated_row.get("template_key")).lower() or "ticket" if old_type_key != new_type_key: old_type = type_labels.get(old_type_key, old_type_key.capitalize()) new_type = type_labels.get(new_type_key, new_type_key.capitalize()) change_messages.append(f"🧩 Type ændret: {old_type} → {new_type}") if "priority" in updates: old_priority = _norm(previous_row.get("priority") or "normal").lower() new_priority = _norm(updated_row.get("priority") or "normal").lower() if old_priority != new_priority: priority_labels = { "low": "Lav", "normal": "Normal", "high": "Høj", "urgent": "Akut", } old_label = priority_labels.get(old_priority, old_priority.capitalize() or "-") new_label = priority_labels.get(new_priority, new_priority.capitalize() or "-") change_messages.append(f"⚠️ Prioritet ændret: {old_label} → {new_label}") if "ansvarlig_bruger_id" in updates: old_user = _resolve_user_name(previous_row.get("ansvarlig_bruger_id")) new_user = _resolve_user_name(updated_row.get("ansvarlig_bruger_id")) if old_user != new_user: change_messages.append(f"👤 Ansvarlig ændret: {old_user} → {new_user}") if "assigned_group_id" in updates: old_group = _resolve_group_name(previous_row.get("assigned_group_id")) new_group = _resolve_group_name(updated_row.get("assigned_group_id")) if old_group != new_group: change_messages.append(f"👥 Gruppe ændret: {old_group} → {new_group}") explicitly_logged = {"status", "template_key", "type", "priority", "ansvarlig_bruger_id", "assigned_group_id"} field_labels = { "titel": "Titel", "beskrivelse": "Beskrivelse", "customer_id": "Kunde", "start_date": "Startdato", "deadline": "Deadline", "deferred_until": "Udskudt til", "deferred_until_case_id": "Afventer sag", "deferred_until_status": "Afventer status", "supplier_flow_type": "Leverandørflow", "supplier_flow_confidence": "Leverandørflow-sikkerhed", } for field in allowed_fields: if field not in updates or field in explicitly_logged: continue old_value = _norm(previous_row.get(field)) or "-" new_value = _norm(updated_row.get(field)) or "-" if old_value != new_value: label = field_labels.get(field, field.replace("_", " ").capitalize()) change_messages.append(f"✏️ {label} ændret: {old_value} → {new_value}") for message in change_messages: execute_query( """ INSERT INTO sag_kommentarer (sag_id, forfatter, indhold, er_system_besked) VALUES (%s, %s, %s, %s) """, (sag_id, changed_by, message, True), ) except Exception as comment_log_error: logger.warning("⚠️ Could not log field-change comments for case %s: %s", sag_id, comment_log_error) logger.info("✅ Case updated: %s", sag_id) return updated_row raise HTTPException(status_code=500, detail="Failed to update case") except HTTPException: raise except Exception as e: logger.error("❌ Error updating case: %s", e) raise HTTPException(status_code=500, detail="Failed to update case") # --------------------------------------------------------------------------- # Beskrivelse inline editing with history # --------------------------------------------------------------------------- class BeskrivelsePatch(BaseModel): beskrivelse: str append: bool = False @router.patch("/sag/{sag_id}/beskrivelse", dependencies=[Depends(case_edit_access)]) async def update_sag_beskrivelse(sag_id: int, body: BeskrivelsePatch, request: Request): """Update case description and store a change history entry.""" try: row = execute_query_single( "SELECT id, beskrivelse FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,) ) if not row: raise HTTPException(status_code=404, detail="Case not found") old_beskrivelse = row.get("beskrivelse") # Resolve acting user (may be None for anonymous) user_id = _get_user_id_from_request(request) changed_by_name = None if user_id: u = execute_query_single( "SELECT COALESCE(full_name, username, CONCAT('Bruger #', user_id::text)) AS name FROM users WHERE user_id = %s", (user_id,) ) if u: changed_by_name = u["name"] if body.append: existing_beskrivelse = str(old_beskrivelse or "").rstrip() addition = body.beskrivelse.strip() name_parts = re.findall(r"[A-Za-zÆØÅæøåÀ-ÖØ-öø-ÿ0-9]+", str(changed_by_name or "Bruger")) initials = "".join(part[0].upper() for part in name_parts[:2]) or "BR" append_date = datetime.now().strftime("%d/%m") safe_addition = html.escape(addition).replace("\n", "
") append_fragment = f"
{initials}/{append_date}

{safe_addition}

" new_beskrivelse = f"{existing_beskrivelse}\n{append_fragment}" if existing_beskrivelse else append_fragment else: new_beskrivelse = body.beskrivelse # Write history entry execute_query( """INSERT INTO sag_beskrivelse_history (sag_id, beskrivelse_before, beskrivelse_after, changed_by_user_id, changed_by_name) VALUES (%s, %s, %s, %s, %s)""", (sag_id, old_beskrivelse, new_beskrivelse, user_id, changed_by_name) ) # Update the case execute_query( "UPDATE sag_sager SET beskrivelse = %s, updated_at = NOW() WHERE id = %s", (new_beskrivelse, sag_id) ) logger.info("✅ Beskrivelse updated for sag %s by user %s", sag_id, user_id) return {"ok": True, "beskrivelse": new_beskrivelse} except HTTPException: raise except Exception as e: logger.error("❌ Error updating beskrivelse for sag %s: %s", sag_id, e) raise HTTPException(status_code=500, detail="Failed to update description") @router.get("/sag/{sag_id}/beskrivelse/history") async def get_sag_beskrivelse_history(sag_id: int): """Return the change history for a case's description, newest first.""" exists = execute_query_single( "SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,) ) if not exists: raise HTTPException(status_code=404, detail="Case not found") rows = execute_query( """SELECT id, beskrivelse_before, beskrivelse_after, changed_by_name, changed_at FROM sag_beskrivelse_history WHERE sag_id = %s ORDER BY changed_at DESC LIMIT 50""", (sag_id,) ) or [] return rows class PipelineUpdate(BaseModel): amount: Optional[float] = None probability: Optional[int] = Field(default=None, ge=0, le=100) stage_id: Optional[int] = None description: Optional[str] = None @router.patch("/sag/{sag_id}/pipeline", dependencies=[Depends(case_edit_access)]) async def update_sag_pipeline(sag_id: int, pipeline_data: PipelineUpdate): """Update pipeline fields for a case.""" try: exists = execute_query( "SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,) ) if not exists: raise HTTPException(status_code=404, detail="Case not found") provided = pipeline_data.model_dump(exclude_unset=True) if not provided: raise HTTPException(status_code=400, detail="No pipeline fields provided") if "stage_id" in provided and provided["stage_id"] is not None: stage_exists = execute_query( "SELECT id FROM pipeline_stages WHERE id = %s", (provided["stage_id"],) ) if not stage_exists: raise HTTPException(status_code=400, detail="Invalid pipeline stage") set_clauses = [] params = [] if "amount" in provided: set_clauses.append("pipeline_amount = %s") params.append(provided["amount"]) if "probability" in provided: set_clauses.append("pipeline_probability = %s") params.append(provided["probability"]) if "stage_id" in provided: set_clauses.append("pipeline_stage_id = %s") params.append(provided["stage_id"]) if "description" in provided: set_clauses.append("pipeline_description = %s") params.append(provided["description"]) params.append(sag_id) query = f"UPDATE sag_sager SET {', '.join(set_clauses)} WHERE id = %s RETURNING *" result = execute_query(query, tuple(params)) if not result: raise HTTPException(status_code=500, detail="Failed to update pipeline") logger.info("✅ Pipeline updated for case: %s", sag_id) return result[0] except HTTPException: raise except Exception as e: logger.error("❌ Error updating pipeline for case %s: %s", sag_id, e) raise HTTPException(status_code=500, detail="Failed to update pipeline") @router.delete("/sag/{sag_id:int}", dependencies=[Depends(case_delete_access)]) async def delete_sag(sag_id: int): """Soft-delete a case.""" try: check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") query = "UPDATE sag_sager SET deleted_at = NOW() WHERE id = %s RETURNING id" result = execute_query(query, (sag_id,)) if result: logger.info("✅ Case soft-deleted: %s", sag_id) return {"status": "deleted", "id": sag_id} raise HTTPException(status_code=500, detail="Failed to delete case") except HTTPException: raise except Exception as e: logger.error("❌ Error deleting case: %s", e) raise HTTPException(status_code=500, detail="Failed to delete case") # ============================================================================ # RELATIONER - Case Relations # ============================================================================ @router.get("/sag/{sag_id}/relationer") async def get_relationer(sag_id: int): """Get all relations for a case.""" try: # Check if case exists check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") query = """ SELECT sr.*, ss_kilde.titel as kilde_titel, ss_mål.titel as mål_titel FROM sag_relationer sr JOIN sag_sager ss_kilde ON sr.kilde_sag_id = ss_kilde.id JOIN sag_sager ss_mål ON sr.målsag_id = ss_mål.id WHERE (sr.kilde_sag_id = %s OR sr.målsag_id = %s) AND sr.deleted_at IS NULL ORDER BY sr.created_at DESC """ result = execute_query(query, (sag_id, sag_id)) return result except HTTPException: raise except Exception as e: logger.error("❌ Error getting relations: %s", e) raise HTTPException(status_code=500, detail="Failed to get relations") @router.post("/sag/{sag_id}/relationer", dependencies=[Depends(case_edit_access)]) async def create_relation(sag_id: int, data: dict): """Add a relation to another case.""" try: if not data.get("målsag_id") or not data.get("relationstype"): raise HTTPException(status_code=400, detail="målsag_id and relationstype required") målsag_id, relationstype = _normalize_relation_input(sag_id, data) # Validate both cases exist check1 = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) check2 = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (målsag_id,)) if not check1 or not check2: raise HTTPException(status_code=404, detail="One or both cases not found") duplicate = execute_query( """ SELECT id FROM sag_relationer WHERE kilde_sag_id = %s AND målsag_id = %s AND relationstype = %s AND deleted_at IS NULL """, (sag_id, målsag_id, relationstype), ) if duplicate: raise HTTPException(status_code=409, detail="Relation already exists") query = """ INSERT INTO sag_relationer (kilde_sag_id, målsag_id, relationstype) VALUES (%s, %s, %s) RETURNING * """ result = execute_query(query, (sag_id, målsag_id, relationstype)) if result: logger.info("✅ Relation created: %s -> %s (%s)", sag_id, målsag_id, relationstype) return result[0] raise HTTPException(status_code=500, detail="Failed to create relation") except HTTPException: raise except Exception as e: logger.error("❌ Error creating relation: %s", e) raise HTTPException(status_code=500, detail="Failed to create relation") @router.delete("/sag/{sag_id}/relationer/{relation_id}", dependencies=[Depends(case_edit_access)]) async def delete_relation(sag_id: int, relation_id: int): """Soft-delete a relation.""" try: check = execute_query( "SELECT id FROM sag_relationer WHERE id = %s AND deleted_at IS NULL AND (kilde_sag_id = %s OR målsag_id = %s)", (relation_id, sag_id, sag_id) ) if not check: raise HTTPException(status_code=404, detail="Relation not found") query = "UPDATE sag_relationer SET deleted_at = NOW() WHERE id = %s RETURNING id" result = execute_query(query, (relation_id,)) if result: logger.info("✅ Relation soft-deleted: %s", relation_id) return {"status": "deleted", "id": relation_id} raise HTTPException(status_code=500, detail="Failed to delete relation") except HTTPException: raise except Exception as e: logger.error("❌ Error deleting relation: %s", e) raise HTTPException(status_code=500, detail="Failed to delete relation") # ============================================================================ # TAGS - Case Tags # ============================================================================ @router.get("/sag/tags/all") async def get_all_tags(): """Return all distinct tag names across all cases (for autocomplete).""" rows = execute_query( "SELECT DISTINCT tag_navn FROM sag_tags WHERE deleted_at IS NULL ORDER BY tag_navn ASC LIMIT 200" ) or [] return rows @router.get("/sag/{sag_id}/tags") async def get_tags(sag_id: int): """Get all tags for a case.""" try: check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") query = "SELECT * FROM sag_tags WHERE sag_id = %s AND deleted_at IS NULL ORDER BY created_at DESC" result = execute_query(query, (sag_id,)) return result except HTTPException: raise except Exception as e: logger.error("❌ Error getting tags: %s", e) raise HTTPException(status_code=500, detail="Failed to get tags") @router.post("/sag/{sag_id}/tags", dependencies=[Depends(case_edit_access)]) async def add_tag(sag_id: int, data: dict): """Add a tag to a case.""" try: if not data.get("tag_navn"): raise HTTPException(status_code=400, detail="tag_navn is required") check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") query = """ INSERT INTO sag_tags (sag_id, tag_navn) VALUES (%s, %s) RETURNING * """ result = execute_query(query, (sag_id, data.get("tag_navn"))) if result: logger.info("✅ Tag added: %s -> %s", sag_id, data.get("tag_navn")) return result[0] raise HTTPException(status_code=500, detail="Failed to add tag") except HTTPException: raise except Exception as e: logger.error("❌ Error adding tag: %s", e) raise HTTPException(status_code=500, detail="Failed to add tag") @router.delete("/sag/{sag_id}/tags/{tag_id}", dependencies=[Depends(case_edit_access)]) async def delete_tag(sag_id: int, tag_id: int): """Soft-delete a tag.""" try: check = execute_query( "SELECT id FROM sag_tags WHERE id = %s AND sag_id = %s AND deleted_at IS NULL", (tag_id, sag_id) ) if not check: raise HTTPException(status_code=404, detail="Tag not found") query = "UPDATE sag_tags SET deleted_at = NOW() WHERE id = %s RETURNING id" result = execute_query(query, (tag_id,)) if result: logger.info("✅ Tag soft-deleted: %s", tag_id) return {"status": "deleted", "id": tag_id} raise HTTPException(status_code=500, detail="Failed to delete tag") except HTTPException: raise except Exception as e: logger.error("❌ Error deleting tag: %s", e) raise HTTPException(status_code=500, detail="Failed to delete tag") # ============================================================================ # BUZZWORDS - Case Buzzwords (Free Text) # ============================================================================ @router.get("/sag/buzzwords/all") async def get_all_buzzwords(limit: int = Query(200, ge=1, le=500)): """Return active buzzwords for autocomplete.""" try: rows = execute_query( """ SELECT id, word, created_at FROM buzzwords WHERE deleted_at IS NULL ORDER BY word ASC LIMIT %s """, (limit,), ) or [] return rows except Exception as e: logger.error("❌ Error loading buzzwords: %s", e) raise HTTPException(status_code=500, detail="Failed to load buzzwords") @router.get("/sag/{sag_id}/buzzwords") async def get_case_buzzwords(sag_id: int): """Get buzzwords linked to a case.""" try: _assert_sag_exists(sag_id) rows = execute_query( """ SELECT sb.id AS relation_id, sb.sag_id, b.id AS buzzword_id, b.word, sb.created_at FROM sag_buzzwords sb JOIN buzzwords b ON b.id = sb.buzzword_id WHERE sb.sag_id = %s AND sb.deleted_at IS NULL AND b.deleted_at IS NULL ORDER BY b.word ASC """, (sag_id,), ) or [] return rows except HTTPException: raise except Exception as e: logger.error("❌ Error loading case buzzwords: %s", e) raise HTTPException(status_code=500, detail="Failed to load case buzzwords") @router.post("/sag/{sag_id}/buzzwords") async def add_case_buzzword(sag_id: int, payload: SagBuzzwordCreateRequest): """Create or link a buzzword to a case using normalized free text.""" try: _assert_sag_exists(sag_id) normalized_word = _normalize_buzzword_text(payload.buzzword) buzzword = _ensure_buzzword(normalized_word) relation, link_status = _ensure_sag_buzzword_link(sag_id, int(buzzword["id"])) return { "status": link_status, "relation_id": relation.get("id"), "sag_id": sag_id, "buzzword_id": buzzword.get("id"), "word": buzzword.get("word"), "created_at": relation.get("created_at"), } except HTTPException: raise except Exception as e: logger.error("❌ Error adding case buzzword: %s", e) raise HTTPException(status_code=500, detail="Failed to add case buzzword") @router.post("/sag/{sag_id}/buzzwords/from-selection") async def add_case_buzzword_from_selection(sag_id: int, payload: SagBuzzwordSelectionRequest): """Create a buzzword from selected text and link it to a case.""" return await add_case_buzzword(sag_id, SagBuzzwordCreateRequest(buzzword=payload.selected_text)) @router.delete("/sag/{sag_id}/buzzwords/{buzzword_id}") async def delete_case_buzzword(sag_id: int, buzzword_id: int): """Soft-delete buzzword relation from a case.""" try: _assert_sag_exists(sag_id) relation = execute_query_single( """ SELECT id FROM sag_buzzwords WHERE sag_id = %s AND buzzword_id = %s AND deleted_at IS NULL """, (sag_id, buzzword_id), ) if not relation: raise HTTPException(status_code=404, detail="Buzzword relation not found") execute_query( "UPDATE sag_buzzwords SET deleted_at = NOW() WHERE id = %s", (relation["id"],), ) return { "status": "deleted", "sag_id": sag_id, "buzzword_id": buzzword_id, "relation_id": relation["id"], } except HTTPException: raise except Exception as e: logger.error("❌ Error deleting case buzzword: %s", e) raise HTTPException(status_code=500, detail="Failed to delete case buzzword") # ============================================================================ # CUSTOMERS - Case Customers (Many-to-Many) # ============================================================================ @router.get("/sag/{sag_id}/customers") async def list_case_customers(sag_id: int): """List customers associated with a case.""" try: query = """ SELECT sk.*, c.name as customer_name, c.email as customer_email FROM sag_kunder sk JOIN customers c ON sk.customer_id = c.id WHERE sk.sag_id = %s AND sk.deleted_at IS NULL """ result = execute_query(query, (sag_id,)) return result except Exception as e: logger.error("❌ Error listing case customers: %s", e) raise HTTPException(status_code=500, detail="Failed to list case customers") @router.post("/sag/{sag_id}/customer/replace", dependencies=[Depends(case_edit_access)]) async def replace_case_customer(sag_id: int, payload: dict, request: Request): """Replace the primary customer on a case and keep relations synchronized.""" try: existing_case = execute_query_single( "SELECT id, customer_id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,), ) if not existing_case: raise HTTPException(status_code=404, detail="Case not found") customer_id = _coerce_optional_int((payload or {}).get("customer_id"), "customer_id") if customer_id is None: raise HTTPException(status_code=400, detail="customer_id is required") _validate_customer_id(customer_id) old_customer_id = existing_case.get("customer_id") old_customer = execute_query_single("SELECT name FROM customers WHERE id = %s", (old_customer_id,)) if old_customer_id else None new_customer = execute_query_single("SELECT name FROM customers WHERE id = %s", (customer_id,)) if table_has_column("sag_sager", "customer_id"): execute_query( "UPDATE sag_sager SET customer_id = %s WHERE id = %s", (customer_id, sag_id), ) if _table_exists("sag_kunder"): execute_query( """ UPDATE sag_kunder SET deleted_at = NOW() WHERE sag_id = %s AND customer_id <> %s AND deleted_at IS NULL AND LOWER(COALESCE(role, '')) = 'kunde' """, (sag_id, customer_id), ) existing_link = execute_query_single( """ SELECT id FROM sag_kunder WHERE sag_id = %s AND customer_id = %s AND deleted_at IS NULL LIMIT 1 """, (sag_id, customer_id), ) if existing_link: execute_query( "UPDATE sag_kunder SET role = %s WHERE id = %s", ("Kunde", existing_link["id"]), ) else: execute_query( "INSERT INTO sag_kunder (sag_id, customer_id, role) VALUES (%s, %s, %s)", (sag_id, customer_id, "Kunde"), ) if old_customer_id != customer_id: try: changed_by = "System" try: user_id = _get_user_id_from_request(request) user = execute_query_single( "SELECT COALESCE(NULLIF(TRIM(full_name), ''), NULLIF(TRIM(username), ''), CONCAT('Bruger #', user_id::text)) AS name FROM users WHERE user_id = %s", (user_id,), ) changed_by = str((user or {}).get("name") or changed_by) except Exception: pass execute_query( """ INSERT INTO sag_kommentarer (sag_id, forfatter, indhold, er_system_besked) VALUES (%s, %s, %s, true) """, ( sag_id, changed_by, f"🏢 Firma ændret: {(old_customer or {}).get('name') or 'Ingen kunde'} → {(new_customer or {}).get('name') or f'Kunde #{customer_id}'}", ), ) except Exception as exc: logger.warning("Could not write customer change history for case %s: %s", sag_id, exc) logger.info("✅ Primary customer replaced for case %s -> customer %s", sag_id, customer_id) return {"status": "ok", "sag_id": sag_id, "customer_id": customer_id} except HTTPException: raise except Exception as e: logger.error("❌ Error replacing case customer: %s", e) raise HTTPException(status_code=500, detail="Failed to replace case customer") @router.post("/sag/{sag_id}/customers") async def add_case_customer(sag_id: int, data: dict): """Add a customer to a case.""" try: if not data.get("customer_id"): raise HTTPException(status_code=400, detail="customer_id is required") role = data.get("role", "Kunde") # Check if already exists check = execute_query( "SELECT id FROM sag_kunder WHERE sag_id = %s AND customer_id = %s AND deleted_at IS NULL", (sag_id, data["customer_id"]) ) if check: return check[0] # Already linked query = """ INSERT INTO sag_kunder (sag_id, customer_id, role) VALUES (%s, %s, %s) RETURNING * """ result = execute_query(query, (sag_id, data["customer_id"], role)) if result: logger.info("✅ Customer %s added to case %s", data["customer_id"], sag_id) return result[0] raise HTTPException(status_code=500, detail="Failed to add case customer") except HTTPException: raise except Exception as e: logger.error("❌ Error adding case customer: %s", e) raise HTTPException(status_code=500, detail="Failed to add case customer") @router.delete("/sag/{sag_id}/customers/{customer_id}") async def remove_case_customer(sag_id: int, customer_id: int): """Remove customer from case.""" try: query = "UPDATE sag_kunder SET deleted_at = NOW() WHERE sag_id = %s AND customer_id = %s RETURNING id" result = execute_query(query, (sag_id, customer_id)) if result: logger.info("✅ Customer %s removed from case %s", customer_id, sag_id) return {"status": "deleted"} raise HTTPException(status_code=404, detail="Customer link not found") except HTTPException: raise except Exception as e: logger.error("❌ Error removing case customer: %s", e) raise HTTPException(status_code=500, detail="Failed to remove case customer") # ============================================================================ # CONTACTS - Case Contacts # ============================================================================ @router.get("/sag/{sag_id}/contacts") async def list_case_contacts(sag_id: int): """List contacts associated with a case.""" try: query = """ SELECT sk.*, c.first_name, c.last_name, c.email, c.phone, c.mobile, c.title, company.customer_name FROM sag_kontakter sk JOIN contacts c ON sk.contact_id = c.id LEFT JOIN LATERAL ( SELECT cu.name AS customer_name FROM contact_companies cc JOIN customers cu ON cu.id = cc.customer_id WHERE cc.contact_id = c.id ORDER BY cc.is_primary DESC, cu.name LIMIT 1 ) company ON TRUE WHERE sk.sag_id = %s AND sk.deleted_at IS NULL """ result = execute_query(query, (sag_id,)) return result except Exception as e: logger.error("❌ Error listing case contacts: %s", e) raise HTTPException(status_code=500, detail="Failed to list case contacts") @router.get("/sag/{sag_id}/reply-recipients") async def list_case_reply_recipients(sag_id: int, q: str = ""): """Email-capable case contacts first, followed by contacts from the case customer.""" rows = execute_query( """ WITH target AS (SELECT customer_id FROM sag_sager WHERE id=%s), candidates AS ( SELECT c.id, c.first_name, c.last_name, c.email, c.title, true AS linked FROM sag_kontakter sk JOIN contacts c ON c.id=sk.contact_id WHERE sk.sag_id=%s AND sk.deleted_at IS NULL UNION SELECT c.id, c.first_name, c.last_name, c.email, c.title, false AS linked FROM contact_companies cc JOIN contacts c ON c.id=cc.contact_id JOIN target t ON t.customer_id=cc.customer_id ) SELECT DISTINCT ON (id) * FROM candidates WHERE NULLIF(TRIM(email),'') IS NOT NULL AND (%s='' OR CONCAT_WS(' ',first_name,last_name,email,title) ILIKE '%%' || %s || '%%') ORDER BY id, linked DESC """, (sag_id, sag_id, q.strip(), q.strip()), ) or [] return rows @router.post("/sag/{sag_id}/contacts") async def add_case_contact(sag_id: int, data: dict): """Add a contact to a case.""" try: if not data.get("contact_id"): raise HTTPException(status_code=400, detail="contact_id is required") role = data.get("role", "Kontakt") is_primary = bool(data.get("is_primary", False)) # Check if already exists check = execute_query( "SELECT id FROM sag_kontakter WHERE sag_id = %s AND contact_id = %s AND deleted_at IS NULL", (sag_id, data["contact_id"]) ) if check: return check[0] # Already linked if is_primary: execute_update( "UPDATE sag_kontakter SET is_primary = FALSE WHERE sag_id = %s", (sag_id,) ) query = """ INSERT INTO sag_kontakter (sag_id, contact_id, role, is_primary) VALUES (%s, %s, %s, %s) RETURNING * """ result = execute_query(query, (sag_id, data["contact_id"], role, is_primary)) if result: logger.info("✅ Contact added to case %s: %s", sag_id, data["contact_id"]) return result[0] raise HTTPException(status_code=500, detail="Failed to add contact") except HTTPException: raise except Exception as e: logger.error("❌ Error adding case contact: %s", e) raise HTTPException(status_code=500, detail="Failed to add contact") @router.delete("/sag/{sag_id}/contacts/{contact_id}") async def remove_case_contact(sag_id: int, contact_id: int): """Remove contact from case.""" try: query = "UPDATE sag_kontakter SET deleted_at = NOW() WHERE sag_id = %s AND contact_id = %s RETURNING id" result = execute_query(query, (sag_id, contact_id)) if result: logger.info("✅ Contact %s removed from case %s", contact_id, sag_id) return {"status": "deleted"} raise HTTPException(status_code=404, detail="Contact link not found") except HTTPException: raise except Exception as e: logger.error("❌ Error removing case contact: %s", e) raise HTTPException(status_code=500, detail="Failed to remove case contact") @router.patch("/sag/{sag_id}/contacts/{contact_id}") async def update_case_contact(sag_id: int, contact_id: int, data: dict): """Update role or primary status for a case contact.""" try: existing = execute_query( "SELECT id FROM sag_kontakter WHERE sag_id = %s AND contact_id = %s AND deleted_at IS NULL", (sag_id, contact_id) ) if not existing: raise HTTPException(status_code=404, detail="Contact link not found") role = data.get("role") is_primary = data.get("is_primary") updates = [] params = [] if role is not None: updates.append("role = %s") params.append(role) if is_primary is not None: if bool(is_primary): execute_update( "UPDATE sag_kontakter SET is_primary = FALSE WHERE sag_id = %s", (sag_id,) ) updates.append("is_primary = %s") params.append(bool(is_primary)) if not updates: raise HTTPException(status_code=400, detail="No fields to update") params.extend([sag_id, contact_id]) query = f""" UPDATE sag_kontakter SET {', '.join(updates)} WHERE sag_id = %s AND contact_id = %s RETURNING * """ result = execute_query(query, tuple(params)) if result: return result[0] raise HTTPException(status_code=500, detail="Failed to update contact") except HTTPException: raise except Exception as e: logger.error("❌ Error updating case contact: %s", e) raise HTTPException(status_code=500, detail="Failed to update contact") # ============================================================================ # HARDWARE - Placeholder endpoints for frontend compatibility # ============================================================================ @router.get("/sag/{sag_id}/hardware") async def list_case_hardware(sag_id: int): """List hardware associated with a case.""" try: query = """ SELECT sh.id as relation_id, h.* FROM sag_hardware sh JOIN hardware_assets h ON sh.hardware_id = h.id WHERE sh.sag_id = %s AND sh.deleted_at IS NULL ORDER BY sh.created_at DESC """ result = execute_query(query, (sag_id,)) return result except Exception as e: logger.error("❌ Error listing case hardware: %s", e) raise HTTPException(status_code=500, detail="Failed to list case hardware") @router.get("/sag/{sag_id}/locations/{location_id}/hardware") async def list_case_location_hardware(sag_id: int, location_id: int): """List hardware physically assigned to a case location and its descendants.""" try: case = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not case: raise HTTPException(status_code=404, detail="Case not found") linked_location = execute_query( "SELECT id FROM sag_lokationer WHERE sag_id = %s AND location_id = %s AND deleted_at IS NULL", (sag_id, location_id), ) if not linked_location: raise HTTPException(status_code=404, detail="Location is not linked to this case") return execute_query( """ WITH RECURSIVE location_tree AS ( SELECT id, name, parent_location_id, ARRAY[id] AS path FROM locations_locations WHERE id = %s AND deleted_at IS NULL UNION ALL SELECT child.id, child.name, child.parent_location_id, parent.path || child.id FROM locations_locations child JOIN location_tree parent ON child.parent_location_id = parent.id WHERE child.deleted_at IS NULL AND NOT child.id = ANY(parent.path) ) SELECT h.id, h.asset_type, h.brand, h.model, h.serial_number, h.customer_asset_id, h.internal_asset_id, h.status, tree.id AS location_id, tree.name AS location_name FROM location_tree tree JOIN hardware_assets h ON h.current_location_id = tree.id AND h.deleted_at IS NULL ORDER BY tree.name, h.asset_type, h.brand, h.model, h.serial_number """, (location_id,), ) or [] except HTTPException: raise except Exception as exc: logger.error("❌ Error listing hardware for case %s location %s: %s", sag_id, location_id, exc) raise HTTPException(status_code=500, detail="Failed to list location hardware") @router.post("/sag/{sag_id}/hardware") async def add_case_hardware(sag_id: int, data: dict): """Add hardware to case.""" try: if not data.get("hardware_id"): raise HTTPException(status_code=400, detail="hardware_id is required") hardware_id = data.get("hardware_id") # Check if already linked check = execute_query( "SELECT id FROM sag_hardware WHERE sag_id = %s AND hardware_id = %s AND deleted_at IS NULL", (sag_id, hardware_id) ) if check: return check[0] # Already linked query = """ INSERT INTO sag_hardware (sag_id, hardware_id, note) VALUES (%s, %s, %s) ON CONFLICT (sag_id, hardware_id) DO UPDATE SET deleted_at = NULL, note = EXCLUDED.note RETURNING * """ result = execute_query(query, (sag_id, hardware_id, data.get("note"))) if result: logger.info("✅ Hardware %s added to case %s", hardware_id, sag_id) return result[0] raise HTTPException(status_code=500, detail="Failed to add hardware") except HTTPException: raise except Exception as e: logger.error("❌ Error adding case hardware: %s", e) raise HTTPException(status_code=500, detail="Failed to add hardware") @router.delete("/sag/{sag_id}/hardware/{hardware_id}") async def remove_case_hardware(sag_id: int, hardware_id: int): """Remove hardware from case.""" try: query = "UPDATE sag_hardware SET deleted_at = NOW() WHERE sag_id = %s AND hardware_id = %s RETURNING id" result = execute_query(query, (sag_id, hardware_id)) if result: logger.info("✅ Hardware %s removed from case %s", hardware_id, sag_id) return {"status": "deleted"} raise HTTPException(status_code=404, detail="Hardware link not found") except HTTPException: raise except Exception as e: logger.error("❌ Error removing case hardware: %s", e) raise HTTPException(status_code=500, detail="Failed to remove hardware") # ============================================================================ # LOCATIONS - Placeholder endpoints for frontend compatibility # ============================================================================ @router.get("/sag/{sag_id}/locations") async def list_case_locations(sag_id: int): """List locations associated with a case.""" try: query = """ SELECT sl.id as relation_id, l.* FROM sag_lokationer sl JOIN locations_locations l ON sl.location_id = l.id WHERE sl.sag_id = %s AND sl.deleted_at IS NULL ORDER BY sl.created_at DESC """ result = execute_query(query, (sag_id,)) return result except Exception as e: logger.error("❌ Error listing case locations: %s", e) raise HTTPException(status_code=500, detail="Failed to list case locations") @router.post("/sag/{sag_id}/locations") async def add_case_location(sag_id: int, data: dict): """Add location to case.""" try: if not data.get("location_id"): raise HTTPException(status_code=400, detail="location_id is required") location_id = data.get("location_id") # Check if already linked check = execute_query( "SELECT id FROM sag_lokationer WHERE sag_id = %s AND location_id = %s AND deleted_at IS NULL", (sag_id, location_id) ) if check: return check[0] # Already linked query = """ INSERT INTO sag_lokationer (sag_id, location_id, note) VALUES (%s, %s, %s) ON CONFLICT (sag_id, location_id) DO UPDATE SET deleted_at = NULL, note = EXCLUDED.note RETURNING * """ result = execute_query(query, (sag_id, location_id, data.get("note"))) if result: logger.info("✅ Location %s added to case %s", location_id, sag_id) return result[0] raise HTTPException(status_code=500, detail="Failed to add location") except HTTPException: raise except Exception as e: logger.error("❌ Error adding case location: %s", e) raise HTTPException(status_code=500, detail="Failed to add location") @router.delete("/sag/{sag_id}/locations/{location_id}") async def remove_case_location(sag_id: int, location_id: int): """Remove location from case.""" try: query = """ UPDATE sag_lokationer SET deleted_at = NOW() WHERE sag_id = %s AND deleted_at IS NULL AND (location_id = %s OR id = %s) RETURNING id """ result = execute_query(query, (sag_id, location_id, location_id)) if result: logger.info("✅ Location %s removed from case %s", location_id, sag_id) return {"status": "deleted"} raise HTTPException(status_code=404, detail="Location link not found") except HTTPException: raise except Exception as e: logger.error("❌ Error removing case location: %s", e) raise HTTPException(status_code=500, detail="Failed to remove location") # ============================================================================ # VAREKØB & SALG - Aggregation (Case Tree) # ============================================================================ @router.get("/sag/{sag_id}/varekob-salg") async def get_varekob_salg(sag_id: int, include_subcases: bool = True): """Aggregate time entries (and future sales items) for a case tree.""" try: check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") has_sale_items_table = _table_exists("sag_salgsvarer") if not has_sale_items_table: logger.warning("⚠️ sag_salgsvarer table missing - sale item aggregation skipped for sag_id=%s", sag_id) if include_subcases: case_tree_query = """ WITH RECURSIVE normalized_relations AS ( SELECT CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN målsag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN kilde_sag_id ELSE kilde_sag_id END AS parent_id, CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN kilde_sag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN målsag_id ELSE målsag_id END AS child_id FROM sag_relationer WHERE deleted_at IS NULL ), case_tree AS ( SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL UNION SELECT nr.child_id FROM normalized_relations nr JOIN case_tree ct ON nr.parent_id = ct.id ) SELECT s.id, s.titel FROM sag_sager s JOIN case_tree ct ON s.id = ct.id WHERE s.deleted_at IS NULL ORDER BY s.id """ case_tree = execute_query(case_tree_query, (sag_id,)) time_query = """ WITH RECURSIVE normalized_relations AS ( SELECT CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN målsag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN kilde_sag_id ELSE kilde_sag_id END AS parent_id, CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN kilde_sag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN målsag_id ELSE målsag_id END AS child_id FROM sag_relationer WHERE deleted_at IS NULL ), case_tree AS ( SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL UNION SELECT nr.child_id FROM normalized_relations nr JOIN case_tree ct ON nr.parent_id = ct.id ) SELECT t.*, s.titel AS source_sag_titel FROM tmodule_times t JOIN case_tree ct ON t.sag_id = ct.id LEFT JOIN sag_sager s ON s.id = t.sag_id ORDER BY t.worked_date DESC NULLS LAST, t.id DESC """ time_entries = execute_query(time_query, (sag_id,)) if has_sale_items_table: sale_items_query = """ WITH RECURSIVE normalized_relations AS ( SELECT CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN målsag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN kilde_sag_id ELSE kilde_sag_id END AS parent_id, CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN kilde_sag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN målsag_id ELSE målsag_id END AS child_id FROM sag_relationer WHERE deleted_at IS NULL ), case_tree AS ( SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL UNION SELECT nr.child_id FROM normalized_relations nr JOIN case_tree ct ON nr.parent_id = ct.id ) SELECT si.*, s.titel AS source_sag_titel FROM sag_salgsvarer si JOIN case_tree ct ON si.sag_id = ct.id LEFT JOIN sag_sager s ON s.id = si.sag_id ORDER BY si.line_date DESC NULLS LAST, si.id DESC """ sale_items = execute_query(sale_items_query, (sag_id,)) else: sale_items = [] else: case_tree = execute_query( "SELECT id, titel FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,) ) time_query = """ SELECT t.*, s.titel AS source_sag_titel FROM tmodule_times t LEFT JOIN sag_sager s ON s.id = t.sag_id WHERE t.sag_id = %s ORDER BY t.worked_date DESC NULLS LAST, t.id DESC """ time_entries = execute_query(time_query, (sag_id,)) if has_sale_items_table: sale_items_query = """ SELECT si.*, s.titel AS source_sag_titel FROM sag_salgsvarer si LEFT JOIN sag_sager s ON s.id = si.sag_id WHERE si.sag_id = %s ORDER BY si.line_date DESC NULLS LAST, si.id DESC """ sale_items = execute_query(sale_items_query, (sag_id,)) else: sale_items = [] total_entries = len(time_entries or []) total_hours = 0 billable_hours = 0 sale_total = 0 purchase_total = 0 for entry in time_entries or []: hours = entry.get("approved_hours") or entry.get("original_hours") or 0 total_hours += float(hours) if entry.get("billable"): billable_hours += float(hours) for item in sale_items or []: amount = item.get("amount") or 0 if (item.get("type") or "").lower() == "purchase": purchase_total += float(amount) else: sale_total += float(amount) return { "sag_id": sag_id, "include_subcases": include_subcases, "case_tree": case_tree or [], "time_entries": time_entries or [], "sale_items": sale_items or [], "totals": { "total_entries": total_entries, "total_hours": round(total_hours, 2), "billable_hours": round(billable_hours, 2), "sale_total": round(sale_total, 2), "purchase_total": round(purchase_total, 2), "net_total": round(sale_total - purchase_total, 2) } } except HTTPException: raise except Exception as e: logger.error("❌ Error aggregating case data: %s", e) raise HTTPException(status_code=500, detail="Failed to aggregate case data") @router.get("/sag/{sag_id}/calendar-events") async def get_case_calendar_events(sag_id: int, include_children: bool = True): """Return calendar events for a case and optionally its child cases.""" try: check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") if include_children: case_tree_query = """ WITH RECURSIVE normalized_relations AS ( SELECT CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN målsag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN kilde_sag_id ELSE kilde_sag_id END AS parent_id, CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN kilde_sag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN målsag_id ELSE målsag_id END AS child_id FROM sag_relationer WHERE deleted_at IS NULL ), case_tree AS ( SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL UNION SELECT nr.child_id FROM normalized_relations nr JOIN case_tree ct ON nr.parent_id = ct.id ) SELECT s.id, s.titel FROM sag_sager s JOIN case_tree ct ON s.id = ct.id WHERE s.deleted_at IS NULL ORDER BY s.id """ case_rows = execute_query(case_tree_query, (sag_id,)) or [] else: case_rows = execute_query( "SELECT id, titel FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,) ) or [] case_ids = [row["id"] for row in case_rows] case_titles = {row["id"]: row.get("titel") for row in case_rows} if not case_ids: return {"current": [], "children": []} placeholders = ",".join(["%s"] * len(case_ids)) reminder_query = f""" SELECT r.id, r.sag_id, r.title, r.message, r.event_type, r.priority, r.next_check_at, r.scheduled_at FROM sag_reminders r WHERE r.deleted_at IS NULL AND r.is_active = true AND r.sag_id IN ({placeholders}) """ reminders = execute_query(reminder_query, tuple(case_ids)) or [] case_query = f""" SELECT id, titel, deadline, deferred_until FROM sag_sager WHERE deleted_at IS NULL AND id IN ({placeholders}) """ case_dates = execute_query(case_query, tuple(case_ids)) or [] events_by_case: dict[int, list] = {cid: [] for cid in case_ids} for row in reminders: start_value = row.get("next_check_at") or row.get("scheduled_at") if not start_value: continue events_by_case[row["sag_id"]].append({ "id": f"reminder:{row['id']}", "title": row.get("title"), "message": row.get("message"), "event_kind": row.get("event_type") or "reminder", "start": start_value.isoformat(), "url": f"/sag/{row['sag_id']}/v3" }) for row in case_dates: if row.get("deadline"): events_by_case[row["id"]].append({ "id": f"deadline:{row['id']}", "title": f"Deadline: {row.get('titel')}", "event_kind": "deadline", "start": row["deadline"].isoformat(), "url": f"/sag/{row['id']}/v3" }) if row.get("deferred_until"): events_by_case[row["id"]].append({ "id": f"deferred:{row['id']}", "title": f"Deferred: {row.get('titel')}", "event_kind": "deferred", "start": row["deferred_until"].isoformat(), "url": f"/sag/{row['id']}/v3" }) current_events = events_by_case.get(sag_id, []) children = [] for cid in case_ids: if cid == sag_id: continue children.append({ "case_id": cid, "case_title": case_titles.get(cid) or f"Sag #{cid}", "events": events_by_case.get(cid, []) }) return {"current": current_events, "children": children} except HTTPException: raise except Exception as e: logger.error("❌ Error loading case calendar events: %s", e) raise HTTPException(status_code=500, detail="Failed to load calendar events") # ============================================================================ # VAREKØB & SALG - CRUD (Case-linked sale items) # ============================================================================ _PURCHASE_PURPOSE_VALUES = { "salg", "lager", "asset", "intern_brug", "retur_reklamation", "projekt_omkostning", } def _normalize_purchase_purpose(value: Optional[object], item_type: str) -> Optional[str]: if item_type != "purchase": return None if value is None: return None normalized = str(value).strip().lower() if not normalized: return None if normalized not in _PURCHASE_PURPOSE_VALUES: allowed = ", ".join(sorted(_PURCHASE_PURPOSE_VALUES)) raise HTTPException(status_code=400, detail=f"purchase_purpose must be one of: {allowed}") return normalized def _resolve_purchase_traceability( supplier_invoice_id_value: Optional[object], supplier_invoice_line_id_value: Optional[object], ) -> tuple[Optional[int], Optional[int]]: supplier_invoice_id = _coerce_optional_int(supplier_invoice_id_value, "supplier_invoice_id") supplier_invoice_line_id = _coerce_optional_int(supplier_invoice_line_id_value, "supplier_invoice_line_id") if supplier_invoice_line_id is not None and supplier_invoice_id is None: line_row = execute_query_single( "SELECT supplier_invoice_id FROM supplier_invoice_lines WHERE id = %s", (supplier_invoice_line_id,) ) if not line_row: raise HTTPException(status_code=400, detail="Invalid supplier_invoice_line_id") supplier_invoice_id = int(line_row["supplier_invoice_id"]) if supplier_invoice_id is not None: invoice_exists = execute_query_single( "SELECT id FROM supplier_invoices WHERE id = %s", (supplier_invoice_id,) ) if not invoice_exists: raise HTTPException(status_code=400, detail="Invalid supplier_invoice_id") if supplier_invoice_line_id is not None: line_exists = execute_query_single( "SELECT id, supplier_invoice_id FROM supplier_invoice_lines WHERE id = %s", (supplier_invoice_line_id,) ) if not line_exists: raise HTTPException(status_code=400, detail="Invalid supplier_invoice_line_id") if supplier_invoice_id is not None and int(line_exists["supplier_invoice_id"]) != supplier_invoice_id: raise HTTPException( status_code=400, detail="supplier_invoice_line_id does not belong to supplier_invoice_id", ) return supplier_invoice_id, supplier_invoice_line_id @router.get("/sag/{sag_id}/sale-items") async def list_sale_items(sag_id: int): """List sale items for a case.""" try: check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") if not _table_exists("sag_salgsvarer"): logger.warning("⚠️ sag_salgsvarer table missing - returning empty sale items list for sag_id=%s", sag_id) return [] query = """ SELECT si.*, s.titel AS source_sag_titel FROM sag_salgsvarer si LEFT JOIN sag_sager s ON s.id = si.sag_id WHERE si.sag_id = %s ORDER BY si.line_date DESC NULLS LAST, si.id DESC """ return execute_query(query, (sag_id,)) or [] except HTTPException: raise except Exception as e: logger.error("❌ Error listing sale items: %s", e) raise HTTPException(status_code=500, detail="Failed to list sale items") @router.get("/procurement/overview") async def procurement_overview(): """Operational queue for purchase lines awaiting order, receipt or delivery.""" rows = execute_query( """ SELECT p.id, p.sag_id, p.description, p.quantity, p.unit, p.unit_price, p.amount, p.status, p.line_date, p.external_ref, p.purchase_purpose, p.supplier_invoice_id, p.supplier_invoice_line_id, s.titel AS case_title, c.name AS customer_name, EXISTS ( SELECT 1 FROM sag_salgsvarer sale WHERE sale.sag_id = p.sag_id AND sale.type = 'sale' AND sale.status <> 'cancelled' ) AS has_sales_line, CASE WHEN p.supplier_invoice_line_id IS NOT NULL THEN 'received' WHEN p.status = 'confirmed' THEN 'ordered' ELSE 'to_order' END AS fulfilment_state FROM sag_salgsvarer p JOIN sag_sager s ON s.id = p.sag_id AND s.deleted_at IS NULL LEFT JOIN customers c ON c.id = s.customer_id WHERE p.type = 'purchase' AND p.status <> 'cancelled' ORDER BY CASE WHEN p.supplier_invoice_line_id IS NOT NULL THEN 2 WHEN p.status = 'confirmed' THEN 1 ELSE 0 END, p.line_date NULLS LAST, p.id DESC """ ) or [] counts = {"to_order": 0, "ordered": 0, "received": 0, "missing_sales_order": 0} for row in rows: state = row.get("fulfilment_state") or "to_order" counts[state] = counts.get(state, 0) + 1 if not row.get("has_sales_line"): counts["missing_sales_order"] += 1 return {"items": rows, "counts": counts} @router.post("/sag/{sag_id}/sale-items") async def create_sale_item(sag_id: int, data: dict): """Create a sale item for a case.""" try: check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") description = data.get("description") amount = data.get("amount") if not description: raise HTTPException(status_code=400, detail="description is required") if amount is None: raise HTTPException(status_code=400, detail="amount is required") item_type = (data.get("type") or "sale").lower() if item_type not in ("sale", "purchase"): raise HTTPException(status_code=400, detail="type must be sale or purchase") status = (data.get("status") or "draft").lower() if status not in ("draft", "confirmed", "cancelled"): raise HTTPException(status_code=400, detail="status must be draft, confirmed, or cancelled") has_purchase_columns = table_has_column("sag_salgsvarer", "purchase_purpose") purchase_purpose = None supplier_invoice_id = None supplier_invoice_line_id = None if has_purchase_columns: purchase_purpose = _normalize_purchase_purpose(data.get("purchase_purpose"), item_type) supplier_invoice_id, supplier_invoice_line_id = _resolve_purchase_traceability( data.get("supplier_invoice_id"), data.get("supplier_invoice_line_id"), ) if item_type != "purchase": supplier_invoice_id = None supplier_invoice_line_id = None if has_purchase_columns: query = """ INSERT INTO sag_salgsvarer (sag_id, type, description, quantity, unit, unit_price, amount, currency, status, line_date, external_ref, product_id, purchase_purpose, supplier_invoice_id, supplier_invoice_line_id) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) RETURNING * """ params = ( sag_id, item_type, description, data.get("quantity"), data.get("unit"), data.get("unit_price"), amount, data.get("currency", "DKK"), status, data.get("line_date"), data.get("external_ref"), data.get("product_id"), purchase_purpose, supplier_invoice_id, supplier_invoice_line_id, ) else: query = """ INSERT INTO sag_salgsvarer (sag_id, type, description, quantity, unit, unit_price, amount, currency, status, line_date, external_ref, product_id) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) RETURNING * """ params = ( sag_id, item_type, description, data.get("quantity"), data.get("unit"), data.get("unit_price"), amount, data.get("currency", "DKK"), status, data.get("line_date"), data.get("external_ref"), data.get("product_id"), ) result = execute_query(query, params) if result: logger.info("✅ Sale item created for case %s", sag_id) return result[0] raise HTTPException(status_code=500, detail="Failed to create sale item") except HTTPException: raise except Exception as e: logger.error("❌ Error creating sale item: %s", e) raise HTTPException(status_code=500, detail="Failed to create sale item") @router.post("/sag/{sag_id}/sale-items/batch") async def create_sale_items_batch(sag_id: int, data: dict): """Create purchase and/or sale lines from one selected product atomically. A product lookup is one business action, but it can have two accounting consequences: an expected supplier purchase and a customer sale. Keeping both inserts in one transaction prevents half-created product flows. """ lines = data.get("lines") if isinstance(data, dict) else None if not isinstance(lines, list) or not lines: raise HTTPException(status_code=400, detail="lines must contain at least one item") if len(lines) > 2: raise HTTPException(status_code=400, detail="A product action can contain at most one purchase and one sale line") try: case_exists = execute_query_single( "SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,), ) if not case_exists: raise HTTPException(status_code=404, detail="Case not found") if not _table_exists("sag_salgsvarer"): raise HTTPException(status_code=503, detail="Varelinjer er ikke klar endnu") has_purchase_columns = table_has_column("sag_salgsvarer", "purchase_purpose") normalized_lines = [] seen_types = set() for raw_line in lines: if not isinstance(raw_line, dict): raise HTTPException(status_code=400, detail="Every line must be an object") item_type = str(raw_line.get("type") or "").strip().lower() if item_type not in {"sale", "purchase"}: raise HTTPException(status_code=400, detail="type must be sale or purchase") if item_type in seen_types: raise HTTPException(status_code=400, detail="Only one line of each type is allowed") seen_types.add(item_type) description = str(raw_line.get("description") or "").strip() if not description: raise HTTPException(status_code=400, detail="description is required") try: amount = float(raw_line.get("amount")) except (TypeError, ValueError): raise HTTPException(status_code=400, detail="amount must be a number") if amount < 0: raise HTTPException(status_code=400, detail="amount cannot be negative") status = str(raw_line.get("status") or "draft").strip().lower() if status not in {"draft", "confirmed", "cancelled"}: raise HTTPException(status_code=400, detail="status must be draft, confirmed, or cancelled") purchase_purpose = _normalize_purchase_purpose(raw_line.get("purchase_purpose"), item_type) supplier_invoice_id = supplier_invoice_line_id = None if has_purchase_columns and item_type == "purchase": supplier_invoice_id, supplier_invoice_line_id = _resolve_purchase_traceability( raw_line.get("supplier_invoice_id"), raw_line.get("supplier_invoice_line_id"), ) normalized_lines.append({ "type": item_type, "description": description, "quantity": raw_line.get("quantity"), "unit": raw_line.get("unit"), "unit_price": raw_line.get("unit_price"), "amount": amount, "currency": str(raw_line.get("currency") or "DKK").upper(), "status": status, "line_date": raw_line.get("line_date"), "external_ref": raw_line.get("external_ref"), "product_id": raw_line.get("product_id"), "purchase_purpose": purchase_purpose, "supplier_invoice_id": supplier_invoice_id, "supplier_invoice_line_id": supplier_invoice_line_id, }) conn = get_db_connection() try: with conn.cursor(cursor_factory=RealDictCursor) as cursor: created = [] for line in normalized_lines: if has_purchase_columns: cursor.execute( """ INSERT INTO sag_salgsvarer (sag_id, type, description, quantity, unit, unit_price, amount, currency, status, line_date, external_ref, product_id, purchase_purpose, supplier_invoice_id, supplier_invoice_line_id) VALUES (%(sag_id)s, %(type)s, %(description)s, %(quantity)s, %(unit)s, %(unit_price)s, %(amount)s, %(currency)s, %(status)s, %(line_date)s, %(external_ref)s, %(product_id)s, %(purchase_purpose)s, %(supplier_invoice_id)s, %(supplier_invoice_line_id)s) RETURNING * """, {"sag_id": sag_id, **line}, ) else: cursor.execute( """ INSERT INTO sag_salgsvarer (sag_id, type, description, quantity, unit, unit_price, amount, currency, status, line_date, external_ref, product_id) VALUES (%(sag_id)s, %(type)s, %(description)s, %(quantity)s, %(unit)s, %(unit_price)s, %(amount)s, %(currency)s, %(status)s, %(line_date)s, %(external_ref)s, %(product_id)s) RETURNING * """, {"sag_id": sag_id, **line}, ) created.append(dict(cursor.fetchone())) conn.commit() logger.info("✅ Created %s linked product lines for case %s", len(created), sag_id) return {"created": created} except Exception: conn.rollback() raise finally: release_db_connection(conn) except HTTPException: raise except Exception as e: logger.error("❌ Error creating product lines for case %s: %s", sag_id, e, exc_info=True) raise HTTPException(status_code=500, detail="Failed to create product lines") @router.get("/sag/{sag_id}/sale-items/{item_id}") async def get_sale_item(sag_id: int, item_id: int): """Get a single sale item for a case.""" try: query = """ SELECT si.*, s.titel AS source_sag_titel FROM sag_salgsvarer si LEFT JOIN sag_sager s ON s.id = si.sag_id WHERE si.sag_id = %s AND si.id = %s """ result = execute_query(query, (sag_id, item_id)) if not result: raise HTTPException(status_code=404, detail="Sale item not found") return result[0] except HTTPException: raise except Exception as e: logger.error("❌ Error getting sale item: %s", e) raise HTTPException(status_code=500, detail="Failed to get sale item") @router.patch("/sag/{sag_id}/sale-items/{item_id}") async def update_sale_item(sag_id: int, item_id: int, updates: dict = Body(...)): """Update a sale item for a case.""" try: check = execute_query( "SELECT id, type FROM sag_salgsvarer WHERE id = %s AND sag_id = %s", (item_id, sag_id) ) if not check: raise HTTPException(status_code=404, detail="Sale item not found") allowed_fields = [ "type", "description", "quantity", "unit", "unit_price", "amount", "currency", "status", "line_date", "external_ref", "product_id", "purchase_purpose", "supplier_invoice_id", "supplier_invoice_line_id", ] set_clauses = [] params = [] has_purchase_columns = table_has_column("sag_salgsvarer", "purchase_purpose") current_type = (check[0].get("type") or "sale").lower() next_type = current_type if "type" in updates: next_type = (updates.get("type") or "").lower() for field in allowed_fields: if field in updates: if field == "type": value = (updates[field] or "").lower() if value not in ("sale", "purchase"): raise HTTPException(status_code=400, detail="type must be sale or purchase") set_clauses.append("type = %s") params.append(value) elif field == "status": value = (updates[field] or "").lower() if value not in ("draft", "confirmed", "cancelled"): raise HTTPException(status_code=400, detail="status must be draft, confirmed, or cancelled") set_clauses.append("status = %s") params.append(value) elif field == "purchase_purpose": if not has_purchase_columns: continue value = _normalize_purchase_purpose(updates.get(field), next_type) set_clauses.append("purchase_purpose = %s") params.append(value) elif field in ("supplier_invoice_id", "supplier_invoice_line_id"): # handled together below to keep consistency between IDs continue else: set_clauses.append(f"{field} = %s") params.append(updates[field]) if has_purchase_columns and ( "supplier_invoice_id" in updates or "supplier_invoice_line_id" in updates or next_type != current_type ): raw_supplier_invoice_id = updates.get("supplier_invoice_id") if "supplier_invoice_id" in updates else None raw_supplier_invoice_line_id = updates.get("supplier_invoice_line_id") if "supplier_invoice_line_id" in updates else None if "supplier_invoice_id" not in updates or "supplier_invoice_line_id" not in updates: current_refs = execute_query_single( "SELECT supplier_invoice_id, supplier_invoice_line_id FROM sag_salgsvarer WHERE id = %s AND sag_id = %s", (item_id, sag_id) ) or {} if "supplier_invoice_id" not in updates: raw_supplier_invoice_id = current_refs.get("supplier_invoice_id") if "supplier_invoice_line_id" not in updates: raw_supplier_invoice_line_id = current_refs.get("supplier_invoice_line_id") supplier_invoice_id, supplier_invoice_line_id = _resolve_purchase_traceability( raw_supplier_invoice_id, raw_supplier_invoice_line_id, ) if next_type != "purchase": supplier_invoice_id = None supplier_invoice_line_id = None set_clauses.append("supplier_invoice_id = %s") params.append(supplier_invoice_id) set_clauses.append("supplier_invoice_line_id = %s") params.append(supplier_invoice_line_id) if has_purchase_columns and next_type != "purchase": if "purchase_purpose" not in updates: set_clauses.append("purchase_purpose = %s") params.append(None) if not set_clauses: raise HTTPException(status_code=400, detail="No valid fields to update") params.extend([item_id, sag_id]) query = f"UPDATE sag_salgsvarer SET {', '.join(set_clauses)} WHERE id = %s AND sag_id = %s RETURNING *" result = execute_query(query, tuple(params)) if result: logger.info("✅ Sale item updated: %s", item_id) return result[0] raise HTTPException(status_code=500, detail="Failed to update sale item") except HTTPException: raise except Exception as e: logger.error("❌ Error updating sale item: %s", e) raise HTTPException(status_code=500, detail="Failed to update sale item") @router.delete("/sag/{sag_id}/sale-items/{item_id}") async def delete_sale_item(sag_id: int, item_id: int): """Delete a sale item for a case.""" try: query = "DELETE FROM sag_salgsvarer WHERE id = %s AND sag_id = %s RETURNING id" result = execute_query(query, (item_id, sag_id)) if result: logger.info("✅ Sale item deleted: %s", item_id) return {"status": "deleted", "id": item_id} raise HTTPException(status_code=404, detail="Sale item not found") except HTTPException: raise except Exception as e: logger.error("❌ Error deleting sale item: %s", e) raise HTTPException(status_code=500, detail="Failed to delete sale item") # ============================================================================ # KOMMENTARER - Case Comments # ============================================================================ @router.get("/sag/{sag_id}/kommentarer") async def get_kommentarer(sag_id: int): """Get all comments for a case.""" try: check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") query = "SELECT * FROM sag_kommentarer WHERE sag_id = %s AND deleted_at IS NULL ORDER BY created_at DESC" result = execute_query(query, (sag_id,)) return result except HTTPException: raise except Exception as e: logger.error("❌ Error getting comments: %s", e) raise HTTPException(status_code=500, detail="Failed to get comments") def _get_case_linked_activities(case_ids: List[int]) -> List[Dict[str, Any]]: """Return non-billable source activities linked directly to cases.""" if not case_ids: return [] placeholders = ",".join(["%s"] * len(case_ids)) activities: List[Dict[str, Any]] = [] if _table_exists("telefoni_opkald"): call_query = f""" SELECT t.id, t.sag_id, t.direction, t.ekstern_nummer, t.intern_extension, t.started_at, t.ended_at, t.duration_sec, COALESCE(NULLIF(TRIM(u.full_name), ''), NULLIF(TRIM(u.username), ''), 'Ukendt medarbejder') AS actor_name, NULLIF(TRIM(CONCAT(COALESCE(c.first_name, ''), ' ', COALESCE(c.last_name, ''))), '') AS contact_name FROM telefoni_opkald t LEFT JOIN users u ON u.user_id = t.bruger_id LEFT JOIN contacts c ON c.id = t.kontakt_id WHERE t.sag_id IN ({placeholders}) ORDER BY t.started_at DESC, t.id DESC LIMIT 600 """ for row in execute_query(call_query, tuple(case_ids)) or []: started_at = row.get("started_at") if not started_at: continue direction = str(row.get("direction") or "inbound").lower() duration_seconds = row.get("duration_sec") if duration_seconds is not None and not 0 <= float(duration_seconds) <= 43200: duration_seconds = None if duration_seconds is None and row.get("ended_at") and isinstance(started_at, datetime) and isinstance(row.get("ended_at"), datetime): calculated_seconds = int((row["ended_at"] - started_at).total_seconds()) duration_seconds = calculated_seconds if 0 <= calculated_seconds <= 43200 else None activities.append({ "id": f"call:{row.get('id')}", "source_id": row.get("id"), "activity_type": "call", "sag_id": row.get("sag_id"), "timestamp": started_at.isoformat() if isinstance(started_at, datetime) else str(started_at), "ended_at": row.get("ended_at").isoformat() if isinstance(row.get("ended_at"), datetime) else row.get("ended_at"), "duration_minutes": round(float(duration_seconds or 0) / 60, 1), "actor_name": str(row.get("actor_name") or "Ukendt medarbejder"), "contact_name": row.get("contact_name"), "number": row.get("ekstern_nummer"), "direction": direction, "title": "Udgående opkald" if direction == "outbound" else "Indgående opkald", "status": "completed" if row.get("ended_at") else "started", }) if _table_exists("anydesk_sessions"): anydesk_query = f""" SELECT a.id, a.anydesk_session_id, a.sag_id, a.started_at, a.ended_at, a.duration_minutes, a.status, COALESCE(NULLIF(TRIM(u.full_name), ''), NULLIF(TRIM(u.username), ''), 'Ukendt medarbejder') AS actor_name, NULLIF(TRIM(CONCAT(COALESCE(c.first_name, ''), ' ', COALESCE(c.last_name, ''))), '') AS contact_name FROM anydesk_sessions a LEFT JOIN users u ON u.user_id = a.created_by_user_id LEFT JOIN contacts c ON c.id = a.contact_id WHERE a.sag_id IN ({placeholders}) ORDER BY a.started_at DESC, a.id DESC LIMIT 600 """ for row in execute_query(anydesk_query, tuple(case_ids)) or []: started_at = row.get("started_at") if not started_at: continue duration_minutes = row.get("duration_minutes") if duration_minutes is None and row.get("ended_at") and isinstance(started_at, datetime) and isinstance(row.get("ended_at"), datetime): duration_minutes = max(0, round((row["ended_at"] - started_at).total_seconds() / 60, 1)) activities.append({ "id": f"anydesk:{row.get('id')}", "source_id": row.get("id"), "external_id": row.get("anydesk_session_id"), "activity_type": "anydesk", "sag_id": row.get("sag_id"), "timestamp": started_at.isoformat() if isinstance(started_at, datetime) else str(started_at), "ended_at": row.get("ended_at").isoformat() if isinstance(row.get("ended_at"), datetime) else row.get("ended_at"), "duration_minutes": float(duration_minutes or 0), "actor_name": str(row.get("actor_name") or "Ukendt medarbejder"), "contact_name": row.get("contact_name"), "title": "AnyDesk-session", "status": str(row.get("status") or "unknown"), }) activities.sort(key=lambda item: str(item.get("timestamp") or ""), reverse=True) return activities @router.get("/sag/{sag_id}/linked-activities") async def get_case_linked_activities(sag_id: int): _assert_sag_exists(sag_id) activities = _get_case_linked_activities([sag_id]) return {"activities": activities, "total": len(activities)} def _normalized_case_relation_sql() -> str: return """SELECT CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN målsag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN kilde_sag_id ELSE kilde_sag_id END AS parent_id, CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN kilde_sag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN målsag_id ELSE målsag_id END AS child_id, relationstype FROM sag_relationer WHERE deleted_at IS NULL""" def _load_case_tree(sag_id: int, include_all: bool = True) -> tuple[list[dict], bool]: """Return the focused case's whole connected parent/child tree, cycle safe.""" relations = execute_query( f"""WITH RECURSIVE normalized AS ({_normalized_case_relation_sql()}), connected(case_id) AS ( SELECT %s UNION SELECT CASE WHEN n.parent_id = c.case_id THEN n.child_id ELSE n.parent_id END FROM connected c JOIN normalized n ON n.parent_id = c.case_id OR n.child_id = c.case_id ) SELECT DISTINCT s.id, s.titel, s.status, s.type FROM connected c JOIN sag_sager s ON s.id = c.case_id WHERE s.deleted_at IS NULL ORDER BY s.id""", (sag_id,), ) or [] if not include_all: relations = [row for row in relations if row.get("id") == sag_id] ids = {row.get("id") for row in relations} if not ids: return [], False marks = ",".join(["%s"] * len(ids)) edges = execute_query( f"""WITH normalized AS ({_normalized_case_relation_sql()}) SELECT n.parent_id, n.child_id, n.relationstype, p.titel AS parent_title, c.titel AS child_title FROM normalized n JOIN sag_sager p ON p.id = n.parent_id AND p.deleted_at IS NULL JOIN sag_sager c ON c.id = n.child_id AND c.deleted_at IS NULL WHERE n.parent_id IN ({marks}) AND n.child_id IN ({marks}) ORDER BY n.parent_id, n.child_id""", tuple(ids) + tuple(ids), ) or [] nodes = {row["id"]: {"id": row["id"], "title": row.get("titel") or f"Sag #{row['id']}", "children": []} for row in relations} parents: dict[int, list[int]] = {case_id: [] for case_id in ids} for edge in edges: parent_id, child_id = edge.get("parent_id"), edge.get("child_id") if parent_id not in nodes or child_id not in nodes: continue parents[child_id].append(parent_id) nodes[parent_id]["children"].append({ "id": child_id, "title": nodes[child_id]["title"], "relation_type": edge.get("relationstype") or "", }) def prune(node_id: int, path: set[int]) -> dict: node = dict(nodes[node_id]) node["is_current"] = node_id == sag_id node["relation"] = "current" if node_id == sag_id else ("parent" if sag_id in _descendant_ids(node_id, nodes) else "child") children = [] for child in node["children"]: child_id = child["id"] if child_id in path: continue children.append({**prune(child_id, path | {child_id}), "relation_type": child.get("relation_type")}) node["children"] = children return node # Render each root so multiple parent branches remain visible. A pure cycle # has no root; start at the focused case and let the visited path break it. root_ids = sorted(case_id for case_id in ids if not parents.get(case_id)) if not root_ids: root_ids = [sag_id] return [prune(root_id, {root_id}) for root_id in root_ids], False def _descendant_ids(node_id: int, nodes: dict[int, dict]) -> set[int]: found: set[int] = set() stack = list(nodes.get(node_id, {}).get("children", [])) while stack: item = stack.pop() child_id = item.get("id") if child_id in found: continue found.add(child_id) stack.extend(nodes.get(child_id, {}).get("children", [])) return found def _ancestors_for_case(case_id: int, parents_by_child: dict[int, set[int]]) -> set[int]: found: set[int] = set() pending = list(parents_by_child.get(case_id, set())) while pending: parent_id = pending.pop() if parent_id == case_id or parent_id in found: continue found.add(parent_id) pending.extend(parents_by_child.get(parent_id, set())) return found @router.get("/sag/{sag_id}/case-tree") async def get_sag_case_tree(sag_id: int): check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") tree, truncated = _load_case_tree(sag_id) return {"tree": tree, "truncated": truncated, "max_depth": None} @router.get("/sag/{sag_id}/timeline") async def get_sag_timeline( sag_id: int, include_subcases: bool = Query(False), whole_tree: bool = Query(False), relation_types: Optional[str] = Query(None), event_types: Optional[str] = Query(None), search: Optional[str] = Query(None, max_length=200), limit: Optional[int] = Query(None, ge=1, le=200), cursor: Optional[str] = Query(None, max_length=1000), ): """Return a unified timeline for the case with optional child cases.""" try: check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") if whole_tree: tree_roots, tree_truncated = _load_case_tree(sag_id) case_rows = [] def collect_tree_cases(nodes: list[dict]) -> None: for node in nodes: case_rows.append({"id": node["id"], "titel": node.get("title")}) collect_tree_cases(node.get("children") or []) collect_tree_cases(tree_roots) elif include_subcases: case_tree_query = """ WITH RECURSIVE normalized_relations AS ( SELECT CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN målsag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN kilde_sag_id ELSE kilde_sag_id END AS parent_id, CASE WHEN LOWER(relationstype) IN ('afledt af', 'afledt_af') THEN kilde_sag_id WHEN LOWER(relationstype) IN ('årsag til', 'årsag_til') THEN målsag_id ELSE målsag_id END AS child_id FROM sag_relationer WHERE deleted_at IS NULL ), case_tree AS ( SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL UNION SELECT nr.child_id FROM normalized_relations nr JOIN case_tree ct ON nr.parent_id = ct.id ) SELECT s.id, s.titel FROM sag_sager s JOIN case_tree ct ON s.id = ct.id WHERE s.deleted_at IS NULL ORDER BY s.id """ case_rows = execute_query(case_tree_query, (sag_id,)) or [] else: tree_truncated = False case_rows = execute_query( "SELECT id, titel FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,) ) or [] case_ids = [row.get("id") for row in case_rows if row.get("id") is not None] if not case_ids: return {"case_tree": [], "events": [], "total": 0} placeholders = ",".join(["%s"] * len(case_ids)) comments_query = f""" SELECT c.*, s.titel AS source_sag_titel FROM sag_kommentarer c LEFT JOIN sag_sager s ON s.id = c.sag_id WHERE c.deleted_at IS NULL AND c.sag_id IN ({placeholders}) ORDER BY c.created_at DESC LIMIT 800 """ comments = execute_query(comments_query, tuple(case_ids)) or [] beskrivelse_history = [] if _table_exists("sag_beskrivelse_history"): history_query = f""" SELECT h.id, h.sag_id, h.beskrivelse_before, h.beskrivelse_after, h.changed_by_name, h.changed_at, s.titel AS source_sag_titel FROM sag_beskrivelse_history h LEFT JOIN sag_sager s ON s.id = h.sag_id WHERE h.sag_id IN ({placeholders}) ORDER BY h.changed_at DESC LIMIT 400 """ beskrivelse_history = execute_query(history_query, tuple(case_ids)) or [] def _detect_source(text: Optional[str]) -> str: value = str(text or "").lower() if re.search(r"\bemail\b|\be-mail\b|✉️|📧|email-kladde|mail\b|indgaaende email|udgaaende email|indgående email|udgående email", value): return "email" if re.search(r"\bsms\b|💬", value): return "sms" if re.search(r"\bopkald\b|\bring\b|\bringet\b|📞|click-to-call|yealink", value): return "call" return "module" def _detect_field_change_subtype(text: Optional[str]) -> Optional[str]: value = str(text or "").lower() if re.search(r"\bstatus\b.*\b(ændret|ændring|skiftet|opdateret|sat til)\b|\bændret status\b|\bstatus:\s*.*->|\bstatus\s*->", value): return "status" if re.search(r"\b(type|sagstype|template_key|template key)\b.*\b(ændret|ændring|skiftet|opdateret|sat til)\b|\bændret type\b|\btype:\s*.*->|\btemplate_key\b", value): return "type" if re.search(r"\b(prioritet|priority)\b.*\b(ændret|ændring|skiftet|opdateret|sat til)\b|\bændret prioritet\b|\bprioritet:\s*.*->", value): return "priority" if re.search(r"\b(ansvarlig|assignee|owner|ansvarlig_bruger_id|ansvarlig bruger)\b.*\b(ændret|ændring|skiftet|opdateret|sat til|tildelt)\b|\bændret ansvarlig\b|\bansvarlig:\s*.*->|\bassign(ed)? to\b", value): return "assignee" if re.search(r"\b(gruppe|team|assigned_group_id|assigned group|gruppe-id)\b.*\b(ændret|ændring|skiftet|opdateret|sat til|tildelt)\b|\bændret gruppe\b|\bgruppe:\s*.*->", value): return "group" return None events = [] for activity in _get_case_linked_activities(case_ids): duration = float(activity.get("duration_minutes") or 0) duration_text = f"{duration:g} min" if duration > 0 else "Varighed ikke registreret" contact = str(activity.get("contact_name") or activity.get("number") or "Ukendt kontakt") activity_type = str(activity.get("activity_type") or "activity") description = f"{contact}\n{duration_text}" if activity_type == "call" and activity.get("number") and activity.get("contact_name"): description = f"{contact} · {activity.get('number')}\n{duration_text}" events.append({ "id": activity.get("id"), "event_type": activity_type, "event_subtype": activity.get("direction") or activity.get("status"), "source": "call" if activity_type == "call" else "anydesk", "timestamp": activity.get("timestamp"), "sag_id": activity.get("sag_id"), "sag_titel": next((row.get("titel") for row in case_rows if row.get("id") == activity.get("sag_id")), None), "forfatter": activity.get("actor_name") or "System", "title": activity.get("title"), "description": description, }) case_details_query = f""" SELECT s.id, s.titel, s.created_at, COALESCE(NULLIF(TRIM(u.full_name), ''), NULLIF(TRIM(u.username), ''), 'System') AS created_by_name FROM sag_sager s LEFT JOIN users u ON u.user_id = s.created_by_user_id WHERE s.id IN ({placeholders}) """ for row in execute_query(case_details_query, tuple(case_ids)) or []: created_at = row.get("created_at") if not created_at: continue events.append({ "id": f"case:{row.get('id')}:created", "event_type": "case", "event_subtype": "created", "source": "case", "timestamp": created_at.isoformat() if isinstance(created_at, datetime) else str(created_at), "sag_id": row.get("id"), "sag_titel": row.get("titel"), "forfatter": str(row.get("created_by_name") or "System"), "title": "Sag oprettet", "description": str(row.get("titel") or ""), }) for row in comments: created_at = row.get("created_at") if not created_at: continue if isinstance(created_at, datetime): ts = created_at.isoformat() else: ts = str(created_at) is_system = bool(row.get("er_system_besked")) is_internal = bool(row.get("er_intern")) subtype = "system" if is_system else ("internal" if is_internal else "external") content = str(row.get("indhold") or "") author = str(row.get("forfatter") or "Bruger") field_change_subtype = _detect_field_change_subtype(content) comment_id = row.get("id") or row.get("kommentar_id") or len(events) + 1 events.append({ "id": f"comment:{comment_id}", "event_type": "field_change" if field_change_subtype else "comment", "event_subtype": field_change_subtype or subtype, "source": "case" if field_change_subtype else _detect_source(content), "timestamp": ts, "sag_id": row.get("sag_id"), "sag_titel": row.get("source_sag_titel"), "forfatter": author, "title": f"Feltændring · {author}" if field_change_subtype else f"Kommentar · {author}", "description": content, }) for row in beskrivelse_history: changed_at = row.get("changed_at") if not changed_at: continue if isinstance(changed_at, datetime): ts = changed_at.isoformat() else: ts = str(changed_at) changed_by = str(row.get("changed_by_name") or "Ukendt") before = str(row.get("beskrivelse_before") or "") after = str(row.get("beskrivelse_after") or "") before_short = (before[:240] + "...") if len(before) > 240 else before after_short = (after[:240] + "...") if len(after) > 240 else after description = f"Før: {before_short or 'tom'}\nEfter: {after_short or 'tom'}" events.append({ "id": f"description:{row.get('id') or len(events) + 1}", "event_type": "description", "event_subtype": "edit", "source": "module", "timestamp": ts, "sag_id": row.get("sag_id"), "sag_titel": row.get("source_sag_titel"), "forfatter": changed_by, "title": f"Beskrivelse opdateret · {changed_by}", "description": description, }) if _table_exists("sag_reminders"): reminders_query = f""" SELECT r.id, r.sag_id, r.title, r.message, r.event_type, r.next_check_at, r.scheduled_at, r.created_at, COALESCE(NULLIF(TRIM(u.full_name), ''), NULLIF(TRIM(u.username), ''), 'System') AS created_by_name, s.titel AS source_sag_titel FROM sag_reminders r LEFT JOIN sag_sager s ON s.id = r.sag_id LEFT JOIN users u ON u.user_id = r.created_by_user_id WHERE r.deleted_at IS NULL AND r.sag_id IN ({placeholders}) ORDER BY COALESCE(r.next_check_at, r.scheduled_at) DESC LIMIT 400 """ reminders = execute_query(reminders_query, tuple(case_ids)) or [] for row in reminders: start_value = row.get("created_at") or row.get("next_check_at") or row.get("scheduled_at") if not start_value: continue ts = start_value.isoformat() if isinstance(start_value, datetime) else str(start_value) title = str(row.get("title") or "Påmindelse") message = str(row.get("message") or "") scheduled_value = row.get("scheduled_at") or row.get("next_check_at") if scheduled_value: scheduled_text = scheduled_value.isoformat() if isinstance(scheduled_value, datetime) else str(scheduled_value) message = f"{message}\nPlanlagt til: {scheduled_text}".strip() event_kind = str(row.get("event_type") or "reminder") events.append({ "id": f"reminder:{row.get('id') or len(events) + 1}", "event_type": "reminder", "event_subtype": event_kind, "source": "reminder", "timestamp": ts, "sag_id": row.get("sag_id"), "sag_titel": row.get("source_sag_titel"), "forfatter": str(row.get("created_by_name") or "System"), "title": f"Påmindelse · {title}", "description": message, }) if _table_exists("tmodule_times"): time_query = f""" SELECT t.id, t.sag_id, t.description, t.entry_type, t.worked_date, t.created_at, t.approved_hours, t.original_hours, COALESCE(NULLIF(TRIM(recorder.full_name), ''), NULLIF(TRIM(recorder.username), ''), NULLIF(TRIM(t.user_name), ''), 'System') AS actor_name, COALESCE(NULLIF(TRIM(employee.full_name), ''), NULLIF(TRIM(employee.username), ''), NULLIF(TRIM(t.user_name), ''), CONCAT('Medarbejder #', t.medarbejder_id::text)) AS employee_name, s.titel AS source_sag_titel FROM tmodule_times t LEFT JOIN sag_sager s ON s.id = t.sag_id LEFT JOIN users employee ON employee.user_id = t.medarbejder_id LEFT JOIN users recorder ON LOWER(recorder.username) = LOWER(t.user_name) WHERE t.sag_id IN ({placeholders}) ORDER BY COALESCE(t.worked_date::timestamp, t.created_at) DESC, t.id DESC LIMIT 600 """ time_entries = execute_query(time_query, tuple(case_ids)) or [] for row in time_entries: raw_ts = row.get("created_at") or row.get("worked_date") if not raw_ts: continue ts = raw_ts.isoformat() if isinstance(raw_ts, datetime) else str(raw_ts) hours = row.get("approved_hours") if hours is None: hours = row.get("original_hours") hours_text = f"{float(hours):.2f} t" if hours is not None else "ukendt tid" description = str(row.get("description") or "") employee_name = str(row.get("employee_name") or "Ukendt medarbejder") description = f"Registreret for: {employee_name}\n{description}".strip() entry_type = str(row.get("entry_type") or "arbejde") events.append({ "id": f"time:{row.get('id') or len(events) + 1}", "event_type": "time", "event_subtype": entry_type, "source": "time", "timestamp": ts, "sag_id": row.get("sag_id"), "sag_titel": row.get("source_sag_titel"), "forfatter": str(row.get("actor_name") or "System"), "title": f"Tidsregistrering · {hours_text}", "description": description, }) if _table_exists("sag_tags"): tag_query = f""" SELECT t.id, t.sag_id, t.tag_navn, t.created_at, t.closed_at, s.titel AS source_sag_titel FROM sag_tags t LEFT JOIN sag_sager s ON s.id = t.sag_id WHERE t.sag_id IN ({placeholders}) LIMIT 600 """ for row in execute_query(tag_query, tuple(case_ids)) or []: for action, timestamp in (("tilføjet", row.get("created_at")), ("lukket", row.get("closed_at"))): if timestamp: events.append({ "id": f"tag:{row.get('id')}:{action}", "event_type": "tag", "event_subtype": action, "source": "case", "timestamp": timestamp.isoformat() if isinstance(timestamp, datetime) else str(timestamp), "sag_id": row.get("sag_id"), "sag_titel": row.get("source_sag_titel"), "forfatter": "System", "title": f"Tag {action}", "description": str(row.get("tag_navn") or ""), }) if _table_exists("sag_todo_steps"): todo_query = f""" SELECT t.*, s.titel AS source_sag_titel, COALESCE(NULLIF(TRIM(uc.full_name), ''), NULLIF(TRIM(uc.username), ''), 'System') AS created_by_name, COALESCE(NULLIF(TRIM(ud.full_name), ''), NULLIF(TRIM(ud.username), ''), 'System') AS completed_by_name FROM sag_todo_steps t LEFT JOIN sag_sager s ON s.id = t.sag_id LEFT JOIN users uc ON uc.user_id = t.created_by_user_id LEFT JOIN users ud ON ud.user_id = t.completed_by_user_id WHERE t.sag_id IN ({placeholders}) LIMIT 800 """ for row in execute_query(todo_query, tuple(case_ids)) or []: todo_events = (("oprettet", row.get("created_at"), row.get("created_by_name")), ("færdiggjort", row.get("completed_at"), row.get("completed_by_name")), ("slettet", row.get("deleted_at"), "System")) for action, timestamp, actor in todo_events: if timestamp: events.append({ "id": f"todo:{row.get('id')}:{action}", "event_type": "todo", "event_subtype": action, "source": "case", "timestamp": timestamp.isoformat() if isinstance(timestamp, datetime) else str(timestamp), "sag_id": row.get("sag_id"), "sag_titel": row.get("source_sag_titel"), "forfatter": str(actor or "System"), "title": f"Tjeklistepunkt {action}", "description": str(row.get("title") or ""), }) if _table_exists("sag_relationer"): relation_query = f""" SELECT id, kilde_sag_id, målsag_id, relationstype, created_at, deleted_at FROM sag_relationer WHERE kilde_sag_id IN ({placeholders}) OR målsag_id IN ({placeholders}) LIMIT 600 """ for row in execute_query(relation_query, tuple(case_ids) + tuple(case_ids)) or []: current_id = row.get("kilde_sag_id") if row.get("kilde_sag_id") in case_ids else row.get("målsag_id") other_id = row.get("målsag_id") if current_id == row.get("kilde_sag_id") else row.get("kilde_sag_id") for action, timestamp in (("oprettet", row.get("created_at")), ("fjernet", row.get("deleted_at"))): if timestamp: events.append({ "id": f"relation:{row.get('id')}:{action}", "event_type": "relation", "event_subtype": action, "source": "case", "timestamp": timestamp.isoformat() if isinstance(timestamp, datetime) else str(timestamp), "sag_id": current_id, "sag_titel": next((r.get("titel") for r in case_rows if r.get("id") == current_id), None), "forfatter": "System", "title": f"Relation {action}", "description": f"{row.get('relationstype') or 'Relateret til'} · Sag #{other_id}", }) def _sort_key(item: Dict) -> datetime: raw = str(item.get("timestamp") or "") try: parsed = datetime.fromisoformat(raw.replace("Z", "+00:00").replace(" ", "T")) if parsed.tzinfo is not None: parsed = parsed.astimezone(timezone.utc).replace(tzinfo=None) return parsed except Exception: return datetime.min relation_edges = execute_query( f"""WITH normalized AS ({_normalized_case_relation_sql()}) SELECT parent_id, child_id FROM normalized WHERE parent_id IN ({placeholders}) OR child_id IN ({placeholders})""", tuple(case_ids) + tuple(case_ids), ) or [] parents_by_child: dict[int, set[int]] = {} for edge in relation_edges: parents_by_child.setdefault(edge["child_id"], set()).add(edge["parent_id"]) current_ancestors = _ancestors_for_case(sag_id, parents_by_child) for event in events: event_case_id = event.get("sag_id") event["relation_type"] = "current" if event_case_id == sag_id else ( "parent" if event_case_id in current_ancestors else "child" ) events = [event for event in events if event.get("timestamp")] if relation_types: selected_relations = {part.strip().lower() for part in relation_types.split(",") if part.strip()} events = [event for event in events if event.get("relation_type") in selected_relations] if event_types: selected_types = {part.strip().lower() for part in event_types.split(",") if part.strip()} events = [event for event in events if str(event.get("event_type") or "").lower() in selected_types] if search: needle = search.casefold() events = [event for event in events if needle in " ".join(str(event.get(key) or "") for key in ("title", "description", "sag_titel", "forfatter", "source")).casefold()] events.sort(key=lambda item: (_sort_key(item), str(item.get("id") or "")), reverse=True) total = len(events) if limit is not None: if cursor: try: decoded = base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4)).decode("utf-8") cursor_ts, cursor_id = decoded.split("|", 1) cursor_time = _sort_key({"timestamp": cursor_ts}) except Exception: raise HTTPException(status_code=400, detail="Invalid timeline cursor") events = [event for event in events if (_sort_key(event), str(event.get("id") or "")) < (cursor_time, cursor_id)] page = events[:limit] has_more = len(events) > limit next_cursor = None if has_more and page: last = page[-1] raw_timestamp = str(last.get("timestamp") or "") next_cursor = base64.urlsafe_b64encode(f"{raw_timestamp}|{last.get('id') or ''}".encode()).decode().rstrip("=") events = page else: has_more = False next_cursor = None return { "case_tree": case_rows, "events": events, "total": total, "next_cursor": next_cursor, "has_more": has_more, "truncated": tree_truncated, } except HTTPException: raise except Exception as e: logger.error("❌ Error loading case timeline: %s", e) raise HTTPException(status_code=500, detail="Failed to load case timeline") @router.post("/sag/{sag_id}/kommentarer") async def add_kommentar(sag_id: int, data: dict, request: Request): """Add a comment to a case.""" try: if not data.get("indhold"): raise HTTPException(status_code=400, detail="indhold is required") check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") er_system_besked = bool(data.get("er_system_besked", False)) er_intern = bool(data.get("er_intern", False)) has_internal_flag = table_has_column("sag_kommentarer", "er_intern") if er_system_besked: forfatter = str(data.get("forfatter") or "System").strip() or "System" else: forfatter = None try: user_id = _get_user_id_from_request(request) user_row = execute_query_single( """ SELECT COALESCE(NULLIF(TRIM(full_name), ''), NULLIF(TRIM(username), '')) AS display_name FROM users WHERE user_id = %s """, (user_id,), ) if user_row and user_row.get("display_name"): forfatter = str(user_row.get("display_name")).strip() except HTTPException: # Fallback to provided author for legacy callers without auth context. pass if not forfatter: provided_author = str(data.get("forfatter") or "").strip() if provided_author and provided_author.lower() != "bruger": forfatter = provided_author else: forfatter = "Bruger" if has_internal_flag: query = """ INSERT INTO sag_kommentarer (sag_id, forfatter, indhold, er_system_besked, er_intern) VALUES (%s, %s, %s, %s, %s) RETURNING * """ result = execute_query(query, (sag_id, forfatter, data.get("indhold"), er_system_besked, er_intern)) else: query = """ INSERT INTO sag_kommentarer (sag_id, forfatter, indhold, er_system_besked) VALUES (%s, %s, %s, %s) RETURNING * """ result = execute_query(query, (sag_id, forfatter, data.get("indhold"), er_system_besked)) if result: logger.info("✅ Comment added to case %s by %s", sag_id, forfatter) return result[0] raise HTTPException(status_code=500, detail="Failed to add comment") except HTTPException: raise except Exception as e: logger.error("❌ Error adding comment: %s", e) raise HTTPException(status_code=500, detail="Failed to add comment") # ============================================================================ # WORK ORDERS / LABELS # ============================================================================ def _resolve_case_row_for_documents(sag_id: int): row = execute_query_single( """ SELECT s.id, s.titel, s.status, s.created_at, s.beskrivelse, s.customer_id, c.name AS customer_name FROM sag_sager s LEFT JOIN customers c ON c.id = s.customer_id WHERE s.id = %s AND s.deleted_at IS NULL """, (sag_id,), ) if not row: raise HTTPException(status_code=404, detail="Case not found") return row def _store_generated_case_file( sag_id: int, filename: str, content_bytes: bytes, content_type: str, source_type: str, source_token: Optional[str] = None, ) -> Dict: stored_name = _generate_stored_name(filename, SAG_FILE_SUBDIR) destination = _resolve_attachment_path(stored_name) destination.parent.mkdir(parents=True, exist_ok=True) destination.write_bytes(content_bytes) query = """ INSERT INTO sag_files ( sag_id, filename, content_type, size_bytes, stored_name, source_type, source_token ) VALUES (%s, %s, %s, %s, %s, %s, %s) RETURNING id, filename, created_at """ rows = execute_query( query, (sag_id, filename, content_type, len(content_bytes), stored_name, source_type, source_token), ) return rows[0] @router.get("/sag/{sag_id}/work-orders/print", response_class=HTMLResponse) async def print_case_work_order(sag_id: int, request: Request): """Render a printable work order with scan token + barcode.""" case = _resolve_case_row_for_documents(sag_id) user_id = None try: user_id = _get_user_id_from_request(request) except HTTPException: user_id = None token = _create_document_token(sag_id, "work_order", user_id=user_id) barcode_svg = _render_code39_svg(token) todo_steps = execute_query( """ SELECT title, description, due_date, is_done FROM sag_todo_steps WHERE sag_id = %s AND deleted_at IS NULL ORDER BY is_done ASC, due_date ASC NULLS LAST, id ASC """, (sag_id,), ) or [] todo_items_html = "".join( ( "" "□" f"{html.escape(step.get('title') or '')}" f"
{html.escape(step.get('description') or '')}
" "" ) for step in todo_steps ) if not todo_items_html: todo_items_html = ( "□" "Ingen todo-opgaver registreret" ) def _nl2br(value: Optional[str]) -> str: text = str(value or "").strip() if not text: return "-" return "
".join(html.escape(part) for part in text.splitlines()) def _clip(value: Optional[str], limit: int = 600) -> str: text = str(value or "").strip() if not text: return "" if len(text) <= limit: return text return f"{text[:limit].rstrip()}..." def _strip_quoted_email_text(value: Optional[str]) -> str: text = str(value or "").replace("\r\n", "\n").replace("\r", "\n").strip() if not text: return "" lines = text.split("\n") kept = [] header_re = re.compile(r"^(fra|from|til|to|sendt|sent|dato|date|emne|subject)\s*:\s*", re.IGNORECASE) original_msg_re = re.compile(r"^(-----\s*original message\s*-----|begin forwarded message)", re.IGNORECASE) wrote_re = re.compile(r"\b(wrote|skrev)\s*:\s*$", re.IGNORECASE) for idx, line in enumerate(lines): trimmed = line.strip() if trimmed.startswith(">"): break if original_msg_re.match(trimmed): break if wrote_re.search(trimmed): break if re.match(r"^[-_]{3,}$", trimmed): lookahead = lines[idx + 1: idx + 5] if any(header_re.match(str(candidate or "").strip()) for candidate in lookahead): break if idx > 0 and header_re.match(trimmed) and not str(lines[idx - 1] or "").strip(): break kept.append(line) while kept and not str(kept[-1]).strip(): kept.pop() return "\n".join(kept).strip() email_from_expr = "NULL" if table_has_column("email_messages", "sender_email"): email_from_expr = "e.sender_email" elif table_has_column("email_messages", "from_email"): email_from_expr = "e.from_email" email_to_expr = "NULL" if table_has_column("email_messages", "recipient_email"): email_to_expr = "e.recipient_email" elif table_has_column("email_messages", "to_email"): email_to_expr = "e.to_email" linked_emails = [] email_comment_rows = [] if _table_exists("sag_emails") and _table_exists("email_messages"): try: linked_emails = execute_query( f""" SELECT e.received_date, e.subject, {email_from_expr} AS from_email, {email_to_expr} AS to_email, e.body_text FROM sag_emails se JOIN email_messages e ON e.id = se.email_id WHERE se.sag_id = %s ORDER BY e.received_date DESC NULLS LAST, e.id DESC LIMIT 30 """, (sag_id,), ) or [] except Exception as exc: logger.warning("⚠️ Work-order linked email query failed for SAG-%s: %s", sag_id, exc) linked_emails = [] if _table_exists("sag_kommentarer"): try: email_comment_rows = execute_query( """ SELECT created_at, forfatter, indhold FROM sag_kommentarer WHERE sag_id = %s AND deleted_at IS NULL AND ( COALESCE(indhold, '') ILIKE '%%Email-ID:%%' OR COALESCE(indhold, '') ILIKE '%%📧%%' OR COALESCE(indhold, '') ILIKE '%%Indgående email%%' OR COALESCE(indhold, '') ILIKE '%%Udgående email%%' ) ORDER BY created_at DESC LIMIT 30 """, (sag_id,), ) or [] except Exception as exc: logger.warning("⚠️ Work-order email comment query failed for SAG-%s: %s", sag_id, exc) email_comment_rows = [] has_name = table_has_column("hardware_assets", "name") has_brand = table_has_column("hardware_assets", "brand") has_model = table_has_column("hardware_assets", "model") has_serial = table_has_column("hardware_assets", "serial_number") has_asset_tag = table_has_column("hardware_assets", "asset_tag") has_customer_asset_id = table_has_column("hardware_assets", "customer_asset_id") has_internal_asset_id = table_has_column("hardware_assets", "internal_asset_id") has_type = table_has_column("hardware_assets", "type") has_asset_type = table_has_column("hardware_assets", "asset_type") name_expr_parts = [] if has_name: name_expr_parts.append("NULLIF(TRIM(h.name), '')") if has_brand and has_model: name_expr_parts.append("NULLIF(TRIM(CONCAT_WS(' ', h.brand, h.model)), '')") if has_brand: name_expr_parts.append("NULLIF(TRIM(h.brand), '')") if has_model: name_expr_parts.append("NULLIF(TRIM(h.model), '')") if has_serial: name_expr_parts.append("NULLIF(TRIM(h.serial_number), '')") name_expr_parts.append("CONCAT('Hardware #', h.id::text)") name_expr = "COALESCE(" + ", ".join(name_expr_parts) + ")" serial_expr = "h.serial_number" if has_serial else "NULL" tag_expr_parts = [] if has_asset_tag: tag_expr_parts.append("NULLIF(TRIM(h.asset_tag), '')") if has_customer_asset_id: tag_expr_parts.append("NULLIF(TRIM(h.customer_asset_id), '')") if has_internal_asset_id: tag_expr_parts.append("NULLIF(TRIM(h.internal_asset_id), '')") tag_expr_parts.append("'-'") tag_expr = "COALESCE(" + ", ".join(tag_expr_parts) + ")" type_expr_parts = [] if has_type: type_expr_parts.append("NULLIF(TRIM(h.type), '')") if has_asset_type: type_expr_parts.append("NULLIF(TRIM(h.asset_type), '')") type_expr_parts.append("'ukendt'") type_expr = "COALESCE(" + ", ".join(type_expr_parts) + ")" hardware_rows = [] if _table_exists("sag_hardware") and _table_exists("hardware_assets"): try: hardware_rows = execute_query( f""" SELECT h.id, {name_expr} AS label_name, {serial_expr} AS serial_number, {tag_expr} AS label_tag, {type_expr} AS label_type FROM sag_hardware sh JOIN hardware_assets h ON h.id = sh.hardware_id WHERE sh.sag_id = %s AND sh.deleted_at IS NULL ORDER BY label_name ASC """, (sag_id,), ) or [] except Exception as exc: logger.warning("⚠️ Work-order hardware query failed for SAG-%s: %s", sag_id, exc) hardware_rows = [] hardware_html = "".join( ( "" f"{html.escape(str(hw.get('label_name') or '-'))}" f"{html.escape(str(hw.get('serial_number') or '-'))}" f"{html.escape(str(hw.get('label_tag') or '-'))}" f"{html.escape(str(hw.get('label_type') or '-'))}" "" ) for hw in hardware_rows ) if not hardware_html: hardware_html = "Ingen hardware er knyttet til sagen." internal_filter = "COALESCE(er_system_besked, FALSE) = TRUE" if table_has_column("sag_kommentarer", "er_intern"): internal_filter = "(COALESCE(er_intern, FALSE) = TRUE OR COALESCE(er_system_besked, FALSE) = TRUE)" internal_messages = [] if _table_exists("sag_kommentarer"): internal_messages = execute_query( f""" SELECT created_at, forfatter, indhold FROM sag_kommentarer WHERE sag_id = %s AND deleted_at IS NULL AND {internal_filter} ORDER BY created_at DESC LIMIT 50 """, (sag_id,), ) or [] emails_html = "".join( ( "
" f"
{html.escape((row.get('subject') or '(Ingen emne)'))}
" f"
Fra: {html.escape(row.get('from_email') or '-')} · Til: {html.escape(row.get('to_email') or '-')}
" f"
Dato: {html.escape(str(row.get('received_date') or '-'))}
" f"
{_nl2br(_clip(_strip_quoted_email_text(row.get('body_text')), 800))}
" "
" ) for row in linked_emails ) if not linked_emails and email_comment_rows: emails_html = "".join( ( "
" f"
{html.escape(row.get('forfatter') or 'Email')} · {html.escape(str(row.get('created_at') or '-'))}
" f"
{_nl2br(_clip(_strip_quoted_email_text(row.get('indhold')), 1200))}
" "
" ) for row in email_comment_rows ) elif not emails_html: emails_html = "
Ingen linkede emails.
" internal_messages_html = "".join( ( "
" f"
{html.escape(row.get('forfatter') or 'Ukendt')} · {html.escape(str(row.get('created_at') or '-'))}
" f"
{_nl2br(_clip(row.get('indhold'), 900))}
" "
" ) for row in internal_messages ) if not internal_messages_html: internal_messages_html = "
Ingen interne beskeder.
" html_doc = f""" Arbejdsseddel SAG-{case['id']}
BMC Work Order
SAG-{case['id']} · {html.escape(case.get('status') or '-')}
Kunde: {html.escape(case.get('customer_name') or '-')}
{barcode_svg}
Sags titel
{html.escape(case.get('titel') or '-')}
Sagsbeskrivelse
{_nl2br(case.get('beskrivelse'))}
Opgaver (afkryds ved udførelse)
{todo_items_html}
Hardware
{hardware_html}
Enhed Serienr. Tag Type
Linkede emails
{emails_html}
Interne beskeder
{internal_messages_html}
Underskrift
Dato: _____________    Navn: __________________________
Scan-token: {html.escape(token)}
""" return HTMLResponse(content=html_doc) @router.post("/sag/{sag_id}/work-orders/{token}/signature-canvas") async def upload_work_order_signature_canvas(sag_id: int, token: str, payload: SignatureCanvasRequest): """Save canvas signature as case file and consume token.""" _resolve_case_row_for_documents(sag_id) token_row = execute_query_single( """ SELECT token, sag_id FROM sag_document_tokens WHERE token = %s AND token_type = 'work_order' AND sag_id = %s """, (token, sag_id), ) if not token_row: raise HTTPException(status_code=404, detail="Work-order token not found") if "," not in payload.data_url: raise HTTPException(status_code=400, detail="Invalid signature payload") _, encoded = payload.data_url.split(",", 1) try: signature_bytes = base64.b64decode(encoded) except Exception as exc: raise HTTPException(status_code=400, detail=f"Invalid base64 signature: {exc}") saved = _store_generated_case_file( sag_id=sag_id, filename=f"SAG-{sag_id}-signature-{datetime.now().strftime('%Y%m%d-%H%M%S')}.png", content_bytes=signature_bytes, content_type="image/png", source_type="signature_canvas", source_token=token, ) execute_query( """ UPDATE sag_document_tokens SET consumed_at = COALESCE(consumed_at, CURRENT_TIMESTAMP) WHERE token = %s """, (token,), ) return {"status": "saved", "file": saved} @router.post("/sag/{sag_id}/work-orders/{token}/signature-file") async def upload_work_order_signature_file( sag_id: int, token: str, file: UploadFile = File(...), source: str = Form("signature_upload"), ): """Save uploaded signature file and consume token.""" _resolve_case_row_for_documents(sag_id) token_row = execute_query_single( """ SELECT token, sag_id FROM sag_document_tokens WHERE token = %s AND token_type = 'work_order' AND sag_id = %s """, (token, sag_id), ) if not token_row: raise HTTPException(status_code=404, detail="Work-order token not found") content = await file.read() if not content: raise HTTPException(status_code=400, detail="Empty file") safe_name = Path(file.filename or "signature-upload.bin").name saved = _store_generated_case_file( sag_id=sag_id, filename=f"SAG-{sag_id}-{safe_name}", content_bytes=content, content_type=file.content_type or "application/octet-stream", source_type=source or "signature_upload", source_token=token, ) execute_query( """ UPDATE sag_document_tokens SET consumed_at = COALESCE(consumed_at, CURRENT_TIMESTAMP) WHERE token = %s """, (token,), ) return {"status": "saved", "file": saved} @router.get("/sag/{sag_id}/labels/hardware/print", response_class=HTMLResponse) async def print_case_hardware_labels( sag_id: int, request: Request, auto_print: bool = Query(False), ): """Render printable hardware labels with IDs and barcodes.""" _resolve_case_row_for_documents(sag_id) has_name = table_has_column("hardware_assets", "name") has_brand = table_has_column("hardware_assets", "brand") has_model = table_has_column("hardware_assets", "model") has_serial = table_has_column("hardware_assets", "serial_number") has_asset_tag = table_has_column("hardware_assets", "asset_tag") has_customer_asset_id = table_has_column("hardware_assets", "customer_asset_id") has_internal_asset_id = table_has_column("hardware_assets", "internal_asset_id") has_type = table_has_column("hardware_assets", "type") has_asset_type = table_has_column("hardware_assets", "asset_type") name_expr_parts = [] if has_name: name_expr_parts.append("NULLIF(TRIM(h.name), '')") if has_brand and has_model: name_expr_parts.append("NULLIF(TRIM(CONCAT_WS(' ', h.brand, h.model)), '')") if has_brand: name_expr_parts.append("NULLIF(TRIM(h.brand), '')") if has_model: name_expr_parts.append("NULLIF(TRIM(h.model), '')") if has_serial: name_expr_parts.append("NULLIF(TRIM(h.serial_number), '')") name_expr_parts.append("CONCAT('Hardware #', h.id::text)") name_expr = "COALESCE(" + ", ".join(name_expr_parts) + ")" tag_expr_parts = [] if has_asset_tag: tag_expr_parts.append("NULLIF(TRIM(h.asset_tag), '')") if has_customer_asset_id: tag_expr_parts.append("NULLIF(TRIM(h.customer_asset_id), '')") if has_internal_asset_id: tag_expr_parts.append("NULLIF(TRIM(h.internal_asset_id), '')") tag_expr_parts.append("'-'") tag_expr = "COALESCE(" + ", ".join(tag_expr_parts) + ")" type_expr_parts = [] if has_type: type_expr_parts.append("NULLIF(TRIM(h.type), '')") if has_asset_type: type_expr_parts.append("NULLIF(TRIM(h.asset_type), '')") type_expr_parts.append("'ukendt'") type_expr = "COALESCE(" + ", ".join(type_expr_parts) + ")" serial_expr = "h.serial_number" if has_serial else "NULL" hardware_id_filter = None if payload and payload.hardware_id is not None: try: hardware_id_filter = int(payload.hardware_id) except (TypeError, ValueError): raise HTTPException(status_code=400, detail="Ugyldigt hardware_id") hardware_query = f""" SELECT h.id, {name_expr} AS label_name, {serial_expr} AS serial_number, {tag_expr} AS label_tag, {type_expr} AS label_type FROM sag_hardware sh JOIN hardware_assets h ON h.id = sh.hardware_id WHERE sh.sag_id = %s AND sh.deleted_at IS NULL """ params = [sag_id] if hardware_id_filter is not None: hardware_query += " AND sh.hardware_id = %s" params.append(hardware_id_filter) hardware_query += " ORDER BY label_name ASC" hardware_rows = execute_query(hardware_query, tuple(params)) or [] user_id = None try: user_id = _get_user_id_from_request(request) except HTTPException: user_id = None label_cards = [] for hw in hardware_rows: token = _create_document_token( sag_id=sag_id, token_type="hardware_label", user_id=user_id, hardware_id=hw.get("id"), ) barcode_svg = _render_code39_svg( token, height=26, narrow=1, wide=2, gap=0, font_size=10, include_text=False, ) label_cards.append( f"""
{html.escape(hw.get('label_name') or 'Ukendt enhed')}
ID: HW-{hw.get('id')} · SAG-{sag_id}
SN: {html.escape(hw.get('serial_number') or '-')} · Tag: {html.escape(hw.get('label_tag') or '-')} · Type: {html.escape(hw.get('label_type') or '-')}
{barcode_svg}
{html.escape(token)}
""" ) if not label_cards: label_cards.append("
Ingen hardware er knyttet til sagen endnu.
") auto_print_script = "" if auto_print: auto_print_script = ( "" ) html_doc = f""" Hardware labels SAG-{sag_id}
{''.join(label_cards)}
{auto_print_script} """ return HTMLResponse(content=html_doc) @router.post("/sag/{sag_id}/labels/hardware/print-direct") async def print_case_hardware_labels_direct( sag_id: int, request: Request, payload: Optional[DirectPrintOverrideRequest] = None, ): """Print hardware labels directly to configured Brother network printer.""" _resolve_case_row_for_documents(sag_id) enabled = (_get_setting_value("label_printer_enabled", "false") or "false").strip().lower() == "true" if not enabled: raise HTTPException(status_code=400, detail="Direkte label-print er ikke aktiveret i indstillinger") host = (payload.printer_host if payload and payload.printer_host else _get_setting_value("label_printer_host", "")).strip() port_raw = payload.printer_port if payload and payload.printer_port is not None else _get_setting_value("label_printer_port", "9100") model = (payload.printer_model if payload and payload.printer_model else _get_setting_value("label_printer_model", "QL-710W")).strip() label_size = (payload.label_size if payload and payload.label_size else _get_setting_value("label_printer_label_size", "62")).strip() try: port = int(port_raw or 9100) except ValueError: raise HTTPException(status_code=400, detail="Ugyldig printer-port") if not host: raise HTTPException(status_code=400, detail="Printer host/IP mangler i indstillinger") has_name = table_has_column("hardware_assets", "name") has_brand = table_has_column("hardware_assets", "brand") has_model = table_has_column("hardware_assets", "model") has_serial = table_has_column("hardware_assets", "serial_number") has_asset_tag = table_has_column("hardware_assets", "asset_tag") has_customer_asset_id = table_has_column("hardware_assets", "customer_asset_id") has_internal_asset_id = table_has_column("hardware_assets", "internal_asset_id") has_type = table_has_column("hardware_assets", "type") has_asset_type = table_has_column("hardware_assets", "asset_type") name_expr_parts = [] if has_name: name_expr_parts.append("NULLIF(TRIM(h.name), '')") if has_brand and has_model: name_expr_parts.append("NULLIF(TRIM(CONCAT_WS(' ', h.brand, h.model)), '')") if has_brand: name_expr_parts.append("NULLIF(TRIM(h.brand), '')") if has_model: name_expr_parts.append("NULLIF(TRIM(h.model), '')") if has_serial: name_expr_parts.append("NULLIF(TRIM(h.serial_number), '')") name_expr_parts.append("CONCAT('Hardware #', h.id::text)") name_expr = "COALESCE(" + ", ".join(name_expr_parts) + ")" tag_expr_parts = [] if has_asset_tag: tag_expr_parts.append("NULLIF(TRIM(h.asset_tag), '')") if has_customer_asset_id: tag_expr_parts.append("NULLIF(TRIM(h.customer_asset_id), '')") if has_internal_asset_id: tag_expr_parts.append("NULLIF(TRIM(h.internal_asset_id), '')") tag_expr_parts.append("'-'") tag_expr = "COALESCE(" + ", ".join(tag_expr_parts) + ")" type_expr_parts = [] if has_type: type_expr_parts.append("NULLIF(TRIM(h.type), '')") if has_asset_type: type_expr_parts.append("NULLIF(TRIM(h.asset_type), '')") type_expr_parts.append("'ukendt'") type_expr = "COALESCE(" + ", ".join(type_expr_parts) + ")" serial_expr = "h.serial_number" if has_serial else "NULL" hardware_rows = execute_query( f""" SELECT h.id, {name_expr} AS label_name, {serial_expr} AS serial_number, {tag_expr} AS label_tag, {type_expr} AS label_type FROM sag_hardware sh JOIN hardware_assets h ON h.id = sh.hardware_id WHERE sh.sag_id = %s AND sh.deleted_at IS NULL ORDER BY label_name ASC """, (sag_id,), ) or [] if not hardware_rows: if hardware_id_filter is not None: raise HTTPException(status_code=404, detail="Valgt hardware er ikke knyttet til sagen") raise HTTPException(status_code=400, detail="Ingen hardware er knyttet til sagen") user_id = None try: user_id = _get_user_id_from_request(request) except HTTPException: user_id = None jobs: List[LabelJob] = [] for hw in hardware_rows: token = _create_document_token( sag_id=sag_id, token_type="hardware_label", user_id=user_id, hardware_id=hw.get("id"), ) meta = ( f"ID: HW-{hw.get('id')} SAG-{sag_id} " f"SN: {hw.get('serial_number') or '-'} Tag: {hw.get('label_tag') or '-'} Type: {hw.get('label_type') or '-'}" ) jobs.append( LabelJob( name=str(hw.get("label_name") or "Ukendt enhed"), meta_line=meta, token=token, ) ) service = BrotherLabelPrintService( model=model, host=host, port=port, label_size=label_size, ) try: printed = service.print_jobs(jobs) except Exception as exc: logger.error("❌ Direct label print failed for SAG-%s: %s", sag_id, exc) raise HTTPException(status_code=500, detail=f"Direkte print fejlede: {exc}") return { "status": "ok", "printed": printed, "hardware_ids": [int(hw.get("id")) for hw in hardware_rows if hw.get("id") is not None], "printer": { "model": model, "host": host, "port": port, "label_size": label_size, }, } # ============================================================================ # FILES - Case Files # ============================================================================ UPLOAD_BASE_PATH = Path(settings.UPLOAD_DIR).resolve() SAG_FILE_SUBDIR = "sag_files" (UPLOAD_BASE_PATH / SAG_FILE_SUBDIR).mkdir(parents=True, exist_ok=True) ALLOWED_EXTENSIONS = {ext.lower() for ext in settings.ALLOWED_EXTENSIONS} MAX_ATTACHMENT_SIZE = settings.EMAIL_MAX_UPLOAD_SIZE_MB * 1024 * 1024 def _generate_stored_name(filename: str, subdir: str) -> str: cleaned = Path(filename).name unique = f"{uuid4().hex}_{cleaned}" return f"{subdir}/{unique}" def _resolve_attachment_path(stored_name: str) -> Path: candidate = (UPLOAD_BASE_PATH / str(stored_name or "")).resolve() try: candidate.relative_to(UPLOAD_BASE_PATH) except ValueError as exc: raise HTTPException(status_code=400, detail="Invalid attachment path") from exc return candidate def _store_upload_file(upload_file: UploadFile, subdir: str): if not upload_file.filename: raise HTTPException(400, detail="Filename missing") ext = Path(upload_file.filename).suffix.lower().lstrip(".") if not ext or ext not in ALLOWED_EXTENSIONS: raise HTTPException(status_code=400, detail=f"File type .{ext or '?'} is not allowed") upload_file.file.seek(0, os.SEEK_END) size = upload_file.file.tell() upload_file.file.seek(0) if size > MAX_ATTACHMENT_SIZE: raise HTTPException(400, detail=f"File too large (> {settings.EMAIL_MAX_UPLOAD_SIZE_MB}MB)") stored_name = _generate_stored_name(upload_file.filename, subdir) destination = _resolve_attachment_path(stored_name) destination.parent.mkdir(parents=True, exist_ok=True) try: with destination.open("wb") as buffer: shutil.copyfileobj(upload_file.file, buffer) except Exception as e: logger.error(f"Upload failed: {e}") raise HTTPException(500, detail="Server upload failed") return stored_name, size @router.get("/sag/{sag_id}/files") async def list_sag_files(sag_id: int): """List files attached to a case.""" try: if not _table_exists("sag_files"): logger.warning("⚠️ sag_files table missing - returning empty file list for SAG-%s", sag_id) return [] order_expr = "created_at DESC" if table_has_column("sag_files", "created_at") else "id DESC" query = """ SELECT * FROM sag_files WHERE sag_id = %s ORDER BY {order_expr} """ query = query.format(order_expr=order_expr) files = execute_query(query, (sag_id,)) # Add download URL if files: for f in files: f["download_url"] = f"/api/v1/sag/{sag_id}/files/{f['id']}" return files or [] except Exception as e: logger.error("❌ Error listing files: %s", e) raise HTTPException(status_code=500, detail="Failed to list files") @router.post("/sag/{sag_id}/files", dependencies=[Depends(case_edit_access)]) async def upload_sag_files(sag_id: int, files: List[UploadFile] = File(...)): """Upload files to a case.""" if not _table_exists("sag_files"): raise HTTPException(status_code=503, detail="sag_files table is missing. Run database migrations first") check = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not check: raise HTTPException(status_code=404, detail="Case not found") saved_files = [] errors = [] for file in files: try: stored_name, size = _store_upload_file(file, SAG_FILE_SUBDIR) query = """ INSERT INTO sag_files (sag_id, filename, content_type, size_bytes, stored_name) VALUES (%s, %s, %s, %s, %s) RETURNING id, filename, created_at """ result = execute_query(query, (sag_id, file.filename, file.content_type, size, stored_name)) if result: saved = result[0] saved["download_url"] = f"/api/v1/sag/{sag_id}/files/{saved['id']}" saved_files.append(saved) except HTTPException as exc: errors.append({"filename": file.filename, "detail": exc.detail}) except Exception as e: logger.error(f"Error saving file {file.filename}: {e}") errors.append({"filename": file.filename, "detail": "Server upload failed"}) if errors: raise HTTPException( status_code=400, detail={"message": "One or more files could not be uploaded", "files": errors, "saved": saved_files}, ) return saved_files @router.get("/sag/{sag_id}/files/{file_id}") async def download_sag_file(sag_id: int, file_id: int, download: bool = False): """Download or preview a specific file. Args: download: If True, force download. If False (default), display inline in browser. """ if not _table_exists("sag_files"): raise HTTPException(status_code=503, detail="sag_files table is missing. Run database migrations first") query = "SELECT * FROM sag_files WHERE id = %s AND sag_id = %s" result = execute_query(query, (file_id, sag_id)) if not result: raise HTTPException(status_code=404, detail="File not found") file_data = result[0] path = _resolve_attachment_path(file_data["stored_name"]) if not path.exists(): raise HTTPException(status_code=404, detail="File lost on server") # Determine content disposition headers = {} if download: headers["Content-Disposition"] = f'attachment; filename="{file_data["filename"]}"' else: headers["Content-Disposition"] = f'inline; filename="{file_data["filename"]}"' return FileResponse( path=path, filename=file_data["filename"], media_type=file_data.get("content_type", "application/octet-stream"), headers=headers ) @router.get("/sag/{sag_id}/files/{file_id}/preview-image") async def preview_sag_pdf_as_image(sag_id: int, file_id: int, page: int = Query(1, ge=1), scale: float = Query(2.8, ge=1.0, le=5.0)): """Render a PDF page as PNG for consistent in-app preview sizing.""" if not _table_exists("sag_files"): raise HTTPException(status_code=503, detail="sag_files table is missing. Run database migrations first") query = "SELECT * FROM sag_files WHERE id = %s AND sag_id = %s" result = execute_query(query, (file_id, sag_id)) if not result: raise HTTPException(status_code=404, detail="File not found") file_data = result[0] path = _resolve_attachment_path(file_data["stored_name"]) if not path.exists(): raise HTTPException(status_code=404, detail="File lost on server") content_type = (file_data.get("content_type") or "").lower() filename = str(file_data.get("filename") or "").lower() if "pdf" not in content_type and not filename.endswith(".pdf"): raise HTTPException(status_code=400, detail="Preview image is only supported for PDF files") try: import pypdfium2 as pdfium document = pdfium.PdfDocument(str(path)) page_index = min(max(page - 1, 0), max(len(document) - 1, 0)) pdf_page = document.get_page(page_index) bitmap = pdf_page.render(scale=scale) png_bytes = bitmap.to_pil().convert("RGB") import io buffer = io.BytesIO() png_bytes.save(buffer, format="PNG", optimize=True) data = buffer.getvalue() try: pdf_page.close() except Exception: pass return Response(content=data, media_type="image/png") except HTTPException: raise except Exception as e: logger.error("❌ PDF preview render failed for SAG-%s file %s: %s", sag_id, file_id, e) raise HTTPException(status_code=500, detail="Could not render PDF preview") @router.delete("/sag/{sag_id}/files/{file_id}", dependencies=[Depends(case_edit_access)]) async def delete_sag_file(sag_id: int, file_id: int): """Delete a file.""" if not _table_exists("sag_files"): raise HTTPException(status_code=503, detail="sag_files table is missing. Run database migrations first") query = "DELETE FROM sag_files WHERE id = %s AND sag_id = %s RETURNING stored_name" result = execute_query(query, (file_id, sag_id)) if result: # Clean up disk path = _resolve_attachment_path(result[0]["stored_name"]) if path.exists(): try: os.remove(path) except: pass return {"status": "deleted"} raise HTTPException(status_code=404, detail="File not found") # ============================================================================ # EMAILS - Case Emails (Linked) # ============================================================================ @router.post("/sag/{sag_id}/email-links") async def add_sag_email_link(sag_id: int, payload: dict): """Link an existing email to a case.""" email_id = payload.get("email_id") if not email_id: raise HTTPException(status_code=400, detail="email_id required") query = """ INSERT INTO sag_emails (sag_id, email_id) VALUES (%s, %s) ON CONFLICT DO NOTHING RETURNING * """ execute_query(query, (sag_id, email_id)) return {"status": "linked"} @router.get("/sag/{sag_id}/email-links") async def get_sag_emails(sag_id: int): """Get emails linked to a case.""" if not _table_exists("sag_emails") or not _table_exists("email_messages"): logger.warning("⚠️ Email links requested for SAG-%s but required tables are missing", sag_id) return [] has_thread_key = table_has_column("email_messages", "thread_key") has_email_references = table_has_column("email_messages", "email_references") has_in_reply_to = table_has_column("email_messages", "in_reply_to") has_subject = table_has_column("email_messages", "subject") has_message_id = table_has_column("email_messages", "message_id") has_folder = table_has_column("email_messages", "folder") has_status = table_has_column("email_messages", "status") has_received_date = table_has_column("email_messages", "received_date") thread_key_expr = "e.thread_key" if has_thread_key else "NULL" email_references_expr = "e.email_references" if has_email_references else "NULL" in_reply_to_expr = "e.in_reply_to" if has_in_reply_to else "NULL" subject_expr = "e.subject" if has_subject else "NULL" message_id_expr = "e.message_id" if has_message_id else "NULL" outgoing_checks = [] if has_folder: outgoing_checks.append("LOWER(COALESCE(linked_emails.folder, '')) LIKE 'sent%%'") if has_status: outgoing_checks.append("LOWER(COALESCE(linked_emails.status, '')) = 'sent'") is_outgoing_expr = " OR ".join(outgoing_checks) if outgoing_checks else "FALSE" if has_received_date: query = f""" WITH linked_emails AS ( SELECT e.*, COALESCE( NULLIF(REGEXP_REPLACE(TRIM(COALESCE({thread_key_expr}, '')), '[<>\\s]', '', 'g'), ''), NULLIF(REGEXP_REPLACE((REGEXP_SPLIT_TO_ARRAY(COALESCE({email_references_expr}, ''), E'[\\s,]+'))[1], '[<>\\s]', '', 'g'), ''), NULLIF( REGEXP_REPLACE( (REGEXP_SPLIT_TO_ARRAY(COALESCE({in_reply_to_expr}, ''), E'[\\s,]+'))[1], '[<>\\s]', '', 'g' ), '' ), NULLIF( REGEXP_REPLACE( LOWER(TRIM(COALESCE({subject_expr}, ''))), '^(?:(?:re|fw|fwd|sv|aw)\\s*:\\s*)+', '', 'i' ), '' ), NULLIF(REGEXP_REPLACE(TRIM(COALESCE({message_id_expr}, '')), '[<>\\s]', '', 'g'), ''), CONCAT('email-', e.id::text) ) AS resolved_thread_key FROM email_messages e JOIN sag_emails se ON e.id = se.email_id WHERE se.sag_id = %s ) SELECT linked_emails.*, ({is_outgoing_expr}) AS is_outgoing, COUNT(*) OVER (PARTITION BY linked_emails.resolved_thread_key) AS thread_message_count, MAX(linked_emails.received_date) OVER (PARTITION BY linked_emails.resolved_thread_key) AS thread_last_received_date FROM linked_emails ORDER BY thread_last_received_date DESC NULLS LAST, received_date DESC """ else: query = f""" WITH linked_emails AS ( SELECT e.*, COALESCE( NULLIF(REGEXP_REPLACE(TRIM(COALESCE({thread_key_expr}, '')), '[<>\\s]', '', 'g'), ''), NULLIF(REGEXP_REPLACE((REGEXP_SPLIT_TO_ARRAY(COALESCE({email_references_expr}, ''), E'[\\s,]+'))[1], '[<>\\s]', '', 'g'), ''), NULLIF( REGEXP_REPLACE( (REGEXP_SPLIT_TO_ARRAY(COALESCE({in_reply_to_expr}, ''), E'[\\s,]+'))[1], '[<>\\s]', '', 'g' ), '' ), NULLIF( REGEXP_REPLACE( LOWER(TRIM(COALESCE({subject_expr}, ''))), '^(?:(?:re|fw|fwd|sv|aw)\\s*:\\s*)+', '', 'i' ), '' ), NULLIF(REGEXP_REPLACE(TRIM(COALESCE({message_id_expr}, '')), '[<>\\s]', '', 'g'), ''), CONCAT('email-', e.id::text) ) AS resolved_thread_key FROM email_messages e JOIN sag_emails se ON e.id = se.email_id WHERE se.sag_id = %s ) SELECT linked_emails.*, ({is_outgoing_expr}) AS is_outgoing, COUNT(*) OVER (PARTITION BY linked_emails.resolved_thread_key) AS thread_message_count, NULL::timestamp AS thread_last_received_date FROM linked_emails ORDER BY linked_emails.id DESC """ try: return execute_query(query, (sag_id,)) or [] except Exception as exc: logger.error("❌ Failed loading linked emails for SAG-%s: %s", sag_id, exc) return [] @router.delete("/sag/{sag_id}/email-links/{email_id}") async def remove_sag_email_link(sag_id: int, email_id: int): """Unlink an email.""" query = "DELETE FROM sag_emails WHERE sag_id = %s AND email_id = %s" execute_query(query, (sag_id, email_id)) return {"status": "unlinked"} def _decode_header_str(header_val): if not header_val: return "" try: decoded_list = decode_header(header_val) result = "" for content, encoding in decoded_list: if isinstance(content, bytes): if encoding: try: result += content.decode(encoding) except: result += content.decode('utf-8', errors='ignore') else: result += content.decode('utf-8', errors='ignore') else: result += str(content) return result except: return str(header_val) def _copy_uploaded_email_attachments_to_case(sag_id: int, email_id: int, attachments: List[Dict]) -> int: """Copy valid manual-email attachments into the normal case-files module.""" if not attachments or not _table_exists("sag_files"): return 0 has_source_email = table_has_column("sag_files", "source_email_id") has_source_type = table_has_column("sag_files", "source_type") copied = 0 for attachment in attachments: filename = Path(str(attachment.get("filename") or "attachment.bin")).name content = attachment.get("content") if not filename or not content: continue content = bytes(content) extension = Path(filename).suffix.lower().lstrip(".") if not extension or extension not in ALLOWED_EXTENSIONS or len(content) > MAX_ATTACHMENT_SIZE: logger.warning("Skipping unsupported or oversized email attachment %s for SAG-%s", filename, sag_id) continue if has_source_email: existing = execute_query( """SELECT 1 FROM sag_files WHERE sag_id = %s AND source_email_id = %s AND filename = %s LIMIT 1""", (sag_id, email_id, filename), ) or [] if existing: continue stored_name = _generate_stored_name(filename, SAG_FILE_SUBDIR) destination = _resolve_attachment_path(stored_name) destination.parent.mkdir(parents=True, exist_ok=True) destination.write_bytes(content) columns = ["sag_id", "filename", "content_type", "size_bytes", "stored_name"] values: List[Any] = [ sag_id, filename, attachment.get("content_type") or "application/octet-stream", len(content), stored_name, ] if has_source_email: columns.append("source_email_id") values.append(email_id) if has_source_type: columns.append("source_type") values.append("email_import") execute_query( f"INSERT INTO sag_files ({', '.join(columns)}) VALUES ({', '.join(['%s'] * len(values))})", tuple(values), ) copied += 1 return copied @router.post("/sag/{sag_id}/upload-email") async def upload_sag_email(sag_id: int, file: UploadFile = File(...)): """Import .eml/.msg into the email tab and copy its attachments to case files.""" filename = str(file.filename or "").lower() if not (filename.endswith(".eml") or filename.endswith(".msg")): raise HTTPException(400, "Only .msg or .eml files allowed") content = await file.read() service = EmailService() email_data = service.parse_msg_file(content) if filename.endswith(".msg") else service.parse_eml_file(content) if not email_data: raise HTTPException(status_code=400, detail="E-mailfilen kunne ikke læses") email_id = await service.save_uploaded_email(email_data) if not email_id: existing = execute_query_single( "SELECT id FROM email_messages WHERE message_id = %s", (email_data["message_id"],), ) if not existing: raise HTTPException(status_code=500, detail="E-mailen kunne ikke gemmes") email_id = existing["id"] await add_sag_email_link(sag_id, {"email_id": email_id}) attachment_files_created = _copy_uploaded_email_attachments_to_case( sag_id, int(email_id), email_data.get("attachments") or [], ) return { "status": "imported", "email_id": email_id, "attachment_files_created": attachment_files_created, } @router.post("/sag/{sag_id}/emails/send") async def send_sag_email(sag_id: int, payload: SagSendEmailRequest, request: Request): """Send outbound email directly from case email tab and link it to case.""" case_exists = execute_query("SELECT id FROM sag_sager WHERE id = %s AND deleted_at IS NULL", (sag_id,)) if not case_exists: raise HTTPException(status_code=404, detail="Case not found") to_addresses = _normalize_email_list(payload.to, "to") cc_addresses = _normalize_email_list(payload.cc, "cc") bcc_addresses = _normalize_email_list(payload.bcc, "bcc") if not to_addresses: raise HTTPException(status_code=400, detail="At least one recipient in 'to' is required") subject = (payload.subject or "").strip() body_text = (payload.body_text or "").strip() if not subject: raise HTTPException(status_code=400, detail="subject is required") if not body_text: raise HTTPException(status_code=400, detail="body_text is required") try: user_id = _get_user_id_from_request(request) except HTTPException: user_id = 1 attachment_rows = [] attachment_ids = list(dict.fromkeys(payload.attachment_file_ids or [])) if attachment_ids: placeholders = ",".join(["%s"] * len(attachment_ids)) attachment_query = f""" SELECT id, filename, content_type, size_bytes, stored_name FROM sag_files WHERE sag_id = %s AND id IN ({placeholders}) """ attachment_rows = execute_query(attachment_query, (sag_id, *attachment_ids)) if len(attachment_rows) != len(attachment_ids): raise HTTPException(status_code=400, detail="One or more selected attachments were not found on this case") smtp_attachments = [] for row in attachment_rows: path = _resolve_attachment_path(row["stored_name"]) if not path.exists(): raise HTTPException(status_code=404, detail=f"Attachment file is missing on server: {row['filename']}") smtp_attachments.append({ "filename": row["filename"], "content_type": row.get("content_type") or "application/octet-stream", "content": path.read_bytes(), "size": row.get("size_bytes") or 0, "file_path": str(path), }) in_reply_to_header = None references_header = None selected_thread_key = None if payload.thread_email_id: thread_row = None try: thread_row = execute_query_single( """ SELECT id, message_id, in_reply_to, email_references, thread_key FROM email_messages WHERE id = %s """, (payload.thread_email_id,), ) except Exception: # Backward compatibility for DBs without in_reply_to/email_references columns. try: thread_row = execute_query_single( """ SELECT id, message_id, thread_key FROM email_messages WHERE id = %s """, (payload.thread_email_id,), ) except Exception: thread_row = execute_query_single( """ SELECT id, message_id FROM email_messages WHERE id = %s """, (payload.thread_email_id,), ) if thread_row: base_message_id = str(thread_row.get("message_id") or "").strip() if base_message_id and not base_message_id.startswith("<"): base_message_id = f"<{base_message_id}>" if base_message_id: in_reply_to_header = base_message_id existing_refs = str(thread_row.get("email_references") or "").strip() if existing_refs: references_header = f"{existing_refs} {base_message_id}".strip() else: references_header = base_message_id selected_thread_key = _derive_thread_key_for_outbound( thread_row.get("thread_key"), thread_row.get("in_reply_to"), thread_row.get("email_references"), thread_row.get("message_id"), ) effective_payload_thread_key = payload.thread_key or selected_thread_key if not effective_payload_thread_key: # Brand-new thread: assign a local key immediately so signature/BMCid # can carry a resolvable thread identity from the first outbound email. effective_payload_thread_key = _generate_local_thread_key_for_new_outbound(sag_id) provisional_thread_key = _derive_thread_key_for_outbound( effective_payload_thread_key, in_reply_to_header, references_header, None, ) signature = _render_signature_for_case_email(user_id, sag_id, provisional_thread_key) body_text = _append_signature_to_body(body_text, signature) body_html = _append_signature_to_html(payload.body_html, signature) # Inject hidden BMCid tracker into HTML body so replies can be routed back bmc_id_tag = _build_case_bmc_id_tag(sag_id, provisional_thread_key) hidden_tracker = f'
BMCid: {bmc_id_tag}
' if body_html: body_html = f"{hidden_tracker}{body_html}" elif body_text: # Synthesize minimal HTML wrapper with tracker when only plain text exists import html as _html body_html = f"{hidden_tracker}
{_html.escape(body_text)}
" # Ensure subject carries [SAG-XX] prefix for reliable subject-line matching sag_prefix = f"[SAG-{sag_id}]" if sag_prefix not in subject: subject = f"{sag_prefix} {subject}" email_service = EmailService() success, send_message, generated_message_id, provider_thread_key = await email_service.send_email_with_attachments( to_addresses=to_addresses, subject=subject, body_text=body_text, body_html=body_html, cc=cc_addresses, bcc=bcc_addresses, in_reply_to=in_reply_to_header, references=references_header, attachments=smtp_attachments, respect_dry_run=False, ) if not success: logger.error("❌ Failed to send case email for case %s: %s", sag_id, send_message) failure_detail = str(send_message or "Email send failed without provider detail").strip() # Keep error user-facing but concise; frontend will display this detail directly. failure_detail = failure_detail.replace("❌", "").strip() if failure_detail.lower() == "failed to send email": failure_detail = "Email send failed (provider returned generic error; check Graph app permissions and API logs)" raise HTTPException(status_code=500, detail=f"{failure_detail} [diag:sag-send-v3]") sender_name = email_service.smtp_config.get("from_name") or "BMC Hub" sender_email = ( email_service.graph_config.get("user_email") if email_service._graph_send_available() else email_service.smtp_config.get("from_address") ) or "" provider_thread_key_normalized = _normalize_message_id_token(provider_thread_key) # Keep replies in the existing case thread when we already know the target thread. # Some providers may return a new conversation id even for replies. derived_thread_key = _derive_thread_key_for_outbound( effective_payload_thread_key, in_reply_to_header, references_header, None, ) thread_key = derived_thread_key or provider_thread_key_normalized if not thread_key: thread_key = _derive_thread_key_for_outbound( effective_payload_thread_key, in_reply_to_header, references_header, generated_message_id, ) insert_result = None insert_error = None try: insert_email_query = """ INSERT INTO email_messages ( message_id, subject, sender_email, sender_name, recipient_email, cc, body_text, body_html, in_reply_to, email_references, thread_key, received_date, folder, has_attachments, attachment_count, status, import_method, linked_case_id ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) ON CONFLICT (message_id) DO UPDATE SET subject = EXCLUDED.subject, sender_email = EXCLUDED.sender_email, sender_name = EXCLUDED.sender_name, recipient_email = EXCLUDED.recipient_email, cc = EXCLUDED.cc, body_text = EXCLUDED.body_text, body_html = EXCLUDED.body_html, in_reply_to = COALESCE(EXCLUDED.in_reply_to, email_messages.in_reply_to), email_references = COALESCE(EXCLUDED.email_references, email_messages.email_references), thread_key = COALESCE(EXCLUDED.thread_key, email_messages.thread_key), folder = 'Sent', has_attachments = EXCLUDED.has_attachments, attachment_count = EXCLUDED.attachment_count, status = 'sent', import_method = COALESCE(email_messages.import_method, EXCLUDED.import_method), linked_case_id = COALESCE(email_messages.linked_case_id, EXCLUDED.linked_case_id), updated_at = CURRENT_TIMESTAMP RETURNING id """ insert_result = execute_query( insert_email_query, ( generated_message_id, subject, sender_email, sender_name, ", ".join(to_addresses), ", ".join(cc_addresses), body_text, body_html, in_reply_to_header, references_header, thread_key, datetime.now(), "Sent", bool(smtp_attachments), len(smtp_attachments), "sent", "manual_upload", sag_id, ), ) except Exception as e: insert_error = e logger.warning("⚠️ Outbound email full insert fallback for case %s: %s", sag_id, e) if not insert_result: try: insert_email_query = """ INSERT INTO email_messages ( message_id, subject, sender_email, sender_name, recipient_email, cc, body_text, body_html, received_date, folder, has_attachments, attachment_count, status, import_method, linked_case_id ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) ON CONFLICT (message_id) DO UPDATE SET subject = EXCLUDED.subject, sender_email = EXCLUDED.sender_email, sender_name = EXCLUDED.sender_name, recipient_email = EXCLUDED.recipient_email, cc = EXCLUDED.cc, body_text = EXCLUDED.body_text, body_html = EXCLUDED.body_html, folder = 'Sent', has_attachments = EXCLUDED.has_attachments, attachment_count = EXCLUDED.attachment_count, status = 'sent', import_method = COALESCE(email_messages.import_method, EXCLUDED.import_method), linked_case_id = COALESCE(email_messages.linked_case_id, EXCLUDED.linked_case_id), updated_at = CURRENT_TIMESTAMP RETURNING id """ insert_result = execute_query( insert_email_query, ( generated_message_id, subject, sender_email, sender_name, ", ".join(to_addresses), ", ".join(cc_addresses), body_text, body_html, datetime.now(), "Sent", bool(smtp_attachments), len(smtp_attachments), "sent", "manual_upload", sag_id, ), ) except Exception as e: insert_error = e logger.warning("⚠️ Outbound email medium insert fallback for case %s: %s", sag_id, e) if not insert_result: # Legacy-safe fallback: persist with minimal guaranteed columns. try: insert_email_query = """ INSERT INTO email_messages ( message_id, subject, sender_email, sender_name, recipient_email, cc, body_text, received_date, folder, has_attachments, attachment_count ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) ON CONFLICT (message_id) DO UPDATE SET subject = EXCLUDED.subject, sender_email = EXCLUDED.sender_email, sender_name = EXCLUDED.sender_name, recipient_email = EXCLUDED.recipient_email, cc = EXCLUDED.cc, body_text = EXCLUDED.body_text, folder = 'Sent', has_attachments = EXCLUDED.has_attachments, attachment_count = EXCLUDED.attachment_count, updated_at = CURRENT_TIMESTAMP RETURNING id """ insert_result = execute_query( insert_email_query, ( generated_message_id, subject, sender_email, sender_name, ", ".join(to_addresses), ", ".join(cc_addresses), body_text, datetime.now(), "Sent", bool(smtp_attachments), len(smtp_attachments), ), ) except Exception as e: insert_error = e logger.error("❌ Email sent but outbound log insert failed for case %s: %s", sag_id, e) email_id = None if insert_result: email_id = insert_result[0]["id"] else: # Last chance recovery: if row exists already, continue with that id. existing_email = execute_query_single( "SELECT id FROM email_messages WHERE message_id = %s", (generated_message_id,), ) if generated_message_id else None if existing_email: email_id = existing_email["id"] else: warning_detail = str(insert_error or "email logging failed") logger.error("❌ Email sent but no local email_id could be resolved for case %s", sag_id) return { "status": "sent", "email_id": None, "message": send_message, "warning": f"Email sent but could not be logged locally: {warning_detail}", } if smtp_attachments and email_id: from psycopg2 import Binary for attachment in smtp_attachments: try: execute_query( """ INSERT INTO email_attachments ( email_id, filename, content_type, size_bytes, file_path, content_data ) VALUES (%s, %s, %s, %s, %s, %s) """, ( email_id, attachment["filename"], attachment["content_type"], attachment.get("size") or len(attachment["content"]), attachment.get("file_path"), Binary(attachment["content"]), ), ) except Exception as e: logger.warning( "⚠️ Could not persist outbound email attachment '%s' for email_id=%s: %s", attachment.get("filename"), email_id, e, ) linked_ok = False try: execute_query( """ INSERT INTO sag_emails (sag_id, email_id) VALUES (%s, %s) ON CONFLICT DO NOTHING """, (sag_id, email_id), ) linked_ok = True except Exception as e: logger.warning("⚠️ Could not insert sag_emails link for case=%s email_id=%s: %s", sag_id, email_id, e) if table_has_column("email_messages", "linked_case_id"): try: execute_query( "UPDATE email_messages SET linked_case_id = %s WHERE id = %s", (sag_id, email_id), ) linked_ok = True except Exception as nested_e: logger.warning( "⚠️ Fallback linked_case_id update also failed for case=%s email_id=%s: %s", sag_id, email_id, nested_e, ) sent_ts = datetime.now().isoformat() outgoing_comment = ( "📧 Udgående email\n" f"Email-ID: {email_id}\n" f"Fra: {sender_email or sender_name or 'BMC Hub'}\n" f"Til: {', '.join(to_addresses)}\n" f"Emne: {subject}\n" f"Modtaget: {sent_ts}\n\n" f"{body_text}" ) comment_row = {} try: has_system_flag = table_has_column("sag_kommentarer", "er_system_besked") attempted_errors = [] has_comment_id_col = table_has_column("sag_kommentarer", "kommentar_id") has_id_col = table_has_column("sag_kommentarer", "id") # Prefer the variant that matches the live schema to avoid noisy SQL errors in logs. if has_comment_id_col: returning_variants = ["kommentar_id", "id AS kommentar_id"] elif has_id_col: returning_variants = ["id AS kommentar_id", "kommentar_id"] else: returning_variants = ["kommentar_id", "id AS kommentar_id"] if has_system_flag: comment_variants = [ ( f""" INSERT INTO sag_kommentarer (sag_id, forfatter, indhold, er_system_besked) VALUES (%s, %s, %s, %s) RETURNING {returning_expr}, created_at """, (sag_id, 'Email Bot', outgoing_comment, True), ) for returning_expr in returning_variants ] else: comment_variants = [ ( f""" INSERT INTO sag_kommentarer (sag_id, forfatter, indhold) VALUES (%s, %s, %s) RETURNING {returning_expr}, created_at """, (sag_id, 'Email Bot', outgoing_comment), ) for returning_expr in returning_variants ] for variant_query, variant_params in comment_variants: try: comment_row = execute_query_single(variant_query, variant_params) or {} if comment_row: break except Exception as variant_error: attempted_errors.append(str(variant_error)) if not comment_row and attempted_errors: logger.warning( "⚠️ Outbound email sent but comment logging variants failed for case %s: %s", sag_id, " | ".join(attempted_errors), ) except Exception as e: logger.warning("⚠️ Outbound email sent but comment logging failed for case %s: %s", sag_id, e) comment_created_at = comment_row.get("created_at") if isinstance(comment_created_at, datetime): comment_created_at = comment_created_at.isoformat() elif comment_created_at is None: comment_created_at = sent_ts logger.info( "✅ Outbound case email sent and linked (case=%s, email_id=%s, thread_email_id=%s, payload_thread_key=%s, stored_thread_key=%s, provider_thread_key=%s, recipients=%s)", sag_id, email_id, payload.thread_email_id, effective_payload_thread_key, thread_key, provider_thread_key_normalized, ", ".join(to_addresses), ) return { "status": "sent", "email_id": email_id, "message": send_message, "linked_to_case": linked_ok, "warning": None if linked_ok else "Email sent, but automatic case-thread link fallback was required", "comment": { "kommentar_id": comment_row.get("kommentar_id"), "forfatter": "Email Bot", "indhold": outgoing_comment, "created_at": comment_created_at, "er_system_besked": True, }, } # ============================================================================ # SOLUTIONS # ============================================================================ from . import solutions router.include_router(solutions.router)