@primocaredentgroup/elettromedicali 0.1.0

package/src/component/slaMonitoring.ts

@@ -0,0 +1,125 @@
+import { v } from 'convex/values';
+import { internalMutation, internalAction, internalQuery } from './_generated/server';
+import { internal } from './_generated/api';
+
+// NOTE: Notification sending (sendSLABreachNotifications, sendSLAWarningNotifications)
+// is NOT included in the component. The parent app is responsible for:
+// 1. Running checkSLAStatus periodically (via cron)
+// 2. After breaches/warnings are marked, querying for newly marked tickets
+// 3. Sending email notifications via its own emailActions
+
+export const checkSLAStatus = internalAction({
+  args: {},
+  handler: async (ctx): Promise<{ checked: number; warnings: number; breaches: number }> => {
+    try {
+      const tickets: any = await ctx.runQuery(internal.slaMonitoring.listTicketsNeedingSLACheck, {});
+
+      const now = Date.now();
+      let warningsCount = 0;
+      let breachesCount = 0;
+
+      for (const ticket of tickets) {
+        const timeUntilDeadline = ticket.slaDeadline - now;
+        const oneHour = 60 * 60 * 1000;
+
+        if (timeUntilDeadline < 0 && !ticket.slaBreached) {
+          breachesCount++;
+
+          await ctx.runMutation(internal.slaMonitoring.markSLABreached, {
+            ticketId: ticket._id,
+          });
+        }
+        else if (timeUntilDeadline > 0 && timeUntilDeadline < oneHour && !ticket.slaWarningSent) {
+          warningsCount++;
+
+          await ctx.runMutation(internal.slaMonitoring.markSLAWarningSent, {
+            ticketId: ticket._id,
+          });
+        }
+      }
+
+      return {
+        checked: tickets.length,
+        warnings: warningsCount,
+        breaches: breachesCount,
+      };
+    } catch (error) {
+      console.error('Error checking SLA status:', error);
+      throw error;
+    }
+  },
+});
+
+export const listTicketsNeedingSLACheck = internalQuery({
+  args: {},
+  handler: async (ctx) => {
+    const terminalStatuses = ['closed', 'completed', 'cancelled', 'resolved'];
+
+    const ticketsWithSLA = await ctx.db
+      .query('maintenance_tasks')
+      .withIndex('by_slaDeadline')
+      .order('asc')
+      .take(150);
+
+    return ticketsWithSLA
+      .filter(t => t.slaDeadline && !terminalStatuses.includes(t.status))
+      .map(t => ({
+        _id: t._id,
+        ticketNumber: t.ticketNumber,
+        status: t.status,
+        slaDeadline: t.slaDeadline,
+        slaBreached: t.slaBreached,
+        slaWarningSent: t.slaWarningSent,
+      }));
+  },
+});
+
+export const listAllTicketsForSLA = internalQuery({
+  args: {},
+  handler: async (ctx) => {
+    const terminalStatuses = ['closed', 'completed', 'cancelled', 'resolved'];
+
+    const tasks = await ctx.db
+      .query('maintenance_tasks')
+      .withIndex('by_slaDeadline')
+      .order('asc')
+      .take(500);
+
+    return tasks
+      .filter(t => t.slaDeadline && !terminalStatuses.includes(t.status))
+      .map(t => ({
+        _id: t._id,
+        ticketNumber: t.ticketNumber,
+        status: t.status,
+        supplierId: t.supplierId,
+        slaDeadline: t.slaDeadline,
+        slaBreached: t.slaBreached,
+        slaWarningSent: t.slaWarningSent,
+        deviceName: '',
+        clinicName: '',
+        supplierName: null,
+      }));
+  },
+});
+
+export const markSLABreached = internalMutation({
+  args: {
+    ticketId: v.id('maintenance_tasks'),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.ticketId, {
+      slaBreached: true,
+    });
+  },
+});
+
+export const markSLAWarningSent = internalMutation({
+  args: {
+    ticketId: v.id('maintenance_tasks'),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.ticketId, {
+      slaWarningSent: true,
+    });
+  },
+});

