@primocaredentgroup/elettromedicali 0.1.0

package/src/component/ticketExport.ts

@@ -0,0 +1,220 @@
+import { v } from 'convex/values';
+import { query } from './_generated/server';
+
+export const exportTickets = query({
+  args: {
+    statuses: v.optional(v.array(v.string())),
+    priorities: v.optional(v.array(v.string())),
+    clinicIds: v.optional(v.array(v.id('clinics'))),
+    supplierIds: v.optional(v.array(v.id('suppliers'))),
+    createdByEmail: v.optional(v.string()),
+    ticketNumber: v.optional(v.string()),
+    dateFrom: v.optional(v.number()),
+    dateTo: v.optional(v.number()),
+    slaBreached: v.optional(v.boolean()),
+    isExternal: v.optional(v.boolean()),
+    needsAssignment: v.optional(v.boolean()),
+    hasDevice: v.optional(v.boolean()),
+    deviceCategory: v.optional(v.string()),
+    deviceBrand: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    let tickets = await ctx.db.query('maintenance_tasks').order('desc').take(1500);
+
+    if (args.statuses && args.statuses.length > 0) {
+      tickets = tickets.filter(t => args.statuses!.includes(t.status));
+    }
+
+    if (args.priorities && args.priorities.length > 0) {
+      tickets = tickets.filter(t => t.priority && args.priorities!.includes(t.priority));
+    }
+
+    if (args.clinicIds && args.clinicIds.length > 0) {
+      tickets = tickets.filter(t => args.clinicIds!.includes(t.clinicId));
+    }
+
+    if (args.supplierIds && args.supplierIds.length > 0) {
+      tickets = tickets.filter(t => t.supplierId && args.supplierIds!.includes(t.supplierId));
+    }
+
+    if (args.createdByEmail) {
+      const emailLower = args.createdByEmail.toLowerCase();
+      tickets = tickets.filter(t =>
+        t.createdByEmail?.toLowerCase().includes(emailLower)
+      );
+    }
+
+    if (args.ticketNumber) {
+      const numLower = args.ticketNumber.toLowerCase();
+      tickets = tickets.filter(t =>
+        t.ticketNumber?.toLowerCase().includes(numLower)
+      );
+    }
+
+    if (args.dateFrom) {
+      tickets = tickets.filter(t => t.created_at >= args.dateFrom!);
+    }
+
+    if (args.dateTo) {
+      tickets = tickets.filter(t => t.created_at <= args.dateTo!);
+    }
+
+    if (args.slaBreached !== undefined) {
+      tickets = tickets.filter(t => t.slaBreached === args.slaBreached);
+    }
+
+    if (args.isExternal !== undefined) {
+      tickets = tickets.filter(t => t.isExternal === args.isExternal);
+    }
+
+    if (args.needsAssignment !== undefined) {
+      tickets = tickets.filter(t => t.needsAssignment === args.needsAssignment);
+    }
+
+    if (args.hasDevice !== undefined) {
+      if (args.hasDevice) {
+        tickets = tickets.filter(t => t.deviceId);
+      } else {
+        tickets = tickets.filter(t => !t.deviceId);
+      }
+    }
+
+    const clinicIds = [...new Set(tickets.map(t => t.clinicId))].slice(0, 300);
+    const supplierIds = [...new Set(tickets.filter(t => t.supplierId).map(t => t.supplierId!))].slice(0, 300);
+    const deviceIds = [...new Set(tickets.filter(t => t.deviceId).map(t => t.deviceId!))].slice(0, 500);
+
+    const clinicsMap = new Map();
+    for (const id of clinicIds) {
+      const clinic = await ctx.db.get(id);
+      if (clinic) clinicsMap.set(id, clinic);
+    }
+
+    const suppliersMap = new Map();
+    for (const id of supplierIds) {
+      const supplier = await ctx.db.get(id);
+      if (supplier) suppliersMap.set(id, supplier);
+    }
+
+    const devicesMap = new Map();
+    for (const id of deviceIds) {
+      const device = await ctx.db.get(id);
+      if (device) devicesMap.set(id, device);
+    }
+
+    if (args.deviceCategory || args.deviceBrand) {
+      tickets = tickets.filter(t => {
+        if (!t.deviceId) return false;
+        const device = devicesMap.get(t.deviceId);
+        if (!device) return false;
+
+        if (args.deviceCategory && device.category !== args.deviceCategory) {
+          return false;
+        }
+        if (args.deviceBrand && device.brand !== args.deviceBrand) {
+          return false;
+        }
+        return true;
+      });
+    }
+
+    const statuses = await ctx.db.query('ticket_statuses').collect();
+    const statusMap = new Map(statuses.map(s => [s.name, s.label]));
+
+    const enrichedTickets = tickets.map(t => {
+      const clinic = clinicsMap.get(t.clinicId);
+      const supplier = t.supplierId ? suppliersMap.get(t.supplierId) : null;
+      const device = t.deviceId ? devicesMap.get(t.deviceId) : null;
+
+      return {
+        _id: t._id,
+        ticketNumber: t.ticketNumber || '-',
+
+        title: t.title || '-',
+        description: t.description,
+        status: t.status,
+        statusLabel: statusMap.get(t.status) || t.status,
+        priority: t.priority || '-',
+
+        createdByEmail: t.createdByEmail || '-',
+        created_by: t.created_by,
+
+        created_at: t.created_at,
+        createdAtFormatted: new Date(t.created_at).toLocaleString('it-IT'),
+        updated_at: t.updated_at,
+        updatedAtFormatted: new Date(t.updated_at).toLocaleString('it-IT'),
+
+        clinicId: t.clinicId,
+        clinicName: clinic?.name || '-',
+        clinicAddress: clinic?.address || '-',
+        clinicRegion: clinic?.region || '-',
+
+        supplierId: t.supplierId || null,
+        supplierName: supplier?.name || '-',
+        supplierEmail: supplier?.contact_email || '-',
+
+        deviceId: t.deviceId || null,
+        deviceName: device?.name || '-',
+        deviceCategory: device?.category || '-',
+        deviceBrand: device?.brand || '-',
+        deviceModel: device?.model || '-',
+        deviceSerialNumber: device?.serial_number || '-',
+
+        slaDeadline: t.slaDeadline || null,
+        slaDeadlineFormatted: t.slaDeadline ? new Date(t.slaDeadline).toLocaleString('it-IT') : '-',
+        slaBreached: t.slaBreached || false,
+
+        isExternal: t.isExternal || false,
+        needsAssignment: t.needsAssignment || false,
+
+        notes: t.notes || '-',
+        customFields: t.customFields || {},
+
+        externalTicketId: t.externalTicketId || '-',
+        externalTicketNumber: t.externalTicketNumber || '-',
+        importSource: t.importSource || '-',
+
+        photosCount: t.photos?.length || 0,
+
+        deviceQuestionAnswers: t.deviceQuestionAnswers || [],
+      };
+    });
+
+    enrichedTickets.sort((a, b) => b.created_at - a.created_at);
+
+    return {
+      tickets: enrichedTickets,
+      totalCount: enrichedTickets.length,
+    };
+  },
+});
+
+export const getFilterOptions = query({
+  args: {},
+  handler: async (ctx) => {
+    const statuses = await ctx.db.query('ticket_statuses').collect();
+    const statusOptions = statuses.map(s => ({ value: s.name, label: s.label }));
+
+    const clinics = await ctx.db.query('clinics').collect();
+    const clinicOptions = clinics.map(c => ({ value: c._id, label: c.name }));
+
+    const suppliers = await ctx.db.query('suppliers').collect();
+    const supplierOptions = suppliers.map(s => ({ value: s._id, label: s.name }));
+
+    const deviceSample = await ctx.db.query('devices').take(2000);
+    const categories = [...new Set(deviceSample.map(d => d.category).filter(Boolean))];
+    const brands = [...new Set(deviceSample.map(d => d.brand).filter(Boolean))];
+
+    return {
+      statuses: statusOptions,
+      priorities: [
+        { value: 'low', label: 'Bassa' },
+        { value: 'medium', label: 'Media' },
+        { value: 'high', label: 'Alta' },
+      ],
+      clinics: clinicOptions.sort((a, b) => a.label.localeCompare(b.label)),
+      suppliers: supplierOptions.sort((a, b) => a.label.localeCompare(b.label)),
+      deviceCategories: categories.sort(),
+      deviceBrands: brands.sort(),
+    };
+  },
+});

