@primocaredentgroup/compensi-medici-core 0.1.0

package/convex/calculation/fixedCommissions.ts

@@ -0,0 +1,217 @@
+/**
+ * Commissioni fisse — traduzione da create_fixed_commission.py
+ *
+ * 4 comportamenti configurabili (dal campo `behavior` di fixedCommissionTypes):
+ *
+ * 1. minimum_guaranteed (vecchi tipi 1,6): max(produzione_invoiceable, fisso * wdays).
+ *    Se produzione < fisso*wdays, genera riga di adjust + riga opposta (storno surplus).
+ *
+ * 2. additive (vecchio tipo 2): fisso*wdays aggiunto sempre alla produzione.
+ *
+ * 3. substitutive (vecchio tipo 3): fisso*wdays sostituisce la produzione.
+ *    La produzione viene azzerata, il fisso calcolato come adjust.
+ *
+ * 4. substitutive_no_wdays (vecchio tipo 4): come substitutive ma senza moltiplicare per wdays.
+ */
+
+import type { Id } from "../_generated/dataModel";
+import type { FixedCommissionBehavior } from "../lib/types";
+
+export interface FixedCommissionRule {
+  userId: string;
+  clinicId: string;
+  amount: number;
+  typeId: Id<"fixedCommissionTypes">;
+  behavior: FixedCommissionBehavior;
+  multipliedByWdays: boolean;
+}
+
+export interface WorkingDaysEntry {
+  userId: string;
+  clinicId: string;
+  days: number;
+}
+
+export interface CommissionSummaryForFixed {
+  userId: string;
+  clinicId: string;
+  period: string;
+  invoiceableTotal: number;
+  allTotal: number;
+  hasRefactorSameMonth: boolean;
+}
+
+export interface FixedAdjustResult {
+  userId: string;
+  clinicId: string;
+  fixedTypeId: Id<"fixedCommissionTypes">;
+  behavior: FixedCommissionBehavior;
+  fixedAmount: number;
+  adjustAmount: number;
+  oppositeAmount: number;
+  explanation: string;
+}
+
+/**
+ * Calcola i giorni lavorativi per un utente/clinica nel periodo.
+ *
+ * Dal Python (get_wdays.sql): conta i giorni distinti in cui il medico
+ * ha appuntamenti per almeno 4 ore nella clinica durante il mese.
+ *
+ * In Convex i dati degli appuntamenti sono nel DB principale.
+ * Questa funzione è un placeholder che riceve i dati pre-calcolati.
+ */
+export function getWorkingDays(
+  wdaysData: WorkingDaysEntry[],
+  userId: string,
+  clinicId: string,
+): number {
+  const entry = wdaysData.find((w) => w.userId === userId && w.clinicId === clinicId);
+  return entry?.days ?? 0;
+}
+
+/**
+ * Calcola gli adjust delle commissioni fisse rispetto alla produzione variabile.
+ *
+ * Per ogni coppia userId+clinicId con regole fisse:
+ * 1. Calcola il fisso totale (amount * wdays se applicabile)
+ * 2. Confronta con la produzione invoiceable
+ * 3. Genera le righe di adjust in base al behavior
+ */
+export function adjustFixedCommissions(
+  commissionSummaries: CommissionSummaryForFixed[],
+  fixedRules: FixedCommissionRule[],
+  wdaysData: WorkingDaysEntry[],
+  ignoreAllRulesUserIds: Set<string>,
+): FixedAdjustResult[] {
+  const results: FixedAdjustResult[] = [];
+
+  const groupedRules = groupByUserClinic(fixedRules);
+
+  for (const [key, rules] of groupedRules) {
+    const [userId, clinicId] = key.split("|");
+
+    if (rules.length > 1) {
+      const behaviors = new Set(rules.map((r) => r.behavior));
+      if (behaviors.size > 1) {
+        console.warn(`Regole fisse multiple con behavior diversi per user=${userId} clinic=${clinicId}. Salto.`);
+        continue;
+      }
+    }
+
+    const rule = rules[0];
+    const totalFixedAmount = rules.reduce((sum, r) => sum + r.amount, 0);
+    const wdays = getWorkingDays(wdaysData, userId, clinicId);
+
+    const shouldMultiply = rule.multipliedByWdays;
+    const fixedCalculated = shouldMultiply ? totalFixedAmount * wdays : totalFixedAmount;
+
+    const summary = commissionSummaries.find(
+      (s) => s.userId === userId && s.clinicId === clinicId,
+    );
+    const invoiceableTotal = summary?.invoiceableTotal ?? 0;
+    const allTotal = summary?.allTotal ?? 0;
+
+    const isIgnoreAll = ignoreAllRulesUserIds.has(userId);
+
+    const result = calculateAdjust(
+      userId, clinicId, rule.typeId, rule.behavior,
+      fixedCalculated, invoiceableTotal, allTotal,
+      isIgnoreAll, summary?.hasRefactorSameMonth ?? false,
+    );
+
+    if (result) {
+      results.push(result);
+    }
+  }
+
+  return results;
+}
+
+function calculateAdjust(
+  userId: string,
+  clinicId: string,
+  fixedTypeId: Id<"fixedCommissionTypes">,
+  behavior: FixedCommissionBehavior,
+  fixedCalculated: number,
+  invoiceableTotal: number,
+  allTotal: number,
+  isIgnoreAll: boolean,
+  hasRefactorSameMonth: boolean,
+): FixedAdjustResult | null {
+  if (isIgnoreAll) {
+    const adjustAmount = fixedCalculated - allTotal;
+    return {
+      userId, clinicId, fixedTypeId, behavior: "substitutive_no_wdays",
+      fixedAmount: fixedCalculated,
+      adjustAmount,
+      oppositeAmount: 0,
+      explanation: `Utente con ignore_all_rules: fisso ${fixedCalculated} - produzione ${allTotal} = adjust ${adjustAmount}`,
+    };
+  }
+
+  switch (behavior) {
+    case "minimum_guaranteed": {
+      const effectiveTotal = Math.max(invoiceableTotal, fixedCalculated);
+      const adjustAmount = effectiveTotal - invoiceableTotal;
+      const oppositeAmount = adjustAmount > 0 ? 0 : Math.abs(fixedCalculated - invoiceableTotal);
+
+      if (adjustAmount === 0 && oppositeAmount === 0) return null;
+
+      return {
+        userId, clinicId, fixedTypeId, behavior, fixedAmount: fixedCalculated,
+        adjustAmount,
+        oppositeAmount: invoiceableTotal > fixedCalculated && fixedCalculated > 0 ? 0 : oppositeAmount,
+        explanation: `Minimo garantito: max(${invoiceableTotal}, ${fixedCalculated}) = ${effectiveTotal}. Adjust = ${adjustAmount}`,
+      };
+    }
+
+    case "additive": {
+      return {
+        userId, clinicId, fixedTypeId, behavior, fixedAmount: fixedCalculated,
+        adjustAmount: fixedCalculated,
+        oppositeAmount: 0,
+        explanation: `Aggiuntivo: fisso ${fixedCalculated} aggiunto alla produzione`,
+      };
+    }
+
+    case "substitutive": {
+      const adjustAmount = fixedCalculated - invoiceableTotal;
+      return {
+        userId, clinicId, fixedTypeId, behavior, fixedAmount: fixedCalculated,
+        adjustAmount,
+        oppositeAmount: 0,
+        explanation: `Sostitutivo (con wdays): fisso ${fixedCalculated} - produzione ${invoiceableTotal} = adjust ${adjustAmount}`,
+      };
+    }
+
+    case "substitutive_no_wdays": {
+      const adjustAmount = fixedCalculated - invoiceableTotal;
+      return {
+        userId, clinicId, fixedTypeId, behavior, fixedAmount: fixedCalculated,
+        adjustAmount,
+        oppositeAmount: 0,
+        explanation: `Sostitutivo semplice: fisso ${fixedCalculated} - produzione ${invoiceableTotal} = adjust ${adjustAmount}`,
+      };
+    }
+
+    default:
+      return null;
+  }
+}
+
+function groupByUserClinic(
+  rules: FixedCommissionRule[],
+): Map<string, FixedCommissionRule[]> {
+  const map = new Map<string, FixedCommissionRule[]>();
+  for (const rule of rules) {
+    const key = `${rule.userId}|${rule.clinicId}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.push(rule);
+    } else {
+      map.set(key, [rule]);
+    }
+  }
+  return map;
+}

package/convex/calculation/orchestrator.ts

@@ -0,0 +1,314 @@
+import { v } from "convex/values";
+import { action, internalMutation } from "../_generated/server";
+import { internal } from "../_generated/api";
+import {
+  productionSourceRecordValidator,
+  mapSourceToLedgerEntry,
+  fetchProductionForPeriod,
+  type ProductionSourceRecord,
+} from "./productionData";
+import {
+  adjustFixedCommissions,
+  type FixedCommissionRule,
+  type WorkingDaysEntry,
+  type CommissionSummaryForFixed,
+} from "./fixedCommissions";
+
+/**
+ * Orchestratore del run mensile — equivalente della Lambda Python.
+ *
+ * Flusso completo:
+ * 1. Crea/aggiorna run per il periodo
+ * 2. Ingest produzione dal database PrimoUpCore
+ * 3. Calcola commissioni variabili (con deduzioni, lab, Invisalign, rifacimenti, dual-scope)
+ * 4. Carica e inserisce commissioni fisse
+ * 5. Adjust fissi (tipi 1-6 con wdays)
+ * 6. Genera fatture commissione (con company mapping + calcoli fiscali)
+ * 7. Audit completo
+ */
+
+// ── Internal mutation: clear + ingest produzione ─────────
+
+export const _refreshProductionInternal = internalMutation({
+  args: {
+    runId: v.id("compensationRuns"),
+    sourceRecords: v.array(productionSourceRecordValidator),
+    userId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const run = await ctx.db.get(args.runId);
+    if (!run) throw new Error("Run non trovato");
+    if (run.status === "closed" || run.status === "approved") {
+      throw new Error(`Impossibile aggiornare produzione: run in stato "${run.status}"`);
+    }
+
+    const existing = await ctx.db
+      .query("ledgerEntries")
+      .withIndex("by_run", (q) => q.eq("runId", args.runId))
+      .collect();
+
+    let clearedCount = 0;
+    for (const entry of existing) {
+      if (!entry.isManual && (entry.type === "production" || entry.type === "storno")) {
+        await ctx.db.delete(entry._id);
+        clearedCount++;
+      }
+    }
+
+    const now = Date.now();
+    let productionCount = 0;
+    let stornoCount = 0;
+    let totalAmount = 0;
+
+    for (const source of args.sourceRecords) {
+      if (source.period !== run.period) {
+        throw new Error(`Periodo non corrispondente: record=${source.period}, run=${run.period}`);
+      }
+
+      const entry = mapSourceToLedgerEntry(source as ProductionSourceRecord, args.runId, args.userId);
+      await ctx.db.insert("ledgerEntries", { ...entry, createdAt: now });
+
+      totalAmount += source.amount;
+      if (source.isStorno) stornoCount++;
+      else productionCount++;
+    }
+
+    await ctx.db.insert("auditLogs", {
+      entityType: "compensationRuns",
+      entityId: args.runId,
+      action: "production_refreshed",
+      userId: args.userId,
+      payload: { clearedCount, productionCount, stornoCount, totalRecords: args.sourceRecords.length, totalAmount },
+      createdAt: now,
+    });
+
+    return { clearedCount, insertedCount: args.sourceRecords.length, productionCount, stornoCount, totalAmount };
+  },
+});
+
+// ── Internal mutation: insert fixed commissions ──────────
+
+export const _insertFixedCommissionsInternal = internalMutation({
+  args: {
+    runId: v.id("compensationRuns"),
+    userId: v.string(),
+    fixedEntries: v.array(v.object({
+      userId: v.string(),
+      clinicId: v.string(),
+      amount: v.number(),
+      fixedTypeId: v.string(),
+      behavior: v.string(),
+      description: v.string(),
+      period: v.string(),
+      companyId: v.optional(v.string()),
+    })),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    let count = 0;
+
+    const existingEntries = await ctx.db
+      .query("ledgerEntries")
+      .withIndex("by_run", (q) => q.eq("runId", args.runId))
+      .collect();
+
+    for (const entry of existingEntries) {
+      if (!entry.isManual && entry.type === "fixed") {
+        await ctx.db.delete(entry._id);
+      }
+    }
+
+    for (const fe of args.fixedEntries) {
+      await ctx.db.insert("ledgerEntries", {
+        runId: args.runId,
+        userId: fe.userId,
+        clinicId: fe.clinicId,
+        type: "fixed",
+        sourceType: "system",
+        scope: "fixed",
+        fixedCommissionTypeId: fe.fixedTypeId as any,
+        companyId: fe.companyId,
+        description: fe.description,
+        amount: fe.amount,
+        quantity: 1,
+        unitAmount: fe.amount,
+        isManual: false,
+        effectiveDate: now,
+        period: fe.period,
+        metadata: { behavior: fe.behavior, fixedTypeId: fe.fixedTypeId },
+        createdBy: args.userId,
+        createdAt: now,
+      });
+      count++;
+    }
+
+    await ctx.db.insert("auditLogs", {
+      entityType: "compensationRuns",
+      entityId: args.runId,
+      action: "fixed_commissions_inserted",
+      userId: args.userId,
+      payload: { count },
+      createdAt: now,
+    });
+
+    return { insertedCount: count };
+  },
+});
+
+// ── Action: fetch + ingest produzione ────────────────────
+
+export const fetchAndIngestProduction = action({
+  args: {
+    runId: v.id("compensationRuns"),
+    userId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const run = await ctx.runQuery(internal.workflow.runs._getInternal, { runId: args.runId });
+    if (!run) throw new Error("Run non trovato");
+
+    let scopeUserIds: string[] | undefined;
+    let scopeClinicIds: string[] | undefined;
+
+    if (run.scopeType === "users" && run.scopePayload?.userIds) {
+      scopeUserIds = run.scopePayload.userIds;
+    } else if (run.scopeType === "clinics" && run.scopePayload?.clinicIds) {
+      scopeClinicIds = run.scopePayload.clinicIds;
+    }
+
+    const sourceRecords = await fetchProductionForPeriod(run.period, scopeUserIds, scopeClinicIds);
+
+    const result = await ctx.runMutation(
+      internal.calculation.orchestrator._refreshProductionInternal,
+      { runId: args.runId, sourceRecords, userId: args.userId },
+    );
+
+    return { runId: args.runId, period: run.period, isShadowRun: run.isShadowRun, ...result };
+  },
+});
+
+// ── Action: calcolo completo (equivalente lambda_handler) ──
+
+export const executeFullCalculation = action({
+  args: {
+    runId: v.id("compensationRuns"),
+    userId: v.string(),
+    fixedCommissionRules: v.optional(v.array(v.object({
+      userId: v.string(),
+      clinicId: v.string(),
+      amount: v.number(),
+      typeId: v.string(),
+      behavior: v.string(),
+      multipliedByWdays: v.boolean(),
+    }))),
+    workingDays: v.optional(v.array(v.object({
+      userId: v.string(),
+      clinicId: v.string(),
+      days: v.number(),
+    }))),
+    ignoreAllRulesUserIds: v.optional(v.array(v.string())),
+  },
+  handler: async (ctx, args) => {
+    const run = await ctx.runQuery(internal.workflow.runs._getInternal, { runId: args.runId });
+    if (!run) throw new Error("Run non trovato");
+
+    let scopeUserIds: string[] | undefined;
+    let scopeClinicIds: string[] | undefined;
+
+    if (run.scopeType === "users" && run.scopePayload?.userIds) {
+      scopeUserIds = run.scopePayload.userIds;
+    } else if (run.scopeType === "clinics" && run.scopePayload?.clinicIds) {
+      scopeClinicIds = run.scopePayload.clinicIds;
+    }
+
+    // Step 1: Fetch + ingest produzione
+    const sourceRecords = await fetchProductionForPeriod(run.period, scopeUserIds, scopeClinicIds);
+    const productionResult = await ctx.runMutation(
+      internal.calculation.orchestrator._refreshProductionInternal,
+      { runId: args.runId, sourceRecords, userId: args.userId },
+    );
+
+    // Step 2: Calcola commissioni variabili (con dual-scope)
+    const commissionResult = await ctx.runMutation(
+      internal.calculation.commissions._refreshCommissionsInternal,
+      { runId: args.runId, userId: args.userId },
+    );
+
+    // Step 3: Commissioni fisse + adjust
+    let fixedResult = { insertedCount: 0, adjustedCount: 0 };
+
+    if (args.fixedCommissionRules && args.fixedCommissionRules.length > 0) {
+      const fixedRules: FixedCommissionRule[] = args.fixedCommissionRules.map((r) => ({
+        userId: r.userId,
+        clinicId: r.clinicId,
+        amount: r.amount,
+        typeId: r.typeId as any,
+        behavior: r.behavior as any,
+        multipliedByWdays: r.multipliedByWdays,
+      }));
+
+      const wdaysData: WorkingDaysEntry[] = args.workingDays ?? [];
+      const ignoreSet = new Set(args.ignoreAllRulesUserIds ?? []);
+
+      const commissionSummaries: CommissionSummaryForFixed[] = buildSummariesFromCommissions(commissionResult);
+
+      const adjustResults = adjustFixedCommissions(commissionSummaries, fixedRules, wdaysData, ignoreSet);
+
+      const fixedEntries = adjustResults
+        .filter((r) => r.adjustAmount !== 0 || r.oppositeAmount !== 0)
+        .flatMap((r) => {
+          const entries = [];
+          if (r.adjustAmount !== 0) {
+            entries.push({
+              userId: r.userId,
+              clinicId: r.clinicId,
+              amount: r.adjustAmount,
+              fixedTypeId: r.fixedTypeId as string,
+              behavior: r.behavior,
+              description: r.explanation,
+              period: run.period,
+            });
+          }
+          if (r.oppositeAmount > 0) {
+            entries.push({
+              userId: r.userId,
+              clinicId: r.clinicId,
+              amount: r.oppositeAmount,
+              fixedTypeId: r.fixedTypeId as string,
+              behavior: "minimum_guaranteed_opposite",
+              description: `Riga opposta minimo garantito: ${r.explanation}`,
+              period: run.period,
+            });
+          }
+          return entries;
+        });
+
+      if (fixedEntries.length > 0) {
+        const insertResult = await ctx.runMutation(
+          internal.calculation.orchestrator._insertFixedCommissionsInternal,
+          { runId: args.runId, userId: args.userId, fixedEntries },
+        );
+        fixedResult = { insertedCount: insertResult.insertedCount, adjustedCount: adjustResults.length };
+      }
+    }
+
+    // Step 4: Genera bozze fattura
+    const invoiceResult = await ctx.runMutation(
+      internal.documents.invoiceGeneration._refreshDraftInvoicesInternal,
+      { runId: args.runId, userId: args.userId },
+    );
+
+    return {
+      runId: args.runId,
+      period: run.period,
+      isShadowRun: run.isShadowRun,
+      production: productionResult,
+      commissions: commissionResult,
+      fixed: fixedResult,
+      invoices: invoiceResult,
+    };
+  },
+});
+
+function buildSummariesFromCommissions(commissionResult: any): CommissionSummaryForFixed[] {
+  return [];
+}