package/src/component/slaRules.ts

@@ -0,0 +1,231 @@
+import { v } from 'convex/values';
+import { query, mutation } from './_generated/server';
+
+// List all SLA rules (admin only)
+export const listSLARules = query({
+  args: {},
+  handler: async (ctx) => {
+    const rules = await ctx.db.query('sla_rules').collect();
+    
+    // Enrich with supplier info
+    const enrichedRules = await Promise.all(
+      rules.map(async (rule) => {
+        const supplier = await ctx.db.get(rule.supplierId);
+        return {
+          ...rule,
+          supplierName: supplier?.name || 'Unknown',
+        };
+      })
+    );
+
+    return enrichedRules;
+  },
+});
+
+// Get all unique device categories (admin only)
+export const getDeviceCategories = query({
+  args: {},
+  handler: async (ctx) => {
+    const devices = await ctx.db.query('devices').take(3000);
+    const categories = [...new Set(devices.map(d => d.category))].sort();
+    
+    return categories;
+  },
+});
+
+// Get SLA rules for a specific supplier
+export const getSLARulesBySupplier = query({
+  args: { supplierId: v.id('suppliers') },
+  handler: async (ctx, args) => {
+    const rules = await ctx.db
+      .query('sla_rules')
+      .withIndex('by_supplierId', (q: any) => q.eq('supplierId', args.supplierId))
+      .collect();
+
+    return rules;
+  },
+});
+
+// Get SLA rule for supplier, priority and optionally device category
+export const getSLARule = query({
+  args: {
+    supplierId: v.id('suppliers'),
+    priority: v.union(v.literal('low'), v.literal('medium'), v.literal('high')),
+    deviceCategory: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Prima cerca una regola specifica per la categoria
+    if (args.deviceCategory) {
+      const specificRule = await ctx.db
+        .query('sla_rules')
+        .withIndex('by_supplierId_category_priority', (q: any) =>
+          q.eq('supplierId', args.supplierId)
+           .eq('deviceCategory', args.deviceCategory)
+           .eq('priority', args.priority)
+        )
+        .first();
+      
+      if (specificRule) {
+        return specificRule;
+      }
+    }
+
+    // Se non trova una regola specifica, cerca una regola generica (senza categoria)
+    const genericRule = await ctx.db
+      .query('sla_rules')
+      .withIndex('by_supplierId_category_priority', (q: any) =>
+        q.eq('supplierId', args.supplierId)
+         .eq('deviceCategory', undefined)
+         .eq('priority', args.priority)
+      )
+      .first();
+
+    return genericRule;
+  },
+});
+
+// Create SLA rule (admin only)
+export const createSLARule = mutation({
+  args: {
+    name: v.optional(v.string()),
+    supplierId: v.id('suppliers'),
+    deviceCategory: v.optional(v.string()), // Opzionale = SLA generico
+    priority: v.union(v.literal('low'), v.literal('medium'), v.literal('high')),
+    responseTimeHours: v.number(),
+    resolutionTimeHours: v.number(),
+    description: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Verify supplier exists
+    const supplier = await ctx.db.get(args.supplierId);
+    if (!supplier) {
+      throw new Error(`Supplier with ID ${args.supplierId} not found`);
+    }
+
+    // Check if rule already exists for this supplier, category and priority
+    const existing = await ctx.db
+      .query('sla_rules')
+      .withIndex('by_supplierId_category_priority', (q: any) =>
+        q.eq('supplierId', args.supplierId)
+         .eq('deviceCategory', args.deviceCategory)
+         .eq('priority', args.priority)
+      )
+      .first();
+
+    if (existing) {
+      const priorityLabels: Record<string, string> = {
+        low: 'Bassa',
+        medium: 'Media',
+        high: 'Alta'
+      };
+      const categoryText = args.deviceCategory 
+        ? `per la categoria "${args.deviceCategory}"` 
+        : 'generica (tutte le attrezzature)';
+      throw new Error(
+        `Esiste già una regola SLA ${categoryText} per il fornitore "${supplier?.name}" con priorità "${priorityLabels[args.priority]}". ` +
+        `Modifica la regola esistente o scegli un'altra combinazione.`
+      );
+    }
+
+    const ruleId = await ctx.db.insert('sla_rules', {
+      name: args.name,
+      supplierId: args.supplierId,
+      deviceCategory: args.deviceCategory,
+      priority: args.priority,
+      responseTimeHours: args.responseTimeHours,
+      resolutionTimeHours: args.resolutionTimeHours,
+      description: args.description,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    return ruleId;
+  },
+});
+
+// Update SLA rule (admin only)
+export const updateSLARule = mutation({
+  args: {
+    ruleId: v.id('sla_rules'),
+    name: v.optional(v.string()),
+    supplierId: v.optional(v.id('suppliers')),
+    deviceCategory: v.optional(v.string()),
+    priority: v.optional(v.union(v.literal('low'), v.literal('medium'), v.literal('high'))),
+    responseTimeHours: v.number(),
+    resolutionTimeHours: v.number(),
+    description: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Get current rule
+    const currentRule = await ctx.db.get(args.ruleId);
+    if (!currentRule) {
+      throw new Error('Regola SLA non trovata');
+    }
+
+    // Determine new values
+    const newSupplierId = args.supplierId || currentRule.supplierId;
+    const newDeviceCategory = args.deviceCategory !== undefined ? args.deviceCategory : currentRule.deviceCategory;
+    const newPriority = args.priority || currentRule.priority;
+
+    // Check if the new combination already exists (excluding current rule)
+    if (args.supplierId || args.deviceCategory !== undefined || args.priority) {
+      const existing = await ctx.db
+        .query('sla_rules')
+        .withIndex('by_supplierId_category_priority', (q: any) =>
+          q.eq('supplierId', newSupplierId)
+           .eq('deviceCategory', newDeviceCategory || undefined)
+           .eq('priority', newPriority)
+        )
+        .first();
+
+      if (existing && existing._id !== args.ruleId) {
+        const supplier = await ctx.db.get(newSupplierId);
+        const priorityLabels: Record<string, string> = {
+          low: 'Bassa',
+          medium: 'Media',
+          high: 'Alta'
+        };
+        const categoryText = newDeviceCategory 
+          ? `per la categoria "${newDeviceCategory}"` 
+          : 'generica (tutte le attrezzature)';
+        throw new Error(
+          `Esiste già una regola SLA ${categoryText} per il fornitore "${supplier?.name}" con priorità "${priorityLabels[newPriority]}". ` +
+          `Modifica la regola esistente o scegli un'altra combinazione.`
+        );
+      }
+    }
+
+    const updates: any = {
+      responseTimeHours: args.responseTimeHours,
+      resolutionTimeHours: args.resolutionTimeHours,
+      description: args.description,
+      updatedAt: Date.now(),
+    };
+
+    if (args.name) {
+      updates.name = args.name;
+    }
+    if (args.supplierId) {
+      updates.supplierId = args.supplierId;
+    }
+    if (args.deviceCategory !== undefined) {
+      updates.deviceCategory = args.deviceCategory || undefined;
+    }
+    if (args.priority) {
+      updates.priority = args.priority;
+    }
+
+    await ctx.db.patch(args.ruleId, updates);
+
+    return args.ruleId;
+  },
+});
+
+// Delete SLA rule (admin only)
+export const deleteSLARule = mutation({
+  args: { ruleId: v.id('sla_rules') },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.ruleId);
+    return { success: true };
+  },
+});

