@primocaredentgroup/elettromedicali 0.1.0

package/src/component/spareParts.ts

@@ -0,0 +1,362 @@
+import { v } from 'convex/values';
+import { mutation, query } from './_generated/server';
+import { paginationOptsValidator } from 'convex/server';
+
+export const importSparePartsBatch = mutation({
+  args: {
+    spareParts: v.array(v.object({
+      warehouseItemId: v.number(),
+      name: v.string(),
+      quantity: v.optional(v.number()),
+      dentalUnitQuantity: v.optional(v.number()),
+      minQuantity: v.optional(v.number()),
+      minimumStockAmount: v.optional(v.number()),
+      lot: v.optional(v.string()),
+      netPrice: v.optional(v.number()),
+      deadlineDate: v.optional(v.string()),
+      warehouseOrisId: v.optional(v.string()),
+      articleId: v.number(),
+      clinicId: v.number(),
+      vendorId: v.optional(v.number()),
+      warehouseCreatedAt: v.optional(v.string()),
+      warehouseUpdatedAt: v.optional(v.string()),
+      warehouseDeletedAt: v.optional(v.string()),
+      articleInternalId: v.optional(v.number()),
+      code: v.optional(v.string()),
+      barcode: v.optional(v.string()),
+      articleName: v.optional(v.string()),
+      brand: v.optional(v.string()),
+      model: v.optional(v.string()),
+      articleCategoryId: v.optional(v.number()),
+      mu: v.optional(v.string()),
+      sellingUnit: v.optional(v.string()),
+      warehouseUnit: v.optional(v.string()),
+      case: v.optional(v.string()),
+      package: v.optional(v.string()),
+      articleOrisId: v.optional(v.string()),
+      articleDeadlineDate: v.optional(v.string()),
+      alternativeArticleId: v.optional(v.number()),
+      type: v.optional(v.string()),
+      labelInfosLength: v.optional(v.number()),
+      articleCreatedAt: v.optional(v.string()),
+      articleUpdatedAt: v.optional(v.string()),
+      articleDeletedAt: v.optional(v.string()),
+      categoryId: v.optional(v.number()),
+      categoryName: v.optional(v.string()),
+      parentId: v.optional(v.number()),
+      activeWarehouseCategory: v.optional(v.number()),
+      categoryOrisId: v.optional(v.string()),
+      categoryType: v.optional(v.string()),
+      categoryCreatedAt: v.optional(v.string()),
+      categoryUpdatedAt: v.optional(v.string()),
+    })),
+  },
+  handler: async (ctx, args) => {
+    const insertedIds = [];
+
+    for (const sparePart of args.spareParts) {
+      const id = await ctx.db.insert('spare_parts', sparePart);
+      insertedIds.push(id);
+    }
+
+    return {
+      success: true,
+      count: insertedIds.length,
+      ids: insertedIds,
+    };
+  },
+});
+
+export const listSpareParts = query({
+  args: {
+    limit: v.optional(v.number()),
+    _triggerReload: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit || 1000;
+
+    const spareParts = await ctx.db
+      .query('spare_parts')
+      .order('desc')
+      .take(limit);
+
+    return spareParts;
+  },
+});
+
+export const listSparePartsByClinic = query({
+  args: {
+    clinicId: v.number(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit || 500;
+
+    const spareParts = await ctx.db
+      .query('spare_parts')
+      .withIndex('by_clinicId', (q) => q.eq('clinicId', args.clinicId))
+      .take(limit);
+
+    return spareParts;
+  },
+});
+
+export const getSparePartByWarehouseItemId = query({
+  args: { warehouseItemId: v.number() },
+  handler: async (ctx, args) => {
+    const sparePart = await ctx.db
+      .query('spare_parts')
+      .withIndex('by_warehouseItemId', (q) => q.eq('warehouseItemId', args.warehouseItemId))
+      .first();
+
+    return sparePart;
+  },
+});
+
+export const searchSpareParts = query({
+  args: {
+    searchTerm: v.string(),
+    clinicId: v.optional(v.number()),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit || 50;
+    const maxFetch = 500;
+
+    let allParts;
+
+    if (args.clinicId !== undefined) {
+      allParts = await ctx.db
+        .query('spare_parts')
+        .withIndex('by_clinicId', (q) => q.eq('clinicId', args.clinicId!))
+        .take(maxFetch);
+    } else {
+      allParts = await ctx.db.query('spare_parts').take(maxFetch);
+    }
+
+    const searchLower = args.searchTerm.toLowerCase();
+    const filtered = allParts.filter(part =>
+      part.name?.toLowerCase().includes(searchLower) ||
+      part.code?.toLowerCase().includes(searchLower) ||
+      part.articleName?.toLowerCase().includes(searchLower)
+    );
+
+    return filtered.slice(0, limit);
+  },
+});
+
+export const listSparePartsPaginated = query({
+  args: {
+    paginationOpts: paginationOptsValidator,
+    clinicId: v.number(),
+    vendorId: v.optional(v.number()),
+    searchTerm: v.optional(v.string()),
+    categoryId: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    let baseQuery = ctx.db
+      .query('spare_parts')
+      .withIndex('by_clinicId', (q) => q.eq('clinicId', args.clinicId));
+
+    let filteredQuery = baseQuery.order('desc');
+
+    if (args.vendorId) {
+      filteredQuery = filteredQuery.filter((q: any) => q.eq(q.field('vendorId'), args.vendorId));
+    }
+
+    if (args.categoryId) {
+      filteredQuery = filteredQuery.filter((q: any) => q.eq(q.field('articleCategoryId'), args.categoryId));
+    }
+
+    const result = await filteredQuery.paginate(args.paginationOpts);
+
+    let filteredPage = result.page;
+
+    if (args.searchTerm) {
+      const search = args.searchTerm.toLowerCase();
+      filteredPage = filteredPage.filter((part: any) =>
+        part.name?.toLowerCase().includes(search) ||
+        part.code?.toLowerCase().includes(search) ||
+        part.articleName?.toLowerCase().includes(search) ||
+        part.brand?.toLowerCase().includes(search)
+      );
+    }
+
+    const minimalPage = filteredPage.map((part: any) => ({
+      _id: part._id,
+      name: part.name,
+      code: part.code,
+      articleName: part.articleName,
+      brand: part.brand,
+      model: part.model,
+      quantity: part.quantity,
+      minQuantity: part.minQuantity,
+      netPrice: part.netPrice,
+      vendorId: part.vendorId,
+      categoryName: part.categoryName,
+      articleCategoryId: part.articleCategoryId,
+    }));
+
+    return {
+      page: minimalPage,
+      isDone: result.isDone,
+      continueCursor: result.continueCursor,
+    };
+  },
+});
+
+export const getSparePartsByCategory = query({
+  args: {
+    categoryId: v.number(),
+    clinicId: v.optional(v.number()),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit || 100;
+
+    const spareParts = await ctx.db
+      .query('spare_parts')
+      .withIndex('by_articleCategoryId', (q) => q.eq('articleCategoryId', args.categoryId))
+      .take(limit);
+
+    if (args.clinicId) {
+      return spareParts.filter(part => part.clinicId === args.clinicId);
+    }
+
+    return spareParts;
+  },
+});
+
+export const getAllSparePartsForMigration = query({
+  args: {
+    lastId: v.optional(v.id('spare_parts')),
+    batchSize: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize || 1000;
+
+    let query = ctx.db.query('spare_parts');
+
+    if (args.lastId) {
+      const lastRecord = await ctx.db.get(args.lastId);
+      if (lastRecord) {
+        query = query.filter((q) => q.gt(q.field('_creationTime'), lastRecord._creationTime));
+      }
+    }
+
+    const spareParts = await query
+      .order('asc')
+      .take(batchSize);
+
+    return {
+      spareParts,
+      hasMore: spareParts.length === batchSize,
+      lastId: spareParts.length > 0 ? spareParts[spareParts.length - 1]._id : null,
+    };
+  },
+});
+
+export const createSparePart = mutation({
+  args: {
+    warehouseItemId: v.number(),
+    name: v.string(),
+    quantity: v.optional(v.number()),
+    dentalUnitQuantity: v.optional(v.number()),
+    minQuantity: v.optional(v.number()),
+    minimumStockAmount: v.optional(v.number()),
+    lot: v.optional(v.string()),
+    netPrice: v.optional(v.number()),
+    deadlineDate: v.optional(v.string()),
+    warehouseOrisId: v.optional(v.string()),
+    articleId: v.number(),
+    clinicId: v.number(),
+    vendorId: v.optional(v.number()),
+    warehouseCreatedAt: v.optional(v.string()),
+    warehouseUpdatedAt: v.optional(v.string()),
+    warehouseDeletedAt: v.optional(v.string()),
+    articleInternalId: v.optional(v.number()),
+    code: v.optional(v.string()),
+    barcode: v.optional(v.string()),
+    articleName: v.optional(v.string()),
+    brand: v.optional(v.string()),
+    model: v.optional(v.string()),
+    articleCategoryId: v.optional(v.number()),
+    mu: v.optional(v.string()),
+    sellingUnit: v.optional(v.string()),
+    warehouseUnit: v.optional(v.string()),
+    case: v.optional(v.string()),
+    package: v.optional(v.string()),
+    articleOrisId: v.optional(v.string()),
+    articleDeadlineDate: v.optional(v.string()),
+    alternativeArticleId: v.optional(v.number()),
+    type: v.optional(v.string()),
+    labelInfosLength: v.optional(v.number()),
+    articleCreatedAt: v.optional(v.string()),
+    articleUpdatedAt: v.optional(v.string()),
+    articleDeletedAt: v.optional(v.string()),
+    categoryId: v.optional(v.number()),
+    categoryName: v.optional(v.string()),
+    parentId: v.optional(v.number()),
+    activeWarehouseCategory: v.optional(v.number()),
+    categoryOrisId: v.optional(v.string()),
+    categoryType: v.optional(v.string()),
+    categoryCreatedAt: v.optional(v.string()),
+    categoryUpdatedAt: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const sparePartId = await ctx.db.insert('spare_parts', args);
+    return sparePartId;
+  },
+});
+
+export const updateSparePart = mutation({
+  args: {
+    sparePartId: v.id('spare_parts'),
+    name: v.optional(v.string()),
+    quantity: v.optional(v.number()),
+    dentalUnitQuantity: v.optional(v.number()),
+    minQuantity: v.optional(v.number()),
+    minimumStockAmount: v.optional(v.number()),
+    lot: v.optional(v.string()),
+    netPrice: v.optional(v.number()),
+    deadlineDate: v.optional(v.string()),
+    code: v.optional(v.string()),
+    barcode: v.optional(v.string()),
+    articleName: v.optional(v.string()),
+    brand: v.optional(v.string()),
+    model: v.optional(v.string()),
+    mu: v.optional(v.string()),
+    vendorId: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const { sparePartId, ...updates } = args;
+
+    await ctx.db.patch(sparePartId, updates);
+
+    return { success: true };
+  },
+});
+
+export const deleteSparePart = mutation({
+  args: {
+    sparePartId: v.id('spare_parts'),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.sparePartId);
+    return { success: true };
+  },
+});
+
+export const updateQuantity = mutation({
+  args: {
+    sparePartId: v.id('spare_parts'),
+    quantity: v.number(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.sparePartId, {
+      quantity: args.quantity,
+    });
+
+    return { success: true };
+  },
+});

