Ricette

from datetime import datetime
from zoneinfo import ZoneInfo

ROME = ZoneInfo("Europe/Rome")

SERVIZI = {
    "bp_svc_2a11": "SRV001",
    "bp_svc_2a12": "SRV002",
}

SQUADRE = {
    "Squadra Nord": "SQN",
    "Squadra Sud": "SQS",
}


def to_erp_record(event: dict) -> dict:
    data = event["data"]
    start = datetime.fromisoformat(data["startAt"]).astimezone(ROME)

    return {
        "RIFEST": data["reference"][:20],
        "CODCLI": lookup_codcli(data["client"]),
        "RAGSOC": data["client"]["displayName"].upper()[:40],
        "CODSER": SERVIZI.get(data["service"]["id"], "SRV999"),
        "DTAPPU": start.strftime("%Y%m%d"),
        "ORAPPU": start.strftime("%H%M"),
        "DURATA": data["service"]["durationMinutes"],
        "SQUADRA": SQUADRE.get(data["resource"]["name"], "SQX"),
        "INDIRZ": data.get("location", {}).get("address", "")[:60],
        "IMPORT": round(data["price"]["amount"] / 100, 2),
        "MATRIC": data.get("customFields", {}).get("matricola_contatore", ""),
    }


def lookup_codcli(client: dict) -> str:
    """Cerca il codice cliente nel gestionale, altrimenti lo crea."""
    existing = gestionale.find_client_by_vat(client.get("vatNumber"))
    if existing:
        return existing["CODCLI"]
    return gestionale.create_client(client)["CODCLI"]

def upsert_ordine(record: dict) -> str:
    esistente = gestionale.find_order_by_reference(record["RIFEST"])
    if esistente:
        gestionale.update_order(esistente["NUMORD"], record)
        return esistente["NUMORD"]
    return gestionale.create_order(record)["NUMORD"]

client.patch_booking(
    booking_id=event["data"]["bookingId"],
    payload={"metadata": {"erpOrderNumber": numero_ordine}},
    idempotency_key=delivery_id,
)

curl -sS -G "$BP_API_BASE_URL/identity/v1/bookings" \
  -H "Authorization: Bearer $BP_API_KEY" \
  -H "X-BP-Project: $BP_PROJECT_ID" \
  --data-urlencode "status=confirmed" \
  --data-urlencode "updatedSince=$(date -u -v-6H +%Y-%m-%dT%H:%M:%SZ)" \
  --data-urlencode "limit=100" \
  | jq -r '.data[] | select(.metadata.erpOrderNumber == null) | .id'

const OUTCOME_QUALIFICANTI = new Set(['risolto', 'qualificato', 'preventivo_richiesto']);

function isRilevante(event) {
  const data = event.data;
  return (
    event.event === 'session.closed' &&
    Boolean(data.clientId) &&
    OUTCOME_QUALIFICANTI.has(data.outcome)
  );
}

const client = await bpRequest(`/identity/v1/clients/${event.data.clientId}`);

function normalizzaTelefono(phone) {
  if (!phone) return null;
  const digits = phone.replace(/[^\d+]/g, '');
  if (digits.startsWith('+')) return digits;
  if (digits.startsWith('00')) return `+${digits.slice(2)}`;
  return `+39${digits}`;
}

async function upsertContatto(client, event) {
  const dati = client.data;

  const esistente =
    (await crm.findByCustomField('bp_client_id', dati.id)) ??
    (dati.vatNumber ? await crm.findByVat(dati.vatNumber) : null) ??
    (dati.email ? await crm.findByEmail(dati.email) : null);

  const payload = {
    bp_client_id: dati.id,
    bp_session_id: event.data.sessionId,
    email: dati.email ?? null,
    phone: normalizzaTelefono(dati.phone),
    vat_number: dati.vatNumber ?? null,
    company_name: dati.type === 'azienda' ? dati.displayName : null,
    full_name: dati.type === 'persona' ? dati.displayName : null,
    city: dati.address?.city ?? null,
    opt_in_marketing: Boolean(dati.consents?.marketing),
    last_csat: event.data.rating?.score ?? null,
    tags: (event.data.tags ?? []).join(','),
  };

  if (esistente) {
    await crm.updateContact(esistente.id, payload);
    return esistente.id;
  }
  return (await crm.createContact(payload)).id;
}

await crm.createActivity({
  contactId,
  type: 'conversazione',
  subject: `Conversazione Blu Pantheon del ${new Date(event.createdAt).toLocaleDateString('it-IT')}`,
  body: event.data.summary,
  durationMinutes: Math.round(event.data.durationSeconds / 60),
  externalId: event.id,
});

import hashlib

def scarica_documento(document_id: str) -> tuple[bytes, str]:
    response = session.get(
        f"{BASE_URL}/identity/v1/documents/{document_id}/content",
        headers={"Authorization": f"Bearer {API_KEY}"},
        timeout=60,
        stream=True,
    )
    response.raise_for_status()
    contenuto = response.content
    digest = hashlib.sha256(contenuto).hexdigest()
    return contenuto, digest

SOGLIA_CONFIDENZA = 0.85

def instrada(event: dict) -> str:
    confidenza = event["data"]["classification"]["confidence"]
    if confidenza < SOGLIA_CONFIDENZA:
        return "revisione_manuale"
    return "deposito_automatico"

