fix atendimentos.ts

Signed-off-by: Rodrigo Martins <rodrigo.sousa.577@gmail.com>

src/server/routes/atendimentos.ts

@@ -12,78 +12,112 @@ const upload = multer({ storage: multer.memoryStorage() });
 
 router.use(authMiddleware);
 
+// Middleware para logging com informações mais detalhadas
+router.use((req, res, next) => {
+  const requestId = Math.random().toString(36).substring(7);
+  console.log(`[${new Date().toISOString()}][${requestId}] Request:`, {
+    method: req.method,
+    path: req.path,
+    originalUrl: req.originalUrl,
+    params: req.params,
+    query: req.query,
+    body: req.body
+  });
+  
+  // Interceptar resposta para logging
+  const oldJson = res.json;
+  res.json = function(data) {
+    console.log(`[${new Date().toISOString()}][${requestId}] Response:`, {
+      statusCode: res.statusCode,
+      data: data
+    });
+    return oldJson.apply(res, arguments);
+  };
+  
+  next();
+});
+
 // Função auxiliar para validar se uma string é um UUID válido
-function isValidUUID(uuid: string): boolean {
+function isValidUUID(uuid: string, isRoute: boolean = false): boolean {
+  // Lista de rotas que não precisam de validação UUID
+  const routeExceptions = ['agendamentos', 'upload'];
+  
+  // Se for uma rota e estiver na lista de exceções, retorna true
+  if (isRoute && (routeExceptions.includes(uuid) || routeExceptions.some(route => uuid.startsWith(route)))) {
+    return true;
+  }
+
   if (!uuid) return false;
   
   try {
-    // Validação principal com regex para UUID padrão
     const regexUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    
+    return regexUUID.test(uuid);
-    // Se passar na validação principal, retorna verdadeiro
-    if (regexUUID.test(uuid)) return true;
-    
-    // Caso contrário, verifica se é um ID válido de alguma outra forma
-    // (como um ID numérico ou string que possa ser convertida em UUID)
-    console.log(`ID recebido em formato não-UUID padrão: ${uuid}`);
-    
-    // Se for "agendamentos", é uma rota especial que não precisa de validação UUID
-    if (uuid === "agendamentos") return true;
-    
-    // Se chegou aqui e não é um UUID válido, retorna falso
-    return false;
   } catch (error) {
     console.error("Erro ao validar UUID:", error);
     return false;
   }
 }
 
+// Middleware para validação de UUID em rotas específicas
+router.param('id', (req, res, next, id) => {
+  const path = req.path.split('/')[1]; // Pega o primeiro segmento da rota após a /
+  
+  if (!isValidUUID(id, true)) {
+    console.error(`ID inválido: ${id} para rota ${path}`);
+    return res.status(400).json({
+      error: "ID inválido",
+      details: "O formato do ID fornecido não é válido para esta operação"
+    });
+  }
+  
+  next();
+});
+
 // Rota para listar agendamentos
 router.get("/agendamentos", async (req: Request, res: Response) => {
   try {
     const { data } = req.query;
-    console.log("Requisição de agendamentos recebida, data:", data);
+    console.log("[Agendamentos] Iniciando busca - Data requisitada:", data);
     
     let dateFilter = {};
 
     if (data) {
       try {
-        // Aceitar e validar o formato da data de forma mais flexível
+        const parsedDate = parseISO(data as string);
-        const parsedDate = new Date(data as string);
         
-        // Verificar se a data é válida
         if (isNaN(parsedDate.getTime())) {
-          console.error("Data inválida recebida:", data);
+          console.error("[Agendamentos] Data inválida:", data);
-          // Em vez de retornar erro, continue sem filtro
+          return res.status(400).json({
-          console.log("Continuando sem filtro de data devido a data inválida");
+            error: "Data inválida",
-        } else {
+            details: "O formato da data deve ser YYYY-MM-DD"
-          console.log("Data parseada:", parsedDate);
-          
-          const weekStart = startOfWeek(parsedDate, { locale: ptBR });
-          const weekEnd = endOfWeek(parsedDate, { locale: ptBR });
-          
-          console.log("Período de busca:", {
-            weekStart: weekStart.toISOString(),
-            weekEnd: weekEnd.toISOString()
           });
-
-          dateFilter = {
-            data: {
-              gte: weekStart,
-              lte: weekEnd,
-            },
-          };
         }
+
+        const weekStart = startOfWeek(parsedDate, { locale: ptBR });
+        const weekEnd = endOfWeek(parsedDate, { locale: ptBR });
+        
+        console.log("[Agendamentos] Período de busca:", {
+          weekStart: weekStart.toISOString(),
+          weekEnd: weekEnd.toISOString()
+        });
+
+        dateFilter = {
+          data: {
+            gte: weekStart,
+            lte: weekEnd,
+          },
+        };
       } catch (parseError) {
-        console.error("Erro ao analisar data:", parseError);
+        console.error("[Agendamentos] Erro ao analisar data:", parseError);
-        // Continuar sem filtro de data em caso de erro, em vez de falhar
+        return res.status(400).json({
-        console.log("Continuando sem filtro de data devido ao erro");
+          error: "Erro ao processar data",
+          details: "Verifique se a data está no formato YYYY-MM-DD"
+        });
       }
     }
 
-    console.log("Filtro de data:", JSON.stringify(dateFilter));
+    console.log("[Agendamentos] Filtro de data:", JSON.stringify(dateFilter));
     
-    // Usando o modelo correto e com tratamento de erro adequado
     try {
       const agendamentos = await prisma.agendamentoAtendimento.findMany({
         where: dateFilter,
@@ -106,18 +140,18 @@ router.get("/agendamentos", async (req: Request, res: Response) => {
         },
       });
 
-      console.log(`Encontrados ${agendamentos.length} agendamentos`);
+      console.log(`[Agendamentos] Encontrados ${agendamentos.length} agendamentos`);
       
       return res.json(agendamentos);
     } catch (dbError) {
-      console.error("Erro na consulta do banco de dados:", dbError);
+      console.error("[Agendamentos] Erro na consulta do banco de dados:", dbError);
       return res.status(500).json({ 
         error: "Erro ao buscar agendamentos no banco de dados",
         details: dbError.message
       });
     }
   } catch (error) {
-    console.error("Erro geral ao listar agendamentos:", error);
+    console.error("[Agendamentos] Erro geral ao listar agendamentos:", error);
     return res.status(500).json({ 
       error: "Erro ao listar agendamentos",
       details: error.message 
@@ -183,15 +217,6 @@ router.put("/agendamentos/:id", async (req: Request, res: Response) => {
     const { id } = req.params;
     const { clienteId, data, observacoes, tipo } = req.body;
     
-    // Validação do UUID antes de consultar o banco de dados
-    if (!isValidUUID(id)) {
-      console.error(`ID de agendamento inválido: ${id}. Não é um UUID válido.`);
-      return res.status(400).json({ 
-        error: "ID de agendamento inválido",
-        details: "O formato do ID fornecido não é um UUID válido."
-      });
-    }
-    
     console.log("Atualizando agendamento:", { id, clienteId, data, observacoes, tipo });
     
     // Verificar se o agendamento existe usando a tabela correta
@@ -241,15 +266,6 @@ router.delete("/agendamentos/:id", async (req: Request, res: Response) => {
     const { id } = req.params;
     console.log("Excluindo agendamento:", id);
     
-    // Validação do UUID antes de consultar o banco de dados
-    if (!isValidUUID(id)) {
-      console.error(`ID de agendamento inválido: ${id}. Não é um UUID válido.`);
-      return res.status(400).json({ 
-        error: "ID de agendamento inválido",
-        details: "O formato do ID fornecido não é um UUID válido."
-      });
-    }
-    
     // Verificar se o agendamento existe usando a tabela correta
     const agendamento = await prisma.agendamentoAtendimento.findUnique({
       where: { id },
@@ -286,15 +302,6 @@ router.patch("/:id", async (req: Request, res: Response) => {
     const { id } = req.params;
     const { anexos, ...data } = req.body;
 
-    // Validação do UUID antes de consultar o banco de dados
-    if (!isValidUUID(id)) {
-      console.error(`ID de atendimento inválido: ${id}. Não é um UUID válido.`);
-      return res.status(400).json({ 
-        error: "ID de atendimento inválido",
-        details: "O formato do ID fornecido não é um UUID válido."
-      });
-    }
-
     console.log("Atualizando atendimento:", id, { anexos, data }); // Debug log
 
     const atendimento = await prisma.atendimento.update({
@@ -363,15 +370,6 @@ router.get("/:id", async (req: Request, res: Response) => {
   try {
     const { id } = req.params;
     
-    // Validação do UUID antes de consultar o banco de dados
-    if (!isValidUUID(id)) {
-      console.error(`ID de atendimento inválido: ${id}. Não é um UUID válido.`);
-      return res.status(400).json({ 
-        error: "ID de atendimento inválido",
-        details: "O formato do ID fornecido não é um UUID válido."
-      });
-    }
-    
     const atendimento = await prisma.atendimento.findUnique({
       where: {
         id: id,