package/src/component/supplierCategories.ts

@@ -0,0 +1,65 @@
+import { v } from 'convex/values';
+import { query, mutation } from './_generated/server';
+
+export const listCategories = query({
+  args: {},
+  handler: async (ctx) => {
+    return await ctx.db.query('supplier_categories').order('asc').collect();
+  },
+});
+
+export const createCategory = mutation({
+  args: {
+    name: v.string(),
+    description: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query('supplier_categories')
+      .withIndex('by_name', (q: any) => q.eq('name', args.name.trim()))
+      .first();
+    if (existing) throw new Error('Category already exists');
+    return await ctx.db.insert('supplier_categories', {
+      name: args.name.trim(),
+      description: args.description?.trim(),
+      createdAt: Date.now(),
+    });
+  },
+});
+
+export const updateCategory = mutation({
+  args: {
+    categoryId: v.id('supplier_categories'),
+    name: v.string(),
+    description: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query('supplier_categories')
+      .withIndex('by_name', (q: any) => q.eq('name', args.name.trim()))
+      .first();
+    if (existing && existing._id !== args.categoryId) {
+      throw new Error('Category name already exists');
+    }
+    await ctx.db.patch(args.categoryId, {
+      name: args.name.trim(),
+      description: args.description?.trim(),
+    });
+    return args.categoryId;
+  },
+});
+
+export const deleteCategory = mutation({
+  args: { categoryId: v.id('supplier_categories') },
+  handler: async (ctx, args) => {
+    const category = await ctx.db.get(args.categoryId);
+    if (!category) throw new Error('Category not found');
+    const suppliers = await ctx.db.query('suppliers').collect();
+    const suppliersUsingCategory = suppliers.filter((s) => s.categories.includes(category.name));
+    if (suppliersUsingCategory.length > 0) {
+      throw new Error(`Cannot delete category: ${suppliersUsingCategory.length} supplier(s) are using it`);
+    }
+    await ctx.db.delete(args.categoryId);
+    return { success: true };
+  },
+});

