add-doctor-edit

susconecta/components/forms/doctor-registration-form.tsx

@@ -158,40 +158,65 @@ export function DoctorRegistrationForm({
       try {
         console.log("[DoctorForm] Carregando médico ID:", doctorId);
         const medico = await buscarMedicoPorId(String(doctorId));
-        console.log("[DoctorForm] Dados recebidos:", medico);
+        console.log("[DoctorForm] Dados recebidos do API:", medico);
-        if (!alive) return;
+        console.log("[DoctorForm] Campos principais:", {
-        setForm({
+          full_name: medico.full_name,
-          photo: null,
+          crm: medico.crm,
-          full_name: medico.full_name ?? "",
+          especialidade: medico.especialidade,
-          nome_social: medico.nome_social ?? "",
+          specialty: (medico as any).specialty,
-          crm: medico.crm ?? "",
+          cpf: medico.cpf,
-          estado_crm: medico.estado_crm ?? "",
+          email: medico.email
-          rqe: medico.rqe ?? "",
-          formacao_academica: medico.formacao_academica ?? [],
-          curriculo: null, 
-          especialidade: medico.especialidade ?? "",
-          cpf: medico.cpf ?? "",
-          rg: medico.rg ?? "",
-          sexo: medico.sexo ?? "",
-          data_nascimento: medico.data_nascimento ?? "",
-          email: medico.email ?? "",
-          telefone: medico.telefone ?? "",
-          celular: medico.celular ?? "",
-          contato_emergencia: medico.contato_emergencia ?? "",
-          cep: "",
-          logradouro: "",
-          numero: "",
-          complemento: "",
-          bairro: "",
-          cidade: "",
-          estado: "",
-          observacoes: medico.observacoes ?? "",
-          anexos: [],
-          tipo_vinculo: medico.tipo_vinculo ?? "",
-          dados_bancarios: medico.dados_bancarios ?? { banco: "", agencia: "", conta: "", tipo_conta: "" },
-          agenda_horario: medico.agenda_horario ?? "",
-          valor_consulta: medico.valor_consulta ? String(medico.valor_consulta) : "",
         });
+        console.log("[DoctorForm] Verificando especialidade:", {
+          'medico.especialidade': medico.especialidade,
+          'medico.specialty': (medico as any).specialty,
+          'typeof especialidade': typeof medico.especialidade,
+          'especialidade length': medico.especialidade?.length
+        });
+        if (!alive) return;
+        
+        // Busca a especialidade em diferentes campos possíveis
+        const especialidade = medico.especialidade || 
+                              (medico as any).specialty || 
+                              (medico as any).speciality || 
+                              "";
+        console.log('🎯 Especialidade encontrada:', especialidade);
+        
+        const formData = {
+          photo: null,
+          full_name: String(medico.full_name || ""),
+          nome_social: String(medico.nome_social || ""),
+          crm: String(medico.crm || ""),
+          estado_crm: String(medico.estado_crm || ""),
+          rqe: String(medico.rqe || ""),
+          formacao_academica: Array.isArray(medico.formacao_academica) ? medico.formacao_academica : [],
+          curriculo: null, 
+          especialidade: String(especialidade),
+          cpf: String(medico.cpf || ""),
+          rg: String(medico.rg || ""),
+          sexo: String(medico.sexo || ""),
+          data_nascimento: String(medico.data_nascimento || ""),
+          email: String(medico.email || ""),
+          telefone: String(medico.telefone || ""),
+          celular: String(medico.celular || ""),
+          contato_emergencia: String(medico.contato_emergencia || ""),
+          cep: String(medico.cep || ""),
+          logradouro: String(medico.street || ""),
+          numero: String(medico.number || ""),
+          complemento: String(medico.complement || ""),
+          bairro: String(medico.neighborhood || ""),
+          cidade: String(medico.city || ""),
+          estado: String(medico.state || ""),
+          observacoes: String(medico.observacoes || ""),
+          anexos: [],
+          tipo_vinculo: String(medico.tipo_vinculo || ""),
+          dados_bancarios: medico.dados_bancarios || { banco: "", agencia: "", conta: "", tipo_conta: "" },
+          agenda_horario: String(medico.agenda_horario || ""),
+          valor_consulta: medico.valor_consulta ? String(medico.valor_consulta) : "",
+        };
+        
+        console.log("[DoctorForm] Dados do formulário preparados:", formData);
+        setForm(formData);
 
         try {
           const list = await listarAnexosMedico(String(doctorId));
@@ -317,44 +342,62 @@ async function handleSubmit(ev: React.FormEvent) {
   setErrors((e) => ({ ...e, submit: "" }));
 
 const payload: MedicoInput = {
-  user_id: null, // ou o UUID real
+  user_id: null,
-  crm: form.crm,
+  crm: form.crm || "",
-  crm_uf: form.estado_crm,
+  crm_uf: form.estado_crm || "",
-  specialty: form.especialidade,
+  specialty: form.especialidade || "",
-  full_name: form.full_name,
+  full_name: form.full_name || "",
-  cpf: form.cpf,
+  cpf: form.cpf || "",
-  email: form.email,
+  email: form.email || "",
-  phone_mobile: form.celular,
+  phone_mobile: form.celular || "",
   phone2: form.telefone || null,
-  cep: form.cep,
+  cep: form.cep || "",
-  street: form.logradouro,
+  street: form.logradouro || "",
-  number: form.numero,
+  number: form.numero || "",
-  complement: form.complemento,
+  complement: form.complemento || undefined,
-  neighborhood: form.bairro,
+  neighborhood: form.bairro || undefined,
-  city: form.cidade,
+  city: form.cidade || "",
-  state: form.estado,
+  state: form.estado || "",
   birth_date: form.data_nascimento || null,
   rg: form.rg || null,
   active: true,
-  created_by: null, // ou o UUID real
+  created_by: null,
-  updated_by: null, // ou o UUID real
+  updated_by: null,
 };
 
+// Validação dos campos obrigatórios
+const requiredFields = ['crm', 'crm_uf', 'specialty', 'full_name', 'cpf', 'email', 'phone_mobile', 'cep', 'street', 'number', 'city', 'state'];
+const missingFields = requiredFields.filter(field => !payload[field as keyof MedicoInput]);
+
+if (missingFields.length > 0) {
+  console.warn('⚠️ Campos obrigatórios vazios:', missingFields);
+}
 
 
-  console.log("Payload being sent:", payload); // Verifique se o payload está correto
+
+  console.log("📤 Payload being sent:", payload);
+  console.log("🔧 Mode:", mode, "DoctorId:", doctorId);
 
   try {
+    if (mode === "edit" && !doctorId) {
+      throw new Error("ID do médico não fornecido para edição");
+    }
+    
     const saved = mode === "create"
       ? await criarMedico(payload)
-      : await atualizarMedico(doctorId as number, payload);
+      : await atualizarMedico(String(doctorId), payload);
 
-    console.log("Médico salvo com sucesso", saved);  // Verifique se o médico foi salvo
+    console.log("✅ Médico salvo com sucesso:", saved);
 
     onSaved?.(saved);
     setSubmitting(false);
   } catch (err: any) {
-    console.error("Erro ao salvar médico:", err);
+    console.error("❌ Erro ao salvar médico:", err);
+    console.error("❌ Detalhes do erro:", {
+      message: err?.message,
+      status: err?.status,
+      stack: err?.stack
+    });
     setErrors((e) => ({ ...e, submit: err?.message || "Erro ao salvar médico" }));
   } finally {
     setSubmitting(false);

susconecta/lib/api.ts

@@ -426,12 +426,50 @@ export async function buscarMedicos(termo: string): Promise<Medico[]> {
 }
 
 export async function buscarMedicoPorId(id: string | number): Promise<Medico> {
+  // Primeiro tenta buscar no Supabase (dados reais)
+  try {
     const url = `${REST}/doctors?id=eq.${id}`;
     const res = await fetch(url, { method: "GET", headers: baseHeaders() });
     const arr = await parse<Medico[]>(res);
-  if (!arr?.length) throw new Error("404: Médico não encontrado");
+    if (arr && arr.length > 0) {
+      console.log('✅ Médico encontrado no Supabase:', arr[0]);
+      console.log('🔍 Campo especialidade no médico:', {
+        especialidade: arr[0].especialidade,
+        specialty: (arr[0] as any).specialty,
+        hasEspecialidade: !!arr[0].especialidade,
+        hasSpecialty: !!((arr[0] as any).specialty)
+      });
       return arr[0];
     }
+  } catch (error) {
+    console.warn('⚠️ Erro ao buscar no Supabase, tentando mock API:', error);
+  }
+  
+  // Se não encontrar no Supabase, tenta o mock API
+  try {
+    const url = `https://mock.apidog.com/m1/1053378-0-default/rest/v1/doctors/${id}`;
+    const res = await fetch(url, { 
+      method: "GET", 
+      headers: {
+        "Accept": "application/json"
+      }
+    });
+    
+    if (!res.ok) {
+      if (res.status === 404) {
+        throw new Error("404: Médico não encontrado");
+      }
+      throw new Error(`Erro ao buscar médico: ${res.status} ${res.statusText}`);
+    }
+    
+    const medico = await res.json();
+    console.log('✅ Médico encontrado no Mock API:', medico);
+    return medico as Medico;
+  } catch (error) {
+    console.error('❌ Erro ao buscar médico em ambas as APIs:', error);
+    throw new Error("404: Médico não encontrado");
+  }
+}
 
 // Dentro de lib/api.ts
 export async function criarMedico(input: MedicoInput): Promise<Medico> {
@@ -452,14 +490,60 @@ export async function criarMedico(input: MedicoInput): Promise<Medico> {
 
 
 export async function atualizarMedico(id: string | number, input: MedicoInput): Promise<Medico> {
+  console.log(`🔄 Tentando atualizar médico ID: ${id}`);
+  console.log(`📤 Payload original:`, input);
+  
+  // Criar um payload limpo apenas com campos básicos que sabemos que existem
+  const cleanPayload = {
+    full_name: input.full_name,
+    crm: input.crm,
+    specialty: input.specialty,
+    email: input.email,
+    phone_mobile: input.phone_mobile,
+    cpf: input.cpf,
+    cep: input.cep,
+    street: input.street,
+    number: input.number,
+    city: input.city,
+    state: input.state,
+    active: input.active ?? true
+  };
+  
+  console.log(`📤 Payload limpo:`, cleanPayload);
+  
+  // Atualizar apenas no Supabase (dados reais)
+  try {
     const url = `${REST}/doctors?id=eq.${id}`;
+    console.log(`🌐 URL de atualização: ${url}`);
+    
     const res = await fetch(url, {
       method: "PATCH",
       headers: withPrefer({ ...baseHeaders(), "Content-Type": "application/json" }, "return=representation"),
-    body: JSON.stringify(input),
+      body: JSON.stringify(cleanPayload),
     });
+    
+    console.log(`📡 Resposta do servidor: ${res.status} ${res.statusText}`);
+    
+    if (res.ok) {
       const arr = await parse<Medico[] | Medico>(res);
-  return Array.isArray(arr) ? arr[0] : (arr as Medico);
+      const result = Array.isArray(arr) ? arr[0] : (arr as Medico);
+      console.log('✅ Médico atualizado no Supabase:', result);
+      return result;
+    } else {
+      // Vamos tentar ver o erro detalhado
+      const errorText = await res.text();
+      console.error(`❌ Erro detalhado do Supabase:`, {
+        status: res.status,
+        statusText: res.statusText,
+        response: errorText,
+        headers: Object.fromEntries(res.headers.entries())
+      });
+      throw new Error(`Supabase error: ${res.status} ${res.statusText} - ${errorText}`);
+    }
+  } catch (error) {
+    console.error('❌ Erro ao atualizar médico:', error);
+    throw error;
+  }
 }
 
 export async function excluirMedico(id: string | number): Promise<void> {

susconecta/next-env.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-/// <reference path="./.next/types/routes.d.ts" />
 
 // NOTE: This file should not be edited
-// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
+// see https://nextjs.org/docs/app/building-your-application/configuring/typescript for more information.