@primocaredentgroup/compensi-medici-core 0.1.0

package/convex/config/deductionRules.ts

@@ -0,0 +1,113 @@
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server";
+
+const conditionsValidator = v.object({
+  companyIds: v.optional(v.array(v.string())),
+  carePlanTypeIds: v.optional(v.array(v.number())),
+  isInsurance: v.optional(v.boolean()),
+  isSinistro: v.optional(v.boolean()),
+  percentageThreshold: v.optional(v.number()),
+  percentageAboveThreshold: v.optional(v.boolean()),
+  conventionNameContains: v.optional(v.string()),
+  serviceCategoryNames: v.optional(v.array(v.string())),
+});
+
+export const create = mutation({
+  args: {
+    code: v.string(),
+    label: v.string(),
+    description: v.optional(v.string()),
+    conditions: conditionsValidator,
+    deductionPercent: v.number(),
+    priority: v.number(),
+    createdBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const { createdBy, ...fields } = args;
+
+    const id = await ctx.db.insert("deductionRules", {
+      ...fields,
+      isActive: true,
+      createdBy,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.insert("auditLogs", {
+      entityType: "deductionRules",
+      entityId: id,
+      action: "created",
+      userId: createdBy,
+      payload: { code: args.code, label: args.label },
+      createdAt: now,
+    });
+
+    return id;
+  },
+});
+
+export const update = mutation({
+  args: {
+    ruleId: v.id("deductionRules"),
+    label: v.optional(v.string()),
+    description: v.optional(v.string()),
+    conditions: v.optional(conditionsValidator),
+    deductionPercent: v.optional(v.number()),
+    priority: v.optional(v.number()),
+    isActive: v.optional(v.boolean()),
+    updatedBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const { ruleId, updatedBy, ...fields } = args;
+    const now = Date.now();
+
+    const patch: Record<string, unknown> = { updatedAt: now };
+    for (const [k, val] of Object.entries(fields)) {
+      if (val !== undefined) patch[k] = val;
+    }
+
+    await ctx.db.patch(ruleId, patch);
+
+    await ctx.db.insert("auditLogs", {
+      entityType: "deductionRules",
+      entityId: ruleId,
+      action: "updated",
+      userId: updatedBy,
+      payload: patch,
+      createdAt: now,
+    });
+  },
+});
+
+export const get = query({
+  args: { ruleId: v.id("deductionRules") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.ruleId);
+  },
+});
+
+export const listActive = query({
+  handler: async (ctx) => {
+    return await ctx.db
+      .query("deductionRules")
+      .withIndex("by_active_priority", (q) => q.eq("isActive", true))
+      .collect();
+  },
+});
+
+export const listAll = query({
+  handler: async (ctx) => {
+    return await ctx.db.query("deductionRules").collect();
+  },
+});
+
+export const getByCode = query({
+  args: { code: v.string() },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("deductionRules")
+      .withIndex("by_code", (q) => q.eq("code", args.code))
+      .first();
+  },
+});

package/convex/config/fixedCommissionTypes.ts

@@ -0,0 +1,79 @@
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server";
+
+const behaviorValidator = v.union(
+  v.literal("minimum_guaranteed"),
+  v.literal("additive"),
+  v.literal("substitutive"),
+  v.literal("substitutive_no_wdays"),
+);
+
+export const create = mutation({
+  args: {
+    code: v.string(),
+    name: v.string(),
+    description: v.optional(v.string()),
+    behavior: behaviorValidator,
+    multipliedByWdays: v.boolean(),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    return await ctx.db.insert("fixedCommissionTypes", {
+      ...args,
+      isActive: true,
+      createdAt: now,
+      updatedAt: now,
+    });
+  },
+});
+
+export const update = mutation({
+  args: {
+    typeId: v.id("fixedCommissionTypes"),
+    name: v.optional(v.string()),
+    description: v.optional(v.string()),
+    behavior: v.optional(behaviorValidator),
+    multipliedByWdays: v.optional(v.boolean()),
+    isActive: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    const { typeId, ...fields } = args;
+    const patch: Record<string, unknown> = { updatedAt: Date.now() };
+    for (const [k, val] of Object.entries(fields)) {
+      if (val !== undefined) patch[k] = val;
+    }
+    await ctx.db.patch(typeId, patch);
+  },
+});
+
+export const get = query({
+  args: { typeId: v.id("fixedCommissionTypes") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.typeId);
+  },
+});
+
+export const listActive = query({
+  handler: async (ctx) => {
+    return await ctx.db
+      .query("fixedCommissionTypes")
+      .withIndex("by_active", (q) => q.eq("isActive", true))
+      .collect();
+  },
+});
+
+export const listAll = query({
+  handler: async (ctx) => {
+    return await ctx.db.query("fixedCommissionTypes").collect();
+  },
+});
+
+export const getByCode = query({
+  args: { code: v.string() },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("fixedCommissionTypes")
+      .withIndex("by_code", (q) => q.eq("code", args.code))
+      .first();
+  },
+});

