+
+ 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}
+ >
+
@@ -518,6 +554,8 @@ 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) => (
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 (
+
+
+ )
+}
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/MessageDetail/MessageDetailPage.tsx b/frontend/src/pages/MessageDetail/MessageDetailPage.tsx
index 663805c..170cc35 100644
--- a/frontend/src/pages/MessageDetail/MessageDetailPage.tsx
+++ b/frontend/src/pages/MessageDetail/MessageDetailPage.tsx
@@ -17,17 +17,132 @@ import {
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 (
+
+
+
+
+
+
+
+
+
+ + {total} messaggi con scadenze +
+
+
+
+
+
+ {isLoading ? (
+
+
+
+
+ ) : total === 0 ? (
+
+
+ ) : (
+ Nessuna scadenza trovata
++ Le scadenze si impostano dal dettaglio di ogni messaggio. +
+
+
+ )}
+
+
+
+
+ )
+}
+
+// ─── 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 }>()
@@ -36,6 +151,15 @@ export function MessageDetailPage() {
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 {
@@ -362,6 +486,52 @@ export function MessageDetailPage() {
)}
Scarica
+
+ {/* Stampa (Feature 8) */}
+
+
+ {/* Scadenza (Feature 4) */}
+
+
+
+ {filename}
+
+
+
+ {isLoading && (
+
+ )}
+ {!isLoading && data && (
+ <>
+ {data.previewable && data.url ? (
+ <>
+ {contentType.startsWith('image/') ? (
+ 
+ ) : contentType === 'application/pdf' ? (
+
+ ) : null}
+
+ ) : (
+
+
+
+ )}
+
+ )}
+ Anteprima non disponibile per questo tipo di file.
+
- {attachments.map((att) => (
-
)}
@@ -558,6 +742,41 @@ export function MessageDetailPage() {
)}
+ {/* Scadenza (Feature 4) */}
+ {(message as any).deadline_at && (
+
+
+ )}
+
+ {/* Thread (Feature 3) */}
+ {message.pec_type === 'posta_certificata' && (
+
+
+
+
+
+
@@ -575,6 +794,63 @@ export function MessageDetailPage() {
+ {/* Modali */}
+
+ {/* Deadline form (Feature 4) */}
+ {showDeadlineForm && (
+
+
+ )}
+
+ {/* Attachment preview (Feature 7) */}
+ {previewAtt && (
+
+
+
+
+
+
+
+
+ setDeadlineDate(e.target.value)}
+ />
+
+
+
+ setDeadlineNote(e.target.value)}
+ placeholder="Es. Termine per impugnare, entro 30 giorni..."
+ />
+
+
+
+
+
+
+
+ )
+}
diff --git a/frontend/src/pages/Templates/TemplatesPage.tsx b/frontend/src/pages/Templates/TemplatesPage.tsx
new file mode 100644
index 0000000..0b05d40
--- /dev/null
+++ b/frontend/src/pages/Templates/TemplatesPage.tsx
@@ -0,0 +1,228 @@
+import { useState } from 'react'
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
+import { Plus, Pencil, Trash2, FileText, Search } 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 { RichTextEditor } from '@/components/RichTextEditor/RichTextEditor'
+import { templatesApi, type TemplateResponse, type TemplateCreate } from '@/api/templates.api'
+import { getErrorMessage } from '@/api/client'
+import { formatDate } from '@/lib/utils'
+import { useAuth } from '@/hooks/useAuth'
+
+export function TemplatesPage() {
+ const queryClient = useQueryClient()
+ const { isAdmin } = useAuth()
+ const [q, setQ] = useState('')
+ const [showForm, setShowForm] = useState(false)
+ const [editing, setEditing] = useState
+
+
+
+
+
+
+
+
+
+ + Applica automaticamente etichette e azioni ai messaggi in arrivo +
+
+ {isLoading ? (
+
+
+
+
+
+
+ ) : items.length === 0 ? (
+
+
+ ) : (
+ items.map((rule) => (
+ Nessuna regola configurata
+Le regole vengono valutate in ordine di priorita' su ogni messaggio inbound.
+
+
+ ))
+ )}
+
+
+ {expandedRules.has(rule.id) && (
+
+
+
+ {rule.name}
+ P:{rule.priority}
+
+ {rule.is_active ? 'Attiva' : 'Inattiva'}
+
+ {rule.stop_processing && (
+ Stop
+ )}
+
+ {rule.description && {rule.description}
} ++ {rule.conditions.length} condizioni / {rule.actions.length} azioni +
+
+
+
+
+
+
+
+
+ )}
+
+
+ Condizioni (AND)
+ {rule.conditions.map((c, i) => ( +
+ {FIELD_LABELS[c.field as ConditionField] ?? c.field}
+ {OPERATOR_LABELS[c.operator as ConditionOperator] ?? c.operator}
+ {c.value}
+
+ ))}
+
+
+ Azioni
+ {rule.actions.map((a, i) => ( +
+ {ACTION_LABELS[a.action_type as ActionType] ?? a.action_type}
+ {a.action_value && {a.action_value}}
+
+ ))}
+
+
+ )
+}
diff --git a/worker/app/imap/sync.py b/worker/app/imap/sync.py
index 2ff0f2d..868f9b6 100644
--- a/worker/app/imap/sync.py
+++ b/worker/app/imap/sync.py
@@ -659,6 +659,32 @@ async def _save_message(
redis_client=redis_client,
)
+ # ── Regole di smistamento automatico (Feature 2) ──────────────────────────
+ # Solo per messaggi inbound posta_certificata (non ricevute di sistema).
+ if direction == "inbound" and pec_class.pec_type == "posta_certificata":
+ try:
+ await redis_client.enqueue_job("apply_routing_rules", str(message.id))
+ except Exception as e:
+ logger.warning(f"[{mailbox.email_address}] Impossibile enqueue apply_routing_rules: {e}")
+
+ # ── Auto-save mittente nella rubrica (Feature 6) ──────────────────────────
+ # Per messaggi inbound di tipo posta_certificata, salva automaticamente
+ # il mittente nella rubrica pec_contacts del tenant (upsert idempotente).
+ if direction == "inbound" and pec_class.pec_type == "posta_certificata" and message.from_address:
+ try:
+ from sqlalchemy import text as _text
+ await db.execute(
+ _text("""
+ INSERT INTO pec_contacts (id, tenant_id, email, auto_saved, created_at, updated_at)
+ VALUES (gen_random_uuid(), :tenant_id, :email, true, now(), now())
+ ON CONFLICT (tenant_id, email) DO NOTHING
+ """),
+ {"tenant_id": str(mailbox.tenant_id), "email": message.from_address.lower().strip()},
+ )
+ await db.flush()
+ except Exception as e:
+ logger.debug(f"[{mailbox.email_address}] Auto-save contatto fallito (non critico): {e}")
+
return True
diff --git a/worker/app/jobs/apply_routing_rules.py b/worker/app/jobs/apply_routing_rules.py
new file mode 100644
index 0000000..d71273b
--- /dev/null
+++ b/worker/app/jobs/apply_routing_rules.py
@@ -0,0 +1,234 @@
+"""
+Job arq: apply_routing_rules – applica le regole di smistamento automatico.
+
+Viene accodato da sync.py dopo il salvataggio di ogni messaggio inbound.
+
+Logica:
+ 1. Carica le regole attive del tenant ordinate per priority
+ 2. Per ogni regola valuta le condizioni (AND)
+ 3. Se match: esegue le azioni (apply_label, mark_read, mark_starred, notify_webhook)
+ 4. Se stop_processing=True, interrompe la catena
+"""
+
+import logging
+import re
+import uuid as uuid_module
+from typing import Any
+
+from sqlalchemy import select, text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import AsyncSessionLocal
+from app.models import Message
+
+logger = logging.getLogger(__name__)
+
+
+# ─── Job principale ───────────────────────────────────────────────────────────
+
+async def apply_routing_rules(ctx: dict[str, Any], message_id: str) -> dict:
+ """
+ Valuta le regole di smistamento automatico per un messaggio.
+
+ Args:
+ ctx: contesto arq
+ message_id: UUID del messaggio da processare
+
+ Returns:
+ dict con: matched_rules, actions_applied
+ """
+ msg_uuid = uuid_module.UUID(message_id)
+
+ async with AsyncSessionLocal() as db:
+ # Carica il messaggio
+ msg = await db.get(Message, msg_uuid)
+ if not msg:
+ logger.warning(f"[routing_rules] Messaggio {message_id} non trovato")
+ return {"status": "skipped", "reason": "message_not_found"}
+
+ # Solo messaggi inbound di tipo posta_certificata
+ if msg.direction != "inbound" or msg.pec_type != "posta_certificata":
+ return {"status": "skipped", "reason": "not_inbound_pec"}
+
+ # Carica regole attive del tenant ordinate per priority ASC
+ rules_result = await db.execute(
+ text("""
+ SELECT r.id, r.name, r.priority, r.stop_processing,
+ COALESCE(
+ json_agg(
+ json_build_object('field', c.field, 'operator', c.operator, 'value', c.value)
+ ORDER BY c.id
+ ) FILTER (WHERE c.id IS NOT NULL),
+ '[]'::json
+ ) AS conditions,
+ COALESCE(
+ json_agg(
+ json_build_object('action_type', a.action_type, 'action_value', a.action_value)
+ ORDER BY a.id
+ ) FILTER (WHERE a.id IS NOT NULL),
+ '[]'::json
+ ) AS actions
+ FROM routing_rules r
+ LEFT JOIN routing_rule_conditions c ON c.rule_id = r.id
+ LEFT JOIN routing_rule_actions a ON a.rule_id = r.id
+ WHERE r.tenant_id = :tenant_id
+ AND r.is_active = true
+ GROUP BY r.id, r.name, r.priority, r.stop_processing
+ ORDER BY r.priority ASC
+ """),
+ {"tenant_id": str(msg.tenant_id)},
+ )
+ rules = rules_result.mappings().all()
+
+ matched_count = 0
+ actions_applied: list[str] = []
+
+ for rule in rules:
+ conditions = rule["conditions"]
+ if not conditions:
+ continue
+
+ # Valuta condizioni (AND)
+ if not _evaluate_conditions(msg, conditions):
+ continue
+
+ matched_count += 1
+ logger.info(
+ f"[routing_rules] Regola '{rule['name']}' (priority={rule['priority']}) "
+ f"match per messaggio {message_id}"
+ )
+
+ # Esegui azioni
+ for action in rule["actions"]:
+ applied = await _apply_action(db, msg, action["action_type"], action["action_value"])
+ if applied:
+ actions_applied.append(action["action_type"])
+
+ if rule["stop_processing"]:
+ break
+
+ if matched_count > 0:
+ await db.commit()
+
+ return {
+ "status": "ok",
+ "message_id": message_id,
+ "matched_rules": matched_count,
+ "actions_applied": actions_applied,
+ }
+
+
+# ─── Valutazione condizioni ────────────────────────────────────────────────────
+
+def _get_field_value(msg: Message, field: str) -> str:
+ if field == "from_address":
+ return (msg.from_address or "").lower()
+ elif field == "to_address":
+ return " ".join(msg.to_addresses or []).lower()
+ elif field == "subject":
+ return (msg.subject or "").lower()
+ elif field == "mailbox_id":
+ return str(msg.mailbox_id)
+ elif field == "pec_type":
+ return msg.pec_type or ""
+ return ""
+
+
+def _evaluate_condition(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
+
+
+def _evaluate_conditions(msg: Message, conditions: list[dict]) -> bool:
+ """Valuta AND tra tutte le condizioni."""
+ for cond in conditions:
+ field_val = _get_field_value(msg, cond["field"])
+ if not _evaluate_condition(field_val, cond["operator"], cond["value"]):
+ return False
+ return True
+
+
+# ─── Esecuzione azioni ─────────────────────────────────────────────────────────
+
+async def _apply_action(
+ db: AsyncSession,
+ msg: Message,
+ action_type: str,
+ action_value: str | None,
+) -> bool:
+ """Esegue una singola azione. Restituisce True se applicata."""
+ try:
+ if action_type == "apply_label" and action_value:
+ return await _action_apply_label(db, msg, uuid_module.UUID(action_value))
+ elif action_type == "mark_read":
+ if not msg.is_read:
+ msg.is_read = True
+ return True
+ elif action_type == "mark_starred":
+ if not msg.is_starred:
+ msg.is_starred = True
+ return True
+ elif action_type == "notify_webhook" and action_value:
+ await _action_notify_webhook(msg, action_value)
+ return True
+ except Exception as e:
+ logger.warning(f"[routing_rules] Errore azione {action_type}: {e}")
+ return False
+
+
+async def _action_apply_label(
+ db: AsyncSession, msg: Message, label_id: uuid_module.UUID
+) -> bool:
+ """Applica un'etichetta al messaggio se non gia' applicata."""
+ # Verifica che la label esista e appartenga al tenant
+ label_check = await db.execute(
+ text("SELECT id FROM labels WHERE id = :lid AND tenant_id = :tid"),
+ {"lid": str(label_id), "tid": str(msg.tenant_id)},
+ )
+ if not label_check.fetchone():
+ return False
+
+ # Inserisci con ON CONFLICT DO NOTHING per idempotenza
+ await db.execute(
+ text("""
+ INSERT INTO message_labels (message_id, label_id)
+ VALUES (:msg_id, :label_id)
+ ON CONFLICT DO NOTHING
+ """),
+ {"msg_id": str(msg.id), "label_id": str(label_id)},
+ )
+ logger.debug(f"[routing_rules] Etichetta {label_id} applicata a {msg.id}")
+ return True
+
+
+async def _action_notify_webhook(msg: Message, url: str) -> None:
+ """Invia notifica webhook per il messaggio."""
+ import aiohttp
+ payload = {
+ "event": "routing_rule_match",
+ "message_id": str(msg.id),
+ "subject": msg.subject,
+ "from_address": msg.from_address,
+ "pec_type": msg.pec_type,
+ }
+ try:
+ async with aiohttp.ClientSession() as session:
+ await session.post(url, json=payload, timeout=aiohttp.ClientTimeout(total=5))
+ except Exception as e:
+ logger.warning(f"[routing_rules] Webhook {url} fallito: {e}")
diff --git a/worker/app/main.py b/worker/app/main.py
index 1f8b248..4b8289f 100644
--- a/worker/app/main.py
+++ b/worker/app/main.py
@@ -24,6 +24,7 @@ from arq.connections import RedisSettings
from app.config import get_settings
from app.imap.pool import MailboxPool
+from app.jobs.apply_routing_rules import apply_routing_rules
from app.jobs.dispatch_notification import dispatch_notification
from app.jobs.send_pec import send_pec
from app.jobs.sync_mailbox import sync_mailbox
@@ -133,7 +134,7 @@ class WorkerSettings:
"""Configurazione del worker arq."""
# Funzioni/job registrati
- functions = [sync_mailbox, send_pec, watch_receipt, dispatch_notification, health_check]
+ functions = [sync_mailbox, send_pec, watch_receipt, dispatch_notification, apply_routing_rules, health_check]
# Callbacks lifecycle
on_startup = on_startup
+
+
+
+
+ {isAdmin && (
+
+ )}
+ Template messaggi
++ Template riutilizzabili per la composizione PEC +
+
+ {/* Ricerca */}
+
+
+ {/* Dialog form */}
+
+
+
+
+ {isLoading ? (
+
+
+
+ ) : items.length === 0 ? (
+
+
+ ) : (
+ Nessun template trovato
++ {isAdmin ? 'Crea il tuo primo template con il pulsante in alto.' : 'Nessun template disponibile.'} +
+
+ {items.map((t) => (
+
+ )}
+
+
+ ))}
+
+
+ {t.subject && (
+
+
+ {isAdmin && (
+ {t.name}
+ {t.description && ( +{t.description}
+ )} +
+
+
+
+ )}
+ + Oggetto: {t.subject} +
+ )} ++ Aggiornato: {formatDate(t.updated_at)} +
+