@primocaredentgroup/elettromedicali 0.1.0

package/src/component/deviceCategories.ts

@@ -0,0 +1,280 @@
+import { v } from 'convex/values';
+import { mutation, query } from './_generated/server';
+
+// Import all categories from JSON
+export const importCategories = mutation({
+  args: {
+    categories: v.array(v.object({
+      id: v.union(v.number(), v.null()),
+      name: v.union(v.string(), v.null()),
+      parent_id: v.union(v.number(), v.null()),
+      active_warehouse_category: v.union(v.number(), v.null()),
+      oris_id: v.union(v.string(), v.null()),
+      type: v.union(v.string(), v.null()),
+      created_at: v.union(v.string(), v.null()),
+      updated_at: v.union(v.string(), v.null()),
+      note: v.union(v.string(), v.null()),
+    })),
+  },
+  handler: async (ctx, args) => {
+    let imported = 0;
+    let skipped = 0;
+    let errors = 0;
+
+    for (const category of args.categories) {
+      try {
+        // Skip if no ID or name
+        if (!category.id || !category.name) {
+          skipped++;
+          continue;
+        }
+
+        // Check if already exists
+        const existing = await ctx.db
+          .query('device_categories')
+          .withIndex('by_primoupId', (q) => q.eq('primoupId', category.id as number))
+          .first();
+
+        if (existing) {
+          // Update existing
+          await ctx.db.patch(existing._id, {
+            name: category.name,
+            parentId: category.parent_id || undefined,
+            activeWarehouseCategory: category.active_warehouse_category || undefined,
+            orisId: category.oris_id || undefined,
+            type: category.type || undefined,
+            note: category.note || undefined,
+            createdAt: category.created_at || undefined,
+            updatedAt: category.updated_at || undefined,
+            importedAt: Date.now(),
+          });
+        } else {
+          // Insert new
+          await ctx.db.insert('device_categories', {
+            primoupId: category.id,
+            name: category.name,
+            parentId: category.parent_id || undefined,
+            activeWarehouseCategory: category.active_warehouse_category || undefined,
+            orisId: category.oris_id || undefined,
+            type: category.type || undefined,
+            note: category.note || undefined,
+            createdAt: category.created_at || undefined,
+            updatedAt: category.updated_at || undefined,
+            importedAt: Date.now(),
+          });
+        }
+
+        imported++;
+      } catch (error) {
+        console.error(`Error importing category ${category.id}:`, error);
+        errors++;
+      }
+    }
+
+    return {
+      success: true,
+      imported,
+      skipped,
+      errors,
+      total: args.categories.length,
+    };
+  },
+});
+
+// Get all categories
+export const list = query({
+  args: {
+    search: v.optional(v.string()),
+    noteFilter: v.optional(v.string()), // null, "1", "2", "3"
+    typeFilter: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    let categories = await ctx.db.query('device_categories').collect();
+
+    // Apply filters
+    if (args.search) {
+      const searchLower = args.search.toLowerCase();
+      categories = categories.filter((c) =>
+        c.name.toLowerCase().includes(searchLower) ||
+        (c.primoupId && c.primoupId.toString().includes(searchLower))
+      );
+    }
+
+    if (args.noteFilter) {
+      if (args.noteFilter === 'null') {
+        categories = categories.filter((c) => !c.note || c.note === '');
+      } else {
+        categories = categories.filter((c) => c.note === args.noteFilter);
+      }
+    }
+
+    if (args.typeFilter) {
+      categories = categories.filter((c) => c.type === args.typeFilter);
+    }
+
+    // Sort by name
+    categories.sort((a, b) => a.name.localeCompare(b.name));
+
+    return categories;
+  },
+});
+
+// Get category by ID
+export const get = query({
+  args: { id: v.id('device_categories') },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.id);
+  },
+});
+
+// Get category by PrimoUP ID
+export const getByPrimoupId = query({
+  args: { primoupId: v.number() },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query('device_categories')
+      .withIndex('by_primoupId', (q) => q.eq('primoupId', args.primoupId))
+      .first();
+  },
+});
+
+// Create category
+export const create = mutation({
+  args: {
+    primoupId: v.number(),
+    name: v.string(),
+    parentId: v.optional(v.number()),
+    activeWarehouseCategory: v.optional(v.number()),
+    orisId: v.optional(v.string()),
+    type: v.optional(v.string()),
+    note: v.optional(v.string()),
+    createdAt: v.optional(v.string()),
+    updatedAt: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Check if already exists
+    const existing = await ctx.db
+      .query('device_categories')
+      .withIndex('by_primoupId', (q) => q.eq('primoupId', args.primoupId))
+      .first();
+
+    if (existing) {
+      throw new Error(`Category with PrimoUP ID ${args.primoupId} already exists`);
+    }
+
+    const categoryId = await ctx.db.insert('device_categories', {
+      primoupId: args.primoupId,
+      name: args.name,
+      parentId: args.parentId,
+      activeWarehouseCategory: args.activeWarehouseCategory,
+      orisId: args.orisId,
+      type: args.type,
+      note: args.note,
+      createdAt: args.createdAt,
+      updatedAt: args.updatedAt,
+      importedAt: Date.now(),
+    });
+
+    return categoryId;
+  },
+});
+
+// Update category
+export const update = mutation({
+  args: {
+    id: v.id('device_categories'),
+    name: v.optional(v.string()),
+    parentId: v.optional(v.number()),
+    activeWarehouseCategory: v.optional(v.number()),
+    orisId: v.optional(v.string()),
+    type: v.optional(v.string()),
+    note: v.optional(v.string()),
+    createdAt: v.optional(v.string()),
+    updatedAt: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const { id, ...updates } = args;
+
+    await ctx.db.patch(id, {
+      ...updates,
+      importedAt: Date.now(),
+    });
+
+    return id;
+  },
+});
+
+// Delete category
+export const remove = mutation({
+  args: { id: v.id('device_categories') },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});
+
+// Get statistics
+export const stats = query({
+  args: {},
+  handler: async (ctx) => {
+    const categories = await ctx.db.query('device_categories').collect();
+
+    const byType: Record<string, number> = {};
+
+    const result = {
+      total: categories.length,
+      byNote: {
+        null: 0,
+        '1': 0,
+        '2': 0,
+        '3': 0,
+      } as Record<string, number>,
+      byType,
+      withParent: 0,
+      withoutParent: 0,
+    };
+
+    categories.forEach((cat) => {
+      // Count by note
+      if (!cat.note || cat.note === '') {
+        result.byNote['null']++;
+      } else if (cat.note === '1') {
+        result.byNote['1']++;
+      } else if (cat.note === '2') {
+        result.byNote['2']++;
+      } else if (cat.note === '3') {
+        result.byNote['3']++;
+      }
+
+      // Count by type
+      const type = cat.type || 'unknown';
+      result.byType[type] = (result.byType[type] || 0) + 1;
+
+      // Count parent/child
+      if (cat.parentId) {
+        result.withParent++;
+      } else {
+        result.withoutParent++;
+      }
+    });
+
+    return result;
+  },
+});
+
+// Clear all categories (for re-import)
+export const deleteAll = mutation({
+  args: {},
+  handler: async (ctx) => {
+    const categories = await ctx.db.query('device_categories').collect();
+    
+    for (const category of categories) {
+      await ctx.db.delete(category._id);
+    }
+
+    return {
+      success: true,
+      deleted: categories.length,
+    };
+  },
+});

