@primocaredentgroup/compensi-medici-core 0.1.0

package/convex/calculation/commissions.ts

@@ -0,0 +1,497 @@
+import { v } from "convex/values";
+import { mutation, query, internalMutation } from "../_generated/server";
+import {
+  calculateBatch,
+  type ProductionEntry,
+  type ResolvedPlan,
+  type ResolvedRule,
+  type CalculationContext,
+  type InvisalignConfigEntry,
+} from "./engine";
+import type { DeductionRuleConfig } from "./deductions";
+import type { RuleType, ExtendedProductionData } from "../lib/types";
+
+/**
+ * Pipeline di calcolo compensi con supporto dual-scope.
+ *
+ * Per ogni riga di produzione si generano fino a 2 commissioni:
+ * 1. "completed_rows" — per l'esecutore (completedBy)
+ * 2. "confirmed_care_plan" — per il titolare del piano di cura (doctorId), se diverso
+ *
+ * La riga extended con scope="confirmed_care_plan" usa doctorId come userId,
+ * e cerca un piano/regola dedicato per quello scope.
+ */
+
+// ── Guard ────────────────────────────────────────────────
+
+async function assertRunWritable(
+  ctx: { db: { get: (id: any) => Promise<any> } },
+  runId: any,
+): Promise<{ period: string }> {
+  const run = await ctx.db.get(runId);
+  if (!run) throw new Error("Run non trovato");
+  if (run.status === "closed") {
+    throw new Error("Impossibile calcolare compensi su un run chiuso");
+  }
+  if (run.status === "approved") {
+    throw new Error(
+      "Impossibile calcolare compensi su un run approvato. " +
+        "Riportarlo in draft prima di rigenerare.",
+    );
+  }
+  return { period: run.period };
+}
+
+// ── Context loader ───────────────────────────────────────
+
+async function loadCalculationContext(ctx: any): Promise<CalculationContext> {
+  const deductionRulesRaw = await ctx.db
+    .query("deductionRules")
+    .withIndex("by_active_priority", (q: any) => q.eq("isActive", true))
+    .collect();
+
+  const deductionRules: DeductionRuleConfig[] = deductionRulesRaw.map((r: any) => ({
+    code: r.code,
+    conditions: r.conditions,
+    deductionPercent: r.deductionPercent,
+    priority: r.priority,
+  }));
+
+  const invisalignConfigRaw = await ctx.db
+    .query("invisalignConfig")
+    .withIndex("by_active", (q: any) => q.eq("isActive", true))
+    .collect();
+
+  const invisalignConfig: InvisalignConfigEntry[] = invisalignConfigRaw.map((c: any) => ({
+    listRowId: c.listRowId,
+    firstPhasePercentage: c.firstPhasePercentage,
+    otherPhasesPercentage: c.otherPhasesPercentage,
+    firstPhaseMin: c.firstPhaseMin,
+    otherPhasesMin: c.otherPhasesMin,
+  }));
+
+  const invisalignMinUsersRaw = await ctx.db
+    .query("invisalignMinUsers")
+    .collect();
+  const invisalignMinUserIds = new Set<string>(
+    invisalignMinUsersRaw.filter((u: any) => u.isActive).map((u: any) => u.userId),
+  );
+
+  const settingsRaw = await ctx.db.query("globalSettings").collect();
+  const globalSettings = new Map<string, string>();
+  for (const s of settingsRaw) {
+    globalSettings.set(s.key, s.value);
+  }
+
+  return { deductionRules, invisalignConfig, invisalignMinUserIds, globalSettings };
+}
+
+// ── Plans & rules loader ─────────────────────────────────
+
+async function loadPlansAndRules(ctx: any, userIds: string[]) {
+  const allPlans: ResolvedPlan[] = [];
+  for (const uid of userIds) {
+    const userPlans = await ctx.db
+      .query("commissionPlans")
+      .withIndex("by_user_status", (q: any) => q.eq("userId", uid).eq("status", "active"))
+      .collect();
+    for (const p of userPlans) {
+      allPlans.push({
+        _id: p._id,
+        userId: p.userId,
+        code: p.code,
+        name: p.name,
+        status: p.status,
+        effectiveFrom: p.effectiveFrom,
+        effectiveTo: p.effectiveTo,
+      });
+    }
+  }
+
+  const rulesByPlan = new Map<string, ResolvedRule[]>();
+  for (const plan of allPlans) {
+    const rules = await ctx.db
+      .query("commissionRules")
+      .withIndex("by_plan_active", (q: any) => q.eq("planId", plan._id).eq("isActive", true))
+      .collect();
+
+    rulesByPlan.set(
+      plan._id,
+      rules.map((r: any) => ({
+        _id: r._id,
+        planId: r.planId,
+        name: r.name,
+        ruleType: r.ruleType as RuleType,
+        priority: r.priority,
+        isActive: r.isActive,
+        outputType: r.outputType,
+        explanationLabel: r.explanationLabel,
+        conditions: r.conditions as Record<string, unknown>,
+        formula: r.formula as Record<string, unknown>,
+        validFrom: r.validFrom,
+        validTo: r.validTo,
+      })),
+    );
+  }
+
+  return { allPlans, rulesByPlan };
+}
+
+// ── Dual-scope expansion ─────────────────────────────────
+
+/**
+ * Espande ogni riga di produzione in 1 o 2 ProductionEntry:
+ * - Una per completed_rows (esecutore)
+ * - Una per confirmed_care_plan (titolare piano di cura), se doctorId è diverso da completedBy
+ */
+function expandForDualScope(
+  entries: ProductionEntry[],
+): ProductionEntry[] {
+  const expanded: ProductionEntry[] = [];
+
+  for (const entry of entries) {
+    expanded.push(entry);
+
+    const ext = entry.extended;
+    if (!ext) continue;
+
+    const doctorId = ext.doctorId;
+    const completedBy = ext.completedBy ?? entry.userId;
+
+    if (doctorId && doctorId !== completedBy) {
+      const confirmedEntry: ProductionEntry = {
+        ...entry,
+        userId: doctorId,
+        extended: {
+          ...ext,
+          scope: "confirmed_care_plan",
+        },
+      };
+      expanded.push(confirmedEntry);
+    }
+  }
+
+  return expanded;
+}
+
+// ── Clear ────────────────────────────────────────────────
+
+export const clearCommissionEntries = mutation({
+  args: {
+    runId: v.id("compensationRuns"),
+    userId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    await assertRunWritable(ctx, args.runId);
+
+    const entries = await ctx.db
+      .query("ledgerEntries")
+      .withIndex("by_run", (q) => q.eq("runId", args.runId))
+      .collect();
+
+    let commissionDeleted = 0;
+    for (const entry of entries) {
+      if (!entry.isManual && entry.type === "commission") {
+        await ctx.db.delete(entry._id);
+        commissionDeleted++;
+      }
+    }
+
+    const ruleApps = await ctx.db
+      .query("ruleApplications")
+      .withIndex("by_run", (q) => q.eq("runId", args.runId))
+      .collect();
+
+    let ruleAppsDeleted = 0;
+    for (const ra of ruleApps) {
+      await ctx.db.delete(ra._id);
+      ruleAppsDeleted++;
+    }
+
+    if (commissionDeleted > 0 || ruleAppsDeleted > 0) {
+      await ctx.db.insert("auditLogs", {
+        entityType: "compensationRuns",
+        entityId: args.runId,
+        action: "commission_entries_cleared",
+        userId: args.userId,
+        payload: { commissionDeleted, ruleAppsDeleted },
+        createdAt: Date.now(),
+      });
+    }
+
+    return { commissionDeleted, ruleAppsDeleted };
+  },
+});
+
+// ── Refresh (idempotente) ────────────────────────────────
+
+async function _refreshHandler(ctx: any, args: { runId: any; userId: string }) {
+  const { period } = await assertRunWritable(ctx, args.runId);
+  const now = Date.now();
+
+  const allEntries = await ctx.db
+    .query("ledgerEntries")
+    .withIndex("by_run", (q: any) => q.eq("runId", args.runId))
+    .collect();
+
+  let clearedCommissions = 0;
+  for (const entry of allEntries) {
+    if (!entry.isManual && entry.type === "commission") {
+      await ctx.db.delete(entry._id);
+      clearedCommissions++;
+    }
+  }
+
+  const existingRuleApps = await ctx.db
+    .query("ruleApplications")
+    .withIndex("by_run", (q: any) => q.eq("runId", args.runId))
+    .collect();
+  for (const ra of existingRuleApps) {
+    await ctx.db.delete(ra._id);
+  }
+
+  const freshEntries = await ctx.db
+    .query("ledgerEntries")
+    .withIndex("by_run", (q: any) => q.eq("runId", args.runId))
+    .collect();
+
+  const productionEntries: ProductionEntry[] = freshEntries
+    .filter((e: any) => !e.isManual && (e.type === "production" || e.type === "storno"))
+    .map((e: any) => {
+      const meta = (e.metadata ?? {}) as Record<string, any>;
+      const extended: ExtendedProductionData | undefined = meta.extended ?? undefined;
+
+      return {
+        _id: e._id,
+        runId: e.runId,
+        userId: e.userId,
+        clinicId: e.clinicId,
+        type: e.type as "production" | "storno",
+        sourceId: e.sourceId,
+        amount: e.amount,
+        effectiveDate: e.effectiveDate,
+        period: e.period,
+        metadata: meta,
+        extended,
+      };
+    });
+
+  if (productionEntries.length === 0) {
+    return {
+      clearedCommissions,
+      productionEntries: 0,
+      commissionsGenerated: 0,
+      unmatchedEntries: 0,
+      unmatched: [],
+      totalCommissionAmount: 0,
+    };
+  }
+
+  const expandedEntries = expandForDualScope(productionEntries);
+
+  const userIds = [...new Set(expandedEntries.map((e) => e.userId))];
+  const { allPlans, rulesByPlan } = await loadPlansAndRules(ctx, userIds);
+  const calcContext = await loadCalculationContext(ctx);
+
+  const batchResult = calculateBatch(
+    expandedEntries,
+    allPlans,
+    rulesByPlan,
+    args.userId,
+    calcContext,
+  );
+
+  for (const result of batchResult.results) {
+    const commissionId = await ctx.db.insert("ledgerEntries", {
+      ...result.entry,
+      createdAt: now,
+    });
+
+    await ctx.db.insert("ruleApplications", {
+      ...result.ruleApplication,
+      generatedLedgerEntryId: commissionId,
+      createdAt: now,
+    });
+  }
+
+  await ctx.db.insert("auditLogs", {
+    entityType: "compensationRuns",
+    entityId: args.runId,
+    action: "commissions_refreshed",
+    userId: args.userId,
+    payload: {
+      clearedCommissions,
+      clearedRuleApps: existingRuleApps.length,
+      productionEntries: productionEntries.length,
+      expandedEntries: expandedEntries.length,
+      commissionsGenerated: batchResult.summary.totalMatched,
+      unmatchedEntries: batchResult.summary.totalUnmatched,
+      totalCommissionAmount: batchResult.summary.totalCommissionAmount,
+    },
+    createdAt: now,
+  });
+
+  return {
+    clearedCommissions,
+    productionEntries: productionEntries.length,
+    commissionsGenerated: batchResult.summary.totalMatched,
+    unmatchedEntries: batchResult.summary.totalUnmatched,
+    unmatched: batchResult.unmatched,
+    totalCommissionAmount: batchResult.summary.totalCommissionAmount,
+  };
+}
+
+export const refreshCommissions = mutation({
+  args: {
+    runId: v.id("compensationRuns"),
+    userId: v.string(),
+  },
+  handler: async (ctx, args) => _refreshHandler(ctx, args),
+});
+
+export const _refreshCommissionsInternal = internalMutation({
+  args: {
+    runId: v.id("compensationRuns"),
+    userId: v.string(),
+  },
+  handler: async (ctx, args) => _refreshHandler(ctx, args),
+});
+
+// ── Query ────────────────────────────────────────────────
+
+export const listCommissionEntries = query({
+  args: { runId: v.id("compensationRuns") },
+  handler: async (ctx, args) => {
+    const entries = await ctx.db
+      .query("ledgerEntries")
+      .withIndex("by_run", (q) => q.eq("runId", args.runId))
+      .collect();
+    return entries.filter((e) => !e.isManual && e.type === "commission");
+  },
+});
+
+export const listCommissionEntriesByUser = query({
+  args: {
+    runId: v.id("compensationRuns"),
+    userId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const entries = await ctx.db
+      .query("ledgerEntries")
+      .withIndex("by_run_user", (q) =>
+        q.eq("runId", args.runId).eq("userId", args.userId),
+      )
+      .collect();
+    return entries.filter((e) => !e.isManual && e.type === "commission");
+  },
+});
+
+export const getCommissionSummary = query({
+  args: { runId: v.id("compensationRuns") },
+  handler: async (ctx, args) => {
+    const entries = await ctx.db
+      .query("ledgerEntries")
+      .withIndex("by_run", (q) => q.eq("runId", args.runId))
+      .collect();
+
+    const commissions = entries.filter((e) => !e.isManual && e.type === "commission");
+
+    const byUser: Record<string, { total: number; count: number; byClinic: Record<string, number>; byScope: Record<string, number> }> = {};
+
+    for (const c of commissions) {
+      if (!byUser[c.userId]) {
+        byUser[c.userId] = { total: 0, count: 0, byClinic: {}, byScope: {} };
+      }
+      byUser[c.userId].total += c.amount;
+      byUser[c.userId].count++;
+      byUser[c.userId].byClinic[c.clinicId] = (byUser[c.userId].byClinic[c.clinicId] ?? 0) + c.amount;
+      const scope = (c.scope as string) ?? "completed_rows";
+      byUser[c.userId].byScope[scope] = (byUser[c.userId].byScope[scope] ?? 0) + c.amount;
+    }
+
+    return {
+      runId: args.runId,
+      totalCommissions: commissions.reduce((s, c) => s + c.amount, 0),
+      totalEntries: commissions.length,
+      byUser,
+    };
+  },
+});
+
+export const getCommissionSummaryByUser = query({
+  args: {
+    runId: v.id("compensationRuns"),
+    userId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const entries = await ctx.db
+      .query("ledgerEntries")
+      .withIndex("by_run_user", (q) =>
+        q.eq("runId", args.runId).eq("userId", args.userId),
+      )
+      .collect();
+
+    const commissions = entries.filter((e) => !e.isManual && e.type === "commission");
+
+    let total = 0;
+    const byClinic: Record<string, number> = {};
+    const byScope: Record<string, number> = {};
+    const byRule: Record<string, { total: number; count: number }> = {};
+
+    for (const c of commissions) {
+      total += c.amount;
+      byClinic[c.clinicId] = (byClinic[c.clinicId] ?? 0) + c.amount;
+      const scope = (c.scope as string) ?? "completed_rows";
+      byScope[scope] = (byScope[scope] ?? 0) + c.amount;
+      const ruleId = c.ruleId as string;
+      if (ruleId) {
+        if (!byRule[ruleId]) byRule[ruleId] = { total: 0, count: 0 };
+        byRule[ruleId].total += c.amount;
+        byRule[ruleId].count++;
+      }
+    }
+
+    return { runId: args.runId, userId: args.userId, total, count: commissions.length, byClinic, byScope, byRule };
+  },
+});
+
+export const getCommissionsForSourceEntry = query({
+  args: { sourceLedgerEntryId: v.id("ledgerEntries") },
+  handler: async (ctx, args) => {
+    const ruleApps = await ctx.db
+      .query("ruleApplications")
+      .withIndex("by_source_entry", (q) =>
+        q.eq("sourceLedgerEntryId", args.sourceLedgerEntryId),
+      )
+      .collect();
+
+    const result = [];
+    for (const ra of ruleApps) {
+      const entry = await ctx.db.get(ra.generatedLedgerEntryId);
+      result.push({ ruleApplication: ra, commissionEntry: entry });
+    }
+    return result;
+  },
+});
+
+export const listUnmatchedProductionEntries = query({
+  args: { runId: v.id("compensationRuns") },
+  handler: async (ctx, args) => {
+    const entries = await ctx.db
+      .query("ledgerEntries")
+      .withIndex("by_run", (q) => q.eq("runId", args.runId))
+      .collect();
+
+    const productionEntries = entries.filter(
+      (e) => !e.isManual && (e.type === "production" || e.type === "storno"),
+    );
+
+    const ruleApps = await ctx.db
+      .query("ruleApplications")
+      .withIndex("by_run", (q) => q.eq("runId", args.runId))
+      .collect();
+
+    const matchedSourceIds = new Set(ruleApps.map((ra) => ra.sourceLedgerEntryId));
+    return productionEntries.filter((e) => !matchedSourceIds.has(e._id));
+  },
+});

