@primocaredentgroup/elettromedicali 0.1.0

package/src/component/ticketComments.ts

@@ -0,0 +1,288 @@
+import { v } from 'convex/values';
+import { query, mutation, internalQuery } from './_generated/server';
+
+export const listComments = query({
+  args: {
+    taskId: v.id('maintenance_tasks'),
+    userRole: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const task = await ctx.db.get(args.taskId);
+    if (!task) {
+      throw new Error('Ticket not found');
+    }
+
+    const comments = await ctx.db
+      .query('ticket_comments')
+      .withIndex('by_taskId', (q) => q.eq('taskId', args.taskId))
+      .collect();
+
+    const filteredComments = comments.filter((comment) => {
+      if (comment.isInternal) {
+        return args.userRole === 'admin' || args.userRole === 'supplier';
+      }
+      return true;
+    });
+
+    const commentsWithUrls = await Promise.all(
+      filteredComments.map(async (comment) => {
+        let attachmentUrls: string[] = [];
+        if (comment.attachments && comment.attachments.length > 0) {
+          attachmentUrls = await Promise.all(
+            comment.attachments.map(async (storageId) => {
+              const url = await ctx.storage.getUrl(storageId);
+              return url || '';
+            })
+          );
+          attachmentUrls = attachmentUrls.filter(url => url !== '');
+        }
+        return {
+          ...comment,
+          attachmentUrls,
+        };
+      })
+    );
+
+    return commentsWithUrls.sort((a, b) => a.createdAt - b.createdAt);
+  },
+});
+
+export const addComment = mutation({
+  args: {
+    taskId: v.id('maintenance_tasks'),
+    content: v.string(),
+    isInternal: v.optional(v.boolean()),
+    attachments: v.optional(v.array(v.id('_storage'))),
+    mentions: v.optional(v.array(v.object({
+      userId: v.id('user_profiles'),
+      name: v.string(),
+      email: v.string(),
+    }))),
+    authorId: v.string(),
+    authorName: v.optional(v.string()),
+    authorEmail: v.optional(v.string()),
+    authorRole: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const task = await ctx.db.get(args.taskId);
+    if (!task) {
+      throw new Error('Ticket not found');
+    }
+
+    if (args.attachments && args.attachments.length > 5) {
+      throw new Error('Maximum 5 attachments allowed');
+    }
+
+    const hasContent = args.content.trim().length > 0;
+    const hasAttachments = args.attachments && args.attachments.length > 0;
+    if (!hasContent && !hasAttachments) {
+      throw new Error('Comment must have either text or attachments');
+    }
+
+    const commentId = await ctx.db.insert('ticket_comments', {
+      taskId: args.taskId,
+      authorId: args.authorId,
+      authorName: args.authorName || args.authorEmail || 'Unknown',
+      authorEmail: args.authorEmail || '',
+      authorRole: args.authorRole || 'user',
+      content: args.content.trim(),
+      isInternal: args.isInternal || false,
+      isFromApi: false,
+      attachments: args.attachments || undefined,
+      mentions: args.mentions || undefined,
+      createdAt: Date.now(),
+    });
+
+    await ctx.db.patch(args.taskId, {
+      updated_at: Date.now(),
+    });
+
+    return commentId;
+  },
+});
+
+export const generateUploadUrl = mutation({
+  args: {},
+  handler: async (ctx) => {
+    return await ctx.storage.generateUploadUrl();
+  },
+});
+
+export const addCommentFromApi = mutation({
+  args: {
+    taskId: v.id('maintenance_tasks'),
+    content: v.string(),
+    authorEmail: v.optional(v.string()),
+    authorName: v.optional(v.string()),
+    isInternal: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    const task = await ctx.db.get(args.taskId);
+    if (!task) {
+      throw new Error('Ticket not found');
+    }
+
+    const commentId = await ctx.db.insert('ticket_comments', {
+      taskId: args.taskId,
+      authorId: 'api',
+      authorName: args.authorName || 'Sistema Esterno',
+      authorEmail: args.authorEmail || 'api@external',
+      authorRole: 'api',
+      content: args.content.trim(),
+      isInternal: args.isInternal || false,
+      isFromApi: true,
+      createdAt: Date.now(),
+    });
+
+    await ctx.db.patch(args.taskId, {
+      updated_at: Date.now(),
+    });
+
+    return commentId;
+  },
+});
+
+export const deleteComment = mutation({
+  args: {
+    commentId: v.id('ticket_comments'),
+    userAuth0Id: v.optional(v.string()),
+    userRole: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const comment = await ctx.db.get(args.commentId);
+    if (!comment) {
+      throw new Error('Comment not found');
+    }
+
+    if (args.userRole !== 'admin' && comment.authorId !== args.userAuth0Id) {
+      throw new Error('Not authorized to delete this comment');
+    }
+
+    await ctx.db.delete(args.commentId);
+    return { success: true };
+  },
+});
+
+export const updateComment = mutation({
+  args: {
+    commentId: v.id('ticket_comments'),
+    content: v.string(),
+    userAuth0Id: v.optional(v.string()),
+    userRole: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const comment = await ctx.db.get(args.commentId);
+    if (!comment) {
+      throw new Error('Comment not found');
+    }
+
+    if (args.userRole !== 'admin' && comment.authorId !== args.userAuth0Id) {
+      throw new Error('Not authorized to edit this comment');
+    }
+
+    await ctx.db.patch(args.commentId, {
+      content: args.content.trim(),
+      updatedAt: Date.now(),
+    });
+
+    return { success: true };
+  },
+});
+
+export const getCommentCount = query({
+  args: { taskId: v.id('maintenance_tasks') },
+  handler: async (ctx, args) => {
+    const comments = await ctx.db
+      .query('ticket_comments')
+      .withIndex('by_taskId', (q) => q.eq('taskId', args.taskId))
+      .collect();
+
+    return comments.length;
+  },
+});
+
+export const getUsersForMention = query({
+  args: {
+    taskId: v.id('maintenance_tasks'),
+    searchQuery: v.optional(v.string()),
+    excludeUserId: v.optional(v.id('user_profiles')),
+  },
+  handler: async (ctx, args) => {
+    const task = await ctx.db.get(args.taskId);
+    if (!task) {
+      throw new Error('Ticket not found');
+    }
+
+    let users = await ctx.db
+      .query('user_profiles')
+      .take(500);
+
+    users = users.filter(u => u.isActive !== false);
+
+    if (args.excludeUserId) {
+      users = users.filter(u => u._id !== args.excludeUserId);
+    }
+
+    if (args.searchQuery && args.searchQuery.trim()) {
+      const search = args.searchQuery.toLowerCase().trim();
+      users = users.filter(u =>
+        u.name?.toLowerCase().includes(search) ||
+        u.email?.toLowerCase().includes(search)
+      );
+    }
+
+    const usersWithRoles = await Promise.all(
+      users.map(async (u) => {
+        const role = u.roleId ? await ctx.db.get(u.roleId) : null;
+        const roleName = (role as any)?.name || u.role || 'user';
+
+        return {
+          _id: u._id,
+          name: u.name || u.email,
+          email: u.email,
+          role: roleName,
+        };
+      })
+    );
+
+    const sortedUsers = usersWithRoles.sort((a, b) => {
+      if (a.role === 'admin' && b.role !== 'admin') return -1;
+      if (b.role === 'admin' && a.role !== 'admin') return 1;
+
+      return (a.name || '').localeCompare(b.name || '');
+    });
+
+    return sortedUsers.slice(0, 20);
+  },
+});
+
+export const listCommentsInternal = internalQuery({
+  args: { taskId: v.string() },
+  handler: async (ctx, args) => {
+    let taskIdTyped;
+    try {
+      taskIdTyped = args.taskId as any;
+    } catch {
+      throw new Error('Invalid taskId format');
+    }
+
+    const comments = await ctx.db
+      .query('ticket_comments')
+      .withIndex('by_taskId', (q) => q.eq('taskId', taskIdTyped))
+      .collect();
+
+    return comments
+      .sort((a, b) => a.createdAt - b.createdAt)
+      .map((c) => ({
+        _id: c._id,
+        authorName: c.authorName,
+        authorEmail: c.authorEmail,
+        authorRole: c.authorRole,
+        content: c.content,
+        isInternal: c.isInternal,
+        isFromApi: c.isFromApi,
+        createdAt: c.createdAt,
+        updatedAt: c.updatedAt,
+      }));
+  },
+});

package/src/component/ticketCustomFields.ts

@@ -0,0 +1,260 @@
+import { v } from 'convex/values';
+import { query, mutation } from './_generated/server';
+
+// Lista tutti i campi custom attivi per un device specifico
+export const listActiveCustomFieldsForDevice = query({
+  args: {
+    deviceId: v.id('devices'),
+  },
+  handler: async (ctx, args) => {
+    // Get device to check category
+    const device = await ctx.db.get(args.deviceId);
+    if (!device) {
+      return [];
+    }
+
+    const allFields = await ctx.db
+      .query('ticket_custom_fields')
+      .withIndex('by_isActive', (q: any) => q.eq('isActive', true))
+      .collect();
+    
+    // Filter fields based on applicability
+    const applicableFields = allFields.filter((field) => {
+      // If applies to all, include it
+      if (field.applyToAll) {
+        return true;
+      }
+      
+      // Check if specific device is included
+      if (field.deviceIds && field.deviceIds.includes(args.deviceId)) {
+        return true;
+      }
+      
+      // Check if device category is included
+      if (field.categories && field.categories.includes(device.category)) {
+        return true;
+      }
+      
+      return false;
+    });
+    
+    // Ordina per order
+    return applicableFields.sort((a, b) => a.order - b.order);
+  },
+});
+
+// Lista tutti i campi custom attivi (per retrocompatibilità)
+export const listActiveCustomFields = query({
+  args: {},
+  handler: async (ctx) => {
+    const fields = await ctx.db
+      .query('ticket_custom_fields')
+      .withIndex('by_isActive', (q: any) => q.eq('isActive', true))
+      .collect();
+    
+    // Ordina per order
+    return fields.sort((a, b) => a.order - b.order);
+  },
+});
+
+// Lista tutti i campi custom (admin only)
+export const listAllCustomFields = query({
+  args: {},
+  handler: async (ctx) => {
+    const fields = await ctx.db
+      .query('ticket_custom_fields')
+      .collect();
+    
+    return fields.sort((a, b) => a.order - b.order);
+  },
+});
+
+// Crea un nuovo campo custom (admin only)
+export const createCustomField = mutation({
+  args: {
+    name: v.string(),
+    fieldType: v.union(
+      v.literal('text'),
+      v.literal('textarea'),
+      v.literal('number'),
+      v.literal('select'),
+      v.literal('multiselect'),
+      v.literal('date'),
+      v.literal('checkbox'),
+      v.literal('radio')
+    ),
+    options: v.optional(v.array(v.string())),
+    isRequired: v.boolean(),
+    placeholder: v.optional(v.string()),
+    helpText: v.optional(v.string()),
+    order: v.optional(v.number()),
+    applyToAll: v.boolean(),
+    categories: v.optional(v.array(v.string())),
+    deviceIds: v.optional(v.array(v.id('devices'))),
+    parentFieldId: v.optional(v.id('ticket_custom_fields')),
+    parentFieldValue: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Se order non è specificato, mettilo alla fine
+    let order = args.order;
+    if (order === undefined) {
+      const allFields = await ctx.db.query('ticket_custom_fields').collect();
+      order = allFields.length > 0 ? Math.max(...allFields.map(f => f.order)) + 1 : 0;
+    }
+
+    const fieldId = await ctx.db.insert('ticket_custom_fields', {
+      name: args.name,
+      fieldType: args.fieldType,
+      options: args.options,
+      isRequired: args.isRequired,
+      placeholder: args.placeholder,
+      helpText: args.helpText,
+      order,
+      isActive: true,
+      applyToAll: args.applyToAll,
+      categories: args.categories,
+      deviceIds: args.deviceIds,
+      parentFieldId: args.parentFieldId,
+      parentFieldValue: args.parentFieldValue,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    return fieldId;
+  },
+});
+
+// Aggiorna un campo custom (admin only)
+export const updateCustomField = mutation({
+  args: {
+    fieldId: v.id('ticket_custom_fields'),
+    name: v.optional(v.string()),
+    fieldType: v.optional(v.union(
+      v.literal('text'),
+      v.literal('textarea'),
+      v.literal('number'),
+      v.literal('select'),
+      v.literal('multiselect'),
+      v.literal('date'),
+      v.literal('checkbox'),
+      v.literal('radio')
+    )),
+    options: v.optional(v.array(v.string())),
+    isRequired: v.optional(v.boolean()),
+    placeholder: v.optional(v.string()),
+    helpText: v.optional(v.string()),
+    order: v.optional(v.number()),
+    isActive: v.optional(v.boolean()),
+    applyToAll: v.optional(v.boolean()),
+    categories: v.optional(v.array(v.string())),
+    deviceIds: v.optional(v.array(v.id('devices'))),
+    parentFieldId: v.optional(v.id('ticket_custom_fields')),
+    parentFieldValue: v.optional(v.string()),
+    childFields: v.optional(v.array(v.object({
+      parentValue: v.string(),
+      childFieldIds: v.array(v.id('ticket_custom_fields')),
+    }))),
+  },
+  handler: async (ctx, args) => {
+    const { fieldId, ...updates } = args;
+    
+    await ctx.db.patch(fieldId, {
+      ...updates,
+      updatedAt: Date.now(),
+    });
+
+    return fieldId;
+  },
+});
+
+// Elimina un campo custom (admin only)
+export const deleteCustomField = mutation({
+  args: {
+    fieldId: v.id('ticket_custom_fields'),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.fieldId);
+    return { success: true };
+  },
+});
+
+// Riordina i campi custom (admin only)
+export const reorderCustomFields = mutation({
+  args: {
+    fieldOrders: v.array(v.object({
+      fieldId: v.id('ticket_custom_fields'),
+      order: v.number(),
+    })),
+  },
+  handler: async (ctx, args) => {
+    for (const { fieldId, order } of args.fieldOrders) {
+      await ctx.db.patch(fieldId, {
+        order,
+        updatedAt: Date.now(),
+      });
+    }
+
+    return { success: true };
+  },
+});
+
+// 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));
+    
+    return Array.from(categories).sort();
+  },
+});
+
+// Get child fields for a specific parent field and value
+export const getChildFields = query({
+  args: {
+    parentFieldId: v.id('ticket_custom_fields'),
+    parentValue: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const childFields = await ctx.db
+      .query('ticket_custom_fields')
+      .withIndex('by_parentFieldId', (q: any) => q.eq('parentFieldId', args.parentFieldId))
+      .filter((q) => q.eq(q.field('parentFieldValue'), args.parentValue))
+      .filter((q) => q.eq(q.field('isActive'), true))
+      .collect();
+    
+    return childFields.sort((a, b) => a.order - b.order);
+  },
+});
+
+// Get all child fields for a parent (grouped by parent value)
+export const getAllChildFieldsForParent = query({
+  args: {
+    parentFieldId: v.id('ticket_custom_fields'),
+  },
+  handler: async (ctx, args) => {
+    const childFields = await ctx.db
+      .query('ticket_custom_fields')
+      .withIndex('by_parentFieldId', (q: any) => q.eq('parentFieldId', args.parentFieldId))
+      .filter((q) => q.eq(q.field('isActive'), true))
+      .collect();
+    
+    // Group by parent value
+    const grouped: Record<string, any[]> = {};
+    for (const field of childFields) {
+      if (field.parentFieldValue) {
+        if (!grouped[field.parentFieldValue]) {
+          grouped[field.parentFieldValue] = [];
+        }
+        grouped[field.parentFieldValue].push(field);
+      }
+    }
+    
+    // Sort each group
+    for (const key in grouped) {
+      grouped[key].sort((a, b) => a.order - b.order);
+    }
+    
+    return grouped;
+  },
+});