def deposita(event: dict, contenuto: bytes, digest: str) -> str:
    data = event["data"]
    estratti = data.get("extracted", {})

    if dms.exists_by_hash(digest):
        return dms.get_by_hash(digest)["protocollo"]

    documento_id = dms.upload(
        contenuto=contenuto,
        nome_file=sanifica(data["fileName"]),
        mime_type=data["mimeType"],
        hash_sha256=digest,
    )

    protocollo = protocollo_informatico.registra(
        documento_id=documento_id,
        tipologia=MAPPATURA_TIPOLOGIE.get(
            data["classification"]["category"], "GENERICO"
        ),
        numero_documento=estratti.get("numero_documento", ""),
        data_documento=converti_data(estratti.get("data_documento")),
        mittente=estratti.get("fornitore", "").upper(),
        mittente_piva=(estratti.get("partita_iva") or "").removeprefix("IT"),
        importo=estratti.get("totale"),
        id_esterno=event["id"],
    )
    return protocollo


def sanifica(nome: str) -> str:
    ammessi = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_."
    return "".join(carattere if carattere in ammessi else "_" for carattere in nome)[:120]


def converti_data(iso: str | None) -> str:
    if not iso:
        return ""
    anno, mese, giorno = iso.split("-")
    return f"{giorno}/{mese}/{anno}"

client.patch_document(
    document_id=event["data"]["documentId"],
    payload={"metadata": {"protocollo": protocollo, "dms_hash": digest}},
    idempotency_key=delivery_id,
)

const esistente = await ticketing.findByExternalId(event.id);
if (esistente) {
  return esistente.key;
}

await bpRequest(`/identity/v1/sessions/${event.data.sessionId}/notes`, {
  method: 'POST',
  idempotencyKey: deliveryId,
  body: {
    body: `Ticket aperto: ${ticketKey}`,
    visibility: 'internal',
    author: 'automazione-ticketing',
  },
});

if (event.event === 'session.closed') {
  const ticket = await ticketing.findBySessionId(event.data.sessionId);
  if (!ticket) return;

  await ticketing.addComment(ticket.id, event.data.summary);
  if (event.data.outcome === 'risolto') {
    await ticketing.transition(ticket.id, 'Chiuso');
  }
}

from datetime import datetime, timedelta
from zoneinfo import ZoneInfo

ROME = ZoneInfo("Europe/Rome")


def intervallo_ieri() -> tuple[str, str]:
    oggi = datetime.now(ROME).replace(hour=0, minute=0, second=0, microsecond=0)
    ieri = oggi - timedelta(days=1)
    return (
        ieri.astimezone(tz=None).isoformat(),
        oggi.astimezone(tz=None).isoformat(),
    )


def estrai_tutto(path: str, params: dict) -> list[dict]:
    risultati: list[dict] = []
    cursore = None

    while True:
        query = dict(params)
        query["limit"] = 100
        if cursore:
            query["cursor"] = cursore

        risposta = client._request("GET", path, params=query)
        risultati.extend(risposta.get("data", []))

        cursore = risposta.get("pagination", {}).get("nextCursor")
        if not cursore:
            break

    return risultati

def calcola_metriche(sessioni: list[dict], prenotazioni: list[dict]) -> dict:
    totale = len(sessioni)
    con_handover = sum(1 for s in sessioni if s.get("handoverRequested"))
    valutate = [s["rating"]["score"] for s in sessioni if s.get("rating")]
    durate = [s["durationSeconds"] for s in sessioni if s.get("durationSeconds")]

    return {
        "conversazioni_totali": totale,
        "conversazioni_con_handover": con_handover,
        "tasso_handover_pct": round(con_handover / totale * 100, 1) if totale else 0.0,
        "durata_media_minuti": round(sum(durate) / len(durate) / 60, 1) if durate else 0.0,
        "csat_medio": round(sum(valutate) / len(valutate), 2) if valutate else None,
        "prenotazioni_confermate": sum(
            1 for p in prenotazioni if p["status"] == "confirmed"
        ),
        "prenotazioni_annullate": sum(
            1 for p in prenotazioni if p["status"] == "cancelled"
        ),
        "mancate_presenze": sum(1 for p in prenotazioni if p["status"] == "no_show"),
    }

from openpyxl import Workbook


def genera_xlsx(metriche: dict, sessioni: list[dict], percorso: str) -> None:
    workbook = Workbook()

    riepilogo = workbook.active
    riepilogo.title = "Riepilogo"
    riepilogo.append(["Metrica", "Valore"])
    for chiave, valore in metriche.items():
        riepilogo.append([chiave.replace("_", " ").capitalize(), valore])

    dettaglio = workbook.create_sheet("Conversazioni")
    dettaglio.append(
        ["ID sessione", "Canale", "Apertura", "Durata (min)", "Esito", "CSAT", "Etichette"]
    )
    for sessione in sessioni:
        dettaglio.append(
            [
                sessione["id"],
                sessione.get("channel", ""),
                sessione.get("startedAt", ""),
                round(sessione.get("durationSeconds", 0) / 60, 1),
                sessione.get("outcome", ""),
                (sessione.get("rating") or {}).get("score", ""),
                ", ".join(sessione.get("tags", [])),
            ]
        )

    workbook.save(percorso)

import requests


def carica_su_sharepoint(percorso_locale: str, nome_file: str, graph_token: str) -> str:
    site_id = "acme.sharepoint.com,11111111-2222-3333-4444-555555555555,66666666-7777-8888-9999-000000000000"
    drive_path = f"/sites/{site_id}/drive/root:/Report Blu Pantheon/{nome_file}:/content"

    with open(percorso_locale, "rb") as file:
        risposta = requests.put(
            f"https://graph.microsoft.com/v1.0{drive_path}",
            headers={
                "Authorization": f"Bearer {graph_token}",
                "Content-Type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            },
            data=file,
            timeout=120,
        )
    risposta.raise_for_status()
    return risposta.json()["webUrl"]

# Report giornaliero alle 07:00 ora italiana
0 7 * * * TZ=Europe/Rome /opt/automazioni/venv/bin/python -m src.report_giornaliero >> /var/log/bp-report.log 2>&1