@primocaredentgroup/elettromedicali 0.1.0 → 0.1.1

package/src/component/contracts.ts

@@ -10,21 +10,14 @@ export const listContracts = query({
       contracts.map(async (contract) => {
         const supplier = await ctx.db.get(contract.supplierId);
 
-        let clinicNames: string[] = [];
-        if (contract.clinicIds && contract.clinicIds.length > 0) {
-          const clinics = await Promise.all(
-            contract.clinicIds.map(id => ctx.db.get(id))
-          );
-          clinicNames = clinics.map(c => c?.name || 'Sconosciuta');
-        } else if (contract.clinicId) {
-          const clinic = await ctx.db.get(contract.clinicId);
-          clinicNames = clinic ? [clinic.name] : [];
-        }
+        const clinicNames = contract.clinicIds && contract.clinicIds.length > 0
+          ? contract.clinicIds
+          : (contract.clinicId ? [contract.clinicId] : ['Tutte le cliniche']);
 
         return {
           ...contract,
           supplierName: supplier?.name || 'Unknown',
-          clinicNames: clinicNames.length > 0 ? clinicNames : ['Tutte le cliniche'],
+          clinicNames,
         };
       })
     );
@@ -46,7 +39,7 @@ export const getContractsBySupplier = query({
 });
 
 export const getContractsByClinic = query({
-  args: { clinicId: v.id('clinics') },
+  args: { clinicId: v.string() },
   handler: async (ctx, args) => {
     const contracts = await ctx.db
       .query('contracts')
@@ -60,7 +53,7 @@ export const getContractsByClinic = query({
 export const createContract = mutation({
   args: {
     supplierId: v.id('suppliers'),
-    clinicIds: v.optional(v.array(v.id('clinics'))),
+    clinicIds: v.optional(v.array(v.string())),
     start_date: v.number(),
     end_date: v.number(),
     amount: v.number(),
@@ -91,7 +84,7 @@ export const createContract = mutation({
 export const updateContract = mutation({
   args: {
     contractId: v.id('contracts'),
-    clinicIds: v.optional(v.array(v.id('clinics'))),
+    clinicIds: v.optional(v.array(v.string())),
     start_date: v.optional(v.number()),
     end_date: v.optional(v.number()),
     description: v.optional(v.string()),

package/src/component/crons.ts

@@ -3,16 +3,11 @@ import { internal } from './_generated/api';
 
 const crons = cronJobs();
 
-crons.cron(
-  'check-sla-status',
-  '0 2 * * *',
-  internal.slaMonitoring.checkSLAStatus
-);
-
 crons.cron(
   'compute-dashboard-stats',
   '*/10 * * * *',
-  internal.dashboardStatsCache.computeAndStoreStats
+  internal.dashboardStatsCache.computeAndStoreStats,
+  {}
 );
 
 export default crons;

package/src/component/dashboardStats.ts

@@ -1,31 +1,28 @@
 import { query } from './_generated/server';
+import { v } from 'convex/values';
 
 export const getAdminDashboardStats = query({
-  args: {},
-  handler: async (ctx) => {
+  args: {
+    totalClinics: v.optional(v.number()),
+    ticketStats: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
     try {
       const cache = await ctx.db.query('dashboard_stats_cache').first();
       if (cache && cache.lastUpdated) {
         const ageMs = Date.now() - cache.lastUpdated;
         if (ageMs < 15 * 60 * 1000) {
           return {
-            totalClinics: cache.totalClinics,
+            totalClinics: args.totalClinics ?? cache.totalClinics,
             totalDevices: cache.totalDevices,
             totalSuppliers: cache.totalSuppliers,
             activeContracts: 0,
-            ticketStats: cache.ticketStats || {},
+            ticketStats: args.ticketStats ?? cache.ticketStats ?? {},
           };
         }
       }
 
-      const [clinics, suppliers, statuses] = await Promise.all([
-        ctx.db.query('clinics').take(500),
-        ctx.db.query('suppliers').take(500),
-        ctx.db
-          .query('ticket_statuses')
-          .withIndex('by_isActive', (q: any) => q.eq('isActive', true))
-          .collect(),
-      ]);
+      const suppliers = await ctx.db.query('suppliers').take(500);
 
       const DEVICE_LIMIT = 300;
       const deviceStatuses = ['active', 'in_maintenance', 'out_of_service'];
@@ -37,22 +34,12 @@ export const getAdminDashboardStats = query({
           .take(DEVICE_LIMIT)).length;
       }
 
-      const TICKET_LIMIT = 300;
-      const ticketStats: any = {};
-      for (const status of statuses) {
-        const count = (await ctx.db
-          .query('maintenance_tasks')
-          .withIndex('by_status', (q: any) => q.eq('status', status.name))
-          .take(TICKET_LIMIT)).length;
-        ticketStats[status.name] = count;
-      }
-
       return {
-        totalClinics: clinics.length,
+        totalClinics: args.totalClinics ?? 0,
         totalDevices,
         totalSuppliers: suppliers.length,
         activeContracts: 0,
-        ticketStats,
+        ticketStats: args.ticketStats ?? {},
       };
     } catch (error) {
       console.error('Error in getAdminDashboardStats:', error);
@@ -68,41 +55,37 @@ export const getAdminDashboardStats = query({
 });
 
 export const getRecentActivity = query({
-  args: {},
-  handler: async (ctx) => {
+  args: {
+    recentTickets: v.optional(v.array(v.any())),
+  },
+  handler: async (ctx, args) => {
     try {
-      const recentTasks = await ctx.db
-        .query('maintenance_tasks')
-        .order('desc')
-        .take(10);
-
+      const recentTasks = args.recentTickets || [];
       const statuses = await ctx.db.query('ticket_statuses').collect();
       const statusMap = new Map(statuses.map(s => [s.name, s.label]));
       const activities = [];
 
       for (const task of recentTasks) {
-        const device = task.deviceId ? await ctx.db.get(task.deviceId) : null;
-        const clinic = task.clinicId ? await ctx.db.get(task.clinicId) : null;
         const statusLabel = statusMap.get(task.status) || task.status;
+        const deviceName = task.deviceName || 'Unknown';
 
         let message = '';
         if (task.status === 'open') {
-          message = `Nuovo ticket creato per dispositivo ${device?.name || 'Unknown'}`;
+          message = `Nuovo ticket creato per dispositivo ${deviceName}`;
         } else if (task.status === 'completed' || task.status === 'closed') {
-          message = `Ticket completato per dispositivo ${device?.name || 'Unknown'}`;
+          message = `Ticket completato per dispositivo ${deviceName}`;
         } else if (task.status === 'assigned_to_supplier') {
-          const supplier = task.supplierId ? await ctx.db.get(task.supplierId) : null;
-          message = `Ticket assegnato a ${supplier?.name || 'fornitore'}`;
+          message = `Ticket assegnato a ${task.supplierName || 'fornitore'}`;
         } else {
-          message = `Ticket ${statusLabel} per dispositivo ${device?.name || 'Unknown'}`;
+          message = `Ticket ${statusLabel} per dispositivo ${deviceName}`;
         }
 
         activities.push({
-          id: task._id,
+          id: task._id || task.ticketId,
           type: 'ticket',
           message,
-          time: task.created_at,
-          clinicName: clinic?.name,
+          time: task.created_at || task.lastActivityAt,
+          clinicId: task.clinicId,
         });
       }
 

package/src/component/dashboardStatsCache.ts

@@ -2,33 +2,6 @@ import { v } from 'convex/values';
 import { internalQuery, internalMutation, internalAction } from './_generated/server';
 import { internal } from './_generated/api';
 
-const BATCH_SIZE = 50;
-
-export const countTicketsBatch = internalQuery({
-  args: {
-    status: v.string(),
-    cursor: v.optional(v.number()),
-  },
-  handler: async (ctx, args) => {
-    const q = ctx.db
-      .query('maintenance_tasks')
-      .withIndex('by_status_created_at', (q) =>
-        args.cursor != null
-          ? q.eq('status', args.status).lt('created_at', args.cursor)
-          : q.eq('status', args.status)
-      )
-      .order('desc')
-      .take(BATCH_SIZE);
-
-    const batch = await q;
-    return {
-      count: batch.length,
-      hasMore: batch.length === BATCH_SIZE,
-      lastCursor: batch.length > 0 ? batch[batch.length - 1].created_at : null,
-    };
-  },
-});
-
 export const countDevicesBatch = internalQuery({
   args: { status: v.union(v.literal('active'), v.literal('in_maintenance'), v.literal('out_of_service')) },
   handler: async (ctx, args) => {
@@ -41,63 +14,41 @@ export const countDevicesBatch = internalQuery({
 });
 
 export const computeAndStoreStats = internalAction({
-  args: {},
-  handler: async (ctx) => {
+  args: {
+    ticketStats: v.optional(v.any()),
+    totalTickets: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
     const now = Date.now();
 
-    const [clinics, suppliers, statuses] = await Promise.all([
-      ctx.runQuery(internal.dashboardStatsCache.countTable, { table: 'clinics' }),
-      ctx.runQuery(internal.dashboardStatsCache.countTable, { table: 'suppliers' }),
-      ctx.runQuery(internal.dashboardStatsCache.getActiveStatuses, {}),
-    ]);
+    const suppliers = await ctx.runQuery(internal.dashboardStatsCache.countTable, { table: 'suppliers' });
 
     const deviceStatuses = ['active', 'in_maintenance', 'out_of_service'] as const;
     const deviceCountByStatus: Record<string, number> = {};
     let totalDevices = 0;
 
     for (const status of deviceStatuses) {
-      const r = await ctx.runQuery(internal.dashboardStatsCache.countDevicesBatch, {
-        status,
-      });
+      const r = await ctx.runQuery(internal.dashboardStatsCache.countDevicesBatch, { status });
       deviceCountByStatus[status] = r.count;
       totalDevices += r.count;
     }
 
-    const ticketStats: Record<string, number> = {};
-    let totalTickets = 0;
-
-    for (const status of statuses) {
-      let cursor: number | null | undefined = undefined;
-      let total = 0;
-      do {
-        const batchResult: { count: number; hasMore: boolean; lastCursor: number | null } =
-          await ctx.runQuery(internal.dashboardStatsCache.countTicketsBatch, {
-            status,
-            cursor: cursor ?? undefined,
-          });
-        total += batchResult.count;
-        cursor = batchResult.hasMore ? batchResult.lastCursor ?? null : null;
-      } while (cursor != null);
-      ticketStats[status] = total;
-      totalTickets += total;
-    }
-
     await ctx.runMutation(internal.dashboardStatsCache.writeCache, {
       lastUpdated: now,
-      totalClinics: clinics,
+      totalClinics: 0,
       totalSuppliers: suppliers,
       totalDevices,
       deviceCountByStatus,
-      ticketStats,
-      totalTickets,
+      ticketStats: args.ticketStats ?? {},
+      totalTickets: args.totalTickets ?? 0,
     });
 
-    return { ok: true, totalTickets, totalDevices };
+    return { ok: true, totalDevices };
   },
 });
 
 export const countTable = internalQuery({
-  args: { table: v.union(v.literal('clinics'), v.literal('suppliers')) },
+  args: { table: v.union(v.literal('suppliers')) },
   handler: async (ctx, args) => {
     const r = await ctx.db.query(args.table).take(2000);
     return r.length;

package/src/component/deviceCategories.ts

@@ -84,14 +84,18 @@ export const importCategories = mutation({
 // Get all categories
 export const list = query({
   args: {
+    page: v.optional(v.number()),
+    pageSize: v.optional(v.number()),
     search: v.optional(v.string()),
-    noteFilter: v.optional(v.string()), // null, "1", "2", "3"
+    noteFilter: v.optional(v.string()),
     typeFilter: v.optional(v.string()),
   },
   handler: async (ctx, args) => {
+    const page = args.page || 1;
+    const pageSize = args.pageSize || 20;
+
     let categories = await ctx.db.query('device_categories').collect();
 
-    // Apply filters
     if (args.search) {
       const searchLower = args.search.toLowerCase();
       categories = categories.filter((c) =>
@@ -112,10 +116,14 @@ export const list = query({
       categories = categories.filter((c) => c.type === args.typeFilter);
     }
 
-    // Sort by name
     categories.sort((a, b) => a.name.localeCompare(b.name));
 
-    return categories;
+    const totalCount = categories.length;
+    const totalPages = Math.ceil(totalCount / pageSize);
+    const startIndex = (page - 1) * pageSize;
+    const pageCategories = categories.slice(startIndex, startIndex + pageSize);
+
+    return { page: pageCategories, totalCount, totalPages, currentPage: page };
   },
 });
 

package/src/component/deviceQuestions.ts

@@ -17,18 +17,25 @@ export const listQuestionsByDevice = query({
 });
 
 export const listAllQuestions = query({
-  args: {},
-  handler: async (ctx) => {
+  args: {
+    page: v.optional(v.number()),
+    pageSize: v.optional(v.number()),
+    search: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const page = args.page || 1;
+    const pageSize = args.pageSize || 20;
+
     try {
       const questions = await ctx.db
         .query('device_questions')
         .collect();
 
       if (questions.length === 0) {
-        return [];
+        return { page: [], totalCount: 0, totalPages: 0, currentPage: page };
       }
 
-      const questionsWithDevices = await Promise.all(
+      let questionsWithDevices = await Promise.all(
         questions.map(async (question) => {
           const device = await ctx.db.get(question.deviceId);
           return {
@@ -39,12 +46,28 @@ export const listAllQuestions = query({
         })
       );
 
-      return questionsWithDevices.sort((a, b) => {
+      questionsWithDevices.sort((a, b) => {
         if (a.deviceName !== b.deviceName) {
           return a.deviceName.localeCompare(b.deviceName);
         }
         return a.order - b.order;
       });
+
+      if (args.search) {
+        const s = args.search.toLowerCase();
+        questionsWithDevices = questionsWithDevices.filter((q) =>
+          q.question?.toLowerCase().includes(s) ||
+          q.deviceName?.toLowerCase().includes(s) ||
+          q.deviceCategory?.toLowerCase().includes(s)
+        );
+      }
+
+      const totalCount = questionsWithDevices.length;
+      const totalPages = Math.ceil(totalCount / pageSize);
+      const startIndex = (page - 1) * pageSize;
+      const pageQuestions = questionsWithDevices.slice(startIndex, startIndex + pageSize);
+
+      return { page: pageQuestions, totalCount, totalPages, currentPage: page };
     } catch (error: any) {
       console.error('Error in listAllQuestions:', error);
       throw error;

package/src/component/deviceRepairHistory.ts

@@ -18,7 +18,7 @@ export const getRepairHistory = query({
 export const sendToRepair = mutation({
   args: {
     deviceId: v.id('devices'),
-    ticketId: v.optional(v.id('maintenance_tasks')),
+    ticketId: v.optional(v.string()),
     notes: v.optional(v.string()),
     createdBy: v.string(),
   },

package/src/component/deviceStatus.ts

@@ -2,35 +2,31 @@ 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);
+  args: {
+    deviceId: v.id('devices'),
+    tickets: v.optional(v.array(v.object({
+      status: v.string(),
+      description: v.optional(v.string()),
+      created_at: v.optional(v.number()),
+      updated_at: v.optional(v.number()),
+    }))),
+  },
+  handler: async (ctx, args) => {
+    const tickets = args.tickets || [];
 
-    if (tickets.length === 0) {
-      return 'in_uso';
-    }
+    if (tickets.length === 0) return 'in_uso';
 
     const smaltito = tickets.find(
-      (t) =>
-        t.status === 'smaltito' &&
-        t.updated_at &&
-        t.created_at < t.updated_at
+      (t) => t.status === 'smaltito' && t.updated_at && t.created_at && t.created_at < t.updated_at
     );
-    if (smaltito) {
-      return 'smaltito';
-    }
+    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';
-    }
+    if (raee && raee.status !== 'closed' && raee.status !== 'completed') return 'da_smaltire';
 
     const openTickets = tickets.filter(
       (t) =>
@@ -40,40 +36,42 @@ export const computeDeviceStatus = query({
         t.status === 'pending'
     );
 
-    if (openTickets.length > 0) {
-      return 'guasto';
-    }
-
+    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);
+  args: {
+    deviceId: v.id('devices'),
+    tickets: v.optional(v.array(v.any())),
+  },
+  handler: async (ctx, args) => {
+    const tickets = args.tickets || [];
+
+    const deviceDataEntries = await ctx.db
+      .query('ticket_device_data')
+      .withIndex('by_deviceId', (q) => q.eq('deviceId', args.deviceId))
+      .collect();
+
+    const ticketIdSet = new Set(deviceDataEntries.map(d => d.ticketId));
 
-    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;
+    const enriched = await Promise.all(
+      tickets
+        .filter((t: any) => ticketIdSet.has(t._id?.toString() || t.ticketId))
+        .map(async (ticket: any) => {
+          const supplier = ticket.supplierId
+            ? await ctx.db.get(ticket.supplierId)
+            : null;
 
-        return {
-          ...ticket,
-          clinic,
-          supplier,
-        };
-      })
+          return {
+            ...ticket,
+            clinic: null,
+            supplier,
+          };
+        })
     );
 
-    return enrichedTickets;
+    return enriched;
   },
 });