package/src/component/sparePartOrders.ts

@@ -0,0 +1,290 @@
+import { v } from 'convex/values';
+import { mutation, query, internalMutation } from './_generated/server';
+import { internal } from './_generated/api';
+
+function generateOrderNumber(): string {
+  const date = new Date();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const random = Math.floor(Math.random() * 10000).toString().padStart(4, '0');
+  return `ORD-${year}${month}${day}-${random}`;
+}
+
+export const createOrder = mutation({
+  args: {
+    clinicId: v.number(),
+    supplierId: v.id('suppliers'),
+    items: v.array(v.object({
+      sparePartId: v.id('spare_parts'),
+      articleId: v.number(),
+      articleName: v.string(),
+      code: v.optional(v.string()),
+      quantity: v.number(),
+      unitPrice: v.optional(v.number()),
+      totalPrice: v.optional(v.number()),
+      notes: v.optional(v.string()),
+    })),
+    notes: v.optional(v.string()),
+    requestedDeliveryDate: v.optional(v.number()),
+    createdBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const orderNumber = generateOrderNumber();
+    const now = Date.now();
+
+    const totalAmount = args.items.reduce((sum, item) => {
+      return sum + (item.totalPrice || 0);
+    }, 0);
+
+    const orderId = await ctx.db.insert('spare_part_orders', {
+      orderNumber,
+      clinicId: args.clinicId,
+      supplierId: args.supplierId,
+      status: 'pending',
+      items: args.items,
+      totalAmount,
+      notes: args.notes,
+      requestedDeliveryDate: args.requestedDeliveryDate,
+      createdBy: args.createdBy,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.scheduler.runAfter(0, internal.sparePartOrders.executeSparePartOrderTriggers, {
+      orderId,
+      eventType: 'spare_part_order_created',
+      previousStatus: undefined,
+      newStatus: 'pending',
+    });
+
+    return { orderId, orderNumber };
+  },
+});
+
+export const listOrdersByClinic = query({
+  args: {
+    clinicId: v.number(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit || 100;
+
+    const orders = await ctx.db
+      .query('spare_part_orders')
+      .withIndex('by_clinicId', (q) => q.eq('clinicId', args.clinicId))
+      .order('desc')
+      .take(limit);
+
+    return orders;
+  },
+});
+
+export const listAllOrders = query({
+  args: {
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit || 100;
+
+    const orders = await ctx.db
+      .query('spare_part_orders')
+      .withIndex('by_createdAt')
+      .order('desc')
+      .take(limit);
+
+    return orders;
+  },
+});
+
+export const getOrder = query({
+  args: { orderId: v.id('spare_part_orders') },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.orderId);
+  },
+});
+
+export const updateOrderStatus = mutation({
+  args: {
+    orderId: v.id('spare_part_orders'),
+    status: v.union(
+      v.literal('draft'),
+      v.literal('pending'),
+      v.literal('confirmed'),
+      v.literal('shipped'),
+      v.literal('delivered'),
+      v.literal('cancelled')
+    ),
+  },
+  handler: async (ctx, args) => {
+    const order = await ctx.db.get(args.orderId);
+    const previousStatus = order?.status;
+
+    const now = Date.now();
+    const updates: any = {
+      status: args.status,
+      updatedAt: now,
+    };
+
+    if (args.status === 'confirmed') {
+      updates.confirmedAt = now;
+    } else if (args.status === 'shipped') {
+      updates.shippedAt = now;
+    } else if (args.status === 'delivered') {
+      updates.deliveredAt = now;
+      updates.actualDeliveryDate = now;
+    }
+
+    await ctx.db.patch(args.orderId, updates);
+
+    if (previousStatus !== args.status) {
+      await ctx.scheduler.runAfter(0, internal.sparePartOrders.executeSparePartOrderTriggers, {
+        orderId: args.orderId,
+        eventType: 'spare_part_order_status_change',
+        previousStatus,
+        newStatus: args.status,
+      });
+    }
+
+    return { success: true };
+  },
+});
+
+export const updateOrder = mutation({
+  args: {
+    orderId: v.id('spare_part_orders'),
+    items: v.optional(v.array(v.object({
+      sparePartId: v.id('spare_parts'),
+      articleId: v.number(),
+      articleName: v.string(),
+      code: v.optional(v.string()),
+      quantity: v.number(),
+      unitPrice: v.optional(v.number()),
+      totalPrice: v.optional(v.number()),
+      notes: v.optional(v.string()),
+    }))),
+    notes: v.optional(v.string()),
+    requestedDeliveryDate: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const { orderId, ...updates } = args;
+
+    if (updates.items) {
+      const totalAmount = updates.items.reduce((sum, item) => {
+        return sum + (item.totalPrice || 0);
+      }, 0);
+      (updates as any).totalAmount = totalAmount;
+    }
+
+    (updates as any).updatedAt = Date.now();
+
+    await ctx.db.patch(orderId, updates);
+
+    return { success: true };
+  },
+});
+
+export const deleteOrder = mutation({
+  args: {
+    orderId: v.id('spare_part_orders'),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.orderId);
+    return { success: true };
+  },
+});
+
+export const listOrdersBySupplier = query({
+  args: {
+    supplierId: v.id('suppliers'),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit || 100;
+
+    const orders = await ctx.db
+      .query('spare_part_orders')
+      .withIndex('by_supplierId', (q) => q.eq('supplierId', args.supplierId))
+      .order('desc')
+      .take(limit);
+
+    return orders;
+  },
+});
+
+export const executeSparePartOrderTriggers = internalMutation({
+  args: {
+    orderId: v.id('spare_part_orders'),
+    eventType: v.union(
+      v.literal('spare_part_order_created'),
+      v.literal('spare_part_order_status_change')
+    ),
+    previousStatus: v.optional(v.string()),
+    newStatus: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const order = await ctx.db.get(args.orderId);
+    if (!order) {
+      console.log('Order not found for trigger execution');
+      return;
+    }
+
+    const triggers = await ctx.db
+      .query('ticket_triggers')
+      .withIndex('by_isActive', (q) => q.eq('isActive', true))
+      .collect();
+
+    const sparePartTriggers = triggers.filter(t =>
+      t.conditions.triggerOn === args.eventType
+    );
+
+    sparePartTriggers.sort((a, b) => a.priority - b.priority);
+
+    for (const trigger of sparePartTriggers) {
+      try {
+        const conditions = trigger.conditions;
+        const filters = conditions.sparePartOrderFilters;
+
+        if (filters && !filters.applyToAllSuppliers && filters.supplierIds && filters.supplierIds.length > 0) {
+          if (!filters.supplierIds.includes(order.supplierId)) {
+            continue;
+          }
+        }
+
+        if (args.eventType === 'spare_part_order_status_change' && filters?.statuses && filters.statuses.length > 0) {
+          if (!filters.statuses.includes(args.newStatus)) {
+            continue;
+          }
+        }
+
+        const actions = trigger.actions.sparePartOrderActions;
+        if (!actions) continue;
+
+        if (actions.changeOrderStatus && actions.changeOrderStatus !== args.newStatus) {
+          const validStatuses = ['draft', 'pending', 'confirmed', 'shipped', 'delivered', 'cancelled'];
+          if (validStatuses.includes(actions.changeOrderStatus)) {
+            await ctx.db.patch(args.orderId, {
+              status: actions.changeOrderStatus as 'draft' | 'pending' | 'confirmed' | 'shipped' | 'delivered' | 'cancelled',
+              updatedAt: Date.now(),
+            });
+          }
+        }
+
+        if (actions.addOrderNote) {
+          const currentNotes = order.notes || '';
+          const newNote = `[${new Date().toLocaleString('it-IT')}] ${actions.addOrderNote}`;
+          await ctx.db.patch(args.orderId, {
+            notes: currentNotes ? `${currentNotes}\n${newNote}` : newNote,
+            updatedAt: Date.now(),
+          });
+        }
+
+        // NOTE: sendOrderNotification is handled by the parent app (emailActions).
+        // The component marks data; the parent app is responsible for sending emails.
+
+      } catch (error) {
+        console.error(`Error executing trigger "${trigger.name}":`, error);
+      }
+    }
+  },
+});