package/convex/calculation/deductions.ts

@@ -0,0 +1,119 @@
+/**
+ * Motore deduzioni — traduzione dell'albero decisionale dal Python.
+ *
+ * Nel vecchio sistema le 9 deduzioni erano hardcoded con company_id, care_plan_type_id, ecc.
+ * Qui le condizioni sono lette da `deductionRules` (configurabili da DB).
+ *
+ * L'ordine di valutazione segue la priorità della regola (numeri bassi = alta priorità).
+ * La prima regola che matcha viene applicata.
+ */
+
+import type { ExtendedProductionData } from "../lib/types";
+
+export interface DeductionRuleConfig {
+  code: string;
+  conditions: {
+    companyIds?: string[];
+    carePlanTypeIds?: number[];
+    isInsurance?: boolean;
+    isSinistro?: boolean;
+    percentageThreshold?: number;
+    percentageAboveThreshold?: boolean;
+    conventionNameContains?: string;
+    serviceCategoryNames?: string[];
+  };
+  deductionPercent: number;
+  priority: number;
+}
+
+export interface DeductionResult {
+  deductionAmount: number;
+  deductionPercent: number;
+  ruleCode: string | null;
+  explanation: string;
+}
+
+/**
+ * Risolve la deduzione applicabile a una riga di produzione.
+ *
+ * Se la riga ha un `amount` fisso (dalla regola commissione), la deduzione è 0.
+ * Altrimenti, cerca la prima deductionRule che matcha le condizioni della riga.
+ */
+export function resolveDeduction(
+  entry: ExtendedProductionData,
+  rules: DeductionRuleConfig[],
+  settings: Map<string, string>,
+  fixedAmount: number | undefined,
+): DeductionResult {
+  if (fixedAmount !== undefined && fixedAmount !== null) {
+    return { deductionAmount: 0, deductionPercent: 0, ruleCode: null, explanation: "Importo fisso: nessuna deduzione" };
+  }
+
+  const sorted = [...rules].sort((a, b) => a.priority - b.priority);
+
+  for (const rule of sorted) {
+    if (matchesDeductionConditions(entry, rule.conditions)) {
+      const percent = rule.deductionPercent;
+      const deductionAmount = roundCurrency(percent * entry.netPrice / 100);
+      return {
+        deductionAmount,
+        deductionPercent: percent,
+        ruleCode: rule.code,
+        explanation: `Deduzione ${rule.code}: ${percent}% di ${entry.netPrice} = ${deductionAmount}`,
+      };
+    }
+  }
+
+  return { deductionAmount: 0, deductionPercent: 0, ruleCode: null, explanation: "Nessuna regola di deduzione applicabile" };
+}
+
+function matchesDeductionConditions(
+  entry: ExtendedProductionData,
+  conditions: DeductionRuleConfig["conditions"],
+): boolean {
+  if (conditions.companyIds && conditions.companyIds.length > 0) {
+    if (!entry.companyId || !conditions.companyIds.includes(entry.companyId)) return false;
+  }
+
+  if (conditions.carePlanTypeIds && conditions.carePlanTypeIds.length > 0) {
+    if (entry.carePlanTypeId === undefined || !conditions.carePlanTypeIds.includes(entry.carePlanTypeId)) return false;
+  }
+
+  if (conditions.isInsurance !== undefined) {
+    if (entry.isInsurance !== conditions.isInsurance) return false;
+  }
+
+  if (conditions.isSinistro !== undefined) {
+    const entrySinistro = !entry.isInsurance && entry.carePlanTypeId !== 2;
+    if (conditions.isSinistro && !entrySinistro) return false;
+    if (!conditions.isSinistro && entrySinistro) return false;
+  }
+
+  if (conditions.percentageThreshold !== undefined) {
+    const rulePercentage = entry.cprPercentage * 100;
+    if (conditions.percentageAboveThreshold) {
+      if (rulePercentage < conditions.percentageThreshold) return false;
+    } else {
+      if (rulePercentage >= conditions.percentageThreshold) return false;
+    }
+  }
+
+  if (conditions.conventionNameContains) {
+    const convName = entry.conventionName?.toLowerCase() ?? "";
+    if (!convName.includes(conditions.conventionNameContains.toLowerCase())) return false;
+  }
+
+  if (conditions.serviceCategoryNames && conditions.serviceCategoryNames.length > 0) {
+    const catName = entry.serviceCategoryName?.toLowerCase() ?? "";
+    const matches = conditions.serviceCategoryNames.some((name) =>
+      catName.includes(name.toLowerCase()),
+    );
+    if (!matches) return false;
+  }
+
+  return true;
+}
+
+function roundCurrency(value: number): number {
+  return Math.round(value * 100) / 100;
+}