package/convex/config/globalSettings.ts

@@ -0,0 +1,79 @@
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server";
+
+export const set = mutation({
+  args: {
+    key: v.string(),
+    value: v.string(),
+    description: v.optional(v.string()),
+    updatedBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("globalSettings")
+      .withIndex("by_key", (q) => q.eq("key", args.key))
+      .first();
+
+    const now = Date.now();
+
+    if (existing) {
+      await ctx.db.patch(existing._id, {
+        value: args.value,
+        description: args.description ?? existing.description,
+        updatedBy: args.updatedBy,
+        updatedAt: now,
+      });
+      return existing._id;
+    }
+
+    return await ctx.db.insert("globalSettings", {
+      key: args.key,
+      value: args.value,
+      description: args.description,
+      updatedBy: args.updatedBy,
+      updatedAt: now,
+    });
+  },
+});
+
+export const get = query({
+  args: { key: v.string() },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("globalSettings")
+      .withIndex("by_key", (q) => q.eq("key", args.key))
+      .first();
+  },
+});
+
+export const getNumber = query({
+  args: { key: v.string(), defaultValue: v.number() },
+  handler: async (ctx, args) => {
+    const setting = await ctx.db
+      .query("globalSettings")
+      .withIndex("by_key", (q) => q.eq("key", args.key))
+      .first();
+    if (!setting) return args.defaultValue;
+    const parsed = parseFloat(setting.value);
+    return isNaN(parsed) ? args.defaultValue : parsed;
+  },
+});
+
+export const listAll = query({
+  handler: async (ctx) => {
+    return await ctx.db.query("globalSettings").collect();
+  },
+});
+
+export const remove = mutation({
+  args: { key: v.string() },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("globalSettings")
+      .withIndex("by_key", (q) => q.eq("key", args.key))
+      .first();
+    if (existing) {
+      await ctx.db.delete(existing._id);
+    }
+  },
+});

package/convex/config/invisalignConfig.ts

@@ -0,0 +1,87 @@
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server";
+
+export const upsert = mutation({
+  args: {
+    listRowId: v.string(),
+    firstPhasePercentage: v.number(),
+    otherPhasesPercentage: v.number(),
+    firstPhaseMin: v.number(),
+    otherPhasesMin: v.number(),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const existing = await ctx.db
+      .query("invisalignConfig")
+      .withIndex("by_listRowId", (q) => q.eq("listRowId", args.listRowId))
+      .first();
+
+    if (existing) {
+      await ctx.db.patch(existing._id, {
+        firstPhasePercentage: args.firstPhasePercentage,
+        otherPhasesPercentage: args.otherPhasesPercentage,
+        firstPhaseMin: args.firstPhaseMin,
+        otherPhasesMin: args.otherPhasesMin,
+        updatedAt: now,
+      });
+      return existing._id;
+    }
+
+    return await ctx.db.insert("invisalignConfig", {
+      ...args,
+      isActive: true,
+      createdAt: now,
+      updatedAt: now,
+    });
+  },
+});
+
+export const listActive = query({
+  handler: async (ctx) => {
+    return await ctx.db
+      .query("invisalignConfig")
+      .withIndex("by_active", (q) => q.eq("isActive", true))
+      .collect();
+  },
+});
+
+export const listAll = query({
+  handler: async (ctx) => {
+    return await ctx.db.query("invisalignConfig").collect();
+  },
+});
+
+export const addMinUser = mutation({
+  args: { userId: v.string() },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("invisalignMinUsers")
+      .withIndex("by_userId", (q) => q.eq("userId", args.userId))
+      .first();
+    if (existing) return existing._id;
+    return await ctx.db.insert("invisalignMinUsers", {
+      userId: args.userId,
+      isActive: true,
+      createdAt: Date.now(),
+    });
+  },
+});
+
+export const removeMinUser = mutation({
+  args: { userId: v.string() },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("invisalignMinUsers")
+      .withIndex("by_userId", (q) => q.eq("userId", args.userId))
+      .first();
+    if (existing) {
+      await ctx.db.patch(existing._id, { isActive: false });
+    }
+  },
+});
+
+export const listMinUsers = query({
+  handler: async (ctx) => {
+    return await ctx.db.query("invisalignMinUsers").collect();
+  },
+});