package/src/component/suppliers.ts

@@ -0,0 +1,234 @@
+import { v } from 'convex/values';
+import { query, mutation } from './_generated/server';
+
+export const listSuppliers = query({
+  args: {},
+  handler: async (ctx) => {
+    const suppliers = await ctx.db.query('suppliers').collect();
+    return suppliers;
+  },
+});
+
+export const listSuppliersForReassignment = query({
+  args: {},
+  handler: async (ctx) => {
+    const suppliers = await ctx.db.query('suppliers').collect();
+    return suppliers;
+  },
+});
+
+export const listSuppliersForOrders = query({
+  args: {},
+  handler: async (ctx) => {
+    const suppliers = await ctx.db.query('suppliers').collect();
+
+    return suppliers.map(s => ({
+      _id: s._id,
+      name: s.name,
+      contact_email: s.contact_email,
+      categories: s.categories,
+      primoupId: s.primoupId,
+    }));
+  },
+});
+
+export const getSupplier = query({
+  args: { supplierId: v.id('suppliers') },
+  handler: async (ctx, args) => {
+    const supplier = await ctx.db.get(args.supplierId);
+    return supplier;
+  },
+});
+
+export const createSupplier = mutation({
+  args: {
+    name: v.string(),
+    contact_email: v.string(),
+    contact_phone: v.string(),
+    categories: v.array(v.string()),
+    sla_days: v.number(),
+    notes: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(args.contact_email)) {
+      throw new Error('Invalid email format');
+    }
+
+    if (args.sla_days < 1 || args.sla_days > 365) {
+      throw new Error('SLA days must be between 1 and 365');
+    }
+
+    if (args.categories.length === 0) {
+      throw new Error('At least one category is required');
+    }
+
+    const supplierId = await ctx.db.insert('suppliers', {
+      name: args.name.trim(),
+      contact_email: args.contact_email.trim().toLowerCase(),
+      contact_phone: args.contact_phone.trim(),
+      categories: args.categories.map((cat) => cat.trim()),
+      sla_days: args.sla_days,
+      notes: args.notes?.trim(),
+    });
+
+    return supplierId;
+  },
+});
+
+export const updateSupplier = mutation({
+  args: {
+    supplierId: v.id('suppliers'),
+    name: v.string(),
+    contact_email: v.string(),
+    contact_phone: v.string(),
+    categories: v.array(v.string()),
+    sla_days: v.number(),
+    notes: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(args.contact_email)) {
+      throw new Error('Invalid email format');
+    }
+
+    if (args.sla_days < 1 || args.sla_days > 365) {
+      throw new Error('SLA days must be between 1 and 365');
+    }
+
+    if (args.categories.length === 0) {
+      throw new Error('At least one category is required');
+    }
+
+    const { supplierId, ...updates } = args;
+    await ctx.db.patch(supplierId, {
+      name: updates.name.trim(),
+      contact_email: updates.contact_email.trim().toLowerCase(),
+      contact_phone: updates.contact_phone.trim(),
+      categories: updates.categories.map((cat) => cat.trim()),
+      sla_days: updates.sla_days,
+      notes: updates.notes?.trim(),
+    });
+
+    return supplierId;
+  },
+});
+
+export const deleteSupplier = mutation({
+  args: { supplierId: v.id('suppliers') },
+  handler: async (ctx, args) => {
+    const contracts = await ctx.db
+      .query('contracts')
+      .withIndex('by_supplierId', (q: any) => q.eq('supplierId', args.supplierId))
+      .collect();
+
+    if (contracts.length > 0) {
+      throw new Error(
+        `Impossibile eliminare il fornitore: ha ${contracts.length} contratto/i attivo/i. ` +
+        `Elimina prima i contratti associati.`
+      );
+    }
+
+    const tasks = await ctx.db
+      .query('maintenance_tasks')
+      .withIndex('by_supplierId', (q: any) => q.eq('supplierId', args.supplierId))
+      .collect();
+
+    if (tasks.length > 0) {
+      throw new Error(
+        `Impossibile eliminare il fornitore: ha ${tasks.length} ticket di manutenzione associato/i. ` +
+        `Riassegna o elimina prima i ticket.`
+      );
+    }
+
+    await ctx.db.delete(args.supplierId);
+    return { success: true };
+  },
+});
+
+export const getSuppliersByCategory = query({
+  args: { category: v.string() },
+  handler: async (ctx, args) => {
+    const suppliers = await ctx.db
+      .query('suppliers')
+      .filter((q: any) => q.field('categories').includes(args.category))
+      .collect();
+
+    return suppliers;
+  },
+});
+
+export const listSupplierUsers = query({
+  args: {},
+  handler: async (ctx) => {
+    const supplierRole = await ctx.db
+      .query('roles')
+      .withIndex('by_name', (q: any) => q.eq('name', 'supplier'))
+      .first();
+
+    if (!supplierRole) {
+      return [];
+    }
+
+    const supplierUsers = await ctx.db
+      .query('user_profiles')
+      .withIndex('by_roleId', (q: any) => q.eq('roleId', supplierRole._id))
+      .collect();
+
+    const result = await Promise.all(
+      supplierUsers.map(async (user) => {
+        const linkedSupplier = user.supplierId
+          ? await ctx.db.get(user.supplierId)
+          : null;
+
+        return {
+          _id: user._id,
+          userId: user._id,
+          email: user.email,
+          name: user.name || user.email,
+          supplierId: user.supplierId || null,
+          supplierName: linkedSupplier?.name || null,
+          supplierEmail: linkedSupplier?.contact_email || null,
+        };
+      })
+    );
+
+    return result;
+  },
+});
+
+export const getOrCreateSupplierForUser = mutation({
+  args: {
+    userId: v.id('user_profiles'),
+  },
+  handler: async (ctx, args) => {
+    const user = await ctx.db.get(args.userId);
+    if (!user) {
+      throw new Error('User not found');
+    }
+
+    const role = user.roleId ? await ctx.db.get(user.roleId) : null;
+    if (role?.name !== 'supplier') {
+      throw new Error('User is not a supplier');
+    }
+
+    if (user.supplierId) {
+      return user.supplierId;
+    }
+
+    const supplierId = await ctx.db.insert('suppliers', {
+      name: user.name || user.email,
+      contact_email: user.email,
+      contact_phone: '',
+      categories: [],
+      sla_days: 7,
+      notes: `Creato automaticamente dall'utente ${user.email}`,
+    });
+
+    await ctx.db.patch(args.userId, {
+      supplierId: supplierId,
+    });
+
+    return supplierId;
+  },
+});