package/src/component/ticketHistory.ts

@@ -0,0 +1,106 @@
+import { v } from 'convex/values';
+import { query, mutation, internalMutation } from './_generated/server';
+
+// Get ticket history (admin only)
+export const getTicketHistory = query({
+  args: { ticketId: v.id('maintenance_tasks') },
+  handler: async (ctx, args) => {
+    const history = await ctx.db
+      .query('ticket_history')
+      .withIndex('by_ticketId', (q: any) => q.eq('ticketId', args.ticketId))
+      .take(200);
+
+    // Sort by timestamp descending (most recent first)
+    return history.sort((a, b) => b.timestamp - a.timestamp);
+  },
+});
+
+// Add history entry (internal mutation - called by other functions)
+export const addHistoryEntry = internalMutation({
+  args: {
+    ticketId: v.id('maintenance_tasks'),
+    eventType: v.union(
+      v.literal('created'),
+      v.literal('status_change'),
+      v.literal('assignee_change'),
+      v.literal('priority_change'),
+      v.literal('trigger_executed'),
+      v.literal('comment_added'),
+      v.literal('sla_set'),
+      v.literal('sla_warning'),
+      v.literal('sla_breach'),
+      v.literal('updated')
+    ),
+    oldValue: v.optional(v.string()),
+    newValue: v.optional(v.string()),
+    triggerName: v.optional(v.string()),
+    triggerId: v.optional(v.id('ticket_triggers')),
+    oldSupplierId: v.optional(v.id('suppliers')),
+    newSupplierId: v.optional(v.id('suppliers')),
+    oldSupplierName: v.optional(v.string()),
+    newSupplierName: v.optional(v.string()),
+    performedBy: v.optional(v.string()),
+    performedByName: v.optional(v.string()),
+    performedByEmail: v.optional(v.string()),
+    isSystemAction: v.boolean(),
+    notes: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.insert('ticket_history', {
+      ...args,
+      timestamp: Date.now(),
+    });
+  },
+});
+
+// Public mutation to add history (for use from frontend/other mutations)
+export const recordHistoryEvent = mutation({
+  args: {
+    ticketId: v.id('maintenance_tasks'),
+    eventType: v.union(
+      v.literal('created'),
+      v.literal('status_change'),
+      v.literal('assignee_change'),
+      v.literal('priority_change'),
+      v.literal('trigger_executed'),
+      v.literal('comment_added'),
+      v.literal('sla_set'),
+      v.literal('sla_warning'),
+      v.literal('sla_breach'),
+      v.literal('updated')
+    ),
+    oldValue: v.optional(v.string()),
+    newValue: v.optional(v.string()),
+    triggerName: v.optional(v.string()),
+    triggerId: v.optional(v.id('ticket_triggers')),
+    oldSupplierId: v.optional(v.id('suppliers')),
+    newSupplierId: v.optional(v.id('suppliers')),
+    oldSupplierName: v.optional(v.string()),
+    newSupplierName: v.optional(v.string()),
+    notes: v.optional(v.string()),
+    isSystemAction: v.optional(v.boolean()),
+    performedBy: v.optional(v.string()),
+    performedByName: v.optional(v.string()),
+    performedByEmail: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.insert('ticket_history', {
+      ticketId: args.ticketId,
+      eventType: args.eventType,
+      oldValue: args.oldValue,
+      newValue: args.newValue,
+      triggerName: args.triggerName,
+      triggerId: args.triggerId,
+      oldSupplierId: args.oldSupplierId,
+      newSupplierId: args.newSupplierId,
+      oldSupplierName: args.oldSupplierName,
+      newSupplierName: args.newSupplierName,
+      performedBy: args.performedBy,
+      performedByName: args.performedByName,
+      performedByEmail: args.performedByEmail,
+      isSystemAction: args.isSystemAction ?? false,
+      notes: args.notes,
+      timestamp: Date.now(),
+    });
+  },
+});

