@primocaredentgroup/elettromedicali 0.1.0

package/src/component/devices.ts

@@ -0,0 +1,645 @@
+import { v } from 'convex/values';
+import { query, mutation } from './_generated/server';
+
+async function getPhotoUrl(ctx: any, device: any) {
+  if (device.photoStorageId) {
+    return await ctx.storage.getUrl(device.photoStorageId);
+  }
+  if (device.photo && device.photo.trim() !== '') {
+    return device.photo;
+  }
+  return null;
+}
+
+export const listDevices = query({
+  args: {
+    paginationOpts: v.optional(v.object({
+      numItems: v.number(),
+      cursor: v.union(v.string(), v.null()),
+    })),
+    clinicId: v.optional(v.id('clinics')),
+    _triggerReload: v.optional(v.number()),
+    userRole: v.optional(v.string()),
+    userClinicId: v.optional(v.id('clinics')),
+    userSelectedClinicId: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.paginationOpts?.numItems || 100;
+
+    let devices: any[];
+    if (args.userRole === 'admin') {
+      if (args.clinicId) {
+        const result = await ctx.db
+          .query('devices')
+          .withIndex('by_clinicId', (q: any) => q.eq('clinicId', args.clinicId))
+          .paginate({ numItems: limit, cursor: args.paginationOpts?.cursor || null });
+        devices = result.page;
+      } else {
+        const result = await ctx.db
+          .query('devices')
+          .paginate({ numItems: limit, cursor: args.paginationOpts?.cursor || null });
+        devices = result.page;
+      }
+    } else if (args.userRole === 'user') {
+      try {
+        const selectedClinicId = args.userSelectedClinicId;
+
+        if (selectedClinicId) {
+          devices = await ctx.db
+            .query('devices')
+            .withIndex('by_primoupClinicId', (q: any) => q.eq('primoupClinicId', selectedClinicId))
+            .take(limit);
+        } else {
+          devices = [];
+        }
+      } catch (error: any) {
+        devices = [];
+      }
+    } else {
+      devices = [];
+    }
+
+    const devicesWithUrls = await Promise.all(
+      devices.map(async (device) => ({
+        ...device,
+        photoUrl: await getPhotoUrl(ctx, device),
+      }))
+    );
+
+    return devicesWithUrls;
+  },
+});
+
+export const listDevicesPaginated = query({
+  args: {
+    paginationOpts: v.object({
+      numItems: v.number(),
+      cursor: v.union(v.string(), v.null()),
+    }),
+    category: v.optional(v.string()),
+    brand: v.optional(v.string()),
+    status: v.optional(v.string()),
+    searchTerm: v.optional(v.string()),
+    clinicId: v.optional(v.id('clinics')),
+    userRole: v.optional(v.string()),
+    userClinicId: v.optional(v.id('clinics')),
+    userSelectedClinicId: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    let baseQuery;
+
+    if (args.userRole === 'admin') {
+      if (args.clinicId) {
+        baseQuery = ctx.db
+          .query('devices')
+          .withIndex('by_clinicId', (q: any) => q.eq('clinicId', args.clinicId));
+      } else if (args.category) {
+        baseQuery = ctx.db
+          .query('devices')
+          .withIndex('by_category', (q: any) => q.eq('category', args.category));
+      } else if (args.status) {
+        baseQuery = ctx.db
+          .query('devices')
+          .withIndex('by_status', (q: any) => q.eq('status', args.status));
+      } else {
+        baseQuery = ctx.db.query('devices');
+      }
+    } else if (args.userRole === 'user') {
+      const selectedClinicId = args.userSelectedClinicId;
+
+      if (!selectedClinicId) {
+        return { page: [], isDone: true, continueCursor: '' };
+      }
+
+      baseQuery = ctx.db
+        .query('devices')
+        .withIndex('by_primoupClinicId', (q: any) => q.eq('primoupClinicId', selectedClinicId));
+    } else {
+      return { page: [], isDone: true, continueCursor: '' };
+    }
+
+    let filteredQuery = baseQuery.order('desc');
+
+    if (args.category && !(args.userRole === 'admin' && !args.clinicId && !args.status)) {
+      filteredQuery = filteredQuery.filter((q: any) => q.eq(q.field('category'), args.category));
+    }
+
+    if (args.brand) {
+      filteredQuery = filteredQuery.filter((q: any) => q.eq(q.field('brand'), args.brand));
+    }
+
+    if (args.status && !(args.userRole === 'admin' && !args.clinicId && !args.category)) {
+      filteredQuery = filteredQuery.filter((q: any) => q.eq(q.field('status'), args.status));
+    }
+
+    const result = await filteredQuery.paginate(args.paginationOpts);
+
+    let filteredPage = result.page;
+
+    if (args.searchTerm) {
+      const search = args.searchTerm.toLowerCase();
+      filteredPage = filteredPage.filter((device: any) =>
+        device.name?.toLowerCase().includes(search) ||
+        device.brand?.toLowerCase().includes(search) ||
+        device.model?.toLowerCase().includes(search) ||
+        device.serialNumber?.toLowerCase().includes(search) ||
+        device.internalId?.toLowerCase().includes(search)
+      );
+    }
+
+    const clinicIds = [...new Set(filteredPage.map((d: any) => d.clinicId).filter(Boolean))];
+    const clinics = await Promise.all(clinicIds.map(id => ctx.db.get(id)));
+    const clinicMap = new Map(clinics.filter(Boolean).map((c: any) => [c._id.toString(), c.name]));
+
+    const minimalPage = await Promise.all(
+      filteredPage.map(async (device: any) => ({
+        _id: device._id,
+        name: device.name,
+        category: device.category,
+        brand: device.brand,
+        model: device.model,
+        serialNumber: device.serialNumber,
+        internalId: device.internalId,
+        status: device.status,
+        clinicId: device.clinicId,
+        clinicName: clinicMap.get(device.clinicId?.toString()) || 'Unknown',
+        photoUrl: device.photoStorageId
+          ? await ctx.storage.getUrl(device.photoStorageId)
+          : null,
+      }))
+    );
+
+    return {
+      page: minimalPage,
+      isDone: result.isDone,
+      continueCursor: result.continueCursor,
+    };
+  },
+});
+
+export const getDevicesCount = query({
+  args: {
+    category: v.optional(v.string()),
+    brand: v.optional(v.string()),
+    status: v.optional(v.string()),
+    clinicId: v.optional(v.id('clinics')),
+    userRole: v.optional(v.string()),
+    userClinicId: v.optional(v.id('clinics')),
+    userSelectedClinicId: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    let devicesQuery;
+
+    if (args.userRole === 'admin') {
+      if (args.clinicId) {
+        devicesQuery = ctx.db.query('devices')
+          .withIndex('by_clinicId', (q: any) => q.eq('clinicId', args.clinicId));
+      } else if (args.category) {
+        devicesQuery = ctx.db.query('devices')
+          .withIndex('by_category', (q: any) => q.eq('category', args.category));
+      } else {
+        devicesQuery = ctx.db.query('devices');
+      }
+    } else if (args.userRole === 'user') {
+      const selectedClinicId = args.userSelectedClinicId;
+      if (!selectedClinicId) return { total: 0 };
+
+      devicesQuery = ctx.db.query('devices')
+        .withIndex('by_primoupClinicId', (q: any) => q.eq('primoupClinicId', selectedClinicId));
+    } else {
+      return { total: 0 };
+    }
+
+    if (args.brand) {
+      devicesQuery = devicesQuery.filter((q: any) => q.eq(q.field('brand'), args.brand));
+    }
+    if (args.status && !args.category) {
+      devicesQuery = devicesQuery.filter((q: any) => q.eq(q.field('status'), args.status));
+    }
+
+    const devices = await devicesQuery.collect();
+    return { total: devices.length };
+  },
+});
+
+export const getDevice = query({
+  args: { deviceId: v.id('devices') },
+  handler: async (ctx, args) => {
+    const device = await ctx.db.get(args.deviceId);
+    if (!device) return null;
+
+    return {
+      ...device,
+      photoUrl: await getPhotoUrl(ctx, device),
+    };
+  },
+});
+
+export const getById = query({
+  args: { id: v.id('devices') },
+  handler: async (ctx, args) => {
+    const device = await ctx.db.get(args.id);
+    if (!device) return null;
+
+    return {
+      ...device,
+      photoUrl: await getPhotoUrl(ctx, device),
+    };
+  },
+});
+
+export const listAllDevicesForMigration = query({
+  args: {
+    limit: v.optional(v.number()),
+    lastCreationTime: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit || 1000;
+
+    const devices = args.lastCreationTime
+      ? await ctx.db
+          .query('devices')
+          .filter((q) => q.gt(q.field('_creationTime'), args.lastCreationTime!))
+          .take(limit)
+      : await ctx.db.query('devices').take(limit);
+
+    return devices;
+  },
+});
+
+export const generateUploadUrl = mutation({
+  args: {},
+  handler: async (ctx) => {
+    return await ctx.storage.generateUploadUrl();
+  },
+});
+
+export const createDevice = mutation({
+  args: {
+    clinicId: v.id('clinics'),
+    supplierId: v.optional(v.id('suppliers')),
+    name: v.string(),
+    category: v.string(),
+    brand: v.string(),
+    model: v.string(),
+    serial_number: v.string(),
+    photoStorageId: v.optional(v.id('_storage')),
+    status: v.union(v.literal('active'), v.literal('in_maintenance'), v.literal('out_of_service')),
+    metadata: v.optional(v.any()),
+    internalId: v.optional(v.string()),
+    industry40Data: v.optional(v.string()),
+    purchaseDate: v.optional(v.number()),
+    vendor: v.optional(v.string()),
+    purchaseCost: v.optional(v.number()),
+    warrantyEndDate: v.optional(v.number()),
+    spareParts: v.optional(v.array(v.object({
+      name: v.string(),
+      code: v.string(),
+      photoStorageId: v.optional(v.id('_storage')),
+      quantity: v.number(),
+      notes: v.optional(v.string()),
+    }))),
+    maintenanceManualStorageId: v.optional(v.id('_storage')),
+    maintenanceReportsStorageIds: v.optional(v.array(v.id('_storage'))),
+    conformityDeclarationStorageId: v.optional(v.id('_storage')),
+    authorizationsStorageIds: v.optional(v.array(v.id('_storage'))),
+    otherAttachmentsStorageIds: v.optional(v.array(v.id('_storage'))),
+  },
+  handler: async (ctx, args) => {
+    const deviceData: any = { ...args };
+
+    const clinic = await ctx.db.get(args.clinicId);
+    if (clinic?.primoupId) {
+      const primoupIdNum = parseInt(clinic.primoupId, 10);
+      if (!isNaN(primoupIdNum)) {
+        deviceData.primoupClinicId = primoupIdNum;
+      }
+    }
+
+    const deviceId = await ctx.db.insert('devices', deviceData);
+    return deviceId;
+  },
+});
+
+export const updateDevice = mutation({
+  args: {
+    deviceId: v.id('devices'),
+    clinicId: v.optional(v.id('clinics')),
+    primoupClinicId: v.optional(v.number()),
+    supplierId: v.optional(v.id('suppliers')),
+    name: v.optional(v.string()),
+    category: v.optional(v.string()),
+    brand: v.optional(v.string()),
+    model: v.optional(v.string()),
+    serial_number: v.optional(v.string()),
+    photoStorageId: v.optional(v.id('_storage')),
+    status: v.optional(v.union(v.literal('active'), v.literal('in_maintenance'), v.literal('out_of_service'))),
+    metadata: v.optional(v.any()),
+    internalId: v.optional(v.string()),
+    primoupCategoryId: v.optional(v.string()),
+    industry40Data: v.optional(v.string()),
+    purchaseDate: v.optional(v.number()),
+    vendor: v.optional(v.string()),
+    purchaseCost: v.optional(v.number()),
+    warrantyEndDate: v.optional(v.number()),
+    spareParts: v.optional(v.array(v.object({
+      name: v.string(),
+      code: v.string(),
+      photoStorageId: v.optional(v.id('_storage')),
+      quantity: v.number(),
+      notes: v.optional(v.string()),
+    }))),
+    maintenanceManualStorageId: v.optional(v.id('_storage')),
+    maintenanceReportsStorageIds: v.optional(v.array(v.id('_storage'))),
+    conformityDeclarationStorageId: v.optional(v.id('_storage')),
+    authorizationsStorageIds: v.optional(v.array(v.id('_storage'))),
+    otherAttachmentsStorageIds: v.optional(v.array(v.id('_storage'))),
+  },
+  handler: async (ctx, args) => {
+    const { deviceId, ...updates } = args;
+
+    const existingDevice = await ctx.db.get(deviceId);
+
+    if (existingDevice?.photoStorageId && updates.photoStorageId && existingDevice.photoStorageId !== updates.photoStorageId) {
+      try {
+        await ctx.storage.delete(existingDevice.photoStorageId);
+      } catch (e) {
+        // Continue even if delete fails
+      }
+    }
+
+    await ctx.db.patch(deviceId, updates);
+    return deviceId;
+  },
+});
+
+export const updateDeviceByUser = mutation({
+  args: {
+    deviceId: v.id('devices'),
+    name: v.optional(v.string()),
+    category: v.optional(v.string()),
+    brand: v.optional(v.string()),
+    model: v.optional(v.string()),
+    serial_number: v.optional(v.string()),
+    status: v.optional(v.union(v.literal('active'), v.literal('in_maintenance'), v.literal('out_of_service'))),
+    industry40Data: v.optional(v.string()),
+    userRole: v.string(),
+    userSelectedClinicId: v.optional(v.number()),
+    userClinicId: v.optional(v.id('clinics')),
+  },
+  handler: async (ctx, args) => {
+    const device = await ctx.db.get(args.deviceId);
+    if (!device) {
+      throw new Error('Device not found');
+    }
+
+    if (args.userRole === 'user') {
+      const selectedClinicId = args.userSelectedClinicId;
+
+      if (selectedClinicId) {
+        if (device.primoupClinicId !== selectedClinicId) {
+          throw new Error('Not authorized to update this device');
+        }
+      } else if (args.userClinicId && args.userClinicId !== device.clinicId) {
+        throw new Error('Not authorized to update this device');
+      }
+    } else if (args.userRole !== 'admin') {
+      throw new Error('Not authorized to update devices');
+    }
+
+    const { deviceId, userRole, userSelectedClinicId, userClinicId, ...updates } = args;
+    await ctx.db.patch(deviceId, updates);
+    return deviceId;
+  },
+});
+
+export const deleteDevice = mutation({
+  args: { deviceId: v.id('devices') },
+  handler: async (ctx, args) => {
+    const device = await ctx.db.get(args.deviceId);
+    if (device?.photoStorageId) {
+      await ctx.storage.delete(device.photoStorageId);
+    }
+
+    await ctx.db.delete(args.deviceId);
+    return { success: true };
+  },
+});
+
+export const getDeviceStats = query({
+  args: {
+    userRole: v.optional(v.string()),
+    userClinicId: v.optional(v.id('clinics')),
+  },
+  handler: async (ctx, args) => {
+    try {
+      if (args.userRole === 'admin') {
+        const LIMIT = 500;
+        const [active, inMaintenance, outOfService] = await Promise.all([
+          ctx.db.query('devices').withIndex('by_status', (q: any) => q.eq('status', 'active')).take(LIMIT),
+          ctx.db.query('devices').withIndex('by_status', (q: any) => q.eq('status', 'in_maintenance')).take(LIMIT),
+          ctx.db.query('devices').withIndex('by_status', (q: any) => q.eq('status', 'out_of_service')).take(LIMIT),
+        ]);
+        return {
+          total: active.length + inMaintenance.length + outOfService.length,
+          active: active.length,
+          in_maintenance: inMaintenance.length,
+          out_of_service: outOfService.length,
+        };
+      } else if (args.userRole === 'user' && args.userClinicId) {
+        const devices = await ctx.db
+          .query('devices')
+          .withIndex('by_clinicId', (q: any) => q.eq('clinicId', args.userClinicId!))
+          .collect();
+        return {
+          total: devices.length,
+          active: devices.filter((d) => d.status === 'active').length,
+          in_maintenance: devices.filter((d) => d.status === 'in_maintenance').length,
+          out_of_service: devices.filter((d) => d.status === 'out_of_service').length,
+        };
+      }
+
+      return { total: 0, active: 0, in_maintenance: 0, out_of_service: 0 };
+    } catch (error) {
+      console.error('Error in getDeviceStats:', error);
+      return { total: 0, active: 0, in_maintenance: 0, out_of_service: 0 };
+    }
+  },
+});
+
+export const getFileUrl = query({
+  args: { storageId: v.id('_storage') },
+  handler: async (ctx, args) => {
+    const url = await ctx.storage.getUrl(args.storageId);
+    return url;
+  },
+});
+
+export const listAllDevicesForExport = query({
+  args: {},
+  handler: async (ctx) => {
+    const clinics = await ctx.db.query('clinics').take(500);
+    const results: any[] = [];
+
+    for (const clinic of clinics) {
+      const clinicDevices = await ctx.db
+        .query('devices')
+        .withIndex('by_clinicId', (q: any) => q.eq('clinicId', clinic._id))
+        .take(1000);
+
+      for (const device of clinicDevices) {
+        results.push({
+          clinicName: clinic.name || 'Sconosciuta',
+          category: device.category || '',
+          brand: device.brand || '',
+          model: device.model || '',
+          serial_number: device.serial_number || '',
+          quantity: device.quantity || 1,
+          status: device.status || 'active',
+        });
+      }
+    }
+
+    return results;
+  },
+});
+
+export const getDeviceTemplates = query({
+  args: {
+    searchQuery: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const devices = await ctx.db.query('devices').take(2000);
+
+    const templateMap = new Map<string, { name: string; category: string; brands: Map<string, Set<string>> }>();
+
+    for (const device of devices) {
+      const name = device.name;
+
+      if (args.searchQuery) {
+        const query = args.searchQuery.toLowerCase();
+        if (!name.toLowerCase().includes(query) &&
+            !device.brand.toLowerCase().includes(query) &&
+            !device.category.toLowerCase().includes(query)) {
+          continue;
+        }
+      }
+
+      if (!templateMap.has(name)) {
+        templateMap.set(name, {
+          name,
+          category: device.category,
+          brands: new Map(),
+        });
+      }
+
+      const template = templateMap.get(name)!;
+      if (!template.brands.has(device.brand)) {
+        template.brands.set(device.brand, new Set());
+      }
+      template.brands.get(device.brand)!.add(device.model);
+    }
+
+    const templates = Array.from(templateMap.values()).map(t => ({
+      name: t.name,
+      category: t.category,
+      brandOptions: Array.from(t.brands.entries()).map(([brand, models]) => ({
+        brand,
+        models: Array.from(models),
+      })),
+    }));
+
+    templates.sort((a, b) => a.name.localeCompare(b.name));
+
+    return templates;
+  },
+});
+
+export const createDeviceByUser = mutation({
+  args: {
+    name: v.string(),
+    category: v.string(),
+    brand: v.string(),
+    model: v.string(),
+    serial_number: v.string(),
+    userSelectedClinicId: v.number(),
+    userPrimoupClinics: v.optional(v.array(v.any())),
+  },
+  handler: async (ctx, args) => {
+    const selectedClinicId = args.userSelectedClinicId;
+
+    const primoupClinics = args.userPrimoupClinics || [];
+    const selectedPrimoupClinic = primoupClinics.find((c: any) => c.id === selectedClinicId);
+
+    if (!selectedPrimoupClinic) {
+      throw new Error('Selected clinic not found in user profile');
+    }
+
+    let clinic = await ctx.db
+      .query('clinics')
+      .withIndex('by_primoupId', (q: any) => q.eq('primoupId', String(selectedClinicId)))
+      .first();
+    if (!clinic) {
+      const clinics = await ctx.db.query('clinics').take(500);
+      clinic = clinics.find(c => c.name === selectedPrimoupClinic.name) || null;
+    }
+
+    if (!clinic) {
+      throw new Error('Clinic not found in database');
+    }
+
+    const deviceId = await ctx.db.insert('devices', {
+      clinicId: clinic._id,
+      primoupClinicId: selectedClinicId,
+      name: args.name,
+      category: args.category,
+      brand: args.brand,
+      model: args.model,
+      serial_number: args.serial_number,
+      status: 'active',
+      quantity: 1,
+    });
+
+    return deviceId;
+  },
+});
+
+export const listAllDevicesForAdmin = query({
+  args: {},
+  handler: async (ctx) => {
+    const devices = await ctx.db.query('devices').take(3000);
+
+    return devices.map(device => ({
+      _id: device._id,
+      name: device.name,
+      category: device.category || '',
+      brand: device.brand || '',
+      model: device.model || '',
+      clinicId: device.clinicId,
+    }));
+  },
+});
+
+export const getUniqueBrandsAndModels = query({
+  args: {},
+  handler: async (ctx) => {
+    const devices = await ctx.db.query('devices').take(3000);
+
+    const brandsSet = new Set<string>();
+    const modelsSet = new Set<string>();
+
+    for (const device of devices) {
+      if (device.brand && device.brand.trim()) {
+        brandsSet.add(device.brand.trim());
+      }
+      if (device.model && device.model.trim()) {
+        modelsSet.add(device.model.trim());
+      }
+    }
+
+    return {
+      brands: Array.from(brandsSet).sort(),
+      models: Array.from(modelsSet).sort(),
+    };
+  },
+});

