@primocaredentgroup/elettromedicali 0.1.0

package/dist/component/ticketTriggers.js

@@ -0,0 +1,941 @@
+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) => 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) => q.eq('isActive', true))
+            .collect();
+        const sortedTriggers = triggers.sort((a, b) => a.priority - b.priority);
+        const evaluateCondition = (condition) => {
+            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?.region;
+                    result = clinicRegion ? regionValues.includes(clinicRegion) : false;
+                    break;
+                case 'priority':
+                    const priorityValues = Array.isArray(value) ? value : [value];
+                    result = priorityValues.includes(ticket.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) => {
+            if (conditions.length === 0)
+                return true;
+            if (conditions.length === 1)
+                return evaluateCondition(conditions[0]);
+            const results = conditions.map(c => evaluateCondition(c));
+            const andGroups = [[]];
+            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;
+            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 = [];
+                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?.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 = {};
+            const actions = trigger.actions;
+            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.priority || 'medium';
+                const slaRule = await ctx.db
+                    .query('sla_rules')
+                    .withIndex('by_supplierId_priority', (q) => 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 = [];
+                    if (updates.status)
+                        actionDescriptions.push(`Stato → ${updates.status}`);
+                    if (updates.supplierId) {
+                        const supplier = await ctx.db.get(updates.supplierId);
+                        actionDescriptions.push(`Assegnato a ${supplier?.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) => q.eq('isActive', true))
+                .collect();
+            const attachmentTriggers = triggers.filter((t) => 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) => {
+                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.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?.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) => {
+                if (conditions.length === 0)
+                    return true;
+                if (conditions.length === 1)
+                    return evaluateCondition(conditions[0]);
+                const results = conditions.map(c => evaluateCondition(c));
+                const andGroups = [[]];
+                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 = [];
+            for (const trigger of attachmentTriggers) {
+                const triggerConditions = trigger.conditions;
+                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.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.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.model);
+                        modelMatch = modelOperator === 'is' ? modelInList : !modelInList;
+                    }
+                    let regionMatch = true;
+                    if (triggerConditions.applyToAllRegions === false) {
+                        const clinicRegion = clinic?.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;
+        const conditionResults = [];
+        const evaluateCondition = (condition) => {
+            const { type, negated, value } = condition;
+            let result = false;
+            let actual = 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) => evaluateCondition(c));
+            const andGroups = [[]];
+            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;
+        const actionDescriptions = [];
+        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?.name || 'Fornitore sconosciuto'}`);
+        }
+        if (actions?.setPriority) {
+            const priorityLabels = { 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 = {
+                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) => 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,
+        };
+    },
+});
+//# sourceMappingURL=ticketTriggers.js.map