package/src/component/deviceQuestions.ts

@@ -0,0 +1,225 @@
+import { v } from 'convex/values';
+import { mutation, query } from './_generated/server';
+
+export const listQuestionsByDevice = query({
+  args: {
+    deviceId: v.id('devices'),
+  },
+  handler: async (ctx, args) => {
+    const questions = await ctx.db
+      .query('device_questions')
+      .withIndex('by_deviceId', (q) => q.eq('deviceId', args.deviceId))
+      .filter((q) => q.eq(q.field('isActive'), true))
+      .collect();
+
+    return questions.sort((a, b) => a.order - b.order);
+  },
+});
+
+export const listAllQuestions = query({
+  args: {},
+  handler: async (ctx) => {
+    try {
+      const questions = await ctx.db
+        .query('device_questions')
+        .collect();
+
+      if (questions.length === 0) {
+        return [];
+      }
+
+      const questionsWithDevices = await Promise.all(
+        questions.map(async (question) => {
+          const device = await ctx.db.get(question.deviceId);
+          return {
+            ...question,
+            deviceName: device?.name || 'Attrezzatura non trovata',
+            deviceCategory: device?.category || '',
+          };
+        })
+      );
+
+      return questionsWithDevices.sort((a, b) => {
+        if (a.deviceName !== b.deviceName) {
+          return a.deviceName.localeCompare(b.deviceName);
+        }
+        return a.order - b.order;
+      });
+    } catch (error: any) {
+      console.error('Error in listAllQuestions:', error);
+      throw error;
+    }
+  },
+});
+
+export const getQuestion = query({
+  args: {
+    questionId: v.id('device_questions'),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.questionId);
+  },
+});
+
+export const createQuestion = mutation({
+  args: {
+    deviceId: v.id('devices'),
+    question: v.string(),
+    questionType: v.union(
+      v.literal('text'),
+      v.literal('textarea'),
+      v.literal('select'),
+      v.literal('multiselect'),
+      v.literal('yes_no'),
+      v.literal('number'),
+      v.literal('date')
+    ),
+    options: v.optional(v.array(v.string())),
+    isRequired: v.boolean(),
+    order: v.number(),
+    placeholder: v.optional(v.string()),
+    helpText: v.optional(v.string()),
+    conditionalLogic: v.optional(v.object({
+      enabled: v.boolean(),
+      conditions: v.array(v.object({
+        questionId: v.id('device_questions'),
+        operator: v.union(
+          v.literal('equals'),
+          v.literal('not_equals'),
+          v.literal('contains'),
+          v.literal('not_contains'),
+          v.literal('greater_than'),
+          v.literal('less_than'),
+          v.literal('is_empty'),
+          v.literal('is_not_empty')
+        ),
+        value: v.any(),
+      })),
+      logic: v.union(v.literal('AND'), v.literal('OR')),
+    })),
+    createdBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const device = await ctx.db.get(args.deviceId);
+    if (!device) {
+      throw new Error('Attrezzatura non trovata');
+    }
+
+    const questionId = await ctx.db.insert('device_questions', {
+      deviceId: args.deviceId,
+      question: args.question,
+      questionType: args.questionType,
+      options: args.options,
+      isRequired: args.isRequired,
+      order: args.order,
+      placeholder: args.placeholder,
+      helpText: args.helpText,
+      conditionalLogic: args.conditionalLogic,
+      isActive: true,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      createdBy: args.createdBy,
+    });
+
+    return questionId;
+  },
+});
+
+export const updateQuestion = mutation({
+  args: {
+    questionId: v.id('device_questions'),
+    question: v.optional(v.string()),
+    questionType: v.optional(
+      v.union(
+        v.literal('text'),
+        v.literal('textarea'),
+        v.literal('select'),
+        v.literal('multiselect'),
+        v.literal('yes_no'),
+        v.literal('number'),
+        v.literal('date')
+      )
+    ),
+    options: v.optional(v.array(v.string())),
+    isRequired: v.optional(v.boolean()),
+    order: v.optional(v.number()),
+    placeholder: v.optional(v.string()),
+    helpText: v.optional(v.string()),
+    conditionalLogic: v.optional(v.object({
+      enabled: v.boolean(),
+      conditions: v.array(v.object({
+        questionId: v.id('device_questions'),
+        operator: v.union(
+          v.literal('equals'),
+          v.literal('not_equals'),
+          v.literal('contains'),
+          v.literal('not_contains'),
+          v.literal('greater_than'),
+          v.literal('less_than'),
+          v.literal('is_empty'),
+          v.literal('is_not_empty')
+        ),
+        value: v.any(),
+      })),
+      logic: v.union(v.literal('AND'), v.literal('OR')),
+    })),
+    isActive: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    const question = await ctx.db.get(args.questionId);
+    if (!question) {
+      throw new Error('Domanda non trovata');
+    }
+
+    const updates: any = {
+      updatedAt: Date.now(),
+    };
+
+    if (args.question !== undefined) updates.question = args.question;
+    if (args.questionType !== undefined) updates.questionType = args.questionType;
+    if (args.options !== undefined) updates.options = args.options;
+    if (args.isRequired !== undefined) updates.isRequired = args.isRequired;
+    if (args.order !== undefined) updates.order = args.order;
+    if (args.placeholder !== undefined) updates.placeholder = args.placeholder;
+    if (args.helpText !== undefined) updates.helpText = args.helpText;
+    if (args.conditionalLogic !== undefined) updates.conditionalLogic = args.conditionalLogic;
+    if (args.isActive !== undefined) updates.isActive = args.isActive;
+
+    await ctx.db.patch(args.questionId, updates);
+
+    return args.questionId;
+  },
+});
+
+export const deleteQuestion = mutation({
+  args: {
+    questionId: v.id('device_questions'),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.questionId, {
+      isActive: false,
+      updatedAt: Date.now(),
+    });
+
+    return args.questionId;
+  },
+});
+
+export const reorderQuestions = mutation({
+  args: {
+    deviceId: v.id('devices'),
+    questionIds: v.array(v.id('device_questions')),
+  },
+  handler: async (ctx, args) => {
+    await Promise.all(
+      args.questionIds.map((questionId, index) =>
+        ctx.db.patch(questionId, {
+          order: index,
+          updatedAt: Date.now(),
+        })
+      )
+    );
+
+    return true;
+  },
+});

