@primocaredentgroup/elettromedicali 0.1.0

package/src/component/emails.ts

@@ -0,0 +1,61 @@
+import { v } from 'convex/values';
+import { mutation, query } from './_generated/server';
+
+export const logEmail = mutation({
+  args: {
+    from: v.string(),
+    to: v.union(v.string(), v.array(v.string())),
+    subject: v.string(),
+    html: v.string(),
+    ticketId: v.optional(v.id('maintenance_tasks')),
+    status: v.union(v.literal('sent'), v.literal('failed'), v.literal('pending')),
+    resendId: v.optional(v.string()),
+    errorMessage: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db.insert('email_logs', {
+      from: args.from,
+      to: args.to,
+      subject: args.subject,
+      html: args.html,
+      ticketId: args.ticketId,
+      status: args.status,
+      resendId: args.resendId,
+      errorMessage: args.errorMessage,
+      sentAt: Date.now(),
+    });
+  },
+});
+
+export const getEmailLogsByTicket = query({
+  args: { ticketId: v.id('maintenance_tasks') },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query('email_logs')
+      .withIndex('by_ticketId', (q) => q.eq('ticketId', args.ticketId))
+      .order('desc')
+      .collect();
+  },
+});
+
+export const getAllEmailLogs = query({
+  args: { limit: v.optional(v.number()) },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query('email_logs')
+      .withIndex('by_sentAt')
+      .order('desc')
+      .take(args.limit || 100);
+  },
+});
+
+export const getFailedEmails = query({
+  args: { limit: v.optional(v.number()) },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query('email_logs')
+      .withIndex('by_status', (q) => q.eq('status', 'failed'))
+      .order('desc')
+      .take(args.limit || 50);
+  },
+});

package/src/component/http.ts

@@ -0,0 +1,231 @@
+import { httpRouter } from 'convex/server';
+import { httpAction } from './_generated/server';
+import { api, internal } from './_generated/api';
+
+const http = httpRouter();
+
+const corsHeaders = {
+  'Access-Control-Allow-Origin': '*',
+  'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+  'Access-Control-Allow-Headers': 'Content-Type, X-API-Key, Authorization',
+};
+
+function jsonResponse(data: any, status: number = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { 'Content-Type': 'application/json', ...corsHeaders },
+  });
+}
+
+function errorResponse(message: string, status: number = 400) {
+  return jsonResponse({ success: false, error: message }, status);
+}
+
+http.route({
+  path: '/api/comments/add',
+  method: 'OPTIONS',
+  handler: httpAction(async () => {
+    return new Response(null, { status: 204, headers: corsHeaders });
+  }),
+});
+
+http.route({
+  path: '/api/comments/add',
+  method: 'POST',
+  handler: httpAction(async (ctx, request) => {
+    try {
+      const apiKey = request.headers.get('X-API-Key');
+      if (!apiKey) return errorResponse('API key mancante. Usa header X-API-Key', 401);
+
+      const keyData = await ctx.runQuery(api.apiKeys.validateApiKey, { plainKey: apiKey });
+      if (!keyData) return errorResponse('API key non valida o scaduta', 401);
+      if (!keyData.permissions.includes('comments:add')) {
+        return errorResponse('API key non ha il permesso "comments:add"', 403);
+      }
+
+      let body: any;
+      try { body = await request.json(); } catch { return errorResponse('Body JSON non valido', 400); }
+
+      const { ticketId, content, authorEmail, authorName, isInternal } = body;
+      if (!ticketId) return errorResponse('Campo "ticketId" obbligatorio', 400);
+      if (!content || typeof content !== 'string' || content.trim().length === 0) {
+        return errorResponse('Campo "content" obbligatorio e non vuoto', 400);
+      }
+
+      try {
+        const commentId = await ctx.runMutation(api.ticketComments.addCommentFromApi, {
+          taskId: ticketId,
+          content: content.trim(),
+          authorEmail: authorEmail || undefined,
+          authorName: authorName || undefined,
+          isInternal: isInternal || false,
+        });
+        await ctx.runMutation(internal.apiKeys.recordApiKeyUsage, { keyId: keyData.keyId });
+        return jsonResponse({ success: true, commentId, message: 'Commento aggiunto con successo' });
+      } catch (error: any) {
+        if (error.message?.includes('Ticket not found')) return errorResponse('Ticket non trovato', 404);
+        throw error;
+      }
+    } catch (error: any) {
+      console.error('Error in /api/comments/add:', error);
+      return errorResponse('Errore interno del server: ' + error.message, 500);
+    }
+  }),
+});
+
+http.route({
+  path: '/api/comments/list',
+  method: 'OPTIONS',
+  handler: httpAction(async () => {
+    return new Response(null, { status: 204, headers: corsHeaders });
+  }),
+});
+
+http.route({
+  path: '/api/comments/list',
+  method: 'GET',
+  handler: httpAction(async (ctx, request) => {
+    try {
+      const apiKey = request.headers.get('X-API-Key');
+      if (!apiKey) return errorResponse('API key mancante', 401);
+
+      const keyData = await ctx.runQuery(api.apiKeys.validateApiKey, { plainKey: apiKey });
+      if (!keyData) return errorResponse('API key non valida', 401);
+      if (!keyData.permissions.includes('comments:read')) {
+        return errorResponse('API key non ha il permesso "comments:read"', 403);
+      }
+
+      const url = new URL(request.url);
+      const ticketId = url.searchParams.get('ticketId');
+      if (!ticketId) return errorResponse('Parametro "ticketId" obbligatorio', 400);
+
+      const comments = await ctx.runQuery(internal.ticketComments.listCommentsInternal, { taskId: ticketId });
+      await ctx.runMutation(internal.apiKeys.recordApiKeyUsage, { keyId: keyData.keyId });
+
+      return jsonResponse({ success: true, comments, count: comments.length });
+    } catch (error: any) {
+      console.error('Error in /api/comments/list:', error);
+      return errorResponse('Errore interno: ' + error.message, 500);
+    }
+  }),
+});
+
+http.route({
+  path: '/api/tickets/get',
+  method: 'OPTIONS',
+  handler: httpAction(async () => {
+    return new Response(null, { status: 204, headers: corsHeaders });
+  }),
+});
+
+http.route({
+  path: '/api/tickets/get',
+  method: 'GET',
+  handler: httpAction(async (ctx, request) => {
+    try {
+      const apiKey = request.headers.get('X-API-Key');
+      if (!apiKey) return errorResponse('API key mancante', 401);
+
+      const keyData = await ctx.runQuery(api.apiKeys.validateApiKey, { plainKey: apiKey });
+      if (!keyData) return errorResponse('API key non valida', 401);
+      if (!keyData.permissions.includes('tickets:read')) {
+        return errorResponse('API key non ha il permesso "tickets:read"', 403);
+      }
+
+      const url = new URL(request.url);
+      const ticketId = url.searchParams.get('ticketId');
+      if (!ticketId) return errorResponse('Parametro "ticketId" obbligatorio', 400);
+
+      const ticket = await ctx.runQuery(internal.maintenanceTasks.getTicketInternal, { taskId: ticketId });
+      if (!ticket) return errorResponse('Ticket non trovato', 404);
+
+      await ctx.runMutation(internal.apiKeys.recordApiKeyUsage, { keyId: keyData.keyId });
+      return jsonResponse({ success: true, ticket });
+    } catch (error: any) {
+      console.error('Error in /api/tickets/get:', error);
+      return errorResponse('Errore interno: ' + error.message, 500);
+    }
+  }),
+});
+
+http.route({
+  path: '/api/tickets/create',
+  method: 'OPTIONS',
+  handler: httpAction(async () => {
+    return new Response(null, { status: 204, headers: corsHeaders });
+  }),
+});
+
+http.route({
+  path: '/api/tickets/create',
+  method: 'POST',
+  handler: httpAction(async (ctx, request) => {
+    try {
+      const apiKey = request.headers.get('X-API-Key');
+      if (!apiKey) return errorResponse('API key mancante. Usa header X-API-Key', 401);
+
+      const keyData = await ctx.runQuery(api.apiKeys.validateApiKey, { plainKey: apiKey });
+      if (!keyData) return errorResponse('API key non valida o scaduta', 401);
+      if (!keyData.permissions.includes('tickets:create')) {
+        return errorResponse('API key non ha il permesso "tickets:create"', 403);
+      }
+
+      let body: any;
+      try { body = await request.json(); } catch { return errorResponse('Body JSON non valido', 400); }
+
+      const { clinicId, primoupId, clinicName, description, title, externalTicketId, externalTicketNumber, creatorEmail, creatorName, priority } = body;
+
+      if (!clinicId && !primoupId && !clinicName) {
+        return errorResponse('Devi fornire almeno uno tra: clinicId, primoupId, clinicName', 400);
+      }
+      if (!description || typeof description !== 'string' || description.trim().length === 0) {
+        return errorResponse('Campo "description" obbligatorio e non vuoto', 400);
+      }
+
+      const clinic = await ctx.runQuery(internal.maintenanceTasks.findClinicInternal, {
+        clinicId, primoupId: primoupId?.toString(), clinicName,
+      });
+      if (!clinic) return errorResponse('Clinica non trovata', 404);
+
+      const validPriorities = ['low', 'medium', 'high'];
+      if (priority && !validPriorities.includes(priority)) {
+        return errorResponse(`Priorità non valida. Usa: ${validPriorities.join(', ')}`, 400);
+      }
+
+      try {
+        const taskId = await ctx.runMutation(internal.maintenanceTasks.createExternalTicket, {
+          clinicId: clinic._id as any,
+          description: description.trim(),
+          title: title || undefined,
+          externalTicketId: externalTicketId || undefined,
+          externalTicketNumber: externalTicketNumber || undefined,
+          creatorEmail: creatorEmail || undefined,
+          creatorName: creatorName || undefined,
+          priority: priority || undefined,
+        });
+        await ctx.runMutation(internal.apiKeys.recordApiKeyUsage, { keyId: keyData.keyId });
+        return jsonResponse({ success: true, ticketId: taskId, message: 'Segnalazione creata con successo.' });
+      } catch (error: any) {
+        return errorResponse('Errore nella creazione del ticket: ' + error.message, 500);
+      }
+    } catch (error: any) {
+      console.error('Error in /api/tickets/create:', error);
+      return errorResponse('Errore interno del server: ' + error.message, 500);
+    }
+  }),
+});
+
+http.route({
+  path: '/api/health',
+  method: 'GET',
+  handler: httpAction(async () => {
+    return jsonResponse({
+      success: true,
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      version: '1.0.0',
+    });
+  }),
+});
+
+export default http;