package/convex/config/planTemplates.ts

@@ -0,0 +1,90 @@
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server";
+
+/**
+ * Template di piani provvigionali.
+ * Da analisi.md: i piani sono "basati su template" e "importabili da CSV/Excel".
+ *
+ * Un template contiene una struttura di regole predefinite
+ * che vengono copiate quando si crea un nuovo piano.
+ */
+
+export const create = mutation({
+  args: {
+    code: v.string(),
+    name: v.string(),
+    description: v.optional(v.string()),
+    defaultRules: v.optional(v.any()),
+    createdBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const { createdBy, ...fields } = args;
+
+    const templateId = await ctx.db.insert("commissionPlanTemplates", {
+      ...fields,
+      isActive: true,
+      createdBy,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.insert("auditLogs", {
+      entityType: "commissionPlanTemplates",
+      entityId: templateId,
+      action: "created",
+      userId: createdBy,
+      payload: { code: args.code, name: args.name },
+      createdAt: now,
+    });
+
+    return templateId;
+  },
+});
+
+export const update = mutation({
+  args: {
+    templateId: v.id("commissionPlanTemplates"),
+    name: v.optional(v.string()),
+    description: v.optional(v.string()),
+    defaultRules: v.optional(v.any()),
+    isActive: v.optional(v.boolean()),
+    updatedBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const { templateId, updatedBy, ...fields } = args;
+    const now = Date.now();
+
+    const patch: Record<string, unknown> = { updatedAt: now };
+    for (const [k, val] of Object.entries(fields)) {
+      if (val !== undefined) patch[k] = val;
+    }
+
+    await ctx.db.patch(templateId, patch);
+
+    await ctx.db.insert("auditLogs", {
+      entityType: "commissionPlanTemplates",
+      entityId: templateId,
+      action: "updated",
+      userId: updatedBy,
+      payload: patch,
+      createdAt: now,
+    });
+  },
+});
+
+export const get = query({
+  args: { templateId: v.id("commissionPlanTemplates") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.templateId);
+  },
+});
+
+export const listActive = query({
+  handler: async (ctx) => {
+    return await ctx.db
+      .query("commissionPlanTemplates")
+      .withIndex("by_active", (q) => q.eq("isActive", true))
+      .collect();
+  },
+});

package/convex/config/taxProfiles.ts

@@ -0,0 +1,122 @@
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server";
+
+export const create = mutation({
+  args: {
+    code: v.string(),
+    name: v.string(),
+    description: v.optional(v.string()),
+    vatRatePercent: v.number(),
+    withholdingRatePercent: v.number(),
+    withholdingOnPercent: v.number(),
+    contributionRatePercent: v.number(),
+    contributionWithholding: v.boolean(),
+    contributionText: v.optional(v.string()),
+    stampDutyEnabled: v.boolean(),
+    stampDutyAmount: v.number(),
+    stampDutyThreshold: v.number(),
+    is104: v.boolean(),
+    isBolloCompreso: v.boolean(),
+    footerText: v.optional(v.string()),
+    additionalRules: v.optional(v.any()),
+    createdBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const { createdBy, ...fields } = args;
+
+    const profileId = await ctx.db.insert("taxProfiles", {
+      ...fields,
+      isActive: true,
+      createdBy,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.insert("auditLogs", {
+      entityType: "taxProfiles",
+      entityId: profileId,
+      action: "created",
+      userId: createdBy,
+      payload: { code: args.code, name: args.name },
+      createdAt: now,
+    });
+
+    return profileId;
+  },
+});
+
+export const update = mutation({
+  args: {
+    profileId: v.id("taxProfiles"),
+    name: v.optional(v.string()),
+    description: v.optional(v.string()),
+    vatRatePercent: v.optional(v.number()),
+    withholdingRatePercent: v.optional(v.number()),
+    withholdingOnPercent: v.optional(v.number()),
+    contributionRatePercent: v.optional(v.number()),
+    contributionWithholding: v.optional(v.boolean()),
+    contributionText: v.optional(v.string()),
+    stampDutyEnabled: v.optional(v.boolean()),
+    stampDutyAmount: v.optional(v.number()),
+    stampDutyThreshold: v.optional(v.number()),
+    is104: v.optional(v.boolean()),
+    isBolloCompreso: v.optional(v.boolean()),
+    footerText: v.optional(v.string()),
+    additionalRules: v.optional(v.any()),
+    isActive: v.optional(v.boolean()),
+    updatedBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const { profileId, updatedBy, ...fields } = args;
+    const now = Date.now();
+
+    const patch: Record<string, unknown> = { updatedAt: now };
+    for (const [k, val] of Object.entries(fields)) {
+      if (val !== undefined) patch[k] = val;
+    }
+
+    await ctx.db.patch(profileId, patch);
+
+    await ctx.db.insert("auditLogs", {
+      entityType: "taxProfiles",
+      entityId: profileId,
+      action: "updated",
+      userId: updatedBy,
+      payload: patch,
+      createdAt: now,
+    });
+  },
+});
+
+export const get = query({
+  args: { profileId: v.id("taxProfiles") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.profileId);
+  },
+});
+
+export const listActive = query({
+  handler: async (ctx) => {
+    return await ctx.db
+      .query("taxProfiles")
+      .withIndex("by_active", (q) => q.eq("isActive", true))
+      .collect();
+  },
+});
+
+export const listAll = query({
+  handler: async (ctx) => {
+    return await ctx.db.query("taxProfiles").collect();
+  },
+});
+
+export const getByCode = query({
+  args: { code: v.string() },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("taxProfiles")
+      .withIndex("by_code", (q) => q.eq("code", args.code))
+      .first();
+  },
+});

package/convex/config/userTaxProfiles.ts

@@ -0,0 +1,87 @@
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server";
+
+/**
+ * Assegnazione profilo fiscale a un medico nel tempo.
+ * Un medico può cambiare regime fiscale; questa tabella
+ * traccia quale profilo è valido in quale periodo.
+ *
+ * Separata da taxProfiles per supportare lo storico:
+ * se un medico passa da forfettario a ordinario,
+ * entrambe le assegnazioni restano nel sistema.
+ */
+
+export const assign = mutation({
+  args: {
+    userId: v.string(),
+    taxProfileId: v.id("taxProfiles"),
+    effectiveFrom: v.number(),
+    effectiveTo: v.optional(v.number()),
+    notes: v.optional(v.string()),
+    createdBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const { createdBy, ...fields } = args;
+    const now = Date.now();
+
+    const assignmentId = await ctx.db.insert("userTaxProfiles", {
+      ...fields,
+      createdBy,
+      createdAt: now,
+    });
+
+    await ctx.db.insert("auditLogs", {
+      entityType: "userTaxProfiles",
+      entityId: assignmentId,
+      action: "assigned",
+      userId: createdBy,
+      payload: {
+        targetUserId: args.userId,
+        taxProfileId: args.taxProfileId,
+      },
+      createdAt: now,
+    });
+
+    return assignmentId;
+  },
+});
+
+/** Elenca tutte le assegnazioni per un medico (storico completo) */
+export const listByUser = query({
+  args: { userId: v.string() },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("userTaxProfiles")
+      .withIndex("by_user", (q) => q.eq("userId", args.userId))
+      .collect();
+  },
+});
+
+/**
+ * Trova il profilo fiscale effettivo per un medico a una data.
+ * Restituisce l'assegnazione con effectiveFrom ≤ date
+ * e effectiveTo > date (o senza scadenza).
+ */
+export const getEffective = query({
+  args: {
+    userId: v.string(),
+    atDate: v.number(),
+  },
+  handler: async (ctx, args) => {
+    const assignments = await ctx.db
+      .query("userTaxProfiles")
+      .withIndex("by_user_effective", (q) => q.eq("userId", args.userId))
+      .collect();
+
+    const effective = assignments.find(
+      (a) =>
+        a.effectiveFrom <= args.atDate &&
+        (a.effectiveTo === undefined || a.effectiveTo > args.atDate),
+    );
+
+    if (!effective) return null;
+
+    const profile = await ctx.db.get(effective.taxProfileId);
+    return { assignment: effective, profile };
+  },
+});

package/convex/convex.config.ts

@@ -0,0 +1,3 @@
+import { defineComponent } from "convex/server";
+
+export default defineComponent("compensiMedici");