package/src/component/deviceRepairHistory.ts

@@ -0,0 +1,94 @@
+import { v } from 'convex/values';
+import { query, mutation } from './_generated/server';
+
+export const getRepairHistory = query({
+  args: {
+    deviceId: v.id('devices'),
+  },
+  handler: async (ctx, args) => {
+    const repairs = await ctx.db
+      .query('device_repair_history')
+      .withIndex('by_deviceId', (q: any) => q.eq('deviceId', args.deviceId))
+      .take(100);
+
+    return repairs.sort((a, b) => b.sentToRepairAt - a.sentToRepairAt);
+  },
+});
+
+export const sendToRepair = mutation({
+  args: {
+    deviceId: v.id('devices'),
+    ticketId: v.optional(v.id('maintenance_tasks')),
+    notes: v.optional(v.string()),
+    createdBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const device = await ctx.db.get(args.deviceId);
+    if (!device) {
+      throw new Error('Device not found');
+    }
+
+    const repairId = await ctx.db.insert('device_repair_history', {
+      deviceId: args.deviceId,
+      clinicId: device.clinicId,
+      ticketId: args.ticketId,
+      sentToRepairAt: Date.now(),
+      notes: args.notes,
+      createdBy: args.createdBy,
+    });
+
+    await ctx.db.patch(args.deviceId, {
+      status: 'in_maintenance',
+    });
+
+    return repairId;
+  },
+});
+
+export const returnFromRepair = mutation({
+  args: {
+    deviceId: v.id('devices'),
+    statusAfterRepair: v.union(v.literal('active'), v.literal('out_of_service')),
+    notes: v.optional(v.string()),
+    returnedBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const device = await ctx.db.get(args.deviceId);
+    if (!device) {
+      throw new Error('Device not found');
+    }
+
+    const repairs = await ctx.db
+      .query('device_repair_history')
+      .withIndex('by_deviceId', (q: any) => q.eq('deviceId', args.deviceId))
+      .take(100);
+
+    const openRepair = repairs.find((r) => !r.returnedAt);
+
+    if (openRepair) {
+      await ctx.db.patch(openRepair._id, {
+        returnedAt: Date.now(),
+        statusAfterRepair: args.statusAfterRepair,
+        notes: args.notes || openRepair.notes,
+        returnedBy: args.returnedBy,
+      });
+    } else {
+      await ctx.db.insert('device_repair_history', {
+        deviceId: args.deviceId,
+        clinicId: device.clinicId,
+        sentToRepairAt: Date.now(),
+        returnedAt: Date.now(),
+        statusAfterRepair: args.statusAfterRepair,
+        notes: args.notes,
+        createdBy: args.returnedBy,
+        returnedBy: args.returnedBy,
+      });
+    }
+
+    await ctx.db.patch(args.deviceId, {
+      status: args.statusAfterRepair,
+    });
+
+    return { success: true };
+  },
+});

package/src/component/deviceStatus.ts

@@ -0,0 +1,79 @@
+import { query } from './_generated/server';
+import { v } from 'convex/values';
+
+export const computeDeviceStatus = query({
+  args: { deviceId: v.id('devices') },
+  handler: async (ctx, { deviceId }) => {
+    const tickets = await ctx.db
+      .query('maintenance_tasks')
+      .withIndex('by_deviceId', (q) => q.eq('deviceId', deviceId))
+      .take(200);
+
+    if (tickets.length === 0) {
+      return 'in_uso';
+    }
+
+    const smaltito = tickets.find(
+      (t) =>
+        t.status === 'smaltito' &&
+        t.updated_at &&
+        t.created_at < t.updated_at
+    );
+    if (smaltito) {
+      return 'smaltito';
+    }
+
+    const raee = tickets.find(
+      (t) =>
+        t.description?.toLowerCase().includes('raee') ||
+        t.description?.toLowerCase().includes('smaltimento')
+    );
+    if (raee && raee.status !== 'closed' && raee.status !== 'completed') {
+      return 'da_smaltire';
+    }
+
+    const openTickets = tickets.filter(
+      (t) =>
+        t.status === 'open' ||
+        t.status === 'assigned_to_supplier' ||
+        t.status === 'in_progress' ||
+        t.status === 'pending'
+    );
+
+    if (openTickets.length > 0) {
+      return 'guasto';
+    }
+
+    return 'in_uso';
+  },
+});
+
+export const getDeviceTicketHistory = query({
+  args: { deviceId: v.id('devices') },
+  handler: async (ctx, { deviceId }) => {
+    const tickets = await ctx.db
+      .query('maintenance_tasks')
+      .withIndex('by_deviceId', (q) => q.eq('deviceId', deviceId))
+      .order('desc')
+      .take(50);
+
+    const enrichedTickets = await Promise.all(
+      tickets.map(async (ticket) => {
+        const clinic = ticket.clinicId
+          ? await ctx.db.get(ticket.clinicId)
+          : null;
+        const supplier = ticket.supplierId
+          ? await ctx.db.get(ticket.supplierId)
+          : null;
+
+        return {
+          ...ticket,
+          clinic,
+          supplier,
+        };
+      })
+    );
+
+    return enrichedTickets;
+  },
+});