@primocaredentgroup/elettromedicali 0.1.0

package/src/component/ticketTriggers.ts

@@ -0,0 +1,1152 @@
+import { v } from 'convex/values';
+import { query, mutation } from './_generated/server';
+import { api } from './_generated/api';
+
+export const listAllTriggers = query({
+  args: {},
+  handler: async (ctx) => {
+    const triggers = await ctx.db
+      .query('ticket_triggers')
+      .collect();
+
+    return triggers.sort((a, b) => a.priority - b.priority);
+  },
+});
+
+export const listActiveTriggers = query({
+  args: {},
+  handler: async (ctx) => {
+    const triggers = await ctx.db
+      .query('ticket_triggers')
+      .withIndex('by_isActive', (q: any) => q.eq('isActive', true))
+      .collect();
+
+    return triggers.sort((a, b) => a.priority - b.priority);
+  },
+});
+
+export const getTrigger = query({
+  args: { triggerId: v.id('ticket_triggers') },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.triggerId);
+  },
+});
+
+export const createTrigger = mutation({
+  args: {
+    name: v.string(),
+    description: v.optional(v.string()),
+    priority: v.optional(v.number()),
+    conditions: v.object({
+      conditionLogic: v.optional(v.union(v.literal('AND'), v.literal('OR'))),
+      conditionsList: v.optional(v.array(v.object({
+        type: v.union(
+          v.literal('trigger_event'),
+          v.literal('status'),
+          v.literal('category'),
+          v.literal('brand'),
+          v.literal('model'),
+          v.literal('region'),
+          v.literal('priority'),
+          v.literal('custom_field')
+        ),
+        negated: v.boolean(),
+        value: v.union(v.string(), v.array(v.string())),
+        nextOperator: v.union(v.literal('AND'), v.literal('OR')),
+        customFieldId: v.optional(v.id('ticket_custom_fields')),
+        customFieldOperator: v.optional(v.union(
+          v.literal('equals'),
+          v.literal('not_equals'),
+          v.literal('contains'),
+          v.literal('greater_than'),
+          v.literal('less_than'),
+          v.literal('is_empty'),
+          v.literal('is_not_empty')
+        )),
+      }))),
+      categories: v.optional(v.array(v.string())),
+      applyToAllCategories: v.boolean(),
+      regions: v.optional(v.array(v.string())),
+      applyToAllRegions: v.optional(v.boolean()),
+      brands: v.optional(v.array(v.string())),
+      brandOperator: v.optional(v.union(v.literal('is'), v.literal('is_not'))),
+      models: v.optional(v.array(v.string())),
+      modelOperator: v.optional(v.union(v.literal('is'), v.literal('is_not'))),
+      statuses: v.optional(v.array(v.string())),
+      statusOperator: v.optional(v.union(v.literal('is'), v.literal('is_not'))),
+      customFieldConditions: v.optional(v.array(v.object({
+        fieldId: v.id('ticket_custom_fields'),
+        operator: v.union(
+          v.literal('equals'),
+          v.literal('not_equals'),
+          v.literal('contains'),
+          v.literal('greater_than'),
+          v.literal('less_than'),
+          v.literal('is_empty'),
+          v.literal('is_not_empty')
+        ),
+        value: v.optional(v.any()),
+      }))),
+      triggerOn: v.union(
+        v.literal('create'),
+        v.literal('status_change'),
+        v.literal('update'),
+        v.literal('sla_warning'),
+        v.literal('sla_breach'),
+        v.literal('spare_part_order_created'),
+        v.literal('spare_part_order_status_change')
+      ),
+      sparePartOrderFilters: v.optional(v.object({
+        supplierIds: v.optional(v.array(v.id('suppliers'))),
+        applyToAllSuppliers: v.optional(v.boolean()),
+        statuses: v.optional(v.array(v.string())),
+      })),
+    }),
+    actions: v.object({
+      changeStatus: v.optional(v.string()),
+      assignSupplier: v.optional(v.id('suppliers')),
+      setSlaHours: v.optional(v.number()),
+      applySlaRule: v.optional(v.boolean()),
+      setPriority: v.optional(v.union(
+        v.literal('low'),
+        v.literal('medium'),
+        v.literal('high')
+      )),
+      addNote: v.optional(v.string()),
+      sendNotification: v.optional(v.object({
+        recipients: v.array(v.object({
+          type: v.union(
+            v.literal('admin'),
+            v.literal('supplier'),
+            v.literal('ticket_creator'),
+            v.literal('ticket_assignee'),
+            v.literal('specific_user'),
+            v.literal('specific_supplier')
+          ),
+          userId: v.optional(v.id('user_profiles')),
+          supplierId: v.optional(v.id('suppliers')),
+        })),
+        message: v.string(),
+      })),
+      requireAttachment: v.optional(v.boolean()),
+      sparePartOrderActions: v.optional(v.object({
+        changeOrderStatus: v.optional(v.string()),
+        addOrderNote: v.optional(v.string()),
+        sendOrderNotification: v.optional(v.object({
+          recipients: v.array(v.union(
+            v.literal('admin'),
+            v.literal('supplier'),
+            v.literal('order_creator')
+          )),
+          message: v.string(),
+        })),
+      })),
+    }),
+    createdBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    let priority = args.priority;
+    if (priority === undefined) {
+      const lastTrigger = await ctx.db
+        .query('ticket_triggers')
+        .withIndex('by_priority')
+        .order('desc')
+        .first();
+      priority = lastTrigger ? lastTrigger.priority + 1 : 0;
+    }
+
+    const triggerId = await ctx.db.insert('ticket_triggers', {
+      name: args.name,
+      description: args.description,
+      isActive: true,
+      priority,
+      conditions: args.conditions,
+      actions: args.actions,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      createdBy: args.createdBy,
+    });
+
+    return triggerId;
+  },
+});
+
+export const updateTrigger = mutation({
+  args: {
+    triggerId: v.id('ticket_triggers'),
+    name: v.optional(v.string()),
+    description: v.optional(v.string()),
+    priority: v.optional(v.number()),
+    isActive: v.optional(v.boolean()),
+    conditions: v.optional(v.object({
+      conditionLogic: v.optional(v.union(v.literal('AND'), v.literal('OR'))),
+      conditionsList: v.optional(v.array(v.object({
+        type: v.union(
+          v.literal('trigger_event'),
+          v.literal('status'),
+          v.literal('category'),
+          v.literal('brand'),
+          v.literal('model'),
+          v.literal('region'),
+          v.literal('priority'),
+          v.literal('custom_field')
+        ),
+        negated: v.boolean(),
+        value: v.union(v.string(), v.array(v.string())),
+        nextOperator: v.union(v.literal('AND'), v.literal('OR')),
+        customFieldId: v.optional(v.id('ticket_custom_fields')),
+        customFieldOperator: v.optional(v.union(
+          v.literal('equals'),
+          v.literal('not_equals'),
+          v.literal('contains'),
+          v.literal('greater_than'),
+          v.literal('less_than'),
+          v.literal('is_empty'),
+          v.literal('is_not_empty')
+        )),
+      }))),
+      categories: v.optional(v.array(v.string())),
+      applyToAllCategories: v.boolean(),
+      regions: v.optional(v.array(v.string())),
+      applyToAllRegions: v.optional(v.boolean()),
+      brands: v.optional(v.array(v.string())),
+      brandOperator: v.optional(v.union(v.literal('is'), v.literal('is_not'))),
+      models: v.optional(v.array(v.string())),
+      modelOperator: v.optional(v.union(v.literal('is'), v.literal('is_not'))),
+      statuses: v.optional(v.array(v.string())),
+      statusOperator: v.optional(v.union(v.literal('is'), v.literal('is_not'))),
+      customFieldConditions: v.optional(v.array(v.object({
+        fieldId: v.id('ticket_custom_fields'),
+        operator: v.union(
+          v.literal('equals'),
+          v.literal('not_equals'),
+          v.literal('contains'),
+          v.literal('greater_than'),
+          v.literal('less_than'),
+          v.literal('is_empty'),
+          v.literal('is_not_empty')
+        ),
+        value: v.optional(v.any()),
+      }))),
+      triggerOn: v.union(
+        v.literal('create'),
+        v.literal('status_change'),
+        v.literal('update'),
+        v.literal('sla_warning'),
+        v.literal('sla_breach'),
+        v.literal('spare_part_order_created'),
+        v.literal('spare_part_order_status_change')
+      ),
+      sparePartOrderFilters: v.optional(v.object({
+        supplierIds: v.optional(v.array(v.id('suppliers'))),
+        applyToAllSuppliers: v.optional(v.boolean()),
+        statuses: v.optional(v.array(v.string())),
+      })),
+    })),
+    actions: v.optional(v.object({
+      changeStatus: v.optional(v.string()),
+      assignSupplier: v.optional(v.id('suppliers')),
+      setSlaHours: v.optional(v.number()),
+      applySlaRule: v.optional(v.boolean()),
+      setPriority: v.optional(v.union(
+        v.literal('low'),
+        v.literal('medium'),
+        v.literal('high')
+      )),
+      addNote: v.optional(v.string()),
+      sendNotification: v.optional(v.object({
+        recipients: v.array(v.object({
+          type: v.union(
+            v.literal('admin'),
+            v.literal('supplier'),
+            v.literal('ticket_creator'),
+            v.literal('ticket_assignee'),
+            v.literal('specific_user'),
+            v.literal('specific_supplier')
+          ),
+          userId: v.optional(v.id('user_profiles')),
+          supplierId: v.optional(v.id('suppliers')),
+        })),
+        message: v.string(),
+      })),
+      requireAttachment: v.optional(v.boolean()),
+      sparePartOrderActions: v.optional(v.object({
+        changeOrderStatus: v.optional(v.string()),
+        addOrderNote: v.optional(v.string()),
+        sendOrderNotification: v.optional(v.object({
+          recipients: v.array(v.union(
+            v.literal('admin'),
+            v.literal('supplier'),
+            v.literal('order_creator')
+          )),
+          message: v.string(),
+        })),
+      })),
+    })),
+  },
+  handler: async (ctx, args) => {
+    const { triggerId, ...updates } = args;
+
+    await ctx.db.patch(triggerId, {
+      ...updates,
+      updatedAt: Date.now(),
+    });
+
+    return triggerId;
+  },
+});
+
+export const deleteTrigger = mutation({
+  args: { triggerId: v.id('ticket_triggers') },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.triggerId);
+    return { success: true };
+  },
+});
+
+export const toggleTrigger = mutation({
+  args: {
+    triggerId: v.id('ticket_triggers'),
+    isActive: v.boolean(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.triggerId, {
+      isActive: args.isActive,
+      updatedAt: Date.now(),
+    });
+
+    return { success: true };
+  },
+});
+
+export const duplicateTrigger = mutation({
+  args: {
+    triggerId: v.id('ticket_triggers'),
+    newName: v.optional(v.string()),
+    createdBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const originalTrigger = await ctx.db.get(args.triggerId);
+    if (!originalTrigger) {
+      throw new Error('Trigger non trovato');
+    }
+
+    const lastTrigger = await ctx.db
+      .query('ticket_triggers')
+      .withIndex('by_priority')
+      .order('desc')
+      .first();
+    const maxPriority = lastTrigger ? lastTrigger.priority + 1 : 0;
+
+    const duplicateName = args.newName?.trim() || `${originalTrigger.name} (copia)`;
+
+    const newTriggerId = await ctx.db.insert('ticket_triggers', {
+      name: duplicateName,
+      description: originalTrigger.description,
+      isActive: false,
+      priority: maxPriority,
+      conditions: originalTrigger.conditions,
+      actions: originalTrigger.actions,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      createdBy: args.createdBy,
+    });
+
+    return newTriggerId;
+  },
+});
+
+export const reorderTriggers = mutation({
+  args: {
+    triggerOrders: v.array(v.object({
+      triggerId: v.id('ticket_triggers'),
+      priority: v.number(),
+    })),
+  },
+  handler: async (ctx, args) => {
+    for (const { triggerId, priority } of args.triggerOrders) {
+      await ctx.db.patch(triggerId, {
+        priority,
+        updatedAt: Date.now(),
+      });
+    }
+
+    return { success: true };
+  },
+});
+
+export const executeTriggers = mutation({
+  args: {
+    ticketId: v.id('maintenance_tasks'),
+    triggerOn: v.union(
+      v.literal('create'),
+      v.literal('status_change'),
+      v.literal('update'),
+      v.literal('sla_warning'),
+      v.literal('sla_breach')
+    ),
+    oldStatus: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const ticket = await ctx.db.get(args.ticketId);
+    if (!ticket) {
+      throw new Error('Ticket not found');
+    }
+
+    const device = ticket.deviceId ? await ctx.db.get(ticket.deviceId) : null;
+
+    const clinic = await ctx.db.get(ticket.clinicId);
+
+    const triggers = await ctx.db
+      .query('ticket_triggers')
+      .withIndex('by_isActive', (q: any) => q.eq('isActive', true))
+      .collect();
+
+    const sortedTriggers = triggers.sort((a, b) => a.priority - b.priority);
+
+    const evaluateCondition = (condition: any): boolean => {
+      const { type, negated, value } = condition;
+      let result = false;
+
+      switch (type) {
+        case 'trigger_event':
+          result = value === args.triggerOn;
+          break;
+        case 'status':
+          const statusValues = Array.isArray(value) ? value : [value];
+          result = statusValues.includes(ticket.status);
+          break;
+        case 'category':
+          const categoryValues = Array.isArray(value) ? value : [value];
+          result = device ? categoryValues.includes(device.category) : false;
+          break;
+        case 'brand':
+          const brandValues = Array.isArray(value) ? value : [value];
+          result = device ? brandValues.includes(device.brand) : false;
+          break;
+        case 'model':
+          const modelValues = Array.isArray(value) ? value : [value];
+          result = device ? modelValues.includes(device.model) : false;
+          break;
+        case 'region':
+          const regionValues = Array.isArray(value) ? value : [value];
+          const clinicRegion = (clinic as any)?.region;
+          result = clinicRegion ? regionValues.includes(clinicRegion) : false;
+          break;
+        case 'priority':
+          const priorityValues = Array.isArray(value) ? value : [value];
+          result = priorityValues.includes((ticket as any).priority);
+          break;
+        case 'custom_field':
+          const { customFieldId, customFieldOperator } = condition;
+          if (!customFieldId) {
+            result = true;
+            break;
+          }
+          const fieldValue = ticket.customFields?.[customFieldId];
+          const operator = customFieldOperator || 'equals';
+
+          switch (operator) {
+            case 'equals':
+              result = fieldValue === value;
+              break;
+            case 'not_equals':
+              result = fieldValue !== value;
+              break;
+            case 'contains':
+              result = fieldValue && String(fieldValue).includes(String(value));
+              break;
+            case 'greater_than':
+              result = fieldValue && Number(fieldValue) > Number(value);
+              break;
+            case 'less_than':
+              result = fieldValue && Number(fieldValue) < Number(value);
+              break;
+            case 'is_empty':
+              result = fieldValue === undefined || fieldValue === null || fieldValue === '';
+              break;
+            case 'is_not_empty':
+              result = fieldValue !== undefined && fieldValue !== null && fieldValue !== '';
+              break;
+            default:
+              result = true;
+          }
+          break;
+        default:
+          result = true;
+      }
+
+      return negated ? !result : result;
+    };
+
+    const evaluateConditionsWithOperators = (conditions: any[]): boolean => {
+      if (conditions.length === 0) return true;
+      if (conditions.length === 1) return evaluateCondition(conditions[0]);
+
+      const results = conditions.map(c => evaluateCondition(c));
+
+      const andGroups: boolean[][] = [[]];
+      let currentGroup = 0;
+
+      for (let i = 0; i < conditions.length; i++) {
+        andGroups[currentGroup].push(results[i]);
+
+        if (i < conditions.length - 1) {
+          const nextOp = conditions[i].nextOperator || 'AND';
+          if (nextOp === 'OR') {
+            currentGroup++;
+            andGroups[currentGroup] = [];
+          }
+        }
+      }
+
+      const groupResults = andGroups.map(group => group.every(r => r));
+      return groupResults.some(r => r);
+    };
+
+    for (const trigger of sortedTriggers) {
+      const triggerConditions = trigger.conditions as any;
+
+      if (triggerConditions.triggerOn && triggerConditions.triggerOn !== args.triggerOn) {
+        continue;
+      }
+
+      if (triggerConditions.conditionsList && triggerConditions.conditionsList.length > 0) {
+        const shouldExecute = evaluateConditionsWithOperators(triggerConditions.conditionsList);
+
+        if (!shouldExecute) {
+          continue;
+        }
+      } else {
+        if (trigger.conditions.triggerOn !== args.triggerOn) {
+          continue;
+        }
+
+        const conditionLogic = trigger.conditions.conditionLogic || 'AND';
+        const conditionResults: boolean[] = [];
+
+        let categoryMatch = true;
+        if (!trigger.conditions.applyToAllCategories && device) {
+          if (!trigger.conditions.categories || !trigger.conditions.categories.includes(device.category)) {
+            categoryMatch = false;
+          }
+        }
+        conditionResults.push(categoryMatch);
+
+        let brandMatch = true;
+        if (triggerConditions.brands && triggerConditions.brands.length > 0 && device) {
+          const brandOperator = triggerConditions.brandOperator || 'is';
+          const brandInList = triggerConditions.brands.includes(device.brand);
+
+          if (brandOperator === 'is') {
+            brandMatch = brandInList;
+          } else {
+            brandMatch = !brandInList;
+          }
+        }
+        conditionResults.push(brandMatch);
+
+        let modelMatch = true;
+        if (triggerConditions.models && triggerConditions.models.length > 0 && device) {
+          const modelOperator = triggerConditions.modelOperator || 'is';
+          const modelInList = triggerConditions.models.includes(device.model);
+
+          if (modelOperator === 'is') {
+            modelMatch = modelInList;
+          } else {
+            modelMatch = !modelInList;
+          }
+        }
+        conditionResults.push(modelMatch);
+
+        let regionMatch = true;
+        if (trigger.conditions.applyToAllRegions === false) {
+          const clinicRegion = (clinic as any)?.region;
+
+          if (!clinicRegion || !trigger.conditions.regions || !trigger.conditions.regions.includes(clinicRegion)) {
+            regionMatch = false;
+          }
+        }
+        conditionResults.push(regionMatch);
+
+        let statusMatch = true;
+        if (trigger.conditions.statuses && trigger.conditions.statuses.length > 0) {
+          const statusOperator = trigger.conditions.statusOperator || 'is';
+          const statusInList = trigger.conditions.statuses.includes(ticket.status);
+
+          if (statusOperator === 'is') {
+            statusMatch = statusInList;
+          } else {
+            statusMatch = !statusInList;
+          }
+        }
+        conditionResults.push(statusMatch);
+
+        let customFieldsMatch = true;
+        if (trigger.conditions.customFieldConditions && trigger.conditions.customFieldConditions.length > 0) {
+          for (const condition of trigger.conditions.customFieldConditions) {
+            const fieldValue = ticket.customFields?.[condition.fieldId];
+            let conditionMet = false;
+
+            switch (condition.operator) {
+              case 'equals':
+                conditionMet = fieldValue === condition.value;
+                break;
+              case 'not_equals':
+                conditionMet = fieldValue !== condition.value;
+                break;
+              case 'contains':
+                conditionMet = fieldValue && String(fieldValue).includes(String(condition.value));
+                break;
+              case 'greater_than':
+                conditionMet = fieldValue && Number(fieldValue) > Number(condition.value);
+                break;
+              case 'less_than':
+                conditionMet = fieldValue && Number(fieldValue) < Number(condition.value);
+                break;
+              case 'is_empty':
+                conditionMet = fieldValue === undefined || fieldValue === null || fieldValue === '';
+                break;
+              case 'is_not_empty':
+                conditionMet = fieldValue !== undefined && fieldValue !== null && fieldValue !== '';
+                break;
+            }
+
+            if (!conditionMet) {
+              customFieldsMatch = false;
+              break;
+            }
+          }
+        }
+        conditionResults.push(customFieldsMatch);
+
+        let shouldExecute = false;
+        if (conditionLogic === 'OR') {
+          shouldExecute = conditionResults.some(result => result === true);
+        } else {
+          shouldExecute = conditionResults.every(result => result === true);
+        }
+
+        if (!shouldExecute) {
+          continue;
+        }
+      }
+
+      const updates: any = {};
+
+      const actions = trigger.actions as any;
+      if (actions.setPriority) {
+        updates.priority = actions.setPriority;
+      }
+
+      if (trigger.actions.changeStatus) {
+        updates.status = trigger.actions.changeStatus;
+      }
+
+      if (trigger.actions.assignSupplier) {
+        updates.supplierId = trigger.actions.assignSupplier;
+      }
+
+      if (actions.applySlaRule && actions.assignSupplier) {
+        const priority = actions.setPriority || (ticket as any).priority || 'medium';
+        const slaRule = await ctx.db
+          .query('sla_rules')
+          .withIndex('by_supplierId_priority', (q: any) =>
+            q.eq('supplierId', actions.assignSupplier).eq('priority', priority)
+          )
+          .first();
+
+        if (slaRule) {
+          const slaDeadline = Date.now() + (slaRule.resolutionTimeHours * 60 * 60 * 1000);
+          updates.slaDeadline = slaDeadline;
+        }
+      } else if (trigger.actions.setSlaHours) {
+        const slaDeadline = Date.now() + (trigger.actions.setSlaHours * 60 * 60 * 1000);
+        updates.slaDeadline = slaDeadline;
+      }
+
+      if (trigger.actions.addNote) {
+        const currentNotes = ticket.notes || '';
+        const newNote = `[Trigger: ${trigger.name}] ${trigger.actions.addNote}`;
+        updates.notes = currentNotes ? `${currentNotes}\n\n${newNote}` : newNote;
+      }
+
+      if (Object.keys(updates).length > 0) {
+        updates.updated_at = Date.now();
+        await ctx.db.patch(args.ticketId, updates);
+
+        try {
+          const actionDescriptions: string[] = [];
+          if (updates.status) actionDescriptions.push(`Stato → ${updates.status}`);
+          if (updates.supplierId) {
+            const supplier = await ctx.db.get(updates.supplierId);
+            actionDescriptions.push(`Assegnato a ${(supplier as any)?.name || 'fornitore'}`);
+          }
+          if (updates.priority) actionDescriptions.push(`Priorità → ${updates.priority}`);
+          if (updates.slaDeadline) actionDescriptions.push(`SLA impostato`);
+
+          await ctx.runMutation(api.ticketHistory.recordHistoryEvent, {
+            ticketId: args.ticketId,
+            eventType: 'trigger_executed',
+            triggerName: trigger.name,
+            triggerId: trigger._id,
+            oldValue: updates.status ? ticket.status : undefined,
+            newValue: updates.status,
+            oldSupplierId: updates.supplierId ? ticket.supplierId : undefined,
+            newSupplierId: updates.supplierId,
+            notes: actionDescriptions.join(', '),
+            isSystemAction: true,
+          });
+        } catch (error) {
+          console.error('Error recording trigger history:', error);
+        }
+      }
+
+    }
+
+    return { success: true };
+  },
+});
+
+export const checkAttachmentRequired = query({
+  args: {
+    deviceId: v.optional(v.id('devices')),
+    clinicId: v.optional(v.id('clinics')),
+    status: v.optional(v.string()),
+    priority: v.optional(v.union(v.literal('low'), v.literal('medium'), v.literal('high'))),
+    customFields: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    try {
+      const triggers = await ctx.db
+        .query('ticket_triggers')
+        .withIndex('by_isActive', (q: any) => q.eq('isActive', true))
+        .collect();
+
+      const attachmentTriggers = triggers.filter((t: any) =>
+        t.actions?.requireAttachment === true
+      );
+
+      if (attachmentTriggers.length === 0) {
+        return { required: false, matchingTriggers: [] };
+      }
+
+      let device = null;
+      let clinic = null;
+
+      try {
+        if (args.deviceId) {
+          device = await ctx.db.get(args.deviceId);
+        }
+      } catch (e) {
+        console.error('Error fetching device:', e);
+      }
+
+      try {
+        if (args.clinicId) {
+          clinic = await ctx.db.get(args.clinicId);
+        }
+      } catch (e) {
+        console.error('Error fetching clinic:', e);
+      }
+
+    const evaluateCondition = (condition: any): boolean => {
+      const { type, negated, value } = condition;
+      let result = false;
+
+      switch (type) {
+        case 'trigger_event':
+          result = value === 'create';
+          break;
+        case 'status':
+          const statusValues = Array.isArray(value) ? value : [value];
+          result = args.status ? statusValues.includes(args.status) : false;
+          break;
+        case 'category':
+          const categoryValues = Array.isArray(value) ? value : [value];
+          result = device ? categoryValues.includes((device as any).category) : false;
+          break;
+        case 'brand':
+          const brandValues = Array.isArray(value) ? value : [value];
+          result = device ? brandValues.includes((device as any).brand) : false;
+          break;
+        case 'model':
+          const modelValues = Array.isArray(value) ? value : [value];
+          result = device ? modelValues.includes((device as any).model) : false;
+          break;
+        case 'region':
+          const regionValues = Array.isArray(value) ? value : [value];
+          const clinicRegion = (clinic as any)?.region;
+          result = clinicRegion ? regionValues.includes(clinicRegion) : false;
+          break;
+        case 'priority':
+          const priorityValues = Array.isArray(value) ? value : [value];
+          result = args.priority ? priorityValues.includes(args.priority) : false;
+          break;
+        case 'custom_field':
+          const { customFieldId, customFieldOperator } = condition;
+          if (!customFieldId) {
+            result = true;
+            break;
+          }
+          const fieldValue = args.customFields?.[customFieldId];
+          const operator = customFieldOperator || 'equals';
+
+          switch (operator) {
+            case 'equals':
+              result = fieldValue === value;
+              break;
+            case 'not_equals':
+              result = fieldValue !== value;
+              break;
+            case 'contains':
+              result = fieldValue && String(fieldValue).includes(String(value));
+              break;
+            case 'greater_than':
+              result = fieldValue && Number(fieldValue) > Number(value);
+              break;
+            case 'less_than':
+              result = fieldValue && Number(fieldValue) < Number(value);
+              break;
+            case 'is_empty':
+              result = fieldValue === undefined || fieldValue === null || fieldValue === '';
+              break;
+            case 'is_not_empty':
+              result = fieldValue !== undefined && fieldValue !== null && fieldValue !== '';
+              break;
+            default:
+              result = true;
+          }
+          break;
+        default:
+          result = true;
+      }
+
+      return negated ? !result : result;
+    };
+
+    const evaluateConditionsWithOperators = (conditions: any[]): boolean => {
+      if (conditions.length === 0) return true;
+      if (conditions.length === 1) return evaluateCondition(conditions[0]);
+
+      const results = conditions.map(c => evaluateCondition(c));
+
+      const andGroups: boolean[][] = [[]];
+      let currentGroup = 0;
+
+      for (let i = 0; i < conditions.length; i++) {
+        andGroups[currentGroup].push(results[i]);
+
+        if (i < conditions.length - 1) {
+          const nextOp = conditions[i].nextOperator || 'AND';
+          if (nextOp === 'OR') {
+            currentGroup++;
+            andGroups[currentGroup] = [];
+          }
+        }
+      }
+
+      const groupResults = andGroups.map(group => group.every(r => r));
+      return groupResults.some(r => r);
+    };
+
+    const matchingTriggers: Array<{ id: string; name: string }> = [];
+
+    for (const trigger of attachmentTriggers) {
+      const triggerConditions = trigger.conditions as any;
+      let matches = false;
+
+      if (triggerConditions.conditionsList && triggerConditions.conditionsList.length > 0) {
+        matches = evaluateConditionsWithOperators(triggerConditions.conditionsList);
+      } else {
+        if (triggerConditions.triggerOn !== 'create') {
+          continue;
+        }
+
+        let categoryMatch = true;
+        if (!triggerConditions.applyToAllCategories && device) {
+          if (!triggerConditions.categories || !triggerConditions.categories.includes((device as any).category)) {
+            categoryMatch = false;
+          }
+        }
+
+        let brandMatch = true;
+        if (triggerConditions.brands && triggerConditions.brands.length > 0 && device) {
+          const brandOperator = triggerConditions.brandOperator || 'is';
+          const brandInList = triggerConditions.brands.includes((device as any).brand);
+          brandMatch = brandOperator === 'is' ? brandInList : !brandInList;
+        }
+
+        let modelMatch = true;
+        if (triggerConditions.models && triggerConditions.models.length > 0 && device) {
+          const modelOperator = triggerConditions.modelOperator || 'is';
+          const modelInList = triggerConditions.models.includes((device as any).model);
+          modelMatch = modelOperator === 'is' ? modelInList : !modelInList;
+        }
+
+        let regionMatch = true;
+        if (triggerConditions.applyToAllRegions === false) {
+          const clinicRegion = (clinic as any)?.region;
+          if (!clinicRegion || !triggerConditions.regions || !triggerConditions.regions.includes(clinicRegion)) {
+            regionMatch = false;
+          }
+        }
+
+        matches = categoryMatch && brandMatch && modelMatch && regionMatch;
+      }
+
+      if (matches) {
+        matchingTriggers.push({
+          id: trigger._id,
+          name: trigger.name,
+        });
+      }
+    }
+
+    return {
+      required: matchingTriggers.length > 0,
+      matchingTriggers,
+    };
+    } catch (error) {
+      console.error('Error in checkAttachmentRequired:', error);
+      return { required: false, matchingTriggers: [] };
+    }
+  },
+});
+
+export const simulateTrigger = query({
+  args: {
+    triggerId: v.id('ticket_triggers'),
+    simulationData: v.object({
+      triggerOn: v.union(
+        v.literal('create'),
+        v.literal('status_change'),
+        v.literal('update'),
+        v.literal('sla_warning'),
+        v.literal('sla_breach')
+      ),
+      status: v.optional(v.string()),
+      category: v.optional(v.string()),
+      brand: v.optional(v.string()),
+      model: v.optional(v.string()),
+      region: v.optional(v.string()),
+      priority: v.optional(v.union(v.literal('low'), v.literal('medium'), v.literal('high'))),
+      customFields: v.optional(v.any()),
+    }),
+  },
+  handler: async (ctx, args) => {
+    const trigger = await ctx.db.get(args.triggerId);
+    if (!trigger) {
+      throw new Error('Trigger non trovato');
+    }
+
+    const { simulationData } = args;
+    const triggerConditions = trigger.conditions as any;
+
+    const conditionResults: Array<{
+      type: string;
+      expected: any;
+      actual: any;
+      negated: boolean;
+      result: boolean;
+      description: string;
+    }> = [];
+
+    const evaluateCondition = (condition: any): boolean => {
+      const { type, negated, value } = condition;
+      let result = false;
+      let actual: any = null;
+      let description = '';
+
+      switch (type) {
+        case 'trigger_event':
+          actual = simulationData.triggerOn;
+          result = value === simulationData.triggerOn;
+          description = `Evento: ${value}`;
+          break;
+        case 'status':
+          const statusValues = Array.isArray(value) ? value : [value];
+          actual = simulationData.status || '(non specificato)';
+          result = simulationData.status ? statusValues.includes(simulationData.status) : false;
+          description = `Stato in: [${statusValues.join(', ')}]`;
+          break;
+        case 'category':
+          const categoryValues = Array.isArray(value) ? value : [value];
+          actual = simulationData.category || '(non specificato)';
+          result = simulationData.category ? categoryValues.includes(simulationData.category) : false;
+          description = `Categoria in: [${categoryValues.join(', ')}]`;
+          break;
+        case 'brand':
+          const brandValues = Array.isArray(value) ? value : [value];
+          actual = simulationData.brand || '(non specificato)';
+          result = simulationData.brand ? brandValues.includes(simulationData.brand) : false;
+          description = `Marca in: [${brandValues.join(', ')}]`;
+          break;
+        case 'model':
+          const modelValues = Array.isArray(value) ? value : [value];
+          actual = simulationData.model || '(non specificato)';
+          result = simulationData.model ? modelValues.includes(simulationData.model) : false;
+          description = `Modello in: [${modelValues.join(', ')}]`;
+          break;
+        case 'region':
+          const regionValues = Array.isArray(value) ? value : [value];
+          actual = simulationData.region || '(non specificato)';
+          result = simulationData.region ? regionValues.includes(simulationData.region) : false;
+          description = `Regione in: [${regionValues.join(', ')}]`;
+          break;
+        case 'priority':
+          const priorityValues = Array.isArray(value) ? value : [value];
+          actual = simulationData.priority || '(non specificato)';
+          result = simulationData.priority ? priorityValues.includes(simulationData.priority) : false;
+          description = `Priorità in: [${priorityValues.join(', ')}]`;
+          break;
+        case 'custom_field':
+          const { customFieldId, customFieldOperator } = condition;
+          if (!customFieldId) {
+            result = true;
+            description = 'Campo custom (non configurato)';
+            break;
+          }
+          const fieldValue = simulationData.customFields?.[customFieldId];
+          actual = fieldValue ?? '(non specificato)';
+          const operator = customFieldOperator || 'equals';
+
+          switch (operator) {
+            case 'equals':
+              result = fieldValue === value;
+              description = `Campo custom = ${value}`;
+              break;
+            case 'not_equals':
+              result = fieldValue !== value;
+              description = `Campo custom ≠ ${value}`;
+              break;
+            case 'contains':
+              result = fieldValue && String(fieldValue).includes(String(value));
+              description = `Campo custom contiene "${value}"`;
+              break;
+            case 'greater_than':
+              result = fieldValue && Number(fieldValue) > Number(value);
+              description = `Campo custom > ${value}`;
+              break;
+            case 'less_than':
+              result = fieldValue && Number(fieldValue) < Number(value);
+              description = `Campo custom < ${value}`;
+              break;
+            case 'is_empty':
+              result = fieldValue === undefined || fieldValue === null || fieldValue === '';
+              description = 'Campo custom è vuoto';
+              break;
+            case 'is_not_empty':
+              result = fieldValue !== undefined && fieldValue !== null && fieldValue !== '';
+              description = 'Campo custom non è vuoto';
+              break;
+            default:
+              result = true;
+              description = 'Campo custom (operatore sconosciuto)';
+          }
+          break;
+        default:
+          result = true;
+          description = `Tipo sconosciuto: ${type}`;
+      }
+
+      const finalResult = negated ? !result : result;
+
+      conditionResults.push({
+        type,
+        expected: value,
+        actual,
+        negated,
+        result: finalResult,
+        description: negated ? `NON (${description})` : description,
+      });
+
+      return finalResult;
+    };
+
+    let wouldTrigger = false;
+
+    if (triggerConditions.conditionsList && triggerConditions.conditionsList.length > 0) {
+      const results = triggerConditions.conditionsList.map((c: any) => evaluateCondition(c));
+
+      const andGroups: boolean[][] = [[]];
+      let currentGroup = 0;
+
+      for (let i = 0; i < triggerConditions.conditionsList.length; i++) {
+        andGroups[currentGroup].push(results[i]);
+
+        if (i < triggerConditions.conditionsList.length - 1) {
+          const nextOp = triggerConditions.conditionsList[i].nextOperator || 'AND';
+          if (nextOp === 'OR') {
+            currentGroup++;
+            andGroups[currentGroup] = [];
+          }
+        }
+      }
+
+      const groupResults = andGroups.map(group => group.every(r => r));
+      wouldTrigger = groupResults.some(r => r);
+    } else {
+      if (triggerConditions.triggerOn !== simulationData.triggerOn) {
+        conditionResults.push({
+          type: 'trigger_event',
+          expected: triggerConditions.triggerOn,
+          actual: simulationData.triggerOn,
+          negated: false,
+          result: false,
+          description: `Evento: ${triggerConditions.triggerOn}`,
+        });
+        wouldTrigger = false;
+      } else {
+        wouldTrigger = true;
+      }
+    }
+
+    const actions = trigger.actions as any;
+    const actionDescriptions: string[] = [];
+
+    if (actions?.changeStatus) {
+      actionDescriptions.push(`📊 Cambierebbe stato a: "${actions.changeStatus}"`);
+    }
+    if (actions?.assignSupplier) {
+      const supplier = await ctx.db.get(actions.assignSupplier);
+      actionDescriptions.push(`👤 Assegnerebbe a: ${(supplier as any)?.name || 'Fornitore sconosciuto'}`);
+    }
+    if (actions?.setPriority) {
+      const priorityLabels: Record<string, string> = { low: '🟢 Bassa', medium: '🟡 Media', high: '🟠 Alta' };
+      actionDescriptions.push(`⚡ Cambierebbe priorità a: ${priorityLabels[actions.setPriority] || actions.setPriority}`);
+    }
+    if (actions?.setSlaHours) {
+      actionDescriptions.push(`⏱️ Imposterebbe SLA: ${actions.setSlaHours} ore`);
+    }
+    if (actions?.applySlaRule) {
+      actionDescriptions.push(`⏱️ Applicherebbe regola SLA automatica`);
+    }
+    if (actions?.addNote) {
+      actionDescriptions.push(`📝 Aggiungerebbe nota: "${actions.addNote.substring(0, 50)}${actions.addNote.length > 50 ? '...' : ''}"`);
+    }
+    if (actions?.sendNotification) {
+      const recipientTypes: Record<string, string> = {
+        admin: 'Admin',
+        supplier: 'Fornitore assegnato',
+        ticket_creator: 'Creatore ticket',
+        ticket_assignee: 'Assegnatario',
+        specific_user: 'Utente specifico',
+        specific_supplier: 'Fornitore specifico',
+      };
+      const recipients = actions.sendNotification.recipients?.map((r: any) =>
+        typeof r === 'string' ? r : recipientTypes[r.type] || r.type
+      ).join(', ');
+      actionDescriptions.push(`📧 Invierebbe email a: ${recipients}`);
+    }
+
+    return {
+      triggerId: trigger._id,
+      triggerName: trigger.name,
+      wouldTrigger,
+      conditionResults,
+      actionDescriptions,
+      isActive: trigger.isActive,
+    };
+  },
+});