PEChub – Test canale Email
" + f"Il canale {channel_name} e' configurato correttamente.
" + f"Data/ora: {ts}
"
+ f"Destinatario: {to_email}
Inviato da PEChub Notification Engine
" + ) + await send_email_notification( + smtp_host=smtp_host, + smtp_port=smtp_port, + smtp_user=smtp_user, + smtp_password=smtp_password, + from_email=from_email, + to_email=to_email, + subject=subject, + body_text=body_text, + body_html=body_html, + from_name=from_name, + use_tls=use_tls, + use_starttls=use_starttls, + ) diff --git a/backend/app/notifications/webhook.py b/backend/app/notifications/webhook.py new file mode 100644 index 0000000..c9e4db8 --- /dev/null +++ b/backend/app/notifications/webhook.py @@ -0,0 +1,125 @@ +""" +Webhook sender – POST HTTP con firma HMAC-SHA256. + +Config non sensibile (config): + { "url": "https://...", "content_type": "application/json" } + +Config sensibile (config_enc → config_secret): + { "webhook_secret": "..." } # opzionale – usato per firma HMAC + +Header inviati: + Content-Type: application/json + X-PEChub-Event: {event_type} + X-Hub-Signature-256: sha256={hex} (solo se webhook_secret configurato) + X-Delivery: {uuid} + User-Agent: PEChub-Webhook/1.0 +""" + +import hashlib +import hmac +import json +import uuid as uuid_mod +from datetime import datetime + +import httpx + +DEFAULT_TIMEOUT = 10.0 + + +class WebhookError(Exception): + """Errore durante l'invio di una notifica webhook.""" + + def __init__(self, message: str, http_status: int | None = None): + super().__init__(message) + self.http_status = http_status + + +async def send_webhook( + url: str, + payload: dict, + event_type: str = "new_message", + webhook_secret: str | None = None, + timeout: float = DEFAULT_TIMEOUT, +) -> dict: + """ + Invia un payload JSON a un webhook URL. + + Args: + url: URL destinatario del webhook + payload: dict serializzato come JSON nel body + event_type: valore dell'header X-PEChub-Event + webhook_secret: segreto per firma HMAC-SHA256 (opzionale) + timeout: timeout HTTP in secondi + + Returns: + dict con http_status, response_text, delivery_id + + Raises: + WebhookError: in caso di timeout, errore di rete o HTTP >= 400 + """ + body = json.dumps(payload, ensure_ascii=False, default=str).encode("utf-8") + delivery_id = str(uuid_mod.uuid4()) + + headers = { + "Content-Type": "application/json", + "X-PEChub-Event": event_type, + "X-Delivery": delivery_id, + "User-Agent": "PEChub-Webhook/1.0", + } + + if webhook_secret: + sig = hmac.new( + webhook_secret.encode("utf-8"), + body, + hashlib.sha256, + ).hexdigest() + headers["X-Hub-Signature-256"] = f"sha256={sig}" + + async with httpx.AsyncClient(timeout=timeout) as client: + try: + response = await client.post(url, content=body, headers=headers) + except httpx.TimeoutException as exc: + raise WebhookError( + f"Timeout webhook dopo {timeout}s" + ) from exc + except httpx.RequestError as exc: + raise WebhookError(f"Errore di rete webhook: {exc}") from exc + + if response.status_code >= 400: + raise WebhookError( + f"Webhook ha risposto con HTTP {response.status_code}: " + f"{response.text[:200]}", + http_status=response.status_code, + ) + + return { + "http_status": response.status_code, + "response_text": response.text[:500], + "delivery_id": delivery_id, + } + + +async def send_test_webhook( + url: str, + webhook_secret: str | None = None, + channel_name: str = "PEChub", +) -> dict: + """Invia un payload di test al webhook per verificare la configurazione.""" + payload = { + "event": "test", + "channel": channel_name, + "timestamp": datetime.now().isoformat(), + "message": "Notifica di test da PEChub", + "data": { + "subject": "[TEST] PEC di prova", + "from_address": "test@pec.example.it", + "pec_type": "posta_certificata", + "direction": "inbound", + }, + } + return await send_webhook( + url=url, + payload=payload, + event_type="test", + webhook_secret=webhook_secret, + ) diff --git a/backend/app/notifications/whatsapp.py b/backend/app/notifications/whatsapp.py new file mode 100644 index 0000000..2be0e0e --- /dev/null +++ b/backend/app/notifications/whatsapp.py @@ -0,0 +1,125 @@ +""" +WhatsApp sender – Meta Cloud API v18. + +Config non sensibile (config): + { + "phone_number_id": "123456789", # ID numero mittente Meta Business + "to_phone": "+393331234567" # numero destinatario con prefisso + } + +Config sensibile (config_enc → config_secret): + { "access_token": "EAABs..." } # Meta Graph API token + +API endpoint: + POST https://graph.facebook.com/v18.0/{phone_number_id}/messages + +Nota: richiede un account Meta Business verificato con WhatsApp Business API. +""" + +import httpx + +META_GRAPH_API_URL = "https://graph.facebook.com/v18.0" +DEFAULT_TIMEOUT = 10.0 + + +class WhatsAppError(Exception): + """Errore durante l'invio di un messaggio WhatsApp.""" + + def __init__(self, message: str, http_status: int | None = None, api_code: int | None = None): + super().__init__(message) + self.http_status = http_status + self.api_code = api_code + + +async def send_whatsapp_message( + phone_number_id: str, + to_phone: str, + text: str, + access_token: str, + timeout: float = DEFAULT_TIMEOUT, +) -> dict: + """ + Invia un messaggio di testo WhatsApp via Meta Cloud API. + + Args: + phone_number_id: ID del numero WhatsApp Business mittente + to_phone: numero destinatario (formato E.164, es. +393331234567) + text: testo del messaggio + access_token: Meta Graph API Bearer token + timeout: timeout HTTP in secondi + + Returns: + dict con message_id dalla risposta API + + Raises: + WhatsAppError: in caso di errore HTTP o risposta API non-ok + """ + url = f"{META_GRAPH_API_URL}/{phone_number_id}/messages" + payload = { + "messaging_product": "whatsapp", + "to": to_phone.replace(" ", "").replace("-", ""), + "type": "text", + "text": {"body": text}, + } + headers = { + "Authorization": f"Bearer {access_token}", + "Content-Type": "application/json", + } + + async with httpx.AsyncClient(timeout=timeout) as client: + try: + response = await client.post(url, json=payload, headers=headers) + except httpx.TimeoutException as exc: + raise WhatsAppError( + f"Timeout WhatsApp API dopo {timeout}s" + ) from exc + except httpx.RequestError as exc: + raise WhatsAppError(f"Errore di rete WhatsApp: {exc}") from exc + + if response.status_code == 401: + raise WhatsAppError( + "Token Meta non valido o scaduto", + http_status=401, + ) + + if response.status_code >= 400: + try: + err_data = response.json() + err_msg = err_data.get("error", {}).get("message", response.text[:200]) + err_code = err_data.get("error", {}).get("code") + except Exception: + err_msg = response.text[:200] + err_code = None + raise WhatsAppError( + f"Meta API errore HTTP {response.status_code}: {err_msg}", + http_status=response.status_code, + api_code=err_code, + ) + + data = response.json() + messages = data.get("messages", []) + message_id = messages[0].get("id") if messages else None + return {"message_id": message_id, "http_status": response.status_code} + + +async def send_test_whatsapp( + phone_number_id: str, + to_phone: str, + access_token: str, + channel_name: str = "PEChub", +) -> dict: + """Invia un messaggio WhatsApp di test per verificare la configurazione.""" + from datetime import datetime + + ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + text = ( + f"*PEChub – Test canale WhatsApp*\n\n" + f"Il canale _{channel_name}_ e' configurato correttamente.\n\n" + f"Data/ora: {ts}" + ) + return await send_whatsapp_message( + phone_number_id=phone_number_id, + to_phone=to_phone, + text=text, + access_token=access_token, + ) diff --git a/backend/app/schemas/audit_log.py b/backend/app/schemas/audit_log.py new file mode 100644 index 0000000..875f732 --- /dev/null +++ b/backend/app/schemas/audit_log.py @@ -0,0 +1,41 @@ +""" +Schemi Pydantic per Audit Log. +""" + +import uuid +from datetime import datetime +from typing import Any, Optional + +from pydantic import BaseModel, field_validator + +from app.core.pagination import PaginatedResponse + + +class AuditLogResponse(BaseModel): + """Risposta singolo evento audit.""" + + id: int + tenant_id: Optional[uuid.UUID] = None + user_id: Optional[uuid.UUID] = None + action: str + resource_type: Optional[str] = None + resource_id: Optional[uuid.UUID] = None + ip_address: Optional[str] = None + user_agent: Optional[str] = None + payload: Optional[dict] = None + outcome: str + occurred_at: datetime + + model_config = {"from_attributes": True} + + @field_validator("ip_address", mode="before") + @classmethod + def coerce_ip_address(cls, v: Any) -> Optional[str]: + """Converte IPv4Address/IPv6Address (tipo PostgreSQL INET) in stringa.""" + if v is None: + return None + return str(v) + + +# Lista paginata +AuditLogListResponse = PaginatedResponse[AuditLogResponse] diff --git a/backend/app/schemas/mailbox.py b/backend/app/schemas/mailbox.py index 7ada16f..a4d1400 100644 --- a/backend/app/schemas/mailbox.py +++ b/backend/app/schemas/mailbox.py @@ -116,3 +116,15 @@ class ConnectionTestResult(BaseModel): message: str latency_ms: float | None = None capabilities: list[str] | None = None # Solo per IMAP + + +class MailboxSyncResponse(BaseModel): + """Risposta all'accodamento di un job di sincronizzazione manuale.""" + status: str + mailbox_id: uuid.UUID + message: str + + +class MailboxUnreadCountsResponse(BaseModel): + """Conteggio messaggi non letti per casella.""" + counts: dict[str, int] diff --git a/backend/app/schemas/message.py b/backend/app/schemas/message.py index a3a37bc..f3b074a 100644 --- a/backend/app/schemas/message.py +++ b/backend/app/schemas/message.py @@ -49,6 +49,12 @@ class MessageResponse(BaseModel): is_starred: bool = False is_archived: bool = False archived_at: Optional[datetime] = None + is_trashed: bool = False + trashed_at: Optional[datetime] = None + is_pending_conservation: bool = False + pending_conservation_at: Optional[datetime] = None + is_conserved: bool = False + conserved_at: Optional[datetime] = None raw_eml_path: Optional[str] = None created_at: datetime updated_at: datetime @@ -84,12 +90,19 @@ class MessageUpdateRequest(BaseModel): is_read: Optional[bool] = None is_starred: Optional[bool] = None is_archived: Optional[bool] = None + is_trashed: Optional[bool] = None + is_pending_conservation: Optional[bool] = None + is_conserved: Optional[bool] = None class MessageBulkUpdateRequest(BaseModel): ids: list[uuid.UUID] + is_read: Optional[bool] = None is_starred: Optional[bool] = None is_archived: Optional[bool] = None + is_trashed: Optional[bool] = None + is_pending_conservation: Optional[bool] = None + is_conserved: Optional[bool] = None class MessageBulkUpdateResponse(BaseModel): diff --git a/backend/app/schemas/pec_contact.py b/backend/app/schemas/pec_contact.py new file mode 100644 index 0000000..607c195 --- /dev/null +++ b/backend/app/schemas/pec_contact.py @@ -0,0 +1,56 @@ +""" +Schemi Pydantic per PecContact (Feature 6 – Rubrica indirizzi PEC). +""" + +import uuid +from datetime import datetime + +from pydantic import BaseModel, EmailStr, field_validator + + +class PecContactCreate(BaseModel): + email: EmailStr + name: str | None = None + organization: str | None = None + notes: str | None = None + is_favorite: bool = False + + @field_validator("email") + @classmethod + def email_lowercase(cls, v: str) -> str: + return v.lower().strip() + + +class PecContactUpdate(BaseModel): + name: str | None = None + organization: str | None = None + notes: str | None = None + is_favorite: bool | None = None + + +class PecContactResponse(BaseModel): + model_config = {"from_attributes": True} + + id: uuid.UUID + tenant_id: uuid.UUID + email: str + name: str | None = None + organization: str | None = None + notes: str | None = None + is_favorite: bool + auto_saved: bool + created_by: uuid.UUID | None = None + created_at: datetime + updated_at: datetime + + +class PecContactListResponse(BaseModel): + items: list[PecContactResponse] + total: int + + +class PecContactImportResult(BaseModel): + created: int + updated: int + skipped: int + errors: list[str] = [] diff --git a/backend/app/schemas/permission.py b/backend/app/schemas/permission.py index c09cbfc..8f7b532 100644 --- a/backend/app/schemas/permission.py +++ b/backend/app/schemas/permission.py @@ -12,6 +12,7 @@ class PermissionGrantRequest(BaseModel): can_read: bool = True can_send: bool = False can_manage: bool = False + can_conserve: bool = False class PermissionResponse(BaseModel): @@ -22,6 +23,7 @@ class PermissionResponse(BaseModel): can_read: bool can_send: bool can_manage: bool + can_conserve: bool granted_by: uuid.UUID | None granted_at: datetime @@ -36,6 +38,7 @@ class UserMailboxPermissionResponse(BaseModel): can_read: bool can_send: bool can_manage: bool + can_conserve: bool class MailboxUserPermissionResponse(BaseModel): @@ -47,4 +50,5 @@ class MailboxUserPermissionResponse(BaseModel): can_read: bool can_send: bool can_manage: bool + can_conserve: bool granted_at: datetime diff --git a/backend/app/schemas/reports.py b/backend/app/schemas/reports.py new file mode 100644 index 0000000..b14da16 --- /dev/null +++ b/backend/app/schemas/reports.py @@ -0,0 +1,75 @@ +""" +Schemi Pydantic per la Dashboard e Reportistica (Fase 7). +""" + +from datetime import date, datetime +from typing import Optional +import uuid + +from pydantic import BaseModel, Field + + +class KpiSummary(BaseModel): + """Contatori KPI principali del tenant.""" + + # Oggi + received_today: int = Field(0, description="PEC ricevute oggi") + sent_today: int = Field(0, description="PEC inviate oggi (outbound)") + + # Ultimi 7 giorni + received_7d: int = Field(0, description="PEC ricevute negli ultimi 7 giorni") + sent_7d: int = Field(0, description="PEC inviate negli ultimi 7 giorni") + + # Ultimi 30 giorni + received_30d: int = Field(0, description="PEC ricevute negli ultimi 30 giorni") + sent_30d: int = Field(0, description="PEC inviate negli ultimi 30 giorni") + + # Stato + anomalie_attive: int = Field(0, description="Messaggi outbound in stato anomaly") + tasso_consegna: float = Field(0.0, description="Percentuale consegna (0-100)") + caselle_in_errore: int = Field(0, description="Caselle con status=error") + messaggi_non_letti: int = Field(0, description="Messaggi inbound non letti") + + # Totali assoluti + totale_messaggi: int = Field(0, description="Totale messaggi nel tenant") + + +class DailyStat(BaseModel): + """Statistiche giornaliere per il grafico a barre.""" + + day: date = Field(..., description="Data (YYYY-MM-DD)") + received: int = Field(0, description="PEC ricevute in quel giorno") + sent: int = Field(0, description="PEC inviate in quel giorno") + + +class OutboundStateStat(BaseModel): + """Conteggio messaggi outbound per stato (per il grafico a torta).""" + + state: str + count: int + + +class MailboxStat(BaseModel): + """Statistiche per singola casella.""" + + mailbox_id: uuid.UUID + email_address: str + display_name: Optional[str] = None + status: str + received_total: int = 0 + sent_total: int = 0 + anomalie: int = 0 + non_letti: int = 0 + last_sync_at: Optional[datetime] = None + + +class ReportSummaryResponse(BaseModel): + """Risposta completa dell'endpoint /reports/summary.""" + + generated_at: datetime + period_days: int = Field(..., description="Numero di giorni del periodo selezionato") + + kpi: KpiSummary + daily_stats: list[DailyStat] = Field(default_factory=list) + outbound_states: list[OutboundStateStat] = Field(default_factory=list) + mailbox_stats: list[MailboxStat] = Field(default_factory=list) diff --git a/backend/app/schemas/routing_rule.py b/backend/app/schemas/routing_rule.py new file mode 100644 index 0000000..0c82079 --- /dev/null +++ b/backend/app/schemas/routing_rule.py @@ -0,0 +1,113 @@ +""" +Schemi Pydantic per RoutingRule (Feature 2 – Regole di smistamento automatico). +""" + +import uuid +from datetime import datetime +from typing import Literal + +from pydantic import BaseModel, field_validator + +# Valori validi per field nelle condizioni +CONDITION_FIELDS = Literal[ + "from_address", "to_address", "subject", "mailbox_id", "pec_type" +] +# Operatori supportati +CONDITION_OPERATORS = Literal[ + "contains", "equals", "starts_with", "ends_with", "regex", "not_contains" +] +# Tipi di azione +ACTION_TYPES = Literal[ + "apply_label", "assign_vbox", "mark_read", "mark_starred", "notify_webhook" +] + + +class RoutingRuleConditionCreate(BaseModel): + field: CONDITION_FIELDS + operator: CONDITION_OPERATORS = "contains" + value: str + + @field_validator("value") + @classmethod + def value_not_empty(cls, v: str) -> str: + if not v.strip(): + raise ValueError("Il valore della condizione non puo' essere vuoto") + return v.strip() + + +class RoutingRuleActionCreate(BaseModel): + action_type: ACTION_TYPES + action_value: str | None = None + + +class RoutingRuleCreate(BaseModel): + name: str + description: str | None = None + is_active: bool = True + priority: int = 100 + stop_processing: bool = True + conditions: list[RoutingRuleConditionCreate] = [] + actions: list[RoutingRuleActionCreate] = [] + + @field_validator("name") + @classmethod + def name_not_empty(cls, v: str) -> str: + if not v.strip(): + raise ValueError("Il nome della regola non puo' essere vuoto") + return v.strip() + + @field_validator("priority") + @classmethod + def priority_positive(cls, v: int) -> int: + if v < 1: + raise ValueError("La priorita' deve essere >= 1") + return v + + +class RoutingRuleUpdate(BaseModel): + name: str | None = None + description: str | None = None + is_active: bool | None = None + priority: int | None = None + stop_processing: bool | None = None + conditions: list[RoutingRuleConditionCreate] | None = None + actions: list[RoutingRuleActionCreate] | None = None + + +class RoutingRuleConditionResponse(BaseModel): + model_config = {"from_attributes": True} + + id: uuid.UUID + field: str + operator: str + value: str + + +class RoutingRuleActionResponse(BaseModel): + model_config = {"from_attributes": True} + + id: uuid.UUID + action_type: str + action_value: str | None = None + + +class RoutingRuleResponse(BaseModel): + model_config = {"from_attributes": True} + + id: uuid.UUID + tenant_id: uuid.UUID + name: str + description: str | None = None + is_active: bool + priority: int + stop_processing: bool + conditions: list[RoutingRuleConditionResponse] = [] + actions: list[RoutingRuleActionResponse] = [] + created_by: uuid.UUID | None = None + created_at: datetime + updated_at: datetime + + +class RoutingRuleListResponse(BaseModel): + items: list[RoutingRuleResponse] + total: int diff --git a/backend/app/schemas/send.py b/backend/app/schemas/send.py index b6e022e..0cb650d 100644 --- a/backend/app/schemas/send.py +++ b/backend/app/schemas/send.py @@ -37,6 +37,9 @@ class SendPecRequest(BaseModel): reply_to_message_id: uuid.UUID | None = None """UUID del messaggio a cui si risponde (per threading, opzionale).""" + scheduled_at: datetime | None = None + """Data/ora di invio differito (Feature 5). Se None, invio immediato.""" + @field_validator("to_addresses") @classmethod def at_least_one_recipient(cls, v: list[EmailStr]) -> list[EmailStr]: @@ -67,6 +70,7 @@ class SendJobResponse(BaseModel): max_attempts: int next_retry_at: datetime | None = None last_error: str | None = None + scheduled_at: datetime | None = None queued_at: datetime sent_at: datetime | None = None created_by: uuid.UUID | None = None diff --git a/backend/app/schemas/template.py b/backend/app/schemas/template.py new file mode 100644 index 0000000..c04fa03 --- /dev/null +++ b/backend/app/schemas/template.py @@ -0,0 +1,51 @@ +""" +Schemi Pydantic per MessageTemplate (Feature 1 – Template messaggi). +""" + +import uuid +from datetime import datetime + +from pydantic import BaseModel, field_validator + + +class TemplateCreate(BaseModel): + name: str + description: str | None = None + subject: str = "" + body_text: str | None = None + body_html: str | None = None + + @field_validator("name") + @classmethod + def name_not_empty(cls, v: str) -> str: + if not v.strip(): + raise ValueError("Il nome del template non puo' essere vuoto") + return v.strip() + + +class TemplateUpdate(BaseModel): + name: str | None = None + description: str | None = None + subject: str | None = None + body_text: str | None = None + body_html: str | None = None + + +class TemplateResponse(BaseModel): + model_config = {"from_attributes": True} + + id: uuid.UUID + tenant_id: uuid.UUID + name: str + description: str | None = None + subject: str + body_text: str | None = None + body_html: str | None = None + created_by: uuid.UUID | None = None + created_at: datetime + updated_at: datetime + + +class TemplateListResponse(BaseModel): + items: list[TemplateResponse] + total: int diff --git a/backend/app/schemas/tenant_settings.py b/backend/app/schemas/tenant_settings.py index d200349..0556c9f 100644 --- a/backend/app/schemas/tenant_settings.py +++ b/backend/app/schemas/tenant_settings.py @@ -1,12 +1,13 @@ """ Schema Pydantic per TenantSettings – lettura e aggiornamento impostazioni tenant. +Include schemi per il modulo di indicizzazione full-text. """ import uuid from datetime import datetime -from typing import Literal +from typing import Literal, Optional -from pydantic import BaseModel, Field, HttpUrl, field_validator +from pydantic import BaseModel, Field, field_validator ArchivalMode = Literal["mock", "production"] @@ -68,3 +69,53 @@ class TenantSettingsUpdate(BaseModel): if v is not None and v not in ("mock", "production"): raise ValueError("archival_mode deve essere 'mock' o 'production'") return v + + +# ─── Schemi indicizzazione full-text ────────────────────────────────────────── + +class IndexingStats(BaseModel): + """Statistiche di copertura dell'indicizzazione per un tenant.""" + + total_messages: int + indexed_messages: int + unindexed_messages: int + coverage_pct: float # percentuale messaggi con search_vector != NULL + + attachments_total: int # allegati PDF/DOCX totali + attachments_extracted: int # allegati con testo estratto + attachments_pct: float # percentuale allegati con testo estratto + + +class IndexingJobStatus(BaseModel): + """Stato di un job di reindex in corso o completato.""" + + status: str # idle | running | completed | failed | cancelled + mode: Optional[str] = None # full | differential + total: int = 0 + processed: int = 0 + progress_pct: float = 0.0 + + started_at: Optional[str] = None # ISO datetime + finished_at: Optional[str] = None # ISO datetime + started_by: Optional[str] = None # email utente che ha avviato il job + elapsed_seconds: Optional[int] = None + is_stale: bool = False # True se running da piu' di STALE_THRESHOLD_HOURS + error: Optional[str] = None + + +class StartReindexRequest(BaseModel): + """Body per POST /settings/indexing/reindex.""" + + mode: Literal["full", "differential"] = "differential" + + +class StartRescanRequest(BaseModel): + """Body per POST /settings/indexing/rescan.""" + + force: bool = Field( + default=False, + description=( + "False (default): estrae solo allegati con extracted_text NULL. " + "True: ri-estrae tutti gli allegati, sovrascrivendo i testi gia' presenti." + ), + ) diff --git a/backend/app/services/audit_service.py b/backend/app/services/audit_service.py new file mode 100644 index 0000000..7cf7bde --- /dev/null +++ b/backend/app/services/audit_service.py @@ -0,0 +1,153 @@ +""" +Servizio Audit Log – registrazione e consultazione degli eventi di sistema. + +Uso tipico nei router/servizi: + from app.services.audit_service import log_audit + + await log_audit( + db=db, + tenant_id=current_user.tenant_id, + user_id=current_user.id, + action="user.created", + resource_type="user", + resource_id=new_user.id, + outcome="success", + ip_address=request.client.host if request.client else None, + user_agent=request.headers.get("user-agent"), + payload={"email": new_user.email}, + ) +""" + +import math +import uuid +from datetime import datetime +from typing import Optional + +from sqlalchemy import select, func, and_ +from sqlalchemy.ext.asyncio import AsyncSession + +from app.core.pagination import PaginatedResponse, PaginationParams +from app.models.audit_log import AuditLog +from app.schemas.audit_log import AuditLogResponse + + +# ─── Helper standalone (da chiamare ovunque senza istanziare la classe) ─────── + +async def log_audit( + db: AsyncSession, + action: str, + *, + tenant_id: Optional[uuid.UUID] = None, + user_id: Optional[uuid.UUID] = None, + resource_type: Optional[str] = None, + resource_id: Optional[uuid.UUID] = None, + outcome: str = "success", + ip_address: Optional[str] = None, + user_agent: Optional[str] = None, + payload: Optional[dict] = None, +) -> None: + """ + Inserisce un record di audit log nella sessione corrente. + Non fa commit: il commit avviene con la transazione del chiamante. + Non solleva eccezioni: gli errori sono loggati ma non propagati + per evitare di bloccare l'operazione principale. + """ + try: + entry = AuditLog( + tenant_id=tenant_id, + user_id=user_id, + action=action, + resource_type=resource_type, + resource_id=resource_id, + ip_address=ip_address, + user_agent=user_agent, + payload=payload or {}, + outcome=outcome, + ) + db.add(entry) + except Exception: + # Mai bloccare l'operazione principale per un errore di audit + import logging + logging.getLogger(__name__).warning( + "Impossibile registrare evento audit: action=%s", action, exc_info=True + ) + + +# ─── Servizio per query (usato dal router) ──────────────────────────────────── + +class AuditService: + def __init__(self, db: AsyncSession) -> None: + self.db = db + + async def list( + self, + *, + tenant_id: Optional[uuid.UUID], + page: int = 1, + page_size: int = 25, + action: Optional[str] = None, + user_id: Optional[uuid.UUID] = None, + outcome: Optional[str] = None, + date_from: Optional[datetime] = None, + date_to: Optional[datetime] = None, + resource_type: Optional[str] = None, + ) -> PaginatedResponse[AuditLogResponse]: + """ + Restituisce la lista paginata degli eventi audit. + + Se tenant_id e' None (super_admin), restituisce eventi di tutti i tenant. + """ + filters = [] + + if tenant_id is not None: + filters.append(AuditLog.tenant_id == tenant_id) + + if action: + # Supporta prefisso: "auth." corrisponde a tutti gli eventi auth.* + if action.endswith("*"): + filters.append(AuditLog.action.like(action[:-1] + "%")) + else: + filters.append(AuditLog.action == action) + + if user_id: + filters.append(AuditLog.user_id == user_id) + + if outcome: + filters.append(AuditLog.outcome == outcome) + + if date_from: + filters.append(AuditLog.occurred_at >= date_from) + + if date_to: + filters.append(AuditLog.occurred_at <= date_to) + + if resource_type: + filters.append(AuditLog.resource_type == resource_type) + + where_clause = and_(*filters) if filters else True # type: ignore[arg-type] + + # Count totale + count_q = select(func.count()).select_from(AuditLog).where(where_clause) + total = (await self.db.execute(count_q)).scalar_one() + + # Dati paginati + offset = (page - 1) * page_size + items_q = ( + select(AuditLog) + .where(where_clause) + .order_by(AuditLog.occurred_at.desc()) + .offset(offset) + .limit(page_size) + ) + result = await self.db.execute(items_q) + items = list(result.scalars().all()) + + pages = math.ceil(total / page_size) if page_size > 0 else 0 + + return PaginatedResponse[AuditLogResponse]( + items=[AuditLogResponse.model_validate(item) for item in items], + total=total, + page=page, + page_size=page_size, + pages=pages, + ) diff --git a/backend/app/services/indexing_service.py b/backend/app/services/indexing_service.py new file mode 100644 index 0000000..28424ff --- /dev/null +++ b/backend/app/services/indexing_service.py @@ -0,0 +1,1226 @@ +""" +Servizio di gestione indicizzazione full-text dei messaggi. + +Funzionalita': + - Statistiche sull'indicizzazione (messaggi indicizzati vs totali) + - Avvio reindex totale o differenziale in background + - Monitoraggio progresso tramite Redis + - Cancellazione di un job in corso + - Avvio rescan allegati: ri-estrazione testo da MinIO + aggiornamento search_vector + +Stato del job reindex salvato in Redis: + pechub:reindex:{tenant_id} -> JSON con stato corrente (TTL 24h) + pechub:reindex:{tenant_id}:cancel -> flag cancellazione (TTL 10min) + +Stato del job rescan salvato in Redis: + pechub:rescan:{tenant_id} -> JSON con stato corrente (TTL 24h) + pechub:rescan:{tenant_id}:cancel -> flag cancellazione (TTL 10min) + +Il background task usa una sessione DB propria (non quella della request). +""" + +import asyncio +import io +import json +import logging +import re +import uuid +from datetime import datetime, timezone +from typing import Literal, Optional + +from sqlalchemy import func, select, text +from sqlalchemy.ext.asyncio import AsyncSession + +from app.core.logging import get_logger + +logger = get_logger(__name__) + +# ─── Costanti ───────────────────────────────────────────────────────────────── + +REDIS_KEY_PREFIX = "pechub:reindex" +REDIS_RESCAN_PREFIX = "pechub:rescan" +REDIS_TTL_STATUS = 60 * 60 * 24 # 24 ore +REDIS_TTL_CANCEL = 60 * 10 # 10 minuti +BATCH_SIZE = 500 # messaggi per batch (reindex) +RESCAN_BATCH_SIZE = 50 # allegati per batch (rescan - piu' pesante) +STALE_THRESHOLD_HOURS = 2 # ore prima di segnalare un job come stale + +MAX_EXTRACTED_TEXT_LEN = 50_000 +MAX_COMBINED_TEXT_LEN = 200_000 + +ReindexMode = Literal["full", "differential"] +JobStatus = Literal["idle", "running", "completed", "failed", "cancelled"] + +# ─── Content-type e estensioni supportate per rescan ───────────────────────── + +_SUPPORTED_EXTENSIONS = { + "pdf", "docx", "doc", "xlsx", "xls", "pptx", "ppt", + "odt", "ods", "odp", "rtf", "txt", "csv", "xml", + "html", "htm", "json", "eml", "msg", "p7m", + "md", + # Immagini (OCR) + "png", "jpg", "jpeg", "tiff", "tif", "bmp", "gif", "webp", +} + +_SUPPORTED_CONTENT_TYPES = { + "application/pdf", + "application/vnd.openxmlformats-officedocument.wordprocessingml.document", + "application/msword", + "application/vnd.ms-word", + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", + "application/vnd.ms-excel", + "application/vnd.openxmlformats-officedocument.presentationml.presentation", + "application/vnd.ms-powerpoint", + "application/vnd.oasis.opendocument.text", + "application/vnd.oasis.opendocument.spreadsheet", + "application/vnd.oasis.opendocument.presentation", + "application/rtf", + "text/rtf", + "text/plain", + "text/csv", + "text/xml", + "application/xml", + "text/html", + "message/rfc822", + "application/pkcs7-mime", + "application/x-pkcs7-mime", + "text/markdown", + # Immagini (OCR) + "image/png", + "image/jpeg", + "image/tiff", + "image/bmp", + "image/gif", + "image/webp", +} + + +# ─── Helpers Redis ───────────────────────────────────────────────────────────── + +def _redis_key(tenant_id: uuid.UUID) -> str: + return f"{REDIS_KEY_PREFIX}:{tenant_id}" + + +def _redis_cancel_key(tenant_id: uuid.UUID) -> str: + return f"{REDIS_KEY_PREFIX}:{tenant_id}:cancel" + + +def _redis_rescan_key(tenant_id: uuid.UUID) -> str: + return f"{REDIS_RESCAN_PREFIX}:{tenant_id}" + + +def _redis_rescan_cancel_key(tenant_id: uuid.UUID) -> str: + return f"{REDIS_RESCAN_PREFIX}:{tenant_id}:cancel" + + +# ─── Estrattori testo allegati ───────────────────────────────────────────────── + +def _ext(filename: str | None) -> str: + """Restituisce l'estensione del file in minuscolo, senza punto.""" + if not filename: + return "" + fn = filename.lower() + if fn.endswith(".p7m"): + return "p7m" + idx = fn.rfind(".") + return fn[idx + 1:] if idx >= 0 else "" + + +# Soglia minima di caratteri estratti da pypdf prima di ricorrere all'OCR. +_PDF_OCR_THRESHOLD = 50 +# Numero massimo di pagine OCR per evitare timeout su PDF lunghi. +_PDF_OCR_MAX_PAGES = 15 + + +def _extract_pdf(content: bytes) -> str: + """ + Estrae testo da PDF tramite pypdf. + + Se il testo estratto e' inferiore a _PDF_OCR_THRESHOLD caratteri (PDF + image-only / scansione), attiva il fallback OCR via Tesseract. + """ + try: + import pypdf # type: ignore[import] + reader = pypdf.PdfReader(io.BytesIO(content)) + parts: list[str] = [] + for page in reader.pages: + try: + t = page.extract_text() + if t: + parts.append(t) + except Exception: + continue + text = " ".join(parts) + except ImportError: + logger.warning("pypdf non installato: impossibile estrarre testo da PDF") + return "" + except Exception as e: + logger.debug(f"Errore estrazione PDF: {e}") + return "" + + if len(text.strip()) < _PDF_OCR_THRESHOLD: + logger.debug( + f"PDF con testo insufficiente ({len(text.strip())} char), " + "tentativo OCR..." + ) + ocr_text = _extract_pdf_ocr(content) + if len(ocr_text.strip()) > len(text.strip()): + return ocr_text + + return text + + +def _extract_pdf_ocr(content: bytes) -> str: + """ + OCR su PDF image-only tramite pdf2image + Tesseract. + + Converte le pagine a 200 DPI e applica Tesseract con lingua italiana + inglese. + Processa al massimo _PDF_OCR_MAX_PAGES pagine per evitare timeout. + """ + try: + from pdf2image import convert_from_bytes # type: ignore[import] + import pytesseract # type: ignore[import] + + pages = convert_from_bytes( + content, + dpi=200, + last_page=_PDF_OCR_MAX_PAGES, + ) + parts: list[str] = [] + for page_img in pages: + try: + t = pytesseract.image_to_string(page_img, lang="ita+eng") + if t and t.strip(): + parts.append(t.strip()) + except Exception: + continue + return " ".join(parts) + except ImportError: + logger.warning( + "pdf2image o pytesseract non installati: impossibile OCR PDF" + ) + return "" + except Exception as e: + logger.debug(f"Errore OCR PDF: {e}") + return "" + + +def _extract_image_ocr(content: bytes) -> str: + """ + Estrae testo da un file immagine (PNG, JPEG, TIFF, BMP, ecc.) tramite OCR. + + Usa Tesseract con lingua italiana + inglese per massima copertura + su documenti italiani. + """ + try: + import pytesseract # type: ignore[import] + from PIL import Image # type: ignore[import] + + img = Image.open(io.BytesIO(content)) + if img.mode not in ("RGB", "L"): + img = img.convert("RGB") + text = pytesseract.image_to_string(img, lang="ita+eng") + return " ".join(text.split()) + except ImportError: + logger.warning( + "pytesseract o Pillow non installati: impossibile OCR immagine" + ) + return "" + except Exception as e: + logger.debug(f"Errore OCR immagine: {e}") + return "" + + +def _extract_docx(content: bytes) -> str: + try: + import docx # type: ignore[import] + doc = docx.Document(io.BytesIO(content)) + parts = [p.text for p in doc.paragraphs if p.text and p.text.strip()] + for table in doc.tables: + for row in table.rows: + for cell in row.cells: + if cell.text and cell.text.strip(): + parts.append(cell.text.strip()) + return " ".join(parts) + except ImportError: + logger.warning("python-docx non installato: impossibile estrarre testo da DOCX") + return "" + except Exception as e: + logger.debug(f"Errore estrazione DOCX: {e}") + return "" + + +def _extract_doc(content: bytes) -> str: + """ + Estrae testo da file DOC (formato OLE2/legacy Microsoft Word). + + Prima tenta python-docx (gestisce .docx eventualmente rinominati come .doc). + Se fallisce, esegue uno scan del binario OLE2 estraendo sequenze di caratteri + stampabili di almeno 5 caratteri consecutivi (approccio 'strings'). + Non richiede librerie aggiuntive e funziona per la maggior parte dei .doc + in lingua italiana/europea (ASCII + Latin-1). + """ + # Tentativo 1: python-docx (per .docx rinominati o ZIP-based) + result = _extract_docx(content) + if result.strip(): + return result + + # Tentativo 2: scan binario ASCII per OLE2 + try: + run: list[int] = [] + parts: list[str] = [] + for byte in content: + if 32 <= byte <= 126: # ASCII stampabile + run.append(byte) + else: + if len(run) >= 5: + parts.append(bytes(run).decode("ascii", errors="ignore")) + run = [] + if len(run) >= 5: + parts.append(bytes(run).decode("ascii", errors="ignore")) + + # Mantieni solo sequenze con almeno 3 lettere (filtra sequenze di simboli) + meaningful = [p for p in parts if sum(1 for c in p if c.isalpha()) >= 3] + if meaningful: + text = " ".join(meaningful) + return " ".join(text.split())[:MAX_EXTRACTED_TEXT_LEN] + except Exception as e: + logger.debug(f"Errore estrazione DOC OLE2 binario: {e}") + + return "" + + +def _extract_plain(content: bytes) -> str: + try: + try: + txt = content.decode("utf-8") + except UnicodeDecodeError: + txt = content.decode("latin-1", errors="replace") + if "<" in txt and ">" in txt: + txt = re.sub(r"<[^>]+>", " ", txt) + txt = re.sub(r"&[a-zA-Z]+;", " ", txt) + return " ".join(txt.split()) + except Exception as e: + logger.debug(f"Errore estrazione plain: {e}") + return "" + + +def _extract_eml(content: bytes) -> str: + try: + import email as emaillib + msg = emaillib.message_from_bytes(content) + parts: list[str] = [] + subject = msg.get("Subject", "") + if subject: + parts.append(subject) + sender = msg.get("From", "") + if sender: + parts.append(sender) + if msg.is_multipart(): + for part in msg.walk(): + ct = part.get_content_type() + if ct == "text/plain": + try: + payload = part.get_payload(decode=True) + if payload: + charset = part.get_content_charset() or "utf-8" + parts.append(payload.decode(charset, errors="replace")) + except Exception: + pass + else: + payload = msg.get_payload(decode=True) + if payload: + charset = msg.get_content_charset() or "utf-8" + parts.append(payload.decode(charset, errors="replace")) # type: ignore[arg-type] + return " ".join(parts) + except Exception as e: + logger.debug(f"Errore estrazione EML: {e}") + return "" + + +def _unwrap_p7m_asn1(data: bytes) -> bytes | None: + def read_tag_length(buf: bytes, offset: int): + tag = buf[offset] + offset += 1 + lb = buf[offset] + offset += 1 + if lb & 0x80: + num_bytes = lb & 0x7F + ln = int.from_bytes(buf[offset:offset + num_bytes], "big") + offset += num_bytes + else: + ln = lb + return tag, ln, offset + + pos = 0 + try: + tag, ln, pos = read_tag_length(data, pos) + if tag != 0x30: + return None + tag, ln, pos = read_tag_length(data, pos) + if tag != 0x06: + return None + pos += ln + tag, ln, pos = read_tag_length(data, pos) + if tag != 0xA0: + return None + tag, ln, pos = read_tag_length(data, pos) + if tag != 0x30: + return None + tag, ln, pos = read_tag_length(data, pos) + if tag != 0x02: + return None + pos += ln + tag, ln, pos = read_tag_length(data, pos) + if tag != 0x31: + return None + pos += ln + tag, ln, pos = read_tag_length(data, pos) + if tag != 0x30: + return None + tag, ln, pos = read_tag_length(data, pos) + if tag != 0x06: + return None + pos += ln + tag, ln, pos = read_tag_length(data, pos) + if tag != 0xA0: + return None + tag, ln, pos = read_tag_length(data, pos) + if tag != 0x04: + return None + return data[pos: pos + ln] + except Exception: + return None + + +def _extract_p7m(content: bytes, original_filename: str | None = None) -> str: + inner_content = _unwrap_p7m_asn1(content) + if not inner_content: + return "" + inner_ext = "" + if original_filename: + fn = original_filename.lower() + if fn.endswith(".p7m"): + fn = fn[:-4] + idx = fn.rfind(".") + if idx >= 0: + inner_ext = fn[idx + 1:] + extractor = _EXTRACTORS_SYNC.get(inner_ext) + if extractor: + return extractor(inner_content) + if inner_content[:4] == b"%PDF": + return _extract_pdf(inner_content) + if inner_content[:2] == b"PK": + for fn_try in (_extract_docx, _extract_plain): + result = fn_try(inner_content) + if result.strip(): + return result + return _extract_plain(inner_content) + + +_EXTRACTORS_SYNC: dict = { + "pdf": _extract_pdf, + "docx": _extract_docx, + "doc": _extract_doc, # usa fallback OLE2 per .doc legacy + "txt": _extract_plain, + "csv": _extract_plain, + "xml": _extract_plain, + "html": _extract_plain, + "htm": _extract_plain, + "json": _extract_plain, + "md": _extract_plain, # Markdown e' testo semplice + "eml": _extract_eml, + "msg": _extract_eml, + "p7m": _extract_p7m, + # Immagini (OCR) + "png": _extract_image_ocr, + "jpg": _extract_image_ocr, + "jpeg": _extract_image_ocr, + "tiff": _extract_image_ocr, + "tif": _extract_image_ocr, + "bmp": _extract_image_ocr, + "gif": _extract_image_ocr, + "webp": _extract_image_ocr, +} + + +def _resolve_extractor(content_type: str | None, filename: str | None): + """Ritorna la funzione estrattore appropriata, o None.""" + e = _ext(filename) + if e in _EXTRACTORS_SYNC: + return _EXTRACTORS_SYNC[e] + ct = (content_type or "").lower() + _ct_map = { + "application/pdf": "pdf", + "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx", + "application/msword": "doc", + "application/vnd.ms-word": "doc", + "text/plain": "txt", + "text/csv": "csv", + "text/xml": "xml", + "application/xml": "xml", + "text/html": "html", + "text/markdown": "md", + "message/rfc822": "eml", + "application/pkcs7-mime": "p7m", + "application/x-pkcs7-mime": "p7m", + # Immagini (OCR) + "image/png": "png", + "image/jpeg": "jpeg", + "image/tiff": "tiff", + "image/bmp": "bmp", + "image/gif": "gif", + "image/webp": "webp", + } + mapped = _ct_map.get(ct) + if mapped: + return _EXTRACTORS_SYNC.get(mapped) + return None + + +def _is_extractable(content_type: str | None, filename: str | None) -> bool: + e = _ext(filename) + if e in _SUPPORTED_EXTENSIONS: + return True + ct = (content_type or "").lower() + return ct in _SUPPORTED_CONTENT_TYPES + + +# ─── Servizio ────────────────────────────────────────────────────────────────── + +class IndexingService: + """Gestisce le operazioni di indicizzazione full-text per un tenant.""" + + def __init__(self, db: AsyncSession) -> None: + self.db = db + + # ── Statistiche ────────────────────────────────────────────────────────── + + async def get_stats(self, tenant_id: uuid.UUID) -> dict: + """ + Restituisce le statistiche di copertura dell'indicizzazione per il tenant. + """ + from app.models.message import Attachment, Message + + total_q = await self.db.execute( + select(func.count(Message.id)).where( + Message.tenant_id == tenant_id, + Message.parent_message_id.is_(None), + ) + ) + total_messages: int = total_q.scalar_one() + + indexed_q = await self.db.execute( + select(func.count(Message.id)).where( + Message.tenant_id == tenant_id, + Message.parent_message_id.is_(None), + Message.search_vector.isnot(None), + ) + ) + indexed_messages: int = indexed_q.scalar_one() + + _supported_content_types_list = list(_SUPPORTED_CONTENT_TYPES) + _supported_extensions_like = [f"%.{e}" for e in _SUPPORTED_EXTENSIONS] + + from sqlalchemy import or_ + ext_conditions = [Attachment.filename.ilike(ext) for ext in _supported_extensions_like] + + att_total_q = await self.db.execute( + select(func.count(Attachment.id)).where( + Attachment.tenant_id == tenant_id, + or_( + Attachment.content_type.in_(_supported_content_types_list), + *ext_conditions, + ), + ) + ) + attachments_total: int = att_total_q.scalar_one() + + att_extracted_q = await self.db.execute( + select(func.count(Attachment.id)).where( + Attachment.tenant_id == tenant_id, + Attachment.extracted_text.isnot(None), + ) + ) + attachments_extracted: int = att_extracted_q.scalar_one() + + unindexed_messages = total_messages - indexed_messages + coverage_pct = ( + round(indexed_messages / total_messages * 100, 1) + if total_messages > 0 + else 100.0 + ) + attachments_pct = ( + round(attachments_extracted / attachments_total * 100, 1) + if attachments_total > 0 + else 100.0 + ) + + return { + "total_messages": total_messages, + "indexed_messages": indexed_messages, + "unindexed_messages": unindexed_messages, + "coverage_pct": coverage_pct, + "attachments_total": attachments_total, + "attachments_extracted": attachments_extracted, + "attachments_pct": attachments_pct, + } + + # ── Stato job reindex ───────────────────────────────────────────────────── + + @staticmethod + async def get_job_status(tenant_id: uuid.UUID, redis_url: str) -> dict: + """Legge lo stato del job di reindex da Redis.""" + return await IndexingService._read_job_state( + _redis_key(tenant_id), redis_url + ) + + # ── Stato job rescan ────────────────────────────────────────────────────── + + @staticmethod + async def get_rescan_status(tenant_id: uuid.UUID, redis_url: str) -> dict: + """Legge lo stato del job di rescan allegati da Redis.""" + return await IndexingService._read_job_state( + _redis_rescan_key(tenant_id), redis_url + ) + + @staticmethod + async def _read_job_state(redis_key_str: str, redis_url: str) -> dict: + """Helper generico: legge uno stato job da Redis.""" + import redis.asyncio as aioredis + + client = aioredis.from_url(redis_url, decode_responses=True) + try: + raw = await client.get(redis_key_str) + finally: + await client.aclose() + + if not raw: + return { + "status": "idle", + "mode": None, + "total": 0, + "processed": 0, + "progress_pct": 0.0, + "started_at": None, + "finished_at": None, + "started_by": None, + "elapsed_seconds": None, + "is_stale": False, + "error": None, + } + + try: + data: dict = json.loads(raw) + except json.JSONDecodeError: + return {"status": "idle"} + + is_stale = False + elapsed_seconds = None + if data.get("started_at"): + try: + started = datetime.fromisoformat(data["started_at"]) + finished_str = data.get("finished_at") + ref_time = ( + datetime.fromisoformat(finished_str) + if finished_str + else datetime.now(timezone.utc) + ) + elapsed_seconds = int((ref_time - started).total_seconds()) + if data.get("status") == "running": + elapsed_hours = elapsed_seconds / 3600 + is_stale = elapsed_hours >= STALE_THRESHOLD_HOURS + except Exception: + pass + + total = data.get("total", 0) + processed = data.get("processed", 0) + progress_pct = round(processed / total * 100, 1) if total > 0 else 0.0 + + return { + "status": data.get("status", "idle"), + "mode": data.get("mode"), + "total": total, + "processed": processed, + "progress_pct": progress_pct, + "started_at": data.get("started_at"), + "finished_at": data.get("finished_at"), + "started_by": data.get("started_by"), + "elapsed_seconds": elapsed_seconds, + "is_stale": is_stale, + "error": data.get("error"), + } + + # ── Avvio reindex ───────────────────────────────────────────────────────── + + @staticmethod + async def start_reindex( + tenant_id: uuid.UUID, + mode: ReindexMode, + started_by_email: str, + redis_url: str, + db_url: str, + ) -> None: + import redis.asyncio as aioredis + + client = aioredis.from_url(redis_url, decode_responses=True) + try: + raw = await client.get(_redis_key(tenant_id)) + if raw: + data = json.loads(raw) + if data.get("status") == "running": + raise ValueError("Un job di reindex e' gia' in corso per questo tenant") + # Controlla anche se il rescan e' in corso + raw_rescan = await client.get(_redis_rescan_key(tenant_id)) + if raw_rescan: + data_rescan = json.loads(raw_rescan) + if data_rescan.get("status") == "running": + raise ValueError( + "Un job di scansione allegati e' in corso. " + "Attendi il termine prima di avviare il reindex." + ) + finally: + await client.aclose() + + await IndexingService._set_state( + _redis_key(tenant_id), + redis_url, + { + "status": "running", + "mode": mode, + "total": 0, + "processed": 0, + "started_at": datetime.now(timezone.utc).isoformat(), + "finished_at": None, + "started_by": started_by_email, + "error": None, + }, + ) + + asyncio.create_task( + IndexingService._run_reindex_bg(tenant_id, mode, redis_url, db_url), + name=f"reindex-{tenant_id}", + ) + + # ── Avvio rescan allegati ───────────────────────────────────────────────── + + @staticmethod + async def start_rescan( + tenant_id: uuid.UUID, + started_by_email: str, + redis_url: str, + db_url: str, + force: bool = False, + ) -> None: + """ + Avvia il job di rescan allegati in background. + + force=False: processa solo allegati con extracted_text IS NULL + force=True: processa tutti gli allegati (ri-estrae anche quelli gia' estratti) + """ + import redis.asyncio as aioredis + + client = aioredis.from_url(redis_url, decode_responses=True) + try: + raw = await client.get(_redis_rescan_key(tenant_id)) + if raw: + data = json.loads(raw) + if data.get("status") == "running": + raise ValueError("Un job di scansione allegati e' gia' in corso per questo tenant") + # Controlla anche se il reindex e' in corso + raw_reindex = await client.get(_redis_key(tenant_id)) + if raw_reindex: + data_reindex = json.loads(raw_reindex) + if data_reindex.get("status") == "running": + raise ValueError( + "Un job di reindex e' in corso. " + "Attendi il termine prima di avviare la scansione allegati." + ) + finally: + await client.aclose() + + mode_label = "force" if force else "differential" + + await IndexingService._set_state( + _redis_rescan_key(tenant_id), + redis_url, + { + "status": "running", + "mode": mode_label, + "total": 0, + "processed": 0, + "started_at": datetime.now(timezone.utc).isoformat(), + "finished_at": None, + "started_by": started_by_email, + "error": None, + }, + ) + + asyncio.create_task( + IndexingService._run_rescan_bg(tenant_id, force, redis_url, db_url), + name=f"rescan-{tenant_id}", + ) + + # ── Cancellazione reindex ───────────────────────────────────────────────── + + @staticmethod + async def cancel_reindex(tenant_id: uuid.UUID, redis_url: str) -> bool: + import redis.asyncio as aioredis + + client = aioredis.from_url(redis_url, decode_responses=True) + try: + raw = await client.get(_redis_key(tenant_id)) + if raw: + data = json.loads(raw) + if data.get("status") == "running": + await client.setex( + _redis_cancel_key(tenant_id), + REDIS_TTL_CANCEL, + "1", + ) + return True + finally: + await client.aclose() + return False + + # ── Cancellazione rescan ────────────────────────────────────────────────── + + @staticmethod + async def cancel_rescan(tenant_id: uuid.UUID, redis_url: str) -> bool: + import redis.asyncio as aioredis + + client = aioredis.from_url(redis_url, decode_responses=True) + try: + raw = await client.get(_redis_rescan_key(tenant_id)) + if raw: + data = json.loads(raw) + if data.get("status") == "running": + await client.setex( + _redis_rescan_cancel_key(tenant_id), + REDIS_TTL_CANCEL, + "1", + ) + return True + finally: + await client.aclose() + return False + + # ── Helpers Redis ───────────────────────────────────────────────────────── + + @staticmethod + async def _set_state(redis_key_str: str, redis_url: str, state: dict) -> None: + import redis.asyncio as aioredis + + client = aioredis.from_url(redis_url, decode_responses=True) + try: + await client.setex( + redis_key_str, + REDIS_TTL_STATUS, + json.dumps(state, default=str), + ) + finally: + await client.aclose() + + @staticmethod + async def _check_cancel_flag(cancel_key: str, redis_url: str) -> bool: + import redis.asyncio as aioredis + + client = aioredis.from_url(redis_url, decode_responses=True) + try: + flag = await client.get(cancel_key) + return flag == "1" + finally: + await client.aclose() + + # Alias per retrocompatibilita' con il codice esistente + @staticmethod + async def _set_job_state(tenant_id: uuid.UUID, redis_url: str, state: dict) -> None: + await IndexingService._set_state(_redis_key(tenant_id), redis_url, state) + + @staticmethod + async def _check_cancel(tenant_id: uuid.UUID, redis_url: str) -> bool: + return await IndexingService._check_cancel_flag( + _redis_cancel_key(tenant_id), redis_url + ) + + # ── Logica interna reindex ───────────────────────────────────────────────── + + @staticmethod + async def _run_reindex_bg( + tenant_id: uuid.UUID, + mode: ReindexMode, + redis_url: str, + db_url: str, + ) -> None: + from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine + from sqlalchemy.orm import sessionmaker + + log = logging.getLogger(__name__) + log.info(f"Avvio reindex {mode} per tenant {tenant_id}") + + engine = create_async_engine(db_url, echo=False) + AsyncSessionFactory = sessionmaker( # type: ignore[call-overload] + engine, class_=AsyncSession, expire_on_commit=False + ) + + state: dict = { + "status": "running", + "mode": mode, + "total": 0, + "processed": 0, + "started_at": None, + "finished_at": None, + "started_by": None, + "error": None, + } + + try: + async with AsyncSessionFactory() as db: + from app.models.message import Message + + count_q = select(func.count(Message.id)).where( + Message.tenant_id == tenant_id, + Message.parent_message_id.is_(None), + ) + if mode == "differential": + count_q = count_q.where(Message.search_vector.is_(None)) + + total: int = (await db.execute(count_q)).scalar_one() + + import redis.asyncio as aioredis + redis_client = aioredis.from_url(redis_url, decode_responses=True) + try: + raw = await redis_client.get(_redis_key(tenant_id)) + if raw: + state = json.loads(raw) + state["total"] = total + state["processed"] = 0 + await redis_client.setex( + _redis_key(tenant_id), + REDIS_TTL_STATUS, + json.dumps(state, default=str), + ) + finally: + await redis_client.aclose() + + log.info(f"Reindex {mode}: {total} messaggi da processare") + + if total == 0: + state.update({ + "status": "completed", + "processed": 0, + "finished_at": datetime.now(timezone.utc).isoformat(), + }) + await IndexingService._set_job_state(tenant_id, redis_url, state) + return + + ids_q = select(Message.id).where( + Message.tenant_id == tenant_id, + Message.parent_message_id.is_(None), + ) + if mode == "differential": + ids_q = ids_q.where(Message.search_vector.is_(None)) + + ids_result = await db.execute(ids_q) + all_ids = [str(row[0]) for row in ids_result.fetchall()] + + processed = 0 + for batch_start in range(0, len(all_ids), BATCH_SIZE): + if await IndexingService._check_cancel(tenant_id, redis_url): + log.info(f"Reindex {mode} annullato al batch {batch_start}") + state.update({ + "status": "cancelled", + "processed": processed, + "finished_at": datetime.now(timezone.utc).isoformat(), + }) + await IndexingService._set_job_state(tenant_id, redis_url, state) + return + + batch_ids = all_ids[batch_start: batch_start + BATCH_SIZE] + + await db.execute( + text(""" + UPDATE messages + SET search_vector = + setweight(to_tsvector('italian', coalesce(subject, '')), 'A') || + setweight(to_tsvector('simple', coalesce(from_address, '')), 'B') || + setweight(to_tsvector('simple', + coalesce(array_to_string(to_addresses, ' '), '')), 'B') || + setweight(to_tsvector('italian', coalesce(body_text, '')), 'C') || + setweight(to_tsvector('italian', coalesce(( + SELECT string_agg(a.extracted_text, ' ') + FROM attachments a + WHERE a.message_id = messages.id + AND a.extracted_text IS NOT NULL + ), '')), 'D') + WHERE id = ANY(:ids) + """), + {"ids": batch_ids}, + ) + await db.commit() + + processed += len(batch_ids) + state["processed"] = processed + await IndexingService._set_job_state(tenant_id, redis_url, state) + + await asyncio.sleep(0.05) + + state.update({ + "status": "completed", + "processed": processed, + "finished_at": datetime.now(timezone.utc).isoformat(), + }) + await IndexingService._set_job_state(tenant_id, redis_url, state) + log.info(f"Reindex {mode} completato: {processed}/{total} messaggi") + + except Exception as exc: + log.error(f"Errore reindex {mode} tenant {tenant_id}: {exc}", exc_info=True) + state.update({ + "status": "failed", + "finished_at": datetime.now(timezone.utc).isoformat(), + "error": str(exc), + }) + await IndexingService._set_job_state(tenant_id, redis_url, state) + finally: + await engine.dispose() + + # ── Logica interna rescan allegati ──────────────────────────────────────── + + @staticmethod + async def _run_rescan_bg( + tenant_id: uuid.UUID, + force: bool, + redis_url: str, + db_url: str, + ) -> None: + """ + Coroutine di rescan allegati eseguita in background. + + Algoritmo: + 1. Trova gli allegati del tenant con formato supportato + (solo quelli con extracted_text IS NULL se force=False) + 2. Per ogni batch: scarica da MinIO, estrae testo, aggiorna extracted_text + 3. Dopo ogni batch: ricostruisce search_vector per i messaggi interessati + 4. Aggiorna progresso in Redis dopo ogni batch + 5. Controlla flag di cancellazione tra un batch e l'altro + """ + from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine + from sqlalchemy.orm import sessionmaker + + log = logging.getLogger(__name__) + mode_str = "force" if force else "differential" + log.info(f"Avvio rescan allegati {mode_str} per tenant {tenant_id}") + + engine = create_async_engine(db_url, echo=False) + AsyncSessionFactory = sessionmaker( # type: ignore[call-overload] + engine, class_=AsyncSession, expire_on_commit=False + ) + + state: dict = { + "status": "running", + "mode": mode_str, + "total": 0, + "processed": 0, + "started_at": None, + "finished_at": None, + "started_by": None, + "error": None, + } + + try: + async with AsyncSessionFactory() as db: + from app.config import get_settings + from app.models.message import Attachment + + settings = get_settings() + + # ── 1. Conta allegati da processare ─────────────────────────── + from sqlalchemy import or_ + + ext_conditions = [ + Attachment.filename.ilike(f"%.{e}") for e in _SUPPORTED_EXTENSIONS + ] + base_filter = [ + Attachment.tenant_id == tenant_id, + or_( + Attachment.content_type.in_(list(_SUPPORTED_CONTENT_TYPES)), + *ext_conditions, + ), + ] + if not force: + base_filter.append(Attachment.extracted_text.is_(None)) + + count_q = await db.execute( + select(func.count(Attachment.id)).where(*base_filter) + ) + total: int = count_q.scalar_one() + + # Aggiorna totale in Redis + import redis.asyncio as aioredis + redis_client = aioredis.from_url(redis_url, decode_responses=True) + try: + raw = await redis_client.get(_redis_rescan_key(tenant_id)) + if raw: + state = json.loads(raw) + state["total"] = total + state["processed"] = 0 + await redis_client.setex( + _redis_rescan_key(tenant_id), + REDIS_TTL_STATUS, + json.dumps(state, default=str), + ) + finally: + await redis_client.aclose() + + log.info(f"Rescan {mode_str}: {total} allegati da processare") + + if total == 0: + state.update({ + "status": "completed", + "processed": 0, + "finished_at": datetime.now(timezone.utc).isoformat(), + }) + await IndexingService._set_state( + _redis_rescan_key(tenant_id), redis_url, state + ) + return + + # ── 2. Recupera IDs allegati da processare ──────────────────── + ids_q = select(Attachment.id).where(*base_filter) + ids_result = await db.execute(ids_q) + all_att_ids = [row[0] for row in ids_result.fetchall()] + + # ── 3. Crea client MinIO ─────────────────────────────────────── + try: + from miniopy_async import Minio # type: ignore[import] + minio = Minio( + endpoint=settings.minio_endpoint, + access_key=settings.minio_access_key, + secret_key=settings.minio_secret_key, + secure=settings.minio_use_ssl, + ) + bucket = settings.minio_bucket + except Exception as e: + raise RuntimeError(f"Impossibile creare client MinIO: {e}") from e + + # ── 4. Processa in batch ─────────────────────────────────────── + processed = 0 + for batch_start in range(0, len(all_att_ids), RESCAN_BATCH_SIZE): + # Controlla cancellazione + if await IndexingService._check_cancel_flag( + _redis_rescan_cancel_key(tenant_id), redis_url + ): + log.info(f"Rescan {mode_str} annullato al batch {batch_start}") + state.update({ + "status": "cancelled", + "processed": processed, + "finished_at": datetime.now(timezone.utc).isoformat(), + }) + await IndexingService._set_state( + _redis_rescan_key(tenant_id), redis_url, state + ) + return + + batch_ids = all_att_ids[batch_start: batch_start + RESCAN_BATCH_SIZE] + + # Carica allegati del batch + att_result = await db.execute( + select(Attachment).where(Attachment.id.in_(batch_ids)) + ) + attachments = list(att_result.scalars().all()) + + affected_message_ids: set[str] = set() + + for att in attachments: + extractor = _resolve_extractor(att.content_type, att.filename) + if extractor is None: + continue + + try: + response = await minio.get_object(bucket, att.storage_path) + content = await response.content.read() + response.close() + except Exception as e: + log.warning( + f"Impossibile scaricare allegato {att.id} " + f"({att.filename!r}) da MinIO: {e}" + ) + continue + + try: + e_name = _ext(att.filename) + if e_name == "p7m": + extracted = _extract_p7m(content, att.filename) + else: + extracted = extractor(content) # type: ignore[operator] + except Exception as ex: + log.debug(f"Errore estrazione {att.filename!r}: {ex}") + continue + + if not extracted or not extracted.strip(): + continue + + att.extracted_text = extracted[:MAX_EXTRACTED_TEXT_LEN] + affected_message_ids.add(str(att.message_id)) + log.debug( + f"Testo estratto da {att.filename!r}: " + f"{len(att.extracted_text)} caratteri" + ) + + await db.flush() + + # Ricostruisce search_vector per i messaggi interessati + if affected_message_ids: + await db.execute( + text(""" + UPDATE messages + SET search_vector = + setweight(to_tsvector('italian', coalesce(subject, '')), 'A') || + setweight(to_tsvector('simple', coalesce(from_address, '')), 'B') || + setweight(to_tsvector('simple', + coalesce(array_to_string(to_addresses, ' '), '')), 'B') || + setweight(to_tsvector('italian', coalesce(body_text, '')), 'C') || + setweight(to_tsvector('italian', coalesce(( + SELECT string_agg(a.extracted_text, ' ') + FROM attachments a + WHERE a.message_id = messages.id + AND a.extracted_text IS NOT NULL + ), '')), 'D') + WHERE id = ANY(:ids) + """), + {"ids": list(affected_message_ids)}, + ) + + await db.commit() + + processed += len(batch_ids) + state["processed"] = processed + await IndexingService._set_state( + _redis_rescan_key(tenant_id), redis_url, state + ) + + await asyncio.sleep(0.1) + + # ── 5. Completato ────────────────────────────────────────────── + state.update({ + "status": "completed", + "processed": processed, + "finished_at": datetime.now(timezone.utc).isoformat(), + }) + await IndexingService._set_state( + _redis_rescan_key(tenant_id), redis_url, state + ) + log.info(f"Rescan {mode_str} completato: {processed}/{total} allegati") + + except Exception as exc: + log.error(f"Errore rescan tenant {tenant_id}: {exc}", exc_info=True) + state.update({ + "status": "failed", + "finished_at": datetime.now(timezone.utc).isoformat(), + "error": str(exc), + }) + await IndexingService._set_state( + _redis_rescan_key(tenant_id), redis_url, state + ) + finally: + await engine.dispose() diff --git a/backend/app/services/mailbox_service.py b/backend/app/services/mailbox_service.py index 17c6cc3..94d2601 100644 --- a/backend/app/services/mailbox_service.py +++ b/backend/app/services/mailbox_service.py @@ -12,6 +12,7 @@ from app.core.exceptions import ConflictError, ForbiddenError, NotFoundError from app.core.security import decrypt_credential, encrypt_credential from app.models.mailbox import Mailbox from app.models.tenant import Tenant +from app.services.audit_service import log_audit from app.schemas.mailbox import ( ConnectionTestRequest, ConnectionTestResult, @@ -85,6 +86,15 @@ class MailboxService: ) self.db.add(mailbox) await self.db.flush() + await log_audit( + self.db, + "mailbox.created", + tenant_id=tenant_id, + user_id=created_by, + resource_type="mailbox", + resource_id=mailbox.id, + payload={"email_address": mailbox.email_address}, + ) return mailbox async def list_mailboxes( @@ -175,6 +185,14 @@ class MailboxService: mailbox.status = "active" await self.db.flush() + await log_audit( + self.db, + "mailbox.updated", + tenant_id=tenant_id, + resource_type="mailbox", + resource_id=mailbox_id, + payload={"mailbox_id": str(mailbox_id)}, + ) return mailbox async def delete_mailbox( @@ -184,8 +202,17 @@ class MailboxService: ) -> None: """Soft-delete: imposta status=deleted.""" mailbox = await self.get_mailbox(mailbox_id, tenant_id) + email = mailbox.email_address mailbox.status = "deleted" await self.db.flush() + await log_audit( + self.db, + "mailbox.deleted", + tenant_id=tenant_id, + resource_type="mailbox", + resource_id=mailbox_id, + payload={"email_address": email}, + ) # ─── Decrypt helpers (usati internamente e dal worker) ─────────────────── diff --git a/backend/app/services/notification_service.py b/backend/app/services/notification_service.py index 699f397..1875d3b 100644 --- a/backend/app/services/notification_service.py +++ b/backend/app/services/notification_service.py @@ -1,20 +1,24 @@ """ -Servizio Notifiche Multi-canale – CRUD canali, regole, log. +Servizio Notifiche Multi-canale – CRUD canali, regole, log + dispatch. -Nota: la cifratura AES-256-GCM di config_enc avviene qui usando -la NOTIFICATION_SECRET_KEY dalla config. Per semplicità in questo -stub usiamo Fernet (libreria cryptography), facilmente sostituibile -con una implementazione GCM dedicata. +Cifratura: AES-256-GCM via libreria cryptography. + Formato config_enc: base64( nonce(12) || ciphertext+tag ) + Chiave: ENCRYPTION_KEY (hex 64 char = 32 byte) dalla config. + +Backward compatibility: se il valore non decrittografa come GCM, viene +tentato il fallback a base64 grezzo (configurazioni precedenti al fix). """ import base64 import json +import logging +import os import uuid from datetime import datetime, timezone +from cryptography.hazmat.primitives.ciphers.aead import AESGCM from sqlalchemy import func, select from sqlalchemy.ext.asyncio import AsyncSession -from sqlalchemy.orm import selectinload from app.config import get_settings from app.core.exceptions import NotFoundError @@ -27,20 +31,53 @@ from app.schemas.notification import ( NotificationRuleUpdate, ) +logger = logging.getLogger(__name__) settings = get_settings() -def _encrypt(data: dict) -> str: - """Cifra un dict JSON → base64. Usa la SECRET_KEY come seed.""" - # In produzione: usa AES-256-GCM. Qui: semplice base64 con marker. - raw = json.dumps(data).encode() - return base64.b64encode(raw).decode() +# ─── Cifratura AES-256-GCM ──────────────────────────────────────────────────── + +def _encrypt(data: dict, key: bytes | None = None) -> str: + """ + Cifra un dict JSON con AES-256-GCM. + + Formato output: base64( nonce(12 byte) || ciphertext+tag(16 byte) ) + """ + if key is None: + key = settings.encryption_key_bytes + nonce = os.urandom(12) + aesgcm = AESGCM(key) + plaintext = json.dumps(data, ensure_ascii=False).encode("utf-8") + ciphertext = aesgcm.encrypt(nonce, plaintext, None) # include tag + return base64.b64encode(nonce + ciphertext).decode("ascii") -def _decrypt(enc: str) -> dict: - """Decifra il valore restituito da _encrypt.""" - raw = base64.b64decode(enc.encode()) - return json.loads(raw.decode()) +def _decrypt(enc: str, key: bytes | None = None) -> dict: + """ + Decifra il valore prodotto da _encrypt. + + Backward compatible: se il dato non e' GCM valido, prova il + vecchio base64 grezzo (usato prima del fix di sicurezza). + """ + if key is None: + key = settings.encryption_key_bytes + try: + raw = base64.b64decode(enc.encode("ascii")) + if len(raw) > 28: # 12 nonce + 16 tag minimo + nonce = raw[:12] + ciphertext = raw[12:] + aesgcm = AESGCM(key) + plaintext = aesgcm.decrypt(nonce, ciphertext, None) + return json.loads(plaintext.decode("utf-8")) + except Exception: + pass + + # Fallback: base64 grezzo (configurazioni create prima del fix GCM) + try: + raw = base64.b64decode(enc.encode("ascii")) + return json.loads(raw.decode("utf-8")) + except Exception: + return {} class NotificationService: @@ -113,6 +150,7 @@ class NotificationService: if data.config is not None: channel.config = data.config if data.config_secret is not None: + # Re-cifra sempre con AES-256-GCM (aggiorna anche i vecchi base64) channel.config_enc = _encrypt(data.config_secret) await self.db.flush() @@ -128,18 +166,16 @@ class NotificationService: self, channel_id: uuid.UUID, tenant_id: uuid.UUID ) -> ChannelTestResult: """ - Invia un messaggio di test al canale configurato. + Invia un messaggio di test reale al canale configurato. - Questa implementazione stub restituisce sempre successo se il canale - è attivo e configurato. Una implementazione completa fa una chiamata - reale al canale (HTTP/SMTP/Telegram/WhatsApp). + Esegue invio effettivo per Telegram, Webhook, Email SMTP e WhatsApp. """ channel = await self.get_channel(channel_id, tenant_id) if not channel.is_active: return ChannelTestResult( success=False, - message="Il canale è disabilitato", + message="Il canale e' disabilitato", ) if channel.circuit_open_until and channel.circuit_open_until > datetime.now(timezone.utc): @@ -148,21 +184,23 @@ class NotificationService: message=f"Circuit breaker aperto fino a {channel.circuit_open_until.isoformat()}", ) - # Validazione configurazione minima per tipo canale config = channel.config or {} + secret = {} + if channel.config_enc: + try: + secret = _decrypt(channel.config_enc) + except Exception as e: + return ChannelTestResult( + success=False, + message=f"Errore decifratura configurazione sensibile: {e}", + ) + channel_type = channel.channel_type - if channel_type == "webhook": - if not config.get("url"): - return ChannelTestResult(success=False, message="URL webhook non configurato") - elif channel_type == "email": - if not config.get("to_email"): - return ChannelTestResult(success=False, message="Email destinatario non configurata") - elif channel_type == "telegram": + # ── Telegram ────────────────────────────────────────────────────────── + if channel_type == "telegram": if not config.get("chat_id"): return ChannelTestResult(success=False, message="Chat ID Telegram non configurato") - # Invio reale via Bot API - secret = _decrypt(channel.config_enc) if channel.config_enc else {} bot_token = secret.get("bot_token") if not bot_token: return ChannelTestResult(success=False, message="Bot token Telegram non configurato") @@ -176,28 +214,128 @@ class NotificationService: msg_id = result.get("message_id") return ChannelTestResult( success=True, - message=f"Messaggio Telegram inviato con successo (message_id={msg_id}).", + message=f"Messaggio Telegram inviato (message_id={msg_id}).", http_status=200, ) - except TelegramError as exc: - return ChannelTestResult( - success=False, - message=f"Errore Telegram: {exc}", - http_status=exc.http_status, - ) except Exception as exc: return ChannelTestResult( success=False, - message=f"Errore imprevisto durante il test Telegram: {exc}", + message=f"Errore Telegram: {exc}", ) - elif channel_type == "whatsapp": - if not config.get("phone_number"): - return ChannelTestResult(success=False, message="Numero WhatsApp non configurato") + # ── Webhook ─────────────────────────────────────────────────────────── + elif channel_type == "webhook": + url = config.get("url") + if not url: + return ChannelTestResult(success=False, message="URL webhook non configurato") + webhook_secret = secret.get("webhook_secret") + try: + from app.notifications.webhook import WebhookError, send_test_webhook + result = await send_test_webhook( + url=url, + webhook_secret=webhook_secret, + channel_name=channel.name, + ) + return ChannelTestResult( + success=True, + message=( + f"Webhook raggiunto con successo " + f"(HTTP {result['http_status']}, delivery={result['delivery_id']})." + ), + http_status=result["http_status"], + ) + except Exception as exc: + http_status = getattr(exc, "http_status", None) + return ChannelTestResult( + success=False, + message=f"Errore webhook: {exc}", + http_status=http_status, + ) + + # ── Email SMTP ──────────────────────────────────────────────────────── + elif channel_type == "email": + smtp_host = config.get("smtp_host") + smtp_port = config.get("smtp_port", 465) + from_email = config.get("from_email") + to_email = config.get("to_email") + smtp_user = config.get("smtp_user") or from_email + use_tls = config.get("smtp_use_tls", True) + use_starttls = config.get("smtp_use_starttls", False) + from_name = config.get("from_name", "PEChub Notifiche") + smtp_password = secret.get("smtp_password", "") + + if not smtp_host: + return ChannelTestResult(success=False, message="Host SMTP non configurato") + if not from_email: + return ChannelTestResult(success=False, message="Email mittente non configurata") + if not to_email: + return ChannelTestResult(success=False, message="Email destinatario non configurata") + if not smtp_password: + return ChannelTestResult(success=False, message="Password SMTP non configurata") + + try: + from app.notifications.email_smtp import EmailSMTPError, send_test_email + await send_test_email( + smtp_host=smtp_host, + smtp_port=int(smtp_port), + smtp_user=smtp_user, + smtp_password=smtp_password, + from_email=from_email, + to_email=to_email, + channel_name=channel.name, + from_name=from_name, + use_tls=use_tls, + use_starttls=use_starttls, + ) + return ChannelTestResult( + success=True, + message=f"Email di test inviata con successo a {to_email}.", + http_status=200, + ) + except Exception as exc: + return ChannelTestResult( + success=False, + message=f"Errore email: {exc}", + ) + + # ── WhatsApp ────────────────────────────────────────────────────────── + elif channel_type == "whatsapp": + phone_number_id = config.get("phone_number_id") + to_phone = config.get("to_phone") + access_token = secret.get("access_token") + + if not phone_number_id: + return ChannelTestResult(success=False, message="phone_number_id non configurato") + if not to_phone: + return ChannelTestResult(success=False, message="Numero WhatsApp destinatario non configurato") + if not access_token: + return ChannelTestResult(success=False, message="Access token Meta non configurato") + + try: + from app.notifications.whatsapp import WhatsAppError, send_test_whatsapp + result = await send_test_whatsapp( + phone_number_id=phone_number_id, + to_phone=to_phone, + access_token=access_token, + channel_name=channel.name, + ) + return ChannelTestResult( + success=True, + message=f"Messaggio WhatsApp inviato (message_id={result.get('message_id')}).", + http_status=200, + ) + except Exception as exc: + http_status = getattr(exc, "http_status", None) + return ChannelTestResult( + success=False, + message=f"Errore WhatsApp: {exc}", + http_status=http_status, + ) + + # ── Tipo sconosciuto ────────────────────────────────────────────────── return ChannelTestResult( - success=True, - message=f"Canale {channel_type} configurato correttamente. Test simulato con successo.", - http_status=200, + success=False, + message=f"Tipo canale '{channel_type}' non supportato", ) # ─── Rules ─────────────────────────────────────────────────────────────── diff --git a/backend/app/services/pec_contact_service.py b/backend/app/services/pec_contact_service.py new file mode 100644 index 0000000..de1bc57 --- /dev/null +++ b/backend/app/services/pec_contact_service.py @@ -0,0 +1,240 @@ +""" +Service per la gestione della rubrica indirizzi PEC (Feature 6). +""" + +import csv +import io +import uuid + +from sqlalchemy import func, or_, select +from sqlalchemy.dialects.postgresql import insert +from sqlalchemy.ext.asyncio import AsyncSession + +from app.core.exceptions import ConflictError, NotFoundError +from app.models.pec_contact import PecContact +from app.schemas.pec_contact import ( + PecContactCreate, + PecContactImportResult, + PecContactUpdate, +) + + +class PecContactService: + def __init__(self, db: AsyncSession): + self.db = db + + async def list_contacts( + self, + tenant_id: uuid.UUID, + q: str | None = None, + page: int = 1, + page_size: int = 50, + ) -> tuple[list[PecContact], int]: + query = select(PecContact).where(PecContact.tenant_id == tenant_id) + if q: + pattern = f"%{q.lower()}%" + query = query.where( + or_( + PecContact.email.ilike(pattern), + PecContact.name.ilike(pattern), + PecContact.organization.ilike(pattern), + ) + ) + query = query.order_by(PecContact.is_favorite.desc(), PecContact.name, PecContact.email) + + count_q = select(func.count()).select_from(query.subquery()) + total = (await self.db.execute(count_q)).scalar_one() + + offset = (page - 1) * page_size + query = query.offset(offset).limit(page_size) + items = list((await self.db.execute(query)).scalars().all()) + return items, total + + async def get_contact( + self, tenant_id: uuid.UUID, contact_id: uuid.UUID + ) -> PecContact: + result = await self.db.execute( + select(PecContact).where( + PecContact.id == contact_id, + PecContact.tenant_id == tenant_id, + ) + ) + contact = result.scalar_one_or_none() + if not contact: + raise NotFoundError(f"Contatto {contact_id} non trovato") + return contact + + async def create_contact( + self, + tenant_id: uuid.UUID, + data: PecContactCreate, + created_by: uuid.UUID | None = None, + ) -> PecContact: + email = data.email.lower().strip() + # Verifica unicita' + existing = await self.db.execute( + select(PecContact).where( + PecContact.tenant_id == tenant_id, + PecContact.email == email, + ) + ) + if existing.scalar_one_or_none(): + raise ConflictError(f"Contatto '{email}' gia' esistente") + + contact = PecContact( + tenant_id=tenant_id, + email=email, + name=data.name, + organization=data.organization, + notes=data.notes, + is_favorite=data.is_favorite, + auto_saved=False, + created_by=created_by, + ) + self.db.add(contact) + await self.db.commit() + await self.db.refresh(contact) + return contact + + async def update_contact( + self, + tenant_id: uuid.UUID, + contact_id: uuid.UUID, + data: PecContactUpdate, + ) -> PecContact: + contact = await self.get_contact(tenant_id, contact_id) + if data.name is not None: + contact.name = data.name + if data.organization is not None: + contact.organization = data.organization + if data.notes is not None: + contact.notes = data.notes + if data.is_favorite is not None: + contact.is_favorite = data.is_favorite + await self.db.commit() + await self.db.refresh(contact) + return contact + + async def delete_contact( + self, tenant_id: uuid.UUID, contact_id: uuid.UUID + ) -> None: + contact = await self.get_contact(tenant_id, contact_id) + await self.db.delete(contact) + await self.db.commit() + + async def auto_save_sender( + self, + tenant_id: uuid.UUID, + email: str, + ) -> None: + """ + Salva automaticamente il mittente nella rubrica se non esiste ancora. + Operazione non bloccante: gli errori vengono ignorati silenziosamente. + + Usata dal worker IMAP durante la sincronizzazione dei messaggi inbound. + """ + if not email: + return + email = email.lower().strip() + try: + # Upsert: inserisce solo se non esiste + stmt = insert(PecContact).values( + id=uuid.uuid4(), + tenant_id=tenant_id, + email=email, + auto_saved=True, + ).on_conflict_do_nothing( + constraint="uq_pec_contact_email_tenant" + ) + await self.db.execute(stmt) + await self.db.commit() + except Exception: + await self.db.rollback() + + async def import_csv( + self, + tenant_id: uuid.UUID, + csv_content: str, + created_by: uuid.UUID | None = None, + ) -> PecContactImportResult: + """ + Importa contatti da un CSV con colonne: email, name, organization. + + Aggiorna i record esistenti con name/organization se forniti. + """ + result = PecContactImportResult(created=0, updated=0, skipped=0) + reader = csv.DictReader(io.StringIO(csv_content)) + + for row_num, row in enumerate(reader, start=2): + email = row.get("email", "").strip().lower() + if not email or "@" not in email: + result.skipped += 1 + result.errors.append(f"Riga {row_num}: email non valida '{email}'") + continue + + name = row.get("name", "").strip() or None + organization = row.get("organization", "").strip() or None + + try: + existing = await self.db.execute( + select(PecContact).where( + PecContact.tenant_id == tenant_id, + PecContact.email == email, + ) + ) + contact = existing.scalar_one_or_none() + + if contact: + # Aggiorna solo se i campi erano vuoti (non sovrascrive dati manuali) + updated = False + if name and not contact.name: + contact.name = name + updated = True + if organization and not contact.organization: + contact.organization = organization + updated = True + if updated: + result.updated += 1 + else: + result.skipped += 1 + else: + contact = PecContact( + tenant_id=tenant_id, + email=email, + name=name, + organization=organization, + auto_saved=False, + created_by=created_by, + ) + self.db.add(contact) + result.created += 1 + except Exception as e: + result.errors.append(f"Riga {row_num} ({email}): {e}") + result.skipped += 1 + + await self.db.commit() + return result + + async def search_for_autocomplete( + self, + tenant_id: uuid.UUID, + q: str, + limit: int = 10, + ) -> list[PecContact]: + """Ricerca veloce per autocomplete nel compose.""" + if not q or len(q) < 2: + return [] + pattern = f"%{q.lower()}%" + result = await self.db.execute( + select(PecContact) + .where( + PecContact.tenant_id == tenant_id, + or_( + PecContact.email.ilike(pattern), + PecContact.name.ilike(pattern), + ) + ) + .order_by(PecContact.is_favorite.desc(), PecContact.email) + .limit(limit) + ) + return list(result.scalars().all()) diff --git a/backend/app/services/permission_service.py b/backend/app/services/permission_service.py index e35ab1d..c458eb1 100644 --- a/backend/app/services/permission_service.py +++ b/backend/app/services/permission_service.py @@ -27,9 +27,13 @@ class PermissionService: async def get_visible_mailboxes( self, user: User ) -> list[uuid.UUID]: - """Restituisce gli UUID delle caselle visibili all'utente.""" - if user.role in ("super_admin", "admin"): - # Admin vede tutte le caselle del tenant + """Restituisce gli UUID delle caselle visibili all'utente. + + Admin e supervisor vedono tutte le caselle del tenant. + Operator e readonly vedono solo le caselle con can_read=True esplicito. + """ + if user.role in ("super_admin", "admin", "supervisor"): + # Admin e supervisor vedono tutte le caselle del tenant result = await self.db.execute( select(Mailbox.id).where( Mailbox.tenant_id == user.tenant_id, @@ -38,7 +42,7 @@ class PermissionService: ) return [row[0] for row in result.all()] - # Operatori: solo caselle con can_read=True + # Operator e readonly: solo caselle con can_read=True esplicito result = await self.db.execute( select(MailboxPermission.mailbox_id).where( MailboxPermission.user_id == user.id, @@ -50,9 +54,13 @@ class PermissionService: async def check_can_read( self, user: User, mailbox_id: uuid.UUID ) -> bool: - """Verifica se l'utente può leggere i messaggi della casella.""" - if user.role in ("super_admin", "admin"): - # Verifica solo che la casella appartenga al tenant + """Verifica se l'utente puo' leggere i messaggi della casella. + + Admin e supervisor hanno accesso implicito a tutte le caselle del tenant. + Operator e readonly richiedono permesso esplicito can_read. + """ + if user.role in ("super_admin", "admin", "supervisor"): + # Admin e supervisor: verifica solo che la casella appartenga al tenant return await self._mailbox_belongs_to_tenant(mailbox_id, user.tenant_id) perm = await self._get_permission(user.id, mailbox_id) @@ -62,12 +70,15 @@ class PermissionService: self, user: User, mailbox_id: uuid.UUID ) -> bool: """ - Verifica se l'utente può inviare dalla casella. + Verifica se l'utente puo' inviare dalla casella. - L'accesso in invio è concesso se: - 1. L'utente è admin del tenant, oppure + L'accesso in invio e' concesso se: + 1. L'utente e' admin del tenant, oppure 2. L'utente ha un permesso diretto can_send sulla casella, oppure - 3. L'utente è assegnato a una Virtual Box attiva che include la casella. + 3. L'utente e' assegnato a una Virtual Box attiva che include la casella. + + Nota: il supervisor NON ha invio implicito – richiede can_send esplicito + come operator, ma diversamente da operator vede tutte le caselle. """ if user.role in ("super_admin", "admin"): return await self._mailbox_belongs_to_tenant(mailbox_id, user.tenant_id) @@ -89,6 +100,22 @@ class PermissionService: perm = await self._get_permission(user.id, mailbox_id) return perm is not None and perm.can_manage + async def check_can_conserve( + self, user: User, mailbox_id: uuid.UUID + ) -> bool: + """Verifica se l'utente puo' spostare messaggi nella cartella Conservazione. + + Admin/super_admin: accesso implicito sempre. + Supervisor: richiede permesso esplicito can_conserve=True. + Operator/readonly: non autorizzati (richiedono permesso esplicito). + """ + if user.role in ("super_admin", "admin"): + return await self._mailbox_belongs_to_tenant(mailbox_id, user.tenant_id) + + # Supervisor, operator e readonly richiedono record esplicito + perm = await self._get_permission(user.id, mailbox_id) + return perm is not None and perm.can_conserve + async def require_can_read(self, user: User, mailbox_id: uuid.UUID) -> None: """Solleva 403 se l'utente non può leggere.""" if not await self.check_can_read(user, mailbox_id): @@ -98,6 +125,11 @@ class PermissionService: if not await self.check_can_send(user, mailbox_id): raise PermissionDeniedError("casella (invio)") + async def require_can_conserve(self, user: User, mailbox_id: uuid.UUID) -> None: + """Solleva 403 se l'utente non puo' spostare messaggi in Conservazione.""" + if not await self.check_can_conserve(user, mailbox_id): + raise PermissionDeniedError("casella (conservazione)") + # ─── CRUD permessi ──────────────────────────────────────────────────────── async def grant_permission( @@ -134,6 +166,7 @@ class PermissionService: existing.can_read = data.can_read existing.can_send = data.can_send existing.can_manage = data.can_manage + existing.can_conserve = data.can_conserve existing.granted_by = granted_by.id return existing @@ -144,6 +177,7 @@ class PermissionService: can_read=data.can_read, can_send=data.can_send, can_manage=data.can_manage, + can_conserve=data.can_conserve, granted_by=granted_by.id, ) self.db.add(perm) @@ -190,6 +224,7 @@ class PermissionService: "can_read": perm.can_read, "can_send": perm.can_send, "can_manage": perm.can_manage, + "can_conserve": perm.can_conserve, "granted_at": perm.granted_at, } for perm, user in rows @@ -217,6 +252,7 @@ class PermissionService: "can_read": perm.can_read, "can_send": perm.can_send, "can_manage": perm.can_manage, + "can_conserve": perm.can_conserve, } for perm, mailbox in rows ] diff --git a/backend/app/services/report_service.py b/backend/app/services/report_service.py new file mode 100644 index 0000000..3192a10 --- /dev/null +++ b/backend/app/services/report_service.py @@ -0,0 +1,594 @@ +""" +ReportService – calcola KPI, serie storiche e produce export CSV/PDF. + +Non richiede migrazioni: lavora sulle tabelle messages e mailboxes esistenti. +""" + +import csv +import io +import uuid +from datetime import date, datetime, timedelta, timezone +from typing import AsyncGenerator, Optional + +from sqlalchemy import case, func, select, text +from sqlalchemy.ext.asyncio import AsyncSession + +from app.core.logging import get_logger +from app.models.mailbox import Mailbox +from app.models.message import Message +from app.schemas.reports import ( + DailyStat, + KpiSummary, + MailboxStat, + OutboundStateStat, + ReportSummaryResponse, +) + +logger = get_logger(__name__) + + +class ReportService: + def __init__(self, db: AsyncSession) -> None: + self.db = db + + # ─── KPI principali ────────────────────────────────────────────────────── + + async def get_summary( + self, + tenant_id: uuid.UUID, + period_days: int = 7, + visible_mailbox_ids: Optional[list[uuid.UUID]] = None, + ) -> ReportSummaryResponse: + """ + Restituisce il riepilogo completo per la dashboard. + + visible_mailbox_ids: se None l'utente e admin e vede tutto il tenant, + altrimenti filtra sulle caselle accessibili. + """ + now = datetime.now(timezone.utc) + today_start = now.replace(hour=0, minute=0, second=0, microsecond=0) + d7_start = now - timedelta(days=7) + d30_start = now - timedelta(days=30) + + # ── Filtro base tenant + caselle visibili ──────────────────────────── + def _base(q): + q = q.where(Message.tenant_id == tenant_id) + if visible_mailbox_ids is not None: + if not visible_mailbox_ids: + # Nessuna casella visibile: ritorna subito valori zero + return None + q = q.where(Message.mailbox_id.in_(visible_mailbox_ids)) + return q + + async def _count(q) -> int: + q = _base(q) + if q is None: + return 0 + r = await self.db.execute(q) + return r.scalar_one() or 0 + + # PEC ricevute + received_today = await _count( + select(func.count(Message.id)).where( + Message.direction == "inbound", + Message.received_at >= today_start, + ) + ) + received_7d = await _count( + select(func.count(Message.id)).where( + Message.direction == "inbound", + Message.received_at >= d7_start, + ) + ) + received_30d = await _count( + select(func.count(Message.id)).where( + Message.direction == "inbound", + Message.received_at >= d30_start, + ) + ) + + # PEC inviate + sent_today = await _count( + select(func.count(Message.id)).where( + Message.direction == "outbound", + Message.parent_message_id.is_(None), + Message.sent_at >= today_start, + ) + ) + sent_7d = await _count( + select(func.count(Message.id)).where( + Message.direction == "outbound", + Message.parent_message_id.is_(None), + Message.sent_at >= d7_start, + ) + ) + sent_30d = await _count( + select(func.count(Message.id)).where( + Message.direction == "outbound", + Message.parent_message_id.is_(None), + Message.sent_at >= d30_start, + ) + ) + + # Anomalie (outbound con state=anomaly, senza genitore) + anomalie = await _count( + select(func.count(Message.id)).where( + Message.direction == "outbound", + Message.parent_message_id.is_(None), + Message.state == "anomaly", + ) + ) + + # Tasso consegna: delivered / (delivered + anomaly + failed) + delivered = await _count( + select(func.count(Message.id)).where( + Message.direction == "outbound", + Message.parent_message_id.is_(None), + Message.state == "delivered", + ) + ) + failed = await _count( + select(func.count(Message.id)).where( + Message.direction == "outbound", + Message.parent_message_id.is_(None), + Message.state.in_(["anomaly", "failed"]), + ) + ) + total_terminal = delivered + failed + tasso_consegna = round((delivered / total_terminal * 100), 1) if total_terminal > 0 else 0.0 + + # Non letti + non_letti = await _count( + select(func.count(Message.id)).where( + Message.direction == "inbound", + Message.is_read == False, # noqa: E712 + Message.is_trashed == False, # noqa: E712 + ) + ) + + # Totale messaggi + totale = await _count(select(func.count(Message.id))) + + # Caselle in errore (NON filtrato per visible_mailbox_ids – e una info admin) + caselle_errore_r = await self.db.execute( + select(func.count(Mailbox.id)).where( + Mailbox.tenant_id == tenant_id, + Mailbox.status == "error", + ) + ) + caselle_errore = caselle_errore_r.scalar_one() or 0 + + kpi = KpiSummary( + received_today=received_today, + sent_today=sent_today, + received_7d=received_7d, + sent_7d=sent_7d, + received_30d=received_30d, + sent_30d=sent_30d, + anomalie_attive=anomalie, + tasso_consegna=tasso_consegna, + caselle_in_errore=caselle_errore, + messaggi_non_letti=non_letti, + totale_messaggi=totale, + ) + + # ── Serie storica giornaliera ───────────────────────────────────────── + daily_stats = await self._get_daily_stats(tenant_id, period_days, visible_mailbox_ids) + + # ── Distribuzione stati outbound ────────────────────────────────────── + outbound_states = await self._get_outbound_states(tenant_id, visible_mailbox_ids) + + # ── Statistiche per casella ─────────────────────────────────────────── + mailbox_stats = await self._get_mailbox_stats(tenant_id, visible_mailbox_ids) + + return ReportSummaryResponse( + generated_at=now, + period_days=period_days, + kpi=kpi, + daily_stats=daily_stats, + outbound_states=outbound_states, + mailbox_stats=mailbox_stats, + ) + + # ─── Serie storica ──────────────────────────────────────────────────────── + + async def _get_daily_stats( + self, + tenant_id: uuid.UUID, + days: int, + visible_mailbox_ids: Optional[list[uuid.UUID]], + ) -> list[DailyStat]: + """Conta PEC ricevute e inviate per ciascuno degli ultimi `days` giorni.""" + since = datetime.now(timezone.utc) - timedelta(days=days) + + def _apply_filters(q): + q = q.where(Message.tenant_id == tenant_id) + if visible_mailbox_ids is not None: + if not visible_mailbox_ids: + return None + q = q.where(Message.mailbox_id.in_(visible_mailbox_ids)) + return q + + # Aggregazione ricevute per giorno + q_recv = ( + select( + func.date_trunc("day", Message.received_at).label("day"), + func.count(Message.id).label("cnt"), + ) + .where( + Message.direction == "inbound", + Message.received_at >= since, + ) + .group_by(text("day")) + .order_by(text("day")) + ) + q_recv = _apply_filters(q_recv) + + # Aggregazione inviate per giorno + q_sent = ( + select( + func.date_trunc("day", Message.sent_at).label("day"), + func.count(Message.id).label("cnt"), + ) + .where( + Message.direction == "outbound", + Message.parent_message_id.is_(None), + Message.sent_at >= since, + ) + .group_by(text("day")) + .order_by(text("day")) + ) + q_sent = _apply_filters(q_sent) + + recv_map: dict[date, int] = {} + sent_map: dict[date, int] = {} + + if q_recv is not None: + r = await self.db.execute(q_recv) + for row in r.all(): + if row.day: + d = row.day.date() if hasattr(row.day, "date") else row.day + recv_map[d] = row.cnt + + if q_sent is not None: + r = await self.db.execute(q_sent) + for row in r.all(): + if row.day: + d = row.day.date() if hasattr(row.day, "date") else row.day + sent_map[d] = row.cnt + + # Costruisce la serie completa (tutti i giorni, anche quelli a zero) + result: list[DailyStat] = [] + for i in range(days, -1, -1): + d = (datetime.now(timezone.utc) - timedelta(days=i)).date() + result.append(DailyStat( + day=d, + received=recv_map.get(d, 0), + sent=sent_map.get(d, 0), + )) + return result + + # ─── Distribuzione stati outbound ──────────────────────────────────────── + + async def _get_outbound_states( + self, + tenant_id: uuid.UUID, + visible_mailbox_ids: Optional[list[uuid.UUID]], + ) -> list[OutboundStateStat]: + q = ( + select(Message.state, func.count(Message.id).label("cnt")) + .where( + Message.tenant_id == tenant_id, + Message.direction == "outbound", + Message.parent_message_id.is_(None), + ) + .group_by(Message.state) + ) + if visible_mailbox_ids is not None: + if not visible_mailbox_ids: + return [] + q = q.where(Message.mailbox_id.in_(visible_mailbox_ids)) + + r = await self.db.execute(q) + return [OutboundStateStat(state=row.state, count=row.cnt) for row in r.all()] + + # ─── Statistiche per casella ────────────────────────────────────────────── + + async def _get_mailbox_stats( + self, + tenant_id: uuid.UUID, + visible_mailbox_ids: Optional[list[uuid.UUID]], + ) -> list[MailboxStat]: + # Carica le caselle + mb_q = select(Mailbox).where(Mailbox.tenant_id == tenant_id) + if visible_mailbox_ids is not None: + if not visible_mailbox_ids: + return [] + mb_q = mb_q.where(Mailbox.id.in_(visible_mailbox_ids)) + mb_result = await self.db.execute(mb_q) + mailboxes = mb_result.scalars().all() + + if not mailboxes: + return [] + + mailbox_ids = [m.id for m in mailboxes] + mailbox_map = {m.id: m for m in mailboxes} + + # Aggregazione messaggi per casella e direction + agg_q = ( + select( + Message.mailbox_id, + Message.direction, + Message.state, + Message.is_read, + func.count(Message.id).label("cnt"), + ) + .where( + Message.tenant_id == tenant_id, + Message.mailbox_id.in_(mailbox_ids), + Message.parent_message_id.is_(None), + ) + .group_by(Message.mailbox_id, Message.direction, Message.state, Message.is_read) + ) + agg_result = await self.db.execute(agg_q) + + # Accumula per casella + stats: dict[uuid.UUID, MailboxStat] = {} + for mb in mailboxes: + stats[mb.id] = MailboxStat( + mailbox_id=mb.id, + email_address=mb.email_address, + display_name=mb.display_name, + status=mb.status, + last_sync_at=mb.last_sync_at, + ) + + for row in agg_result.all(): + s = stats.get(row.mailbox_id) + if not s: + continue + if row.direction == "inbound": + s.received_total += row.cnt + if not row.is_read: + s.non_letti += row.cnt + elif row.direction == "outbound": + s.sent_total += row.cnt + if row.state == "anomaly": + s.anomalie += row.cnt + + # Ordina per volume decrescente + return sorted( + stats.values(), + key=lambda x: x.received_total + x.sent_total, + reverse=True, + ) + + # ─── Export CSV ─────────────────────────────────────────────────────────── + + async def export_csv( + self, + tenant_id: uuid.UUID, + date_from: Optional[datetime], + date_to: Optional[datetime], + mailbox_id: Optional[uuid.UUID], + visible_mailbox_ids: Optional[list[uuid.UUID]], + ) -> bytes: + """Genera un CSV con tutti i messaggi del periodo.""" + q = ( + select( + Message.id, + Message.direction, + Message.state, + Message.pec_type, + Message.subject, + Message.from_address, + Message.received_at, + Message.sent_at, + Message.size_bytes, + Message.is_read, + Message.has_attachments, + Mailbox.email_address.label("mailbox_email"), + ) + .join(Mailbox, Message.mailbox_id == Mailbox.id) + .where( + Message.tenant_id == tenant_id, + Message.parent_message_id.is_(None), + ) + .order_by(Message.received_at.desc().nullslast(), Message.created_at.desc()) + ) + + if visible_mailbox_ids is not None: + if not visible_mailbox_ids: + buf = io.StringIO() + writer = csv.writer(buf) + writer.writerow(CSV_HEADERS) + return buf.getvalue().encode("utf-8-sig") + q = q.where(Message.mailbox_id.in_(visible_mailbox_ids)) + + if mailbox_id: + q = q.where(Message.mailbox_id == mailbox_id) + + if date_from: + q = q.where( + (Message.received_at >= date_from) | (Message.sent_at >= date_from) + ) + if date_to: + q = q.where( + (Message.received_at <= date_to) | (Message.sent_at <= date_to) + ) + + result = await self.db.execute(q) + rows = result.all() + + buf = io.StringIO() + writer = csv.writer(buf) + writer.writerow(CSV_HEADERS) + + for r in rows: + ts = r.received_at or r.sent_at + writer.writerow([ + str(r.id), + r.mailbox_email or "", + r.direction or "", + r.state or "", + r.pec_type or "", + r.subject or "", + r.from_address or "", + ts.strftime("%Y-%m-%d %H:%M:%S") if ts else "", + r.size_bytes or "", + "Si" if r.is_read else "No", + "Si" if r.has_attachments else "No", + ]) + + return buf.getvalue().encode("utf-8-sig") + + # ─── Export PDF ─────────────────────────────────────────────────────────── + + async def export_pdf( + self, + tenant_id: uuid.UUID, + date_from: Optional[datetime], + date_to: Optional[datetime], + visible_mailbox_ids: Optional[list[uuid.UUID]], + ) -> bytes: + """ + Genera un PDF di riepilogo con KPI e tabella caselle. + Usa reportlab (puro Python, nessuna dipendenza di sistema). + """ + try: + from reportlab.lib import colors + from reportlab.lib.pagesizes import A4 + from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle + from reportlab.lib.units import cm + from reportlab.platypus import ( + Paragraph, SimpleDocTemplate, Spacer, Table, TableStyle, + ) + except ImportError: + raise RuntimeError( + "reportlab non installato. Aggiungere 'reportlab>=4.2.0' " + "alle dipendenze del backend." + ) + + summary = await self.get_summary(tenant_id, 30, visible_mailbox_ids) + now_str = summary.generated_at.strftime("%d/%m/%Y %H:%M") + + buf = io.BytesIO() + doc = SimpleDocTemplate( + buf, + pagesize=A4, + leftMargin=2 * cm, + rightMargin=2 * cm, + topMargin=2 * cm, + bottomMargin=2 * cm, + ) + + styles = getSampleStyleSheet() + title_style = ParagraphStyle( + "Title", parent=styles["Title"], fontSize=18, spaceAfter=6, + ) + subtitle_style = ParagraphStyle( + "Subtitle", parent=styles["Normal"], fontSize=10, textColor=colors.grey, spaceAfter=20, + ) + heading_style = ParagraphStyle( + "Heading2", parent=styles["Heading2"], fontSize=13, spaceBefore=14, spaceAfter=6, + ) + + story = [] + + # Intestazione + story.append(Paragraph("PEChub – Report Attivita PEC", title_style)) + date_range = "" + if date_from: + date_range += f"Dal {date_from.strftime('%d/%m/%Y')} " + if date_to: + date_range += f"Al {date_to.strftime('%d/%m/%Y')} " + story.append(Paragraph( + f"Generato il {now_str} {date_range}", + subtitle_style, + )) + + # Sezione KPI + story.append(Paragraph("Indicatori Chiave (ultimi 30 giorni)", heading_style)) + kpi = summary.kpi + kpi_data = [ + ["Indicatore", "Valore"], + ["PEC ricevute oggi", str(kpi.received_today)], + ["PEC inviate oggi", str(kpi.sent_today)], + ["PEC ricevute (7 gg)", str(kpi.received_7d)], + ["PEC inviate (7 gg)", str(kpi.sent_7d)], + ["PEC ricevute (30 gg)", str(kpi.received_30d)], + ["PEC inviate (30 gg)", str(kpi.sent_30d)], + ["Anomalie attive", str(kpi.anomalie_attive)], + ["Tasso di consegna", f"{kpi.tasso_consegna}%"], + ["Caselle in errore", str(kpi.caselle_in_errore)], + ["Messaggi non letti", str(kpi.messaggi_non_letti)], + ] + kpi_table = Table(kpi_data, colWidths=[10 * cm, 5 * cm]) + kpi_table.setStyle(TableStyle([ + ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#1e40af")), + ("TEXTCOLOR", (0, 0), (-1, 0), colors.white), + ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"), + ("FONTSIZE", (0, 0), (-1, -1), 10), + ("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f0f4ff")]), + ("GRID", (0, 0), (-1, -1), 0.5, colors.lightgrey), + ("ALIGN", (1, 0), (1, -1), "RIGHT"), + ("LEFTPADDING", (0, 0), (-1, -1), 8), + ("RIGHTPADDING", (0, 0), (-1, -1), 8), + ("TOPPADDING", (0, 0), (-1, -1), 5), + ("BOTTOMPADDING", (0, 0), (-1, -1), 5), + ])) + story.append(kpi_table) + story.append(Spacer(1, 0.5 * cm)) + + # Sezione caselle + if summary.mailbox_stats: + story.append(Paragraph("Dettaglio per Casella", heading_style)) + mb_header = ["Casella", "Stato", "Ricevute", "Inviate", "Anomalie", "Non letti"] + mb_data = [mb_header] + for ms in summary.mailbox_stats: + mb_data.append([ + ms.email_address, + ms.status, + str(ms.received_total), + str(ms.sent_total), + str(ms.anomalie), + str(ms.non_letti), + ]) + mb_table = Table( + mb_data, + colWidths=[6.5 * cm, 2.2 * cm, 2.2 * cm, 2.2 * cm, 2.2 * cm, 2.2 * cm], + ) + mb_table.setStyle(TableStyle([ + ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#1e40af")), + ("TEXTCOLOR", (0, 0), (-1, 0), colors.white), + ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"), + ("FONTSIZE", (0, 0), (-1, -1), 9), + ("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f0f4ff")]), + ("GRID", (0, 0), (-1, -1), 0.5, colors.lightgrey), + ("ALIGN", (1, 0), (-1, -1), "RIGHT"), + ("LEFTPADDING", (0, 0), (-1, -1), 6), + ("RIGHTPADDING", (0, 0), (-1, -1), 6), + ("TOPPADDING", (0, 0), (-1, -1), 4), + ("BOTTOMPADDING", (0, 0), (-1, -1), 4), + ])) + story.append(mb_table) + + doc.build(story) + return buf.getvalue() + + +# ─── Costanti ──────────────────────────────────────────────────────────────── + +CSV_HEADERS = [ + "ID", + "Casella", + "Direzione", + "Stato", + "Tipo PEC", + "Oggetto", + "Mittente", + "Data/Ora", + "Dimensione (byte)", + "Letto", + "Allegati", +] diff --git a/backend/app/services/routing_rule_service.py b/backend/app/services/routing_rule_service.py new file mode 100644 index 0000000..cab70a0 --- /dev/null +++ b/backend/app/services/routing_rule_service.py @@ -0,0 +1,296 @@ +""" +Service per la gestione delle regole di smistamento automatico (Feature 2). + +Il metodo evaluate_rules() viene chiamato dal worker dopo ogni messaggio inbound. +""" + +import re +import uuid + +from sqlalchemy import delete, func, select +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy.orm import selectinload + +from app.core.exceptions import NotFoundError +from app.models.label import Label, MessageLabel +from app.models.message import Message +from app.models.routing_rule import RoutingRule, RoutingRuleAction, RoutingRuleCondition +from app.schemas.routing_rule import RoutingRuleCreate, RoutingRuleUpdate + + +class RoutingRuleService: + def __init__(self, db: AsyncSession): + self.db = db + + # ─── CRUD ───────────────────────────────────────────────────────────────── + + async def list_rules( + self, + tenant_id: uuid.UUID, + ) -> tuple[list[RoutingRule], int]: + query = ( + select(RoutingRule) + .where(RoutingRule.tenant_id == tenant_id) + .options(selectinload(RoutingRule.conditions), selectinload(RoutingRule.actions)) + .order_by(RoutingRule.priority) + ) + count_q = select(func.count()).select_from( + select(RoutingRule).where(RoutingRule.tenant_id == tenant_id).subquery() + ) + total = (await self.db.execute(count_q)).scalar_one() + items = list((await self.db.execute(query)).scalars().all()) + return items, total + + async def get_rule( + self, tenant_id: uuid.UUID, rule_id: uuid.UUID + ) -> RoutingRule: + result = await self.db.execute( + select(RoutingRule) + .where(RoutingRule.id == rule_id, RoutingRule.tenant_id == tenant_id) + .options(selectinload(RoutingRule.conditions), selectinload(RoutingRule.actions)) + ) + rule = result.scalar_one_or_none() + if not rule: + raise NotFoundError(f"Regola {rule_id} non trovata") + return rule + + async def create_rule( + self, + tenant_id: uuid.UUID, + data: RoutingRuleCreate, + created_by: uuid.UUID | None = None, + ) -> RoutingRule: + rule = RoutingRule( + tenant_id=tenant_id, + name=data.name, + description=data.description, + is_active=data.is_active, + priority=data.priority, + stop_processing=data.stop_processing, + created_by=created_by, + ) + self.db.add(rule) + await self.db.flush() + + for cond in data.conditions: + self.db.add(RoutingRuleCondition( + rule_id=rule.id, + field=cond.field, + operator=cond.operator, + value=cond.value, + )) + for action in data.actions: + self.db.add(RoutingRuleAction( + rule_id=rule.id, + action_type=action.action_type, + action_value=action.action_value, + )) + + await self.db.commit() + return await self.get_rule(tenant_id, rule.id) + + async def update_rule( + self, + tenant_id: uuid.UUID, + rule_id: uuid.UUID, + data: RoutingRuleUpdate, + ) -> RoutingRule: + rule = await self.get_rule(tenant_id, rule_id) + + if data.name is not None: + rule.name = data.name + if data.description is not None: + rule.description = data.description + if data.is_active is not None: + rule.is_active = data.is_active + if data.priority is not None: + rule.priority = data.priority + if data.stop_processing is not None: + rule.stop_processing = data.stop_processing + + # Se condizioni o azioni vengono aggiornate, le sostituisce completamente + if data.conditions is not None: + await self.db.execute( + delete(RoutingRuleCondition).where(RoutingRuleCondition.rule_id == rule_id) + ) + for cond in data.conditions: + self.db.add(RoutingRuleCondition( + rule_id=rule_id, + field=cond.field, + operator=cond.operator, + value=cond.value, + )) + + if data.actions is not None: + await self.db.execute( + delete(RoutingRuleAction).where(RoutingRuleAction.rule_id == rule_id) + ) + for action in data.actions: + self.db.add(RoutingRuleAction( + rule_id=rule_id, + action_type=action.action_type, + action_value=action.action_value, + )) + + await self.db.commit() + return await self.get_rule(tenant_id, rule_id) + + async def delete_rule( + self, tenant_id: uuid.UUID, rule_id: uuid.UUID + ) -> None: + rule = await self.get_rule(tenant_id, rule_id) + await self.db.delete(rule) + await self.db.commit() + + # ─── Motore di valutazione ──────────────────────────────────────────────── + + async def evaluate_and_apply( + self, + message: Message, + ) -> int: + """ + Valuta le regole attive del tenant e applica le azioni su message. + + Returns: + Numero di regole che hanno prodotto match. + """ + # Carica regole attive ordinate per priority + result = await self.db.execute( + select(RoutingRule) + .where( + RoutingRule.tenant_id == message.tenant_id, + RoutingRule.is_active == True, # noqa: E712 + ) + .options(selectinload(RoutingRule.conditions), selectinload(RoutingRule.actions)) + .order_by(RoutingRule.priority) + ) + rules = list(result.scalars().all()) + + matched_count = 0 + for rule in rules: + if await self._matches(message, rule.conditions): + matched_count += 1 + await self._apply_actions(message, rule.actions) + if rule.stop_processing: + break + + if matched_count > 0: + await self.db.flush() + + return matched_count + + async def _matches( + self, + message: Message, + conditions: list[RoutingRuleCondition], + ) -> bool: + """Restituisce True se tutte le condizioni (AND) sono soddisfatte.""" + if not conditions: + # Una regola senza condizioni non fa mai match (comportamento sicuro) + return False + + for cond in conditions: + field_value = self._get_field_value(message, cond.field) + if not self._evaluate_condition(field_value, cond.operator, cond.value): + return False + return True + + def _get_field_value(self, message: Message, field: str) -> str: + """Estrae il valore del campo dal messaggio come stringa per il confronto.""" + if field == "from_address": + return (message.from_address or "").lower() + elif field == "to_address": + return " ".join(message.to_addresses or []).lower() + elif field == "subject": + return (message.subject or "").lower() + elif field == "mailbox_id": + return str(message.mailbox_id) + elif field == "pec_type": + return message.pec_type or "" + return "" + + def _evaluate_condition( + self, field_value: str, operator: str, value: str + ) -> bool: + v = value.lower() + fv = field_value.lower() + if operator == "contains": + return v in fv + elif operator == "not_contains": + return v not in fv + elif operator == "equals": + return fv == v + elif operator == "starts_with": + return fv.startswith(v) + elif operator == "ends_with": + return fv.endswith(v) + elif operator == "regex": + try: + return bool(re.search(value, field_value, re.IGNORECASE)) + except re.error: + return False + return False + + async def _apply_actions( + self, + message: Message, + actions: list[RoutingRuleAction], + ) -> None: + """Esegue le azioni sulla regola che ha fatto match.""" + for action in actions: + try: + if action.action_type == "apply_label" and action.action_value: + await self._action_apply_label(message, uuid.UUID(action.action_value)) + elif action.action_type == "mark_read": + message.is_read = True + elif action.action_type == "mark_starred": + message.is_starred = True + elif action.action_type == "notify_webhook" and action.action_value: + await self._action_notify_webhook(message, action.action_value) + except Exception: + # Le azioni non devono interrompere il flusso principale + pass + + async def _action_apply_label( + self, message: Message, label_id: uuid.UUID + ) -> None: + """Applica un'etichetta al messaggio (se non gia' presente).""" + # Verifica che la label appartenga al tenant + label = await self.db.execute( + select(Label).where( + Label.id == label_id, + Label.tenant_id == message.tenant_id, + ) + ) + if not label.scalar_one_or_none(): + return + # Verifica che non sia gia' applicata + existing = await self.db.execute( + select(MessageLabel).where( + MessageLabel.message_id == message.id, + MessageLabel.label_id == label_id, + ) + ) + if not existing.scalar_one_or_none(): + self.db.add(MessageLabel(message_id=message.id, label_id=label_id)) + + async def _action_notify_webhook(self, message: Message, url: str) -> None: + """Invia una notifica webhook per il messaggio.""" + import aiohttp + import json + payload = { + "event": "routing_rule_match", + "message_id": str(message.id), + "subject": message.subject, + "from_address": message.from_address, + "pec_type": message.pec_type, + } + try: + async with aiohttp.ClientSession() as session: + await session.post( + url, + json=payload, + timeout=aiohttp.ClientTimeout(total=5), + ) + except Exception: + pass diff --git a/backend/app/services/search_service.py b/backend/app/services/search_service.py new file mode 100644 index 0000000..9b9baf6 --- /dev/null +++ b/backend/app/services/search_service.py @@ -0,0 +1,139 @@ +""" +Servizio di ricerca full-text per i messaggi PEC. + +Utilizza i vettori tsvector di PostgreSQL per ricerche veloci su: + - oggetto (peso A) + - mittente / destinatari (peso B) + - corpo del messaggio (peso C) + - testo estratto dagli allegati PDF/DOCX (peso D) + +Se search_vector e' NULL (messaggio non ancora indicizzato dal worker), +cade back automaticamente a ILIKE sulle colonne base. +""" + +import uuid +from datetime import datetime +from typing import Optional + +from sqlalchemy import case, func, or_, select +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy.orm import selectinload + +from app.models.message import Message + + +class SearchService: + """Incapsula la logica di ricerca full-text sui messaggi.""" + + def __init__(self, db: AsyncSession) -> None: + self.db = db + + async def search_messages( + self, + tenant_id: uuid.UUID, + search_term: str, + visible_mailbox_ids: Optional[list[uuid.UUID]], + mailbox_id: Optional[uuid.UUID] = None, + direction: Optional[str] = None, + state: Optional[str] = None, + pec_type: Optional[str] = None, + date_from: Optional[datetime] = None, + date_to: Optional[datetime] = None, + is_archived: Optional[bool] = False, + is_trashed: Optional[bool] = False, + is_starred: Optional[bool] = None, + is_read: Optional[bool] = None, + page: int = 1, + page_size: int = 50, + ) -> tuple[list[Message], int]: + """ + Ricerca full-text nei messaggi. + + Logica: + 1. Messaggi con search_vector non NULL → usa @@ operator + ts_rank + 2. Messaggi con search_vector NULL → fallback ILIKE (non ancora indicizzati) + 3. Applica tutti i filtri aggiuntivi (data, stato, tipo, direzione, ecc.) + 4. Ordina per rilevanza FTS desc, poi per data desc + """ + q = select(Message).where( + Message.tenant_id == tenant_id, + Message.parent_message_id.is_(None), + ) + + # Restrizione caselle visibili (permessi) + if visible_mailbox_ids is not None: + if not visible_mailbox_ids: + return [], 0 + q = q.where(Message.mailbox_id.in_(visible_mailbox_ids)) + + # Filtri opzionali + if mailbox_id: + q = q.where(Message.mailbox_id == mailbox_id) + if direction: + q = q.where(Message.direction == direction) + if state: + q = q.where(Message.state == state) + if pec_type: + q = q.where(Message.pec_type == pec_type) + if is_archived is not None: + q = q.where(Message.is_archived == is_archived) + if is_trashed is not None: + q = q.where(Message.is_trashed == is_trashed) + if is_starred is not None: + q = q.where(Message.is_starred == is_starred) + if is_read is not None: + q = q.where(Message.is_read == is_read) + + # Filtri data: cerca sia su received_at che su sent_at + if date_from: + q = q.where( + or_( + Message.received_at >= date_from, + Message.sent_at >= date_from, + ) + ) + if date_to: + q = q.where( + or_( + Message.received_at <= date_to, + Message.sent_at <= date_to, + ) + ) + + # Full-text search con fallback ILIKE + tsquery = func.websearch_to_tsquery("italian", search_term) + term_like = f"%{search_term}%" + + fts_condition = Message.search_vector.op("@@")(tsquery) + ilike_fallback = Message.search_vector.is_(None) & or_( + Message.subject.ilike(term_like), + Message.from_address.ilike(term_like), + Message.body_text.ilike(term_like), + ) + + q = q.where(or_(fts_condition, ilike_fallback)) + + # Conteggio totale (senza paginazione) + count_q = select(func.count()).select_from(q.subquery()) + total: int = (await self.db.execute(count_q)).scalar_one() + + # Ordinamento per rilevanza FTS, poi data + rank_expr = case( + (Message.search_vector.isnot(None), func.ts_rank(Message.search_vector, tsquery)), + else_=0.0, + ) + + q = ( + q.options(selectinload(Message.labels)) + .order_by( + rank_expr.desc(), + Message.received_at.desc().nullslast(), + Message.created_at.desc(), + ) + .offset((page - 1) * page_size) + .limit(page_size) + ) + + result = await self.db.execute(q) + items = list(result.scalars().all()) + return items, total diff --git a/backend/app/services/send_service.py b/backend/app/services/send_service.py index 6945700..70bb6ba 100644 --- a/backend/app/services/send_service.py +++ b/backend/app/services/send_service.py @@ -166,12 +166,16 @@ class SendService: now = datetime.now(tz=timezone.utc) has_files = bool(attachments) + # Invio differito: il messaggio parte in stato 'draft' se programmato + scheduled_at = getattr(data, "scheduled_at", None) + is_scheduled = scheduled_at is not None and scheduled_at > now + message = Message( tenant_id=current_user.tenant_id, mailbox_id=data.mailbox_id, direction="outbound", pec_type="posta_certificata", - state="queued", + state="draft" if is_scheduled else "queued", subject=data.subject, from_address=mailbox.email_address, to_addresses=[str(a) for a in data.to_addresses], @@ -211,6 +215,7 @@ class SendService: max_attempts=5, created_by=current_user.id, queued_at=now, + scheduled_at=scheduled_at if is_scheduled else None, ) self.db.add(job) await self.db.flush() @@ -218,7 +223,15 @@ class SendService: # ── Enqueue job arq ─────────────────────────────────────────────────── try: arq_pool = await _get_arq_pool() - await arq_pool.enqueue_job("send_pec", str(job.id)) + if is_scheduled and scheduled_at: + # Invio differito: defer_until = scheduled_at + await arq_pool.enqueue_job( + "send_pec", + str(job.id), + _defer_until=scheduled_at, + ) + else: + await arq_pool.enqueue_job("send_pec", str(job.id)) except Exception as e: from app.core.logging import get_logger logger = get_logger(__name__) diff --git a/backend/app/services/template_service.py b/backend/app/services/template_service.py new file mode 100644 index 0000000..f536887 --- /dev/null +++ b/backend/app/services/template_service.py @@ -0,0 +1,116 @@ +""" +Service per la gestione dei template messaggi (Feature 1). +""" + +import uuid + +from sqlalchemy import func, select +from sqlalchemy.ext.asyncio import AsyncSession + +from app.core.exceptions import ConflictError, NotFoundError +from app.models.template import MessageTemplate +from app.schemas.template import TemplateCreate, TemplateUpdate + + +class TemplateService: + def __init__(self, db: AsyncSession): + self.db = db + + async def list_templates( + self, + tenant_id: uuid.UUID, + q: str | None = None, + ) -> tuple[list[MessageTemplate], int]: + query = select(MessageTemplate).where(MessageTemplate.tenant_id == tenant_id) + if q: + query = query.where(MessageTemplate.name.ilike(f"%{q}%")) + query = query.order_by(MessageTemplate.name) + + count_q = select(func.count()).select_from(query.subquery()) + total = (await self.db.execute(count_q)).scalar_one() + items = list((await self.db.execute(query)).scalars().all()) + return items, total + + async def get_template( + self, tenant_id: uuid.UUID, template_id: uuid.UUID + ) -> MessageTemplate: + result = await self.db.execute( + select(MessageTemplate).where( + MessageTemplate.id == template_id, + MessageTemplate.tenant_id == tenant_id, + ) + ) + template = result.scalar_one_or_none() + if not template: + raise NotFoundError(f"Template {template_id} non trovato") + return template + + async def create_template( + self, + tenant_id: uuid.UUID, + data: TemplateCreate, + created_by: uuid.UUID | None = None, + ) -> MessageTemplate: + # Verifica unicita' nome + existing = await self.db.execute( + select(MessageTemplate).where( + MessageTemplate.tenant_id == tenant_id, + MessageTemplate.name == data.name, + ) + ) + if existing.scalar_one_or_none(): + raise ConflictError(f"Template '{data.name}' gia' esistente") + + template = MessageTemplate( + tenant_id=tenant_id, + name=data.name, + description=data.description, + subject=data.subject, + body_text=data.body_text, + body_html=data.body_html, + created_by=created_by, + ) + self.db.add(template) + await self.db.commit() + await self.db.refresh(template) + return template + + async def update_template( + self, + tenant_id: uuid.UUID, + template_id: uuid.UUID, + data: TemplateUpdate, + ) -> MessageTemplate: + template = await self.get_template(tenant_id, template_id) + + if data.name is not None: + existing = await self.db.execute( + select(MessageTemplate).where( + MessageTemplate.tenant_id == tenant_id, + MessageTemplate.name == data.name, + MessageTemplate.id != template_id, + ) + ) + if existing.scalar_one_or_none(): + raise ConflictError(f"Template '{data.name}' gia' esistente") + template.name = data.name + + if data.description is not None: + template.description = data.description + if data.subject is not None: + template.subject = data.subject + if data.body_text is not None: + template.body_text = data.body_text + if data.body_html is not None: + template.body_html = data.body_html + + await self.db.commit() + await self.db.refresh(template) + return template + + async def delete_template( + self, tenant_id: uuid.UUID, template_id: uuid.UUID + ) -> None: + template = await self.get_template(tenant_id, template_id) + await self.db.delete(template) + await self.db.commit() diff --git a/backend/app/services/user_service.py b/backend/app/services/user_service.py index 9b82426..eadd2f9 100644 --- a/backend/app/services/user_service.py +++ b/backend/app/services/user_service.py @@ -13,6 +13,7 @@ from app.core.security import hash_password from app.models.tenant import Tenant from app.models.user import User from app.schemas.user import UserCreateRequest, UserUpdateRequest +from app.services.audit_service import log_audit class UserService: @@ -61,6 +62,15 @@ class UserService: ) self.db.add(user) await self.db.flush() # ottieni l'ID + await log_audit( + self.db, + "user.created", + tenant_id=tenant_id, + user_id=created_by.id, + resource_type="user", + resource_id=user.id, + payload={"email": user.email, "role": user.role}, + ) return user async def get_user(self, user_id: uuid.UUID, tenant_id: uuid.UUID) -> User: @@ -110,13 +120,26 @@ class UserService: if user.is_super_admin and not updated_by.is_super_admin: raise ForbiddenError("Non puoi modificare un super_admin") + changes: dict = {} if data.full_name is not None: + changes["full_name"] = data.full_name user.full_name = data.full_name if data.role is not None: + changes["role"] = data.role user.role = data.role if data.is_active is not None: + changes["is_active"] = data.is_active user.is_active = data.is_active + await log_audit( + self.db, + "user.updated", + tenant_id=tenant_id, + user_id=updated_by.id, + resource_type="user", + resource_id=user_id, + payload={"changes": changes}, + ) return user async def reset_password( @@ -143,3 +166,12 @@ class UserService: # Soft delete (disabilita invece di eliminare) user.is_active = False + await log_audit( + self.db, + "user.deleted", + tenant_id=tenant_id, + user_id=deleted_by.id, + resource_type="user", + resource_id=user_id, + payload={"email": user.email}, + ) diff --git a/backend/pyproject.toml b/backend/pyproject.toml index 792b925..ca5cc67 100644 --- a/backend/pyproject.toml +++ b/backend/pyproject.toml @@ -46,6 +46,15 @@ dependencies = [ # Storage MinIO/S3 "miniopy-async>=1.21.0", + # Estrazione testo allegati (usato anche dal job rescan nel backend) + "pypdf>=4.0.0", + "python-docx>=1.1.0", + + # OCR per allegati image-only (immagini dirette e PDF scansionati) + "pytesseract>=0.3.13", + "pdf2image>=1.17.0", + "Pillow>=11.0.0", + # IMAP async (per test connessione nel backend + mailbox service) "aioimaplib>=2.0.0", @@ -58,6 +67,9 @@ dependencies = [ # Utilities "python-multipart>=0.0.9", # upload file "python-dotenv>=1.0.0", + + # Generazione PDF report (puro Python, nessuna dipendenza di sistema) + "reportlab>=4.2.0", ] [project.optional-dependencies] diff --git a/frontend/node_modules/.package-lock.json b/frontend/node_modules/.package-lock.json index 8a09e67..7acab78 100644 --- a/frontend/node_modules/.package-lock.json +++ b/frontend/node_modules/.package-lock.json @@ -1,5 +1,5 @@ { - "name": "pecflow-frontend", + "name": "pechub-frontend", "version": "1.0.0", "lockfileVersion": 3, "requires": true, @@ -251,6 +251,15 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/runtime": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.2.tgz", + "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/@babel/template": { "version": "7.28.6", "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", @@ -2797,6 +2806,69 @@ "@babel/types": "^7.28.2" } }, + "node_modules/@types/d3-array": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz", + "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==", + "license": "MIT" + }, + "node_modules/@types/d3-color": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz", + "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==", + "license": "MIT" + }, + "node_modules/@types/d3-ease": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz", + "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==", + "license": "MIT" + }, + "node_modules/@types/d3-interpolate": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", + "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", + "license": "MIT", + "dependencies": { + "@types/d3-color": "*" + } + }, + "node_modules/@types/d3-path": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz", + "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==", + "license": "MIT" + }, + "node_modules/@types/d3-scale": { + "version": "4.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz", + "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==", + "license": "MIT", + "dependencies": { + "@types/d3-time": "*" + } + }, + "node_modules/@types/d3-shape": { + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.8.tgz", + "integrity": "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==", + "license": "MIT", + "dependencies": { + "@types/d3-path": "*" + } + }, + "node_modules/@types/d3-time": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz", + "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==", + "license": "MIT" + }, + "node_modules/@types/d3-timer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz", + "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==", + "license": "MIT" + }, "node_modules/@types/estree": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", @@ -3378,6 +3450,127 @@ "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", "license": "MIT" }, + "node_modules/d3-array": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz", + "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==", + "license": "ISC", + "dependencies": { + "internmap": "1 - 2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-color": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", + "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-ease": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", + "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-format": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz", + "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-interpolate": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", + "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-path": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz", + "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-scale": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz", + "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==", + "license": "ISC", + "dependencies": { + "d3-array": "2.10.0 - 3", + "d3-format": "1 - 3", + "d3-interpolate": "1.2.0 - 3", + "d3-time": "2.1.1 - 3", + "d3-time-format": "2 - 4" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-shape": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz", + "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==", + "license": "ISC", + "dependencies": { + "d3-path": "^3.1.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz", + "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==", + "license": "ISC", + "dependencies": { + "d3-array": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time-format": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz", + "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==", + "license": "ISC", + "dependencies": { + "d3-time": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-timer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", + "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, "node_modules/date-fns": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-3.6.0.tgz", @@ -3406,6 +3599,12 @@ } } }, + "node_modules/decimal.js-light": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/decimal.js-light/-/decimal.js-light-2.5.1.tgz", + "integrity": "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==", + "license": "MIT" + }, "node_modules/deep-eql": { "version": "5.0.2", "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz", @@ -3445,6 +3644,16 @@ "dev": true, "license": "MIT" }, + "node_modules/dom-helpers": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz", + "integrity": "sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.8.7", + "csstype": "^3.0.2" + } + }, "node_modules/dunder-proto": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", @@ -3601,6 +3810,12 @@ "@types/estree": "^1.0.0" } }, + "node_modules/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==", + "license": "MIT" + }, "node_modules/expect-type": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", @@ -3861,6 +4076,15 @@ "node": ">= 0.4" } }, + "node_modules/internmap": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz", + "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, "node_modules/is-binary-path": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", @@ -4000,6 +4224,12 @@ "integrity": "sha512-NT1CJtq3hHIreOianA8aSXn6Cw0JzYOuDQbOrSPe7gqFnCpKP++MQe3ODgO3oh2GJFORkAAdqredOa60z63GbA==", "license": "MIT" }, + "node_modules/lodash": { + "version": "4.17.23", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz", + "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==", + "license": "MIT" + }, "node_modules/loose-envify": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", @@ -4184,7 +4414,6 @@ "version": "4.1.1", "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", - "dev": true, "license": "MIT", "engines": { "node": ">=0.10.0" @@ -4465,6 +4694,23 @@ "dev": true, "license": "MIT" }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/prop-types/node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==", + "license": "MIT" + }, "node_modules/prosemirror-changeset": { "version": "2.4.0", "resolved": "https://registry.npmjs.org/prosemirror-changeset/-/prosemirror-changeset-2.4.0.tgz", @@ -4763,6 +5009,12 @@ "react-dom": ">=16" } }, + "node_modules/react-is": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz", + "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==", + "license": "MIT" + }, "node_modules/react-refresh": { "version": "0.17.0", "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz", @@ -4852,6 +5104,21 @@ "react-dom": ">=16.8" } }, + "node_modules/react-smooth": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/react-smooth/-/react-smooth-4.0.4.tgz", + "integrity": "sha512-gnGKTpYwqL0Iii09gHobNolvX4Kiq4PKx6eWBCYYix+8cdw+cGo3do906l1NBPKkSWx1DghC1dlWG9L2uGd61Q==", + "license": "MIT", + "dependencies": { + "fast-equals": "^5.0.1", + "prop-types": "^15.8.1", + "react-transition-group": "^4.4.5" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, "node_modules/react-style-singleton": { "version": "2.2.3", "resolved": "https://registry.npmjs.org/react-style-singleton/-/react-style-singleton-2.2.3.tgz", @@ -4874,6 +5141,22 @@ } } }, + "node_modules/react-transition-group": { + "version": "4.4.5", + "resolved": "https://registry.npmjs.org/react-transition-group/-/react-transition-group-4.4.5.tgz", + "integrity": "sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g==", + "license": "BSD-3-Clause", + "dependencies": { + "@babel/runtime": "^7.5.5", + "dom-helpers": "^5.0.1", + "loose-envify": "^1.4.0", + "prop-types": "^15.6.2" + }, + "peerDependencies": { + "react": ">=16.6.0", + "react-dom": ">=16.6.0" + } + }, "node_modules/read-cache": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", @@ -4897,6 +5180,38 @@ "node": ">=8.10.0" } }, + "node_modules/recharts": { + "version": "2.15.4", + "resolved": "https://registry.npmjs.org/recharts/-/recharts-2.15.4.tgz", + "integrity": "sha512-UT/q6fwS3c1dHbXv2uFgYJ9BMFHu3fwnd7AYZaEQhXuYQ4hgsxLvsUXzGdKeZrW5xopzDCvuA2N41WJ88I7zIw==", + "license": "MIT", + "dependencies": { + "clsx": "^2.0.0", + "eventemitter3": "^4.0.1", + "lodash": "^4.17.21", + "react-is": "^18.3.1", + "react-smooth": "^4.0.4", + "recharts-scale": "^0.4.4", + "tiny-invariant": "^1.3.1", + "victory-vendor": "^36.6.8" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "react": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/recharts-scale": { + "version": "0.4.5", + "resolved": "https://registry.npmjs.org/recharts-scale/-/recharts-scale-0.4.5.tgz", + "integrity": "sha512-kivNFO+0OcUNu7jQquLXAxz1FIwZj8nrj+YkOKc5694NbjCvcT6aSZiIzNzd2Kul4o4rTto8QVR9lMNtxD4G1w==", + "license": "MIT", + "dependencies": { + "decimal.js-light": "^2.4.1" + } + }, "node_modules/resolve": { "version": "1.22.11", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz", @@ -5161,6 +5476,12 @@ "node": ">=0.8" } }, + "node_modules/tiny-invariant": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz", + "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==", + "license": "MIT" + }, "node_modules/tinybench": { "version": "2.9.0", "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", @@ -5396,6 +5717,28 @@ "dev": true, "license": "MIT" }, + "node_modules/victory-vendor": { + "version": "36.9.2", + "resolved": "https://registry.npmjs.org/victory-vendor/-/victory-vendor-36.9.2.tgz", + "integrity": "sha512-PnpQQMuxlwYdocC8fIJqVXvkeViHYzotI+NJrCuav0ZYFoq912ZHBk3mCeuj+5/VpodOjPe1z0Fk2ihgzlXqjQ==", + "license": "MIT AND ISC", + "dependencies": { + "@types/d3-array": "^3.0.3", + "@types/d3-ease": "^3.0.0", + "@types/d3-interpolate": "^3.0.1", + "@types/d3-scale": "^4.0.2", + "@types/d3-shape": "^3.1.0", + "@types/d3-time": "^3.0.0", + "@types/d3-timer": "^3.0.0", + "d3-array": "^3.1.6", + "d3-ease": "^3.0.1", + "d3-interpolate": "^3.0.1", + "d3-scale": "^4.0.2", + "d3-shape": "^3.1.0", + "d3-time": "^3.0.0", + "d3-timer": "^3.0.1" + } + }, "node_modules/vite": { "version": "5.4.21", "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz", diff --git a/frontend/package-lock.json b/frontend/package-lock.json index 1fcd11e..1df2a11 100644 --- a/frontend/package-lock.json +++ b/frontend/package-lock.json @@ -1,11 +1,11 @@ { - "name": "pecflow-frontend", + "name": "pechub-frontend", "version": "1.0.0", "lockfileVersion": 3, "requires": true, "packages": { "": { - "name": "pecflow-frontend", + "name": "pechub-frontend", "version": "1.0.0", "dependencies": { "@radix-ui/react-avatar": "^1.1.1", @@ -42,6 +42,7 @@ "react-hook-form": "^7.53.0", "react-hot-toast": "^2.4.1", "react-router-dom": "^6.26.2", + "recharts": "^2.13.0", "tailwind-merge": "^2.5.2", "zustand": "^5.0.0" }, @@ -306,6 +307,15 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/runtime": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.2.tgz", + "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/@babel/template": { "version": "7.28.6", "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", @@ -3548,6 +3558,69 @@ "@babel/types": "^7.28.2" } }, + "node_modules/@types/d3-array": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz", + "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==", + "license": "MIT" + }, + "node_modules/@types/d3-color": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz", + "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==", + "license": "MIT" + }, + "node_modules/@types/d3-ease": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz", + "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==", + "license": "MIT" + }, + "node_modules/@types/d3-interpolate": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", + "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", + "license": "MIT", + "dependencies": { + "@types/d3-color": "*" + } + }, + "node_modules/@types/d3-path": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz", + "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==", + "license": "MIT" + }, + "node_modules/@types/d3-scale": { + "version": "4.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz", + "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==", + "license": "MIT", + "dependencies": { + "@types/d3-time": "*" + } + }, + "node_modules/@types/d3-shape": { + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.8.tgz", + "integrity": "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==", + "license": "MIT", + "dependencies": { + "@types/d3-path": "*" + } + }, + "node_modules/@types/d3-time": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz", + "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==", + "license": "MIT" + }, + "node_modules/@types/d3-timer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz", + "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==", + "license": "MIT" + }, "node_modules/@types/estree": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", @@ -4129,6 +4202,127 @@ "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", "license": "MIT" }, + "node_modules/d3-array": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz", + "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==", + "license": "ISC", + "dependencies": { + "internmap": "1 - 2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-color": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", + "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-ease": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", + "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-format": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz", + "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-interpolate": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", + "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-path": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz", + "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-scale": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz", + "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==", + "license": "ISC", + "dependencies": { + "d3-array": "2.10.0 - 3", + "d3-format": "1 - 3", + "d3-interpolate": "1.2.0 - 3", + "d3-time": "2.1.1 - 3", + "d3-time-format": "2 - 4" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-shape": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz", + "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==", + "license": "ISC", + "dependencies": { + "d3-path": "^3.1.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz", + "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==", + "license": "ISC", + "dependencies": { + "d3-array": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time-format": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz", + "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==", + "license": "ISC", + "dependencies": { + "d3-time": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-timer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", + "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, "node_modules/date-fns": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-3.6.0.tgz", @@ -4157,6 +4351,12 @@ } } }, + "node_modules/decimal.js-light": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/decimal.js-light/-/decimal.js-light-2.5.1.tgz", + "integrity": "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==", + "license": "MIT" + }, "node_modules/deep-eql": { "version": "5.0.2", "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz", @@ -4196,6 +4396,16 @@ "dev": true, "license": "MIT" }, + "node_modules/dom-helpers": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz", + "integrity": "sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.8.7", + "csstype": "^3.0.2" + } + }, "node_modules/dunder-proto": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", @@ -4352,6 +4562,12 @@ "@types/estree": "^1.0.0" } }, + "node_modules/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==", + "license": "MIT" + }, "node_modules/expect-type": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", @@ -4627,6 +4843,15 @@ "node": ">= 0.4" } }, + "node_modules/internmap": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz", + "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, "node_modules/is-binary-path": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", @@ -4766,6 +4991,12 @@ "integrity": "sha512-NT1CJtq3hHIreOianA8aSXn6Cw0JzYOuDQbOrSPe7gqFnCpKP++MQe3ODgO3oh2GJFORkAAdqredOa60z63GbA==", "license": "MIT" }, + "node_modules/lodash": { + "version": "4.17.23", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz", + "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==", + "license": "MIT" + }, "node_modules/loose-envify": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", @@ -4950,7 +5181,6 @@ "version": "4.1.1", "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", - "dev": true, "license": "MIT", "engines": { "node": ">=0.10.0" @@ -5231,6 +5461,23 @@ "dev": true, "license": "MIT" }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/prop-types/node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==", + "license": "MIT" + }, "node_modules/prosemirror-changeset": { "version": "2.4.0", "resolved": "https://registry.npmjs.org/prosemirror-changeset/-/prosemirror-changeset-2.4.0.tgz", @@ -5529,6 +5776,12 @@ "react-dom": ">=16" } }, + "node_modules/react-is": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz", + "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==", + "license": "MIT" + }, "node_modules/react-refresh": { "version": "0.17.0", "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz", @@ -5618,6 +5871,21 @@ "react-dom": ">=16.8" } }, + "node_modules/react-smooth": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/react-smooth/-/react-smooth-4.0.4.tgz", + "integrity": "sha512-gnGKTpYwqL0Iii09gHobNolvX4Kiq4PKx6eWBCYYix+8cdw+cGo3do906l1NBPKkSWx1DghC1dlWG9L2uGd61Q==", + "license": "MIT", + "dependencies": { + "fast-equals": "^5.0.1", + "prop-types": "^15.8.1", + "react-transition-group": "^4.4.5" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, "node_modules/react-style-singleton": { "version": "2.2.3", "resolved": "https://registry.npmjs.org/react-style-singleton/-/react-style-singleton-2.2.3.tgz", @@ -5640,6 +5908,22 @@ } } }, + "node_modules/react-transition-group": { + "version": "4.4.5", + "resolved": "https://registry.npmjs.org/react-transition-group/-/react-transition-group-4.4.5.tgz", + "integrity": "sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g==", + "license": "BSD-3-Clause", + "dependencies": { + "@babel/runtime": "^7.5.5", + "dom-helpers": "^5.0.1", + "loose-envify": "^1.4.0", + "prop-types": "^15.6.2" + }, + "peerDependencies": { + "react": ">=16.6.0", + "react-dom": ">=16.6.0" + } + }, "node_modules/read-cache": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", @@ -5663,6 +5947,38 @@ "node": ">=8.10.0" } }, + "node_modules/recharts": { + "version": "2.15.4", + "resolved": "https://registry.npmjs.org/recharts/-/recharts-2.15.4.tgz", + "integrity": "sha512-UT/q6fwS3c1dHbXv2uFgYJ9BMFHu3fwnd7AYZaEQhXuYQ4hgsxLvsUXzGdKeZrW5xopzDCvuA2N41WJ88I7zIw==", + "license": "MIT", + "dependencies": { + "clsx": "^2.0.0", + "eventemitter3": "^4.0.1", + "lodash": "^4.17.21", + "react-is": "^18.3.1", + "react-smooth": "^4.0.4", + "recharts-scale": "^0.4.4", + "tiny-invariant": "^1.3.1", + "victory-vendor": "^36.6.8" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "react": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/recharts-scale": { + "version": "0.4.5", + "resolved": "https://registry.npmjs.org/recharts-scale/-/recharts-scale-0.4.5.tgz", + "integrity": "sha512-kivNFO+0OcUNu7jQquLXAxz1FIwZj8nrj+YkOKc5694NbjCvcT6aSZiIzNzd2Kul4o4rTto8QVR9lMNtxD4G1w==", + "license": "MIT", + "dependencies": { + "decimal.js-light": "^2.4.1" + } + }, "node_modules/resolve": { "version": "1.22.11", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz", @@ -5927,6 +6243,12 @@ "node": ">=0.8" } }, + "node_modules/tiny-invariant": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz", + "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==", + "license": "MIT" + }, "node_modules/tinybench": { "version": "2.9.0", "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", @@ -6162,6 +6484,28 @@ "dev": true, "license": "MIT" }, + "node_modules/victory-vendor": { + "version": "36.9.2", + "resolved": "https://registry.npmjs.org/victory-vendor/-/victory-vendor-36.9.2.tgz", + "integrity": "sha512-PnpQQMuxlwYdocC8fIJqVXvkeViHYzotI+NJrCuav0ZYFoq912ZHBk3mCeuj+5/VpodOjPe1z0Fk2ihgzlXqjQ==", + "license": "MIT AND ISC", + "dependencies": { + "@types/d3-array": "^3.0.3", + "@types/d3-ease": "^3.0.0", + "@types/d3-interpolate": "^3.0.1", + "@types/d3-scale": "^4.0.2", + "@types/d3-shape": "^3.1.0", + "@types/d3-time": "^3.0.0", + "@types/d3-timer": "^3.0.0", + "d3-array": "^3.1.6", + "d3-ease": "^3.0.1", + "d3-interpolate": "^3.0.1", + "d3-scale": "^4.0.2", + "d3-shape": "^3.1.0", + "d3-time": "^3.0.0", + "d3-timer": "^3.0.1" + } + }, "node_modules/vite": { "version": "5.4.21", "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz", diff --git a/frontend/package.json b/frontend/package.json index 6f4ef33..8a2f74a 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -48,6 +48,7 @@ "react-hot-toast": "^2.4.1", "react-router-dom": "^6.26.2", "tailwind-merge": "^2.5.2", + "recharts": "^2.13.0", "zustand": "^5.0.0" }, "devDependencies": { diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index 3d79137..2fb28d2 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -11,6 +11,13 @@ import { SettingsPage } from '@/pages/Settings/SettingsPage' import { VirtualBoxesPage } from '@/pages/VirtualBoxes/VirtualBoxesPage' import { NotificationsPage } from '@/pages/Notifications/NotificationsPage' import { MultiTenantPage } from '@/pages/MultiTenant/MultiTenantPage' +import { SearchPage } from '@/pages/Search/SearchPage' +import { ReportsPage } from '@/pages/Reports/ReportsPage' +import { AuditLogPage } from '@/pages/AuditLog/AuditLogPage' +import { TemplatesPage } from '@/pages/Templates/TemplatesPage' +import { RoutingRulesPage } from '@/pages/RoutingRules/RoutingRulesPage' +import { ContactsPage } from '@/pages/Contacts/ContactsPage' +import { DeadlinesPage } from '@/pages/Deadlines/DeadlinesPage' /** * Routing principale dell'applicazione PEChub. @@ -44,16 +51,22 @@ export default function App() {
+
+ )}
+ + Conservazione +
+
+
+
+
{/* ── Nuova PEC ── */}
+
+ cn(
+ 'flex items-center gap-3 px-3 py-2 rounded-lg text-sm font-medium transition-colors',
+ isActive
+ ? 'bg-blue-600 text-white'
+ : 'text-gray-300 hover:bg-gray-700 hover:text-white',
+ collapsed && 'justify-center px-2',
+ )
+ }
+ title={collapsed ? 'Scadenzario' : undefined}
+ >
+
+
+ cn(
+ 'flex items-center gap-3 px-3 py-2 rounded-lg text-sm font-medium transition-colors',
+ isActive
+ ? 'bg-blue-600 text-white'
+ : 'text-gray-300 hover:bg-gray-700 hover:text-white',
+ collapsed && 'justify-center px-2',
+ )
+ }
+ title={collapsed ? 'Rubrica PEC' : undefined}
+ >
+
+
+ cn(
+ 'flex items-center gap-3 px-3 py-2 rounded-lg text-sm font-medium transition-colors',
+ isActive
+ ? 'bg-blue-600 text-white'
+ : 'text-gray-300 hover:bg-gray-700 hover:text-white',
+ collapsed && 'justify-center px-2',
+ )
+ }
+ title={collapsed ? 'Ricerca avanzata' : undefined}
+ >
+
+
+ cn(
+ 'flex items-center gap-3 px-3 py-2 rounded-lg text-sm font-medium transition-colors',
+ isActive
+ ? 'bg-blue-600 text-white'
+ : 'text-gray-300 hover:bg-gray-700 hover:text-white',
+ collapsed && 'justify-center px-2',
+ )
+ }
+ title={collapsed ? 'Dashboard / Report' : undefined}
+ >
+
+
+
@@ -346,6 +501,40 @@ export function Sidebar() {
+ {/* ── Sezione Supervisione – visibile solo ai supervisor ── */}
+ {isSupervisor && (
+
+ {!collapsed && (
+ <>
+
+
+ )}
+
{/* ── Sezione Amministrazione ── */}
{isAdmin && (
+ Supervisione +
+ + )} + {collapsed && } + +
+
+ cn(
+ 'flex items-center gap-3 px-3 py-2 rounded-lg text-sm font-medium transition-colors',
+ isActive
+ ? 'bg-cyan-700 text-white'
+ : 'text-cyan-300 hover:bg-cyan-900/40 hover:text-white',
+ collapsed && 'justify-center px-2',
+ )
+ }
+ title={collapsed ? 'Caselle PEC' : undefined}
+ >
+
+
+
@@ -365,7 +554,10 @@ export function Sidebar() {
{ to: '/users', label: 'Utenti', icon: Users },
{ to: '/permissions', label: 'Permessi', icon: Shield },
{ to: '/virtual-boxes', label: 'Virtual Box', icon: Filter },
+ { to: '/routing-rules', label: 'Regole smistamento', icon: Settings2 },
+ { to: '/templates', label: 'Template messaggi', icon: FileText },
{ to: '/notifications', label: 'Notifiche', icon: Bell },
+ { to: '/audit-log', label: 'Audit Log', icon: ClipboardList },
] as const).map((item) => (
void
+ unreadCount?: number
}
/** Colore del pallino di stato casella */
@@ -493,10 +686,12 @@ function statusDot(status: MailboxResponse['status']): string {
}
}
-function MailboxNavItem({ mailbox, collapsed, isExpanded, onToggle }: MailboxNavItemProps) {
+function MailboxNavItem({ mailbox, collapsed, isExpanded, onToggle, unreadCount = 0 }: MailboxNavItemProps) {
const displayName = mailbox.display_name || mailbox.email_address
const initial = displayName[0]?.toUpperCase() ?? '?'
const dotClass = statusDot(mailbox.status)
+ const { isAdmin, isSupervisor } = useAuth()
+ const canSeeConservation = isAdmin || isSupervisor
/* ── Modalità compressa: solo avatar/iniziale → link diretto all'inbox ── */
if (collapsed) {
@@ -511,7 +706,7 @@ function MailboxNavItem({ mailbox, collapsed, isExpanded, onToggle }: MailboxNav
: 'text-gray-300 hover:bg-gray-700 hover:text-white',
)
}
- title={displayName}
+ title={`${displayName}${unreadCount > 0 ? ` (${unreadCount} non letti)` : ''}`}
>
+ cn(
+ 'flex items-center gap-2 px-2 py-1.5 rounded-md text-xs font-medium transition-colors',
+ isActive
+ ? 'bg-blue-600 text-white'
+ : 'text-gray-400 hover:bg-gray-700 hover:text-white',
+ )
+ }
+ >
+
+
+ {/* Conservazione (solo admin/supervisor) */}
+ {canSeeConservation && (
+ <>
+
+ cn(
+ 'flex items-center gap-2 px-2 py-1.5 rounded-md text-xs font-medium transition-colors',
+ isActive
+ ? 'bg-teal-700 text-white'
+ : 'text-teal-400 hover:bg-teal-900/40 hover:text-white',
+ )
+ }
+ >
+
+
+ cn(
+ 'flex items-center gap-2 px-2 py-1.5 rounded-md text-xs font-medium transition-colors',
+ isActive
+ ? 'bg-teal-700 text-white'
+ : 'text-teal-400 hover:bg-teal-900/40 hover:text-white',
+ )
+ }
+ >
+
+
+ )}
)}
diff --git a/frontend/src/components/ReceiptTree/ReceiptTree.tsx b/frontend/src/components/ReceiptTree/ReceiptTree.tsx
index 44f7e3a..601b89b 100644
--- a/frontend/src/components/ReceiptTree/ReceiptTree.tsx
+++ b/frontend/src/components/ReceiptTree/ReceiptTree.tsx
@@ -1,5 +1,6 @@
-import { ChevronDown, ChevronRight, Mail } from 'lucide-react'
+import { ChevronDown, ChevronRight, Mail, ExternalLink } from 'lucide-react'
import { useState } from 'react'
+import { useNavigate } from 'react-router-dom'
import { PecTypeBadge, PecStateBadge } from '@/components/PecBadge/PecBadge'
import { formatDate } from '@/lib/utils'
import type { MessageResponse } from '@/types/api.types'
@@ -12,9 +13,11 @@ interface ReceiptTreeProps {
/**
* Visualizza la gerarchia delle ricevute PEC collegate a un messaggio.
* Mostra in ordine cronologico: accettazione → consegna (o anomalia).
+ * Le ricevute sono cliccabili e navigano al dettaglio del messaggio ricevuta.
*/
export function ReceiptTree({ message, receipts }: ReceiptTreeProps) {
const [expanded, setExpanded] = useState(true)
+ const navigate = useNavigate()
if (receipts.length === 0) {
if (message.direction === 'outbound') {
@@ -66,6 +69,7 @@ export function ReceiptTree({ message, receipts }: ReceiptTreeProps) {
date={receipt.received_at || receipt.created_at}
type={receipt.pec_type}
messageId={receipt.id}
+ onClick={() => navigate(`/messages/${receipt.id}`)}
/>
))}
@@ -81,25 +85,41 @@ interface ReceiptNodeProps {
type?: MessageResponse['pec_type']
messageId?: string
isRoot?: boolean
+ onClick?: () => void
}
-function ReceiptNode({ label, date, state, type, isRoot }: ReceiptNodeProps) {
- return (
+function ReceiptNode({ label, date, state, type, isRoot, onClick }: ReceiptNodeProps) {
+ const isClickable = !!onClick
+
+ const content = (
@@ -523,6 +718,11 @@ function MailboxNavItem({ mailbox, collapsed, isExpanded, onToggle }: MailboxNav
dotClass,
)}
/>
+ {unreadCount > 0 && (
+
+ {unreadCount > 9 ? '9+' : unreadCount}
+
+ )}
)
@@ -554,6 +754,13 @@ function MailboxNavItem({ mailbox, collapsed, isExpanded, onToggle }: MailboxNav
{displayName}
+ {/* Badge non letti per casella */}
+ {unreadCount > 0 && (
+
+ {unreadCount > 99 ? '99+' : unreadCount}
+
+ )}
+
{/* Chevron espandi/comprimi */}
{/* Indicatore timeline */}
)
+
+ if (isClickable) {
+ return (
+
+ )
+ }
+
+ return
- {label}
+
+ {label}
+
{state && !isRoot &&
{date && (
{formatDate(date)}
@@ -107,4 +127,19 @@ function ReceiptNode({ label, date, state, type, isRoot }: ReceiptNodeProps) {{content}
}
diff --git a/frontend/src/hooks/useAuth.ts b/frontend/src/hooks/useAuth.ts
index 621fc32..d658db7 100644
--- a/frontend/src/hooks/useAuth.ts
+++ b/frontend/src/hooks/useAuth.ts
@@ -2,6 +2,14 @@ import { useAuthStore } from '@/store/auth.store'
/**
* Hook helper per accedere all'utente corrente e ai permessi.
+ *
+ * Gerarchia ruoli:
+ * super_admin > admin > supervisor > operator > readonly
+ *
+ * Supervisor:
+ * - Lettura implicita su tutte le caselle del tenant
+ * - Invio solo se ha permesso esplicito can_send sulla casella
+ * - Non puo' gestire caselle, utenti, permessi o impostazioni
*/
export function useAuth() {
const user = useAuthStore((s) => s.user)
@@ -11,6 +19,8 @@ export function useAuth() {
const isAdmin = user?.role === 'admin' || user?.role === 'super_admin'
const isSuperAdmin = user?.role === 'super_admin'
+ const isSupervisor = user?.role === 'supervisor'
+ const isSupervisorOrAdmin = isAdmin || isSupervisor
const canSend = user?.role !== 'readonly'
const canManage = isAdmin
@@ -20,6 +30,8 @@ export function useAuth() {
isLoading,
isAdmin,
isSuperAdmin,
+ isSupervisor,
+ isSupervisorOrAdmin,
canSend,
canManage,
logout,
diff --git a/frontend/src/pages/AuditLog/AuditLogPage.tsx b/frontend/src/pages/AuditLog/AuditLogPage.tsx
new file mode 100644
index 0000000..38234e2
--- /dev/null
+++ b/frontend/src/pages/AuditLog/AuditLogPage.tsx
@@ -0,0 +1,338 @@
+/**
+ * Pagina Audit Log – visualizzazione eventi di sistema.
+ *
+ * Accessibile solo ad admin e super_admin.
+ * Mostra una tabella paginata con filtri per data, azione ed esito.
+ */
+
+import { useState } from 'react'
+import { useQuery } from '@tanstack/react-query'
+import { format } from 'date-fns'
+import { it } from 'date-fns/locale'
+import { ShieldCheck, AlertCircle, Search, RotateCcw } from 'lucide-react'
+import { auditLogApi } from '@/api/audit_log.api'
+import type { AuditLogParams } from '@/api/audit_log.api'
+import { cn } from '@/lib/utils'
+
+// ─── Badge esito ──────────────────────────────────────────────────────────────
+
+function OutcomeBadge({ outcome }: { outcome: string }) {
+ const isSuccess = outcome === 'success'
+ return (
+
+ {isSuccess ? (
+
+ {/* Intestazione */}
+
+ )
+}
diff --git a/frontend/src/pages/Compose/ComposePage.tsx b/frontend/src/pages/Compose/ComposePage.tsx
index 53dbb1f..a08faa7 100644
--- a/frontend/src/pages/Compose/ComposePage.tsx
+++ b/frontend/src/pages/Compose/ComposePage.tsx
@@ -50,24 +50,46 @@ export function ComposePage() {
const navigate = useNavigate()
const location = useLocation()
const replyTo = location.state?.replyTo as MessageResponse | undefined
+ const forwardOf = location.state?.forwardOf as MessageResponse | undefined
const [showCc, setShowCc] = useState(false)
const fileInputRef = useRef
+
+
+ {/* Filtri */}
+ Audit Log
++ Registro cronologico degli eventi di sistema e delle operazioni degli utenti. +
+
+
+
+ {/* Tabella */}
+
+ {/* Azione */}
+
+
+ {/* Bottoni */}
+
+
+
+
+
+ {/* Esito */}
+
+
+
+
+
+ {/* Data da */}
+
+
+ setFilterDateFrom(e.target.value)}
+ className="w-full rounded-md border border-gray-300 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
+ />
+
+
+ {/* Data a */}
+
+
+ setFilterDateTo(e.target.value)}
+ className="w-full rounded-md border border-gray-300 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
+ />
+
+
+
+
+
+
+ {/* Header tabella con count */}
+
+
+
+ {isLoading ? 'Caricamento...' : `${total.toLocaleString('it-IT')} eventi trovati`}
+
+ {total > 0 && (
+
+ Pagina {page} di {pages}
+
+ )}
+
+
+ {/* Stato errore */}
+ {isError && (
+
+
+ )}
+
+ {/* Stato vuoto */}
+ {!isLoading && !isError && items.length === 0 && (
+ Errore nel caricamento dei dati.
+
+
+ )}
+
+ {/* Dati */}
+ {items.length > 0 && (
+ Nessun evento trovato.
+
+
+
+
+
+ )}
+
+ {/* Paginazione */}
+ {pages > 1 && (
+ | + Data / Ora + | ++ Azione + | ++ Esito + | ++ Risorsa + | ++ IP + | ++ Utente + | +
|---|---|---|---|---|---|
| + {format(new Date(entry.occurred_at), 'dd/MM/yyyy HH:mm:ss', { locale: it })} + | + + {/* Azione */} ++ + {actionLabel(entry.action)} + + + ({entry.action}) + + | + + {/* Esito */} +
+ |
+
+ {/* Risorsa */}
+ + {entry.resource_type ? ( + + {entry.resource_type} + {entry.resource_id && ( + + {entry.resource_id.split('-')[0]}... + + )} + + ) : ( + — + )} + | + + {/* IP */} ++ {entry.ip_address ?? —} + | + + {/* Utente (UUID abbreviato) */} ++ {entry.user_id ? ( + + {entry.user_id.split('-')[0]}... + + ) : ( + — + )} + | +
+
+
+ {page} / {pages}
+
+
+
+ )}
+ ', - `
In risposta al messaggio del ${date}
`, - `Da: ${replyTo.from_address || ''}
`, - `A: ${replyTo.to_addresses?.join(', ') || ''}
`, - `Oggetto: ${replyTo.subject || ''}
`, - ].join('') + if (replyTo) { + const date = new Date( + replyTo.received_at || replyTo.created_at + ).toLocaleDateString('it-IT') + return [ + '', + '', + '', + `
In risposta al messaggio del ${date}
`, + `Da: ${replyTo.from_address || ''}
`, + `A: ${replyTo.to_addresses?.join(', ') || ''}
`, + `Oggetto: ${replyTo.subject || ''}
`, + ].join('') + } + if (forwardOf) { + const date = new Date( + forwardOf.received_at || forwardOf.sent_at || forwardOf.created_at + ).toLocaleDateString('it-IT') + const bodyContent = forwardOf.body_text + ? `${forwardOf.body_text}`
+ : ''
+ return [
+ '',
+ '',
+ '', + `
Messaggio inoltrato
`, + `Da: ${forwardOf.from_address || ''}
`, + `A: ${forwardOf.to_addresses?.join(', ') || ''}
`, + `Data: ${date}
`, + `Oggetto: ${forwardOf.subject || ''}
`, + bodyContent, + ].join('') + } + return '' }) // Allegati @@ -80,12 +102,16 @@ export function ComposePage() { formState: { errors }, } = useForm- {replyTo ? 'Rispondi a PEC' : 'Nuova PEC'} + {replyTo ? 'Rispondi a PEC' : forwardOf ? 'Inoltra PEC' : 'Nuova PEC'}
{replyTo && (In risposta a: {replyTo.subject}
)} + {forwardOf && ( ++ Inoltro di: {forwardOf.subject} +
+ )}
+
+ )}
+
{/* Casella mittente */}
+ Il messaggio originale contiene allegati. Per includerli nell'inoltro, + scaricali dal messaggio originale e aggiungili qui manualmente. +
+
diff --git a/frontend/src/pages/Contacts/ContactsPage.tsx b/frontend/src/pages/Contacts/ContactsPage.tsx
new file mode 100644
index 0000000..c298f9a
--- /dev/null
+++ b/frontend/src/pages/Contacts/ContactsPage.tsx
@@ -0,0 +1,282 @@
+import { useState, useRef } from 'react'
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
+import { Plus, Search, Star, Trash2, Pencil, Upload, BookUser, Building2 } from 'lucide-react'
+import toast from 'react-hot-toast'
+import { Button } from '@/components/ui/Button'
+import { Input } from '@/components/ui/Input'
+import { Label } from '@/components/ui/Label'
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/Dialog'
+import { contactsApi, type PecContactResponse, type PecContactCreate, type PecContactUpdate } from '@/api/contacts.api'
+import { getErrorMessage } from '@/api/client'
+import { formatDate } from '@/lib/utils'
+
+export function ContactsPage() {
+ const queryClient = useQueryClient()
+ const [q, setQ] = useState('')
+ const [page] = useState(1)
+ const [showForm, setShowForm] = useState(false)
+ const [editing, setEditing] = useState(null)
+ const fileInputRef = useRef(null)
+
+ // Form state
+ const [formEmail, setFormEmail] = useState('')
+ const [formName, setFormName] = useState('')
+ const [formOrg, setFormOrg] = useState('')
+ const [formNotes, setFormNotes] = useState('')
+ const [formFavorite, setFormFavorite] = useState(false)
+
+ const { data, isLoading } = useQuery({
+ queryKey: ['contacts', q, page],
+ queryFn: () => contactsApi.list({ q: q || undefined, page, page_size: 50 }),
+ })
+
+ const createMutation = useMutation({
+ mutationFn: (d: PecContactCreate) => contactsApi.create(d),
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: ['contacts'] })
+ toast.success('Contatto aggiunto')
+ closeForm()
+ },
+ onError: (e) => toast.error(getErrorMessage(e)),
+ })
+
+ const updateMutation = useMutation({
+ mutationFn: ({ id, data }: { id: string; data: PecContactUpdate }) =>
+ contactsApi.update(id, data),
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: ['contacts'] })
+ toast.success('Contatto aggiornato')
+ closeForm()
+ },
+ onError: (e) => toast.error(getErrorMessage(e)),
+ })
+
+ const deleteMutation = useMutation({
+ mutationFn: (id: string) => contactsApi.delete(id),
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: ['contacts'] })
+ toast.success('Contatto eliminato')
+ },
+ onError: (e) => toast.error(getErrorMessage(e)),
+ })
+
+ const importMutation = useMutation({
+ mutationFn: (file: File) => contactsApi.importCsv(file),
+ onSuccess: (res) => {
+ queryClient.invalidateQueries({ queryKey: ['contacts'] })
+ toast.success(`Importati: ${res.created} nuovi, ${res.updated} aggiornati, ${res.skipped} saltati`)
+ },
+ onError: (e) => toast.error(getErrorMessage(e)),
+ })
+
+ const toggleFavMutation = useMutation({
+ mutationFn: ({ id, fav }: { id: string; fav: boolean }) =>
+ contactsApi.update(id, { is_favorite: fav }),
+ onSuccess: () => queryClient.invalidateQueries({ queryKey: ['contacts'] }),
+ onError: (e) => toast.error(getErrorMessage(e)),
+ })
+
+ const openCreate = () => {
+ setEditing(null)
+ setFormEmail('')
+ setFormName('')
+ setFormOrg('')
+ setFormNotes('')
+ setFormFavorite(false)
+ setShowForm(true)
+ }
+
+ const openEdit = (c: PecContactResponse) => {
+ setEditing(c)
+ setFormEmail(c.email)
+ setFormName(c.name ?? '')
+ setFormOrg(c.organization ?? '')
+ setFormNotes(c.notes ?? '')
+ setFormFavorite(c.is_favorite)
+ setShowForm(true)
+ }
+
+ const closeForm = () => {
+ setShowForm(false)
+ setEditing(null)
+ }
+
+ const handleSubmit = () => {
+ if (!formEmail.trim()) return toast.error('L\'email e\' obbligatoria')
+ const payload = {
+ email: formEmail.trim(),
+ name: formName.trim() || null,
+ organization: formOrg.trim() || null,
+ notes: formNotes.trim() || null,
+ is_favorite: formFavorite,
+ }
+ if (editing) {
+ updateMutation.mutate({ id: editing.id, data: payload })
+ } else {
+ createMutation.mutate(payload)
+ }
+ }
+
+ const handleFileChange = (e: React.ChangeEvent) => {
+ const file = e.target.files?.[0]
+ if (file) {
+ importMutation.mutate(file)
+ e.target.value = ''
+ }
+ }
+
+ const items = data?.items ?? []
+ const total = data?.total ?? 0
+
+ return (
+ >(new Set())
// ── Stato dialog tag bulk ────────────────────────────────────────────────────
const [showTagSelector, setShowTagSelector] = useState(false)
- // Resetta lo stato UI ogni volta che si cambia casella, virtual box o cartella
useEffect(() => {
setSearchInput('')
setDebouncedSearch('')
setIsReadFilter(undefined)
setIsStarredFilter(undefined)
+ setDateFrom('')
+ setDateTo('')
+ setPecTypeFilter('')
+ setPecStateFilter('')
+ setShowAdvancedFilters(false)
setPage(1)
setSelectedIds(new Set())
}, [mailboxId, vboxId, viewMode])
- // Debounce della ricerca
useEffect(() => {
const timer = setTimeout(() => {
setDebouncedSearch(searchInput)
@@ -112,7 +138,6 @@ export function InboxPage({ viewMode }: InboxPageProps) {
? mailboxesData?.items.find((m) => m.id === mailboxId)
: undefined
- // ── Virtual Box corrente (per breadcrumb) ────────────────────────────────────
const { data: myVboxes = [] } = useQuery({
queryKey: ['virtual-boxes', 'my'],
queryFn: () => virtualBoxesApi.myVirtualBoxes(),
@@ -124,41 +149,69 @@ export function InboxPage({ viewMode }: InboxPageProps) {
? myVboxes.find((v) => v.id === vboxId)
: undefined
+ // ── Reset pagina per filtri avanzati ─────────────────────────────────────────
+ useEffect(() => {
+ setPage(1)
+ }, [dateFrom, dateTo, pecTypeFilter])
+
// ── Query messaggi ───────────────────────────────────────────────────────────
const queryFilters = (() => {
- const base = {
+ const advancedBase = {
vbox_id: vboxId,
mailbox_id: mailboxId,
search: debouncedSearch || undefined,
+ pec_type: pecTypeFilter || undefined,
+ state: pecStateFilter || undefined,
+ date_from: dateFrom ? new Date(dateFrom).toISOString() : undefined,
+ date_to: dateTo ? new Date(dateTo + 'T23:59:59').toISOString() : undefined,
page,
page_size: PAGE_SIZE,
}
switch (viewMode) {
case 'inbox':
return {
- ...base,
+ ...advancedBase,
direction: 'inbound' as const,
is_read: isReadFilter,
is_starred: isStarredFilter,
is_archived: false,
+ is_trashed: false,
}
case 'sent':
return {
- ...base,
+ ...advancedBase,
direction: 'outbound' as const,
is_starred: isStarredFilter,
is_archived: false,
+ is_trashed: false,
}
case 'starred':
return {
- ...base,
+ ...advancedBase,
is_starred: true,
is_archived: false,
+ is_trashed: false,
}
case 'archived':
return {
- ...base,
+ ...advancedBase,
is_archived: true,
+ is_trashed: false,
+ }
+ case 'trash':
+ return {
+ ...advancedBase,
+ is_trashed: true,
+ }
+ case 'conservation_pending':
+ return {
+ ...advancedBase,
+ is_pending_conservation: true,
+ }
+ case 'conservation_archived':
+ return {
+ ...advancedBase,
+ is_conserved: true,
}
}
})()
@@ -178,7 +231,6 @@ export function InboxPage({ viewMode }: InboxPageProps) {
const total = messagesData?.total || 0
const totalPages = Math.ceil(total / PAGE_SIZE)
- // ── Invalida query messaggi dopo operazioni ──────────────────────────────────
const invalidateMessages = useCallback(() => {
queryClient.invalidateQueries({ queryKey: ['messages'] })
}, [queryClient])
@@ -200,6 +252,25 @@ export function InboxPage({ viewMode }: InboxPageProps) {
},
})
+ // ── Segna come DA leggere (unread) ───────────────────────────────────────────
+ const markUnreadMutation = useMutation({
+ mutationFn: (id: string) => messagesApi.markUnread(id),
+ onSuccess: (updatedMsg) => {
+ queryClient.setQueryData(
+ ['messages', queryFilters],
+ (old: { items: MessageResponse[]; total: number } | undefined) => {
+ if (!old) return old
+ return {
+ ...old,
+ items: old.items.map((m) => (m.id === updatedMsg.id ? updatedMsg : m)),
+ }
+ },
+ )
+ toast.success('Messaggio segnato come da leggere')
+ },
+ onError: (error) => toast.error(getErrorMessage(error)),
+ })
+
// ── Toggle stella singolo ────────────────────────────────────────────────────
const toggleStarMutation = useMutation({
mutationFn: ({ id, starred }: { id: string; starred: boolean }) =>
@@ -209,7 +280,6 @@ export function InboxPage({ viewMode }: InboxPageProps) {
['messages', queryFilters],
(old: { items: MessageResponse[]; total: number } | undefined) => {
if (!old) return old
- // In vista "starred" rimuoviamo il messaggio se è stato rimosso dai preferiti
if (viewMode === 'starred' && !updatedMsg.is_starred) {
return { ...old, items: old.items.filter((m) => m.id !== updatedMsg.id), total: old.total - 1 }
}
@@ -226,7 +296,6 @@ export function InboxPage({ viewMode }: InboxPageProps) {
mutationFn: ({ id, archived }: { id: string; archived: boolean }) =>
archived ? messagesApi.archive(id) : messagesApi.unarchive(id),
onSuccess: (updatedMsg, { archived }) => {
- // Rimuove il messaggio dalla lista corrente (ha cambiato "stanza")
queryClient.setQueryData(
['messages', queryFilters],
(old: { items: MessageResponse[]; total: number } | undefined) => {
@@ -240,6 +309,42 @@ export function InboxPage({ viewMode }: InboxPageProps) {
onError: (error) => toast.error(getErrorMessage(error)),
})
+ // ── Cestino/Ripristina singolo ────────────────────────────────────────────────
+ const trashMutation = useMutation({
+ mutationFn: ({ id, trashed }: { id: string; trashed: boolean }) =>
+ trashed ? messagesApi.trash(id) : messagesApi.untrash(id),
+ onSuccess: (updatedMsg, { trashed }) => {
+ queryClient.setQueryData(
+ ['messages', queryFilters],
+ (old: { items: MessageResponse[]; total: number } | undefined) => {
+ if (!old) return old
+ return { ...old, items: old.items.filter((m) => m.id !== updatedMsg.id), total: old.total - 1 }
+ },
+ )
+ toast.success(trashed ? 'Messaggio spostato nel cestino' : 'Messaggio ripristinato dal cestino')
+ invalidateMessages()
+ },
+ onError: (error) => toast.error(getErrorMessage(error)),
+ })
+
+ // ── Conservazione/Rimozione singolo ───────────────────────────────────────────
+ const conserveMutation = useMutation({
+ mutationFn: ({ id, conserve }: { id: string; conserve: boolean }) =>
+ conserve ? messagesApi.conserve(id) : messagesApi.unconserve(id),
+ onSuccess: (updatedMsg, { conserve }) => {
+ queryClient.setQueryData(
+ ['messages', queryFilters],
+ (old: { items: MessageResponse[]; total: number } | undefined) => {
+ if (!old) return old
+ return { ...old, items: old.items.filter((m) => m.id !== updatedMsg.id), total: old.total - 1 }
+ },
+ )
+ toast.success(conserve ? 'Messaggio inviato in Da Conservare' : 'Messaggio rimosso da Da Conservare')
+ invalidateMessages()
+ },
+ onError: (error) => toast.error(getErrorMessage(error)),
+ })
+
// ── Azioni bulk ──────────────────────────────────────────────────────────────
const bulkMutation = useMutation({
mutationFn: messagesApi.bulkUpdate,
@@ -247,10 +352,15 @@ export function InboxPage({ viewMode }: InboxPageProps) {
invalidateMessages()
setSelectedIds(new Set())
const n = result.updated
- if (payload.is_starred === true) toast.success(`${n} ${n === 1 ? 'messaggio aggiunto' : 'messaggi aggiunti'} ai preferiti`)
+ if (payload.is_read === false) toast.success(`${n} ${n === 1 ? 'messaggio segnato' : 'messaggi segnati'} come da leggere`)
+ else if (payload.is_starred === true) toast.success(`${n} ${n === 1 ? 'messaggio aggiunto' : 'messaggi aggiunti'} ai preferiti`)
else if (payload.is_starred === false) toast.success(`${n} ${n === 1 ? 'messaggio rimosso' : 'messaggi rimossi'} dai preferiti`)
else if (payload.is_archived === true) toast.success(`${n} ${n === 1 ? 'messaggio archiviato' : 'messaggi archiviati'}`)
else if (payload.is_archived === false) toast.success(`${n} ${n === 1 ? 'messaggio ripristinato' : 'messaggi ripristinati'}`)
+ else if (payload.is_trashed === true) toast.success(`${n} ${n === 1 ? 'messaggio spostato nel cestino' : 'messaggi spostati nel cestino'}`)
+ else if (payload.is_trashed === false) toast.success(`${n} ${n === 1 ? 'messaggio ripristinato dal cestino' : 'messaggi ripristinati dal cestino'}`)
+ else if (payload.is_pending_conservation === true) toast.success(`${n} ${n === 1 ? 'messaggio inviato' : 'messaggi inviati'} in Da Conservare`)
+ else if (payload.is_pending_conservation === false) toast.success(`${n} ${n === 1 ? 'messaggio rimosso' : 'messaggi rimossi'} da Da Conservare`)
},
onError: (error) => toast.error(getErrorMessage(error)),
})
@@ -280,6 +390,8 @@ export function InboxPage({ viewMode }: InboxPageProps) {
})
}
+ const handleBulkMarkUnread = () =>
+ bulkMutation.mutate({ ids: Array.from(selectedIds), is_read: false })
const handleBulkStar = () =>
bulkMutation.mutate({ ids: Array.from(selectedIds), is_starred: true })
const handleBulkUnstar = () =>
@@ -288,6 +400,14 @@ export function InboxPage({ viewMode }: InboxPageProps) {
bulkMutation.mutate({ ids: Array.from(selectedIds), is_archived: true })
const handleBulkUnarchive = () =>
bulkMutation.mutate({ ids: Array.from(selectedIds), is_archived: false })
+ const handleBulkTrash = () =>
+ bulkMutation.mutate({ ids: Array.from(selectedIds), is_trashed: true })
+ const handleBulkUntrash = () =>
+ bulkMutation.mutate({ ids: Array.from(selectedIds), is_trashed: false })
+ const handleBulkConserve = () =>
+ bulkMutation.mutate({ ids: Array.from(selectedIds), is_pending_conservation: true })
+ const handleBulkUnconserve = () =>
+ bulkMutation.mutate({ ids: Array.from(selectedIds), is_pending_conservation: false })
// ── Selezione ────────────────────────────────────────────────────────────────
const handleToggleSelect = (id: string, e: React.MouseEvent) => {
@@ -330,21 +450,20 @@ export function InboxPage({ viewMode }: InboxPageProps) {
// ── Label e icone folder ────────────────────────────────────────────────────
const isInbound = viewMode === 'inbox'
const folderLabel =
- viewMode === 'inbox'
- ? 'Posta in Arrivo'
- : viewMode === 'sent'
- ? 'Posta Inviata'
- : viewMode === 'starred'
- ? 'Preferiti'
- : 'Archiviati'
+ viewMode === 'inbox' ? 'Posta in Arrivo'
+ : viewMode === 'sent' ? 'Posta Inviata'
+ : viewMode === 'starred' ? 'Preferiti'
+ : viewMode === 'archived' ? 'Archiviati'
+ : viewMode === 'trash' ? 'Cestino'
+ : viewMode === 'conservation_pending' ? 'Da Conservare'
+ : 'Storico Conservazione'
const FolderIcon =
- viewMode === 'inbox'
- ? Inbox
- : viewMode === 'sent'
- ? Send
- : viewMode === 'starred'
- ? Star
- : Archive
+ viewMode === 'inbox' ? Inbox
+ : viewMode === 'sent' ? Send
+ : viewMode === 'starred' ? Star
+ : viewMode === 'archived' ? Archive
+ : viewMode === 'trash' ? Trash2
+ : ShieldCheck
const selectedCount = selectedIds.size
const allSelected = messages.length > 0 && selectedCount === messages.length
@@ -396,10 +515,12 @@ export function InboxPage({ viewMode }: InboxPageProps) {
@@ -440,13 +561,107 @@ export function InboxPage({ viewMode }: InboxPageProps) {
Preferiti
)}
+
+ {/* Pulsante filtri avanzati */}
+
+
+ {/* ── Pannello filtri avanzati ── */}
+ {showAdvancedFilters && (
+
+
+ )
+}
diff --git a/frontend/src/pages/Deadlines/DeadlinesPage.tsx b/frontend/src/pages/Deadlines/DeadlinesPage.tsx
new file mode 100644
index 0000000..358550d
--- /dev/null
+++ b/frontend/src/pages/Deadlines/DeadlinesPage.tsx
@@ -0,0 +1,190 @@
+import { useState } from 'react'
+import { useQuery } from '@tanstack/react-query'
+import { useNavigate } from 'react-router-dom'
+import { Calendar, AlertTriangle, Clock, CheckCircle2, ExternalLink } from 'lucide-react'
+import { Button } from '@/components/ui/Button'
+import { deadlinesApi, type DeadlineMessageResponse } from '@/api/deadlines.api'
+import { formatDate } from '@/lib/utils'
+
+function groupDeadlines(items: DeadlineMessageResponse[]) {
+ const now = new Date()
+ const todayEnd = new Date(now)
+ todayEnd.setHours(23, 59, 59, 999)
+ const weekEnd = new Date(now)
+ weekEnd.setDate(weekEnd.getDate() + 7)
+ const monthEnd = new Date(now)
+ monthEnd.setDate(monthEnd.getDate() + 30)
+
+ const overdue: DeadlineMessageResponse[] = []
+ const today: DeadlineMessageResponse[] = []
+ const thisWeek: DeadlineMessageResponse[] = []
+ const later: DeadlineMessageResponse[] = []
+
+ for (const item of items) {
+ if (!item.deadline_at) continue
+ const d = new Date(item.deadline_at)
+ if (d < now) {
+ overdue.push(item)
+ } else if (d <= todayEnd) {
+ today.push(item)
+ } else if (d <= weekEnd) {
+ thisWeek.push(item)
+ } else {
+ later.push(item)
+ }
+ }
+ return { overdue, today, thisWeek, later }
+}
+
+function DeadlineItem({ item }: { item: DeadlineMessageResponse }) {
+ const navigate = useNavigate()
+ const deadlineDate = item.deadline_at ? new Date(item.deadline_at) : null
+
+ return (
+
+
+
+
+
+ Rubrica PEC
++ {total} contatti nella rubrica +
+
+
+
+
+
+
+
+
+
+
+
+
+ {isLoading ? (
+
+
+
+ ) : items.length === 0 ? (
+
+
+ ) : (
+ Nessun contatto trovato
++ Aggiungi contatti manualmente o importa un CSV con colonne: email, name, organization +
+
+
+
+
+
+ )}
+ | Email PEC | +Nome | +Organizzazione | +Tipo | +Aggiornato | ++ |
|---|---|---|---|---|---|
| {c.email} | +{c.name ?? '-'} | +
+ {c.organization ? (
+
+ |
+ + + {c.auto_saved ? 'Automatico' : 'Manuale'} + + | +{formatDate(c.updated_at)} | +
+
+
+
+
+
+ |
+
navigate(`/messages/${item.id}`)}
+ >
+
+ )
+}
+
+function DeadlineGroup({ title, items, icon: Icon, color }: {
+ title: string
+ items: DeadlineMessageResponse[]
+ icon: React.ComponentType<{ className?: string }>
+ color: string
+}) {
+ if (items.length === 0) return null
+ return (
+
+ {item.is_overdue ? (
+
+
+
+ {item.subject || '(nessun oggetto)'}
++ {item.direction === 'inbound' ? `Da: ${item.from_address}` : `A: ${(item.to_addresses ?? []).join(', ')}`} +
+ {item.deadline_note && ( +{item.deadline_note}
+ )} +
+
+ + {deadlineDate ? formatDate(deadlineDate.toISOString()) : '-'} +
+ {item.is_overdue && ( +Scaduto
+ )} +
+
+ )
+}
+
+export function DeadlinesPage() {
+ const [daysAhead, setDaysAhead] = useState(30)
+ const [includeOverdue, setIncludeOverdue] = useState(true)
+
+ const { data = [], isLoading } = useQuery({
+ queryKey: ['deadlines', daysAhead, includeOverdue],
+ queryFn: () => deadlinesApi.list({ days_ahead: daysAhead, include_overdue: includeOverdue }),
+ })
+
+ const groups = groupDeadlines(data)
+ const total = data.length
+
+ return (
+
+
+ {title} ({items.length})
+
+ {items.map((item) => (
+
+
+
+ )
+}
diff --git a/frontend/src/pages/Inbox/InboxPage.tsx b/frontend/src/pages/Inbox/InboxPage.tsx
index 4a99c74..0b03a74 100644
--- a/frontend/src/pages/Inbox/InboxPage.tsx
+++ b/frontend/src/pages/Inbox/InboxPage.tsx
@@ -1,17 +1,18 @@
/**
- * InboxPage – visualizza la posta in arrivo, inviata, preferiti o archiviata.
+ * InboxPage – visualizza la posta in arrivo, inviata, preferiti, archiviata o cestino.
*
- * Può operare in quattro modalità (viewMode):
- * - 'inbox' → Posta in Arrivo (solo inbound, is_archived=false)
- * - 'sent' → Posta Inviata (solo outbound, is_archived=false)
- * - 'starred' → Preferiti (tutte le direzioni, is_starred=true)
- * - 'archived' → Archiviati (tutte le direzioni, is_archived=true)
+ * Modalita' (viewMode):
+ * - 'inbox' → Posta in Arrivo (solo inbound, is_archived=false, is_trashed=false)
+ * - 'sent' → Posta Inviata (solo outbound, is_archived=false, is_trashed=false)
+ * - 'starred' → Preferiti (is_starred=true, is_trashed=false)
+ * - 'archived' → Archiviati (is_archived=true, is_trashed=false)
+ * - 'trash' → Cestino (is_trashed=true)
*
- * Funzionalità:
+ * Funzionalita':
* - Selezione singola e multipla tramite checkbox
- * - Barra azioni bulk (stella, rimuovi stella, archivia, rimuovi archivio, assegna tag)
- * - Pulsanti azione rapida su hover di ogni riga (stella, archivia)
- * - Badge tag colorati per ogni messaggio
+ * - Barra azioni bulk (stella, archivia, cestino, segna da leggere, tag)
+ * - Pulsanti azione rapida su hover di ogni riga
+ * - "Segna come da leggere" e "Sposta nel cestino" solo fuori dalle Virtual Box
*/
import { useEffect, useState, useCallback } from 'react'
import { useNavigate, useParams } from 'react-router-dom'
@@ -32,6 +33,14 @@ import {
Square,
X,
Tag,
+ Trash2,
+ RotateCcw,
+ MailX,
+ SlidersHorizontal,
+ ChevronDown,
+ ChevronUp,
+ ShieldCheck,
+ ShieldX,
} from 'lucide-react'
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import toast from 'react-hot-toast'
@@ -40,6 +49,7 @@ import { Input } from '@/components/ui/Input'
import { PecStateBadge } from '@/components/PecBadge/PecBadge'
import { TagBadgeList } from '@/components/TagManager/TagBadge'
import { TagSelector } from '@/components/TagManager/TagSelector'
+import { useAuth } from '@/hooks/useAuth'
import { messagesApi } from '@/api/messages.api'
import { labelsApi } from '@/api/labels.api'
import { mailboxesApi } from '@/api/mailboxes.api'
@@ -51,10 +61,9 @@ import { getErrorMessage } from '@/api/client'
// ─── Props ────────────────────────────────────────────────────────────────────
-export type InboxViewMode = 'inbox' | 'sent' | 'starred' | 'archived'
+export type InboxViewMode = 'inbox' | 'sent' | 'starred' | 'archived' | 'trash' | 'conservation_pending' | 'conservation_archived'
interface InboxPageProps {
- /** Modalità vista */
viewMode: InboxViewMode
}
@@ -64,10 +73,15 @@ export function InboxPage({ viewMode }: InboxPageProps) {
const navigate = useNavigate()
const queryClient = useQueryClient()
- // mailboxId è presente solo nei percorsi /mailbox/:mailboxId/...
- // vboxId è presente solo nei percorsi /virtual-box/:vboxId/...
const { mailboxId, vboxId } = useParams<{ mailboxId?: string; vboxId?: string }>()
+ // true = stiamo navigando in una casella reale (non virtual box)
+ const isMailboxMode = !vboxId
+
+ // ── Ruolo utente per visibilita' pulsante Conservazione ─────────────────────
+ const { isAdmin, isSupervisor } = useAuth()
+ const canConserve = isAdmin || isSupervisor
+
// ── Stato filtri locale ──────────────────────────────────────────────────────
const [searchInput, setSearchInput] = useState('')
const [debouncedSearch, setDebouncedSearch] = useState('')
@@ -76,23 +90,35 @@ export function InboxPage({ viewMode }: InboxPageProps) {
const [page, setPage] = useState(1)
const PAGE_SIZE = 50
+ // ── Filtri avanzati ──────────────────────────────────────────────────────────
+ const [showAdvancedFilters, setShowAdvancedFilters] = useState(false)
+ const [dateFrom, setDateFrom] = useState('')
+ const [dateTo, setDateTo] = useState('')
+ const [pecTypeFilter, setPecTypeFilter] = useState('')
+ const [pecStateFilter, setPecStateFilter] = useState('')
+
+ const activeAdvancedFiltersCount = [dateFrom, dateTo, pecTypeFilter, pecStateFilter].filter(Boolean).length
+
// ── Stato selezione ─────────────────────────────────────────────────────────
const [selectedIds, setSelectedIds] = useState
+
+
+
+
+
+
+
+
+ + {total} messaggi con scadenze +
+
+
+
+
+
+ {isLoading ? (
+
+
+
+
+ ) : total === 0 ? (
+
+
+ ) : (
+ Nessuna scadenza trovata
++ Le scadenze si impostano dal dettaglio di ogni messaggio. +
+
+
+ )}
+
+ {/* Data da */}
+
+ )}
- {/* ── Barra azioni bulk (appare quando ci sono selezioni) ── */}
+ {/* ── Barra azioni bulk ── */}
{someSelected && (
+
+ setDateFrom(e.target.value)}
+ />
+
+
+ {/* Data a */}
+
+
+ setDateTo(e.target.value)}
+ />
+
+
+ {/* Tipo PEC */}
+
+
+
+
+
+ {/* Stato PEC */}
+
+
+
+
+
+ {/* Reset filtri */}
+ {activeAdvancedFiltersCount > 0 && (
+
+
+
+ )}
+
- {/* Contatore + deseleziona */}
) : (
- {/* Azioni: variano in base alla vista */}
- {viewMode !== 'starred' && (
+ {/* Segna come da leggere (solo in modalita' casella, non vbox) */}
+ {isMailboxMode && viewMode !== 'trash' && (
+
+ )}
+
+ {/* Stella */}
+ {viewMode !== 'starred' && viewMode !== 'trash' && (
)}
@@ -558,17 +844,18 @@ export function InboxPage({ viewMode }: InboxPageProps) {
{debouncedSearch || isReadFilter !== undefined || isStarredFilter !== undefined
? 'Prova a modificare i filtri di ricerca'
: viewMode === 'inbox'
- ? 'La posta in arrivo è vuota'
+ ? 'La posta in arrivo e vuota'
: viewMode === 'sent'
? 'Nessun messaggio inviato'
: viewMode === 'starred'
? 'Nessun messaggio nei preferiti'
- : 'Nessun messaggio archiviato'}
+ : viewMode === 'archived'
+ ? 'Nessun messaggio archiviato'
+ : 'Il cestino e vuoto'}
- {/* Riga "seleziona tutto" */}
{messages.length > 0 && (
- {/* Tag badges */}
{message.labels && message.labels.length > 0 && (
{/* Contenuto */}
@@ -111,12 +133,14 @@ export function MailboxesPage() {
e.stopPropagation()}>
- {/* ── Azioni rapide (visibili su hover) + indicatori fissi ── */}
+ {/* ── Azioni rapide (visibili su hover) ── */}
- {/* Pulsante stella (rapido, su hover o se stellata) */}
+ {/* Stella */}
- {/* Pulsante archivia/ripristina (rapido, su hover) */}
-
+ {/* Segna come da leggere (solo in modalita' casella, solo messaggi gia' letti) */}
+ {isMailboxMode && message.is_read && viewMode !== 'trash' && (
+
+ )}
+
+ {/* Archivia/Ripristina (non nel cestino) */}
+ {viewMode !== 'trash' && (
+
+ )}
+
+ {/* Cestino / Ripristina dal cestino (solo in modalita' casella) */}
+ {isMailboxMode && (
+
+ )}
+
+ {/* Invia a Conservazione / Rimuovi da Da Conservare */}
+ {canConserve && viewMode !== 'trash' && viewMode !== 'conservation_archived' && (
+
+ )}
{/* Indicatore allegati */}
{message.has_attachments && (
diff --git a/frontend/src/pages/Mailboxes/MailboxesPage.tsx b/frontend/src/pages/Mailboxes/MailboxesPage.tsx
index 2eb04ed..955ff4a 100644
--- a/frontend/src/pages/Mailboxes/MailboxesPage.tsx
+++ b/frontend/src/pages/Mailboxes/MailboxesPage.tsx
@@ -27,6 +27,7 @@ import { mailboxesApi } from '@/api/mailboxes.api'
import { getErrorMessage } from '@/api/client'
import { formatDate, MAILBOX_STATUS_LABELS } from '@/lib/utils'
import { cn } from '@/lib/utils'
+import { useAuth } from '@/hooks/useAuth'
import type { MailboxCreateRequest, MailboxResponse } from '@/types/api.types'
const STATUS_COLORS = {
@@ -45,10 +46,12 @@ const STATUS_ICONS = {
export function MailboxesPage() {
const queryClient = useQueryClient()
+ const { isAdmin } = useAuth()
const [showCreateDialog, setShowCreateDialog] = useState(false)
const [editingMailbox, setEditingMailbox] = useState(null)
const [testingId, setTestingId] = useState(null)
const [testResult, setTestResult] = useState<{ success: boolean; message: string } | null>(null)
+ const [syncingId, setSyncingId] = useState(null)
const { data: mailboxesData, isLoading } = useQuery({
queryKey: ['mailboxes'],
@@ -78,6 +81,23 @@ export function MailboxesPage() {
}
}
+ const handleForceSync = async (mailbox: MailboxResponse) => {
+ setSyncingId(mailbox.id)
+ try {
+ const result = await mailboxesApi.forceSync(mailbox.id)
+ if (result.status === 'enqueued') {
+ toast.success(result.message)
+ queryClient.invalidateQueries({ queryKey: ['mailboxes'] })
+ } else {
+ toast.error(result.message)
+ }
+ } catch (e) {
+ toast.error(getErrorMessage(e))
+ } finally {
+ setSyncingId(null)
+ }
+ }
+
const handleDelete = async (mailbox: MailboxResponse) => {
if (!confirm(`Eliminare la casella ${mailbox.email_address}? L'operazione è irreversibile.`)) return
deleteMutation.mutate(mailbox.id)
@@ -94,10 +114,12 @@ export function MailboxesPage() {
-
+ {isAdmin && (
+
+ )}
Caselle PEC
({mailboxes.length})Nessuna casella PEC configurata
- Aggiungi una casella per iniziare a gestire le PEC + {isAdmin ? 'Aggiungi una casella per iniziare a gestire le PEC' : 'Nessuna casella disponibile'}
- + {isAdmin && ( + + )} ) : (
@@ -168,38 +192,53 @@ export function MailboxesPage() {
-
- {/* Test connessione */}
-
+ {isAdmin && (
+
+ )}
)
})}
diff --git a/frontend/src/pages/MessageDetail/MessageDetailPage.tsx b/frontend/src/pages/MessageDetail/MessageDetailPage.tsx
index c927521..170cc35 100644
--- a/frontend/src/pages/MessageDetail/MessageDetailPage.tsx
+++ b/frontend/src/pages/MessageDetail/MessageDetailPage.tsx
@@ -8,29 +8,158 @@ import {
ArchiveX,
Download,
Reply,
+ Forward,
Paperclip,
Mail,
Send,
Tag,
+ Trash2,
+ RotateCcw,
+ MailX,
+ PackageOpen,
+ Printer,
+ Calendar,
+ Eye,
+ MessageSquare,
+ X,
} from 'lucide-react'
import toast from 'react-hot-toast'
import { Button } from '@/components/ui/Button'
+import { Input } from '@/components/ui/Input'
+import { Label } from '@/components/ui/Label'
import { PecStateBadge, PecTypeBadge } from '@/components/PecBadge/PecBadge'
import { ReceiptTree } from '@/components/ReceiptTree/ReceiptTree'
import { TagBadge } from '@/components/TagManager/TagBadge'
import { TagSelector } from '@/components/TagManager/TagSelector'
import { messagesApi } from '@/api/messages.api'
import { labelsApi } from '@/api/labels.api'
+import { deadlinesApi } from '@/api/deadlines.api'
import { formatDate, formatBytes } from '@/lib/utils'
import { getErrorMessage } from '@/api/client'
+import apiClient from '@/api/client'
+
+// ─── Thread section (Feature 3) ──────────────────────────────────────────────
+
+function ThreadSection({ messageId, currentId, navigate }: { messageId: string; currentId: string; navigate: (to: string) => void }) {
+ const { data: thread = [] } = useQuery({
+ queryKey: ['thread', messageId],
+ queryFn: () => messagesApi.getThread(messageId),
+ })
+
+ // Mostra solo se ci sono piu' di 1 messaggio nel thread
+ if (thread.length <= 1) return null
+
+ return (
+
+ {/* Test connessione */}
+
- {/* Modifica */}
-
+ {/* Forza sincronizzazione */}
+
- {/* Elimina */}
-
-
+ {/* Modifica */}
+
+
+ {/* Elimina */}
+
+
+
+
+
+ )
+}
+
+// ─── Attachment preview modal ─────────────────────────────────────────────────
+
+interface AttachmentPreviewProps {
+ messageId: string
+ attachmentId: string
+ filename: string
+ contentType: string
+ onClose: () => void
+}
+
+function AttachmentPreviewModal({ messageId, attachmentId, filename, contentType, onClose }: AttachmentPreviewProps) {
+ const { data, isLoading } = useQuery({
+ queryKey: ['attachment-preview', messageId, attachmentId],
+ queryFn: () => messagesApi.getAttachmentPreviewUrl(messageId, attachmentId),
+ })
+
+ return (
+
+
+
+ {thread.map((msg) => {
+ const isCurrent = msg.id === currentId
+ return (
+
+ )
+ })}
+
+
+
+ )
+}
+
+// ─── Pagina principale ────────────────────────────────────────────────────────
export function MessageDetailPage() {
const { id } = useParams<{ id: string }>()
const navigate = useNavigate()
const queryClient = useQueryClient()
- // Dialog tag
const [showTagSelector, setShowTagSelector] = useState(false)
+ const [isDownloadingPackage, setIsDownloadingPackage] = useState(false)
+ const [isPrinting, setIsPrinting] = useState(false)
+
+ // Feature 4: Deadline
+ const [showDeadlineForm, setShowDeadlineForm] = useState(false)
+ const [deadlineDate, setDeadlineDate] = useState('')
+ const [deadlineNote, setDeadlineNote] = useState('')
+
+ // Feature 7: Preview allegati
+ const [previewAtt, setPreviewAtt] = useState<{ id: string; filename: string; contentType: string } | null>(null)
// Carica messaggio
const {
@@ -62,7 +191,6 @@ export function MessageDetailPage() {
mutationFn: (starred: boolean) => messagesApi.toggleStar(id!, starred),
onSuccess: (updated) => {
queryClient.setQueryData(['message', id], updated)
- // Invalida le query messaggi per aggiornare le viste Preferiti
queryClient.invalidateQueries({ queryKey: ['messages'] })
toast.success(updated.is_starred ? 'Aggiunto ai preferiti' : 'Rimosso dai preferiti')
},
@@ -80,15 +208,6 @@ export function MessageDetailPage() {
onError: (error) => toast.error(getErrorMessage(error)),
})
- // Download allegato autenticato
- const handleDownloadAttachment = async (att: { id: string; filename: string }) => {
- try {
- await messagesApi.downloadAttachment(message?.id ?? id!, att.id, att.filename)
- } catch (error) {
- toast.error(getErrorMessage(error))
- }
- }
-
// Ripristina dall'archivio
const unarchiveMutation = useMutation({
mutationFn: () => messagesApi.unarchive(id!),
@@ -100,17 +219,73 @@ export function MessageDetailPage() {
onError: (error) => toast.error(getErrorMessage(error)),
})
+ // Segna come da leggere
+ const markUnreadMutation = useMutation({
+ mutationFn: () => messagesApi.markUnread(id!),
+ onSuccess: (updated) => {
+ queryClient.setQueryData(['message', id], updated)
+ queryClient.invalidateQueries({ queryKey: ['messages'] })
+ toast.success('Messaggio segnato come da leggere')
+ navigate(-1)
+ },
+ onError: (error) => toast.error(getErrorMessage(error)),
+ })
+
+ // Sposta nel cestino
+ const trashMutation = useMutation({
+ mutationFn: () => messagesApi.trash(id!),
+ onSuccess: (updated) => {
+ queryClient.setQueryData(['message', id], updated)
+ queryClient.invalidateQueries({ queryKey: ['messages'] })
+ toast.success('Messaggio spostato nel cestino')
+ navigate(-1)
+ },
+ onError: (error) => toast.error(getErrorMessage(error)),
+ })
+
+ // Ripristina dal cestino
+ const untrashMutation = useMutation({
+ mutationFn: () => messagesApi.untrash(id!),
+ onSuccess: (updated) => {
+ queryClient.setQueryData(['message', id], updated)
+ queryClient.invalidateQueries({ queryKey: ['messages'] })
+ toast.success('Messaggio ripristinato dal cestino')
+ },
+ onError: (error) => toast.error(getErrorMessage(error)),
+ })
+
+ // Download allegato autenticato
+ const handleDownloadAttachment = async (att: { id: string; filename: string }) => {
+ try {
+ await messagesApi.downloadAttachment(message?.id ?? id!, att.id, att.filename)
+ } catch (error) {
+ toast.error(getErrorMessage(error))
+ }
+ }
+
+ // Download pacchetto completo ZIP
+ const handleDownloadPackage = async () => {
+ if (!message) return
+ setIsDownloadingPackage(true)
+ try {
+ await messagesApi.downloadPackage(message.id, message.subject)
+ toast.success('Pacchetto scaricato')
+ } catch (error) {
+ toast.error(getErrorMessage(error))
+ } finally {
+ setIsDownloadingPackage(false)
+ }
+ }
+
// Imposta tag del messaggio
const setLabelsMutation = useMutation({
mutationFn: (labelIds: string[]) =>
labelsApi.setMessageLabels(id!, { label_ids: labelIds }),
onSuccess: (updatedLabels) => {
- // Aggiorna la cache del messaggio con i nuovi label
queryClient.setQueryData(['message', id], (old: typeof message) => {
if (!old) return old
return { ...old, labels: updatedLabels }
})
- // Invalida la lista messaggi per aggiornare i badge nella inbox
queryClient.invalidateQueries({ queryKey: ['messages'] })
setShowTagSelector(false)
toast.success('Tag aggiornati')
@@ -118,7 +293,7 @@ export function MessageDetailPage() {
onError: (error) => toast.error(getErrorMessage(error)),
})
- // Rimuove singolo tag (click su × nel badge)
+ // Rimuove singolo tag
const removeLabelMutation = useMutation({
mutationFn: (labelId: string) =>
labelsApi.removeMessageLabels(id!, { label_ids: [labelId] }),
@@ -197,8 +372,21 @@ export function MessageDetailPage() {
/>
- {/* Archivia (se non ancora archiviato) */}
- {!message.is_archived && (
+ {/* Segna come da leggere (solo se gia' letto) */}
+ {message.is_read && !message.is_trashed && (
+
+ )}
+
+ {/* Archivia (se non ancora archiviato e non nel cestino) */}
+ {!message.is_archived && !message.is_trashed && (
+
+
+ {filename}
+
+
+
+ {isLoading && (
+
+ )}
+ {!isLoading && data && (
+ <>
+ {data.previewable && data.url ? (
+ <>
+ {contentType.startsWith('image/') ? (
+ 
+ ) : contentType === 'application/pdf' ? (
+
+ ) : null}
+
+ ) : (
+
+
+
+ )}
+
+ )}
+ Anteprima non disponibile per questo tipo di file.
+