package/src/component/emailHelpers.ts

@@ -0,0 +1,38 @@
+import { query } from './_generated/server';
+import { v } from 'convex/values';
+
+export const getAdminEmails = query({
+  args: {},
+  handler: async (ctx) => {
+    const adminRole = await ctx.db
+      .query('roles')
+      .withIndex('by_name', (q) => q.eq('name', 'admin'))
+      .first();
+    if (!adminRole) return [];
+    const adminUsers = await ctx.db
+      .query('user_profiles')
+      .withIndex('by_roleId', (q) => q.eq('roleId', adminRole._id))
+      .collect();
+    return adminUsers
+      .filter((user) => user.email)
+      .map((user) => ({ email: user.email, name: user.name || user.email }));
+  },
+});
+
+export const getSupplierEmail = query({
+  args: { supplierId: v.id('suppliers') },
+  handler: async (ctx, args) => {
+    const supplier = await ctx.db.get(args.supplierId);
+    if (!supplier || !supplier.contact_email) return null;
+    return { email: supplier.contact_email, name: supplier.name };
+  },
+});
+
+export const getClinicEmail = query({
+  args: { clinicId: v.id('clinics') },
+  handler: async (ctx, args) => {
+    const clinic = await ctx.db.get(args.clinicId);
+    if (!clinic || !clinic.contact_email) return null;
+    return { email: clinic.contact_email, name: clinic.name };
+  },
+});