package/src/component/ticketMacros.ts

@@ -0,0 +1,291 @@
+import { v } from 'convex/values';
+import { query, mutation } from './_generated/server';
+import type { Id } from './_generated/dataModel';
+
+export const listMacros = query({
+  args: {
+    userProfileId: v.optional(v.id('user_profiles')),
+  },
+  handler: async (ctx, args) => {
+    const allMacros = await ctx.db.query('ticket_macros').collect();
+
+    const filteredMacros = allMacros.filter(m =>
+      m.isGlobal || (args.userProfileId && m.createdBy === args.userProfileId)
+    );
+
+    const macrosWithCreator = await Promise.all(
+      filteredMacros.map(async (macro) => {
+        const creator = await ctx.db.get(macro.createdBy);
+        return {
+          ...macro,
+          creatorName: creator?.name || creator?.email || 'Sconosciuto',
+          creatorEmail: creator?.email,
+          isOwner: args.userProfileId ? macro.createdBy === args.userProfileId : false,
+        };
+      })
+    );
+
+    return macrosWithCreator;
+  },
+});
+
+export const listActiveMacros = query({
+  args: {
+    userProfileId: v.optional(v.id('user_profiles')),
+  },
+  handler: async (ctx, args) => {
+    const allMacros = await ctx.db
+      .query('ticket_macros')
+      .withIndex('by_isActive', (q) => q.eq('isActive', true))
+      .collect();
+
+    return allMacros.filter(m =>
+      m.isGlobal || (args.userProfileId && m.createdBy === args.userProfileId)
+    ).map(m => ({
+      _id: m._id,
+      name: m.name,
+      description: m.description,
+      isGlobal: m.isGlobal,
+    }));
+  },
+});
+
+export const getMacro = query({
+  args: {
+    macroId: v.id('ticket_macros'),
+    userProfileId: v.optional(v.id('user_profiles')),
+  },
+  handler: async (ctx, args) => {
+    const macro = await ctx.db.get(args.macroId);
+    if (!macro) {
+      throw new Error('Macro non trovata');
+    }
+
+    if (!macro.isGlobal && args.userProfileId && macro.createdBy !== args.userProfileId) {
+      throw new Error('Non hai accesso a questa macro');
+    }
+
+    return macro;
+  },
+});
+
+export const createMacro = mutation({
+  args: {
+    name: v.string(),
+    description: v.optional(v.string()),
+    isGlobal: v.boolean(),
+    actions: v.object({
+      changeStatus: v.optional(v.string()),
+      assignSupplier: v.optional(v.id('suppliers')),
+      assignUser: v.optional(v.id('user_profiles')),
+      setSlaHours: v.optional(v.number()),
+      applySlaRule: v.optional(v.boolean()),
+      addNote: v.optional(v.string()),
+      sendNotification: v.optional(v.object({
+        recipients: v.array(v.any()),
+        message: v.string(),
+      })),
+      setPriority: v.optional(v.string()),
+    }),
+    createdBy: v.id('user_profiles'),
+  },
+  handler: async (ctx, args) => {
+    const macroId = await ctx.db.insert('ticket_macros', {
+      name: args.name,
+      description: args.description,
+      isGlobal: args.isGlobal,
+      isActive: true,
+      actions: args.actions,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      createdBy: args.createdBy,
+    });
+
+    return macroId;
+  },
+});
+
+export const updateMacro = mutation({
+  args: {
+    macroId: v.id('ticket_macros'),
+    name: v.optional(v.string()),
+    description: v.optional(v.string()),
+    isGlobal: v.optional(v.boolean()),
+    isActive: v.optional(v.boolean()),
+    actions: v.optional(v.object({
+      changeStatus: v.optional(v.string()),
+      assignSupplier: v.optional(v.id('suppliers')),
+      assignUser: v.optional(v.id('user_profiles')),
+      setSlaHours: v.optional(v.number()),
+      applySlaRule: v.optional(v.boolean()),
+      addNote: v.optional(v.string()),
+      sendNotification: v.optional(v.object({
+        recipients: v.array(v.any()),
+        message: v.string(),
+      })),
+      setPriority: v.optional(v.string()),
+    })),
+  },
+  handler: async (ctx, args) => {
+    const macro = await ctx.db.get(args.macroId);
+    if (!macro) {
+      throw new Error('Macro non trovata');
+    }
+
+    const updateData: any = { updatedAt: Date.now() };
+    if (args.name !== undefined) updateData.name = args.name;
+    if (args.description !== undefined) updateData.description = args.description;
+    if (args.isGlobal !== undefined) updateData.isGlobal = args.isGlobal;
+    if (args.isActive !== undefined) updateData.isActive = args.isActive;
+    if (args.actions !== undefined) updateData.actions = args.actions;
+
+    await ctx.db.patch(args.macroId, updateData);
+    return args.macroId;
+  },
+});
+
+export const deleteMacro = mutation({
+  args: { macroId: v.id('ticket_macros') },
+  handler: async (ctx, args) => {
+    const macro = await ctx.db.get(args.macroId);
+    if (!macro) {
+      throw new Error('Macro non trovata');
+    }
+
+    await ctx.db.delete(args.macroId);
+    return { success: true };
+  },
+});
+
+export const toggleMacro = mutation({
+  args: {
+    macroId: v.id('ticket_macros'),
+    isActive: v.boolean(),
+  },
+  handler: async (ctx, args) => {
+    const macro = await ctx.db.get(args.macroId);
+    if (!macro) {
+      throw new Error('Macro non trovata');
+    }
+
+    await ctx.db.patch(args.macroId, {
+      isActive: args.isActive,
+      updatedAt: Date.now(),
+    });
+
+    return { success: true };
+  },
+});
+
+export const duplicateMacro = mutation({
+  args: {
+    macroId: v.id('ticket_macros'),
+    newName: v.string(),
+    createdBy: v.id('user_profiles'),
+  },
+  handler: async (ctx, args) => {
+    const macro = await ctx.db.get(args.macroId);
+    if (!macro) {
+      throw new Error('Macro non trovata');
+    }
+
+    const newMacroId = await ctx.db.insert('ticket_macros', {
+      name: args.newName,
+      description: macro.description,
+      isGlobal: false,
+      isActive: false,
+      actions: macro.actions,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      createdBy: args.createdBy,
+    });
+
+    return newMacroId;
+  },
+});
+
+export const executeMacro = mutation({
+  args: {
+    macroId: v.id('ticket_macros'),
+    ticketId: v.id('maintenance_tasks'),
+    userProfileId: v.optional(v.id('user_profiles')),
+    userAuth0Id: v.optional(v.string()),
+    userName: v.optional(v.string()),
+    userEmail: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const macro = await ctx.db.get(args.macroId);
+    if (!macro) {
+      throw new Error('Macro non trovata');
+    }
+
+    if (!macro.isActive) {
+      throw new Error('Questa macro non è attiva');
+    }
+
+    if (!macro.isGlobal && args.userProfileId && macro.createdBy !== args.userProfileId) {
+      throw new Error('Non hai accesso a questa macro');
+    }
+
+    const ticket = await ctx.db.get(args.ticketId);
+    if (!ticket) {
+      throw new Error('Ticket non trovato');
+    }
+
+    const actions = macro.actions;
+    const updates: any = { updated_at: Date.now() };
+    const executedActions: string[] = [];
+
+    if (actions.changeStatus) {
+      updates.status = actions.changeStatus;
+      executedActions.push(`Stato cambiato a: ${actions.changeStatus}`);
+    }
+
+    if (actions.assignSupplier) {
+      updates.supplierId = actions.assignSupplier;
+      executedActions.push('Fornitore assegnato');
+    }
+
+    if (actions.assignUser) {
+      const user = await ctx.db.get(actions.assignUser);
+      if (user?.supplierId) {
+        updates.supplierId = user.supplierId;
+      }
+      executedActions.push('Utente assegnato');
+    }
+
+    if (actions.setSlaHours) {
+      updates.slaHours = actions.setSlaHours;
+      updates.slaDueDate = Date.now() + (actions.setSlaHours * 60 * 60 * 1000);
+      executedActions.push(`SLA impostato a ${actions.setSlaHours} ore`);
+    }
+
+    if (actions.setPriority) {
+      updates.priority = actions.setPriority;
+      executedActions.push(`Priorità impostata a: ${actions.setPriority}`);
+    }
+
+    await ctx.db.patch(args.ticketId, updates);
+
+    if (actions.addNote) {
+      await ctx.db.insert('ticket_comments', {
+        taskId: args.ticketId,
+        authorId: args.userAuth0Id || 'system',
+        authorName: args.userName || args.userEmail || 'Sistema',
+        authorEmail: args.userEmail || 'system@app',
+        authorRole: 'admin',
+        content: `[Macro: ${macro.name}] ${actions.addNote}`,
+        isInternal: true,
+        createdAt: Date.now(),
+      });
+      executedActions.push('Nota aggiunta');
+    }
+
+    return {
+      success: true,
+      ticketId: args.ticketId,
+      macroName: macro.name,
+      executedActions,
+    };
+  },
+});