Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

ola

  1. User

    ola

  2. Assistant

    Olá! Como posso ajudar você hoje?

  3. User

    analise meu codigo, o AppointmentRequestDTO e um objeto completo com outros ojbetos dentro, atualmente tenho um botao que ja salva os itens pra criar um objeto, ao criar AppointmentRequestDTO, ele ja gera um id, preciso ter uma função que quando tem um id, atualiza AppointmentRequestDTO, porem preciso que essa funçaõ seja passada como prop e seja usada no componente procecedimento, ao clicar no const handleConfirmEdit

    export interface DoctorDTO { id: string; cpf: string; name: string; email: string; phone?: string; profiles?: string[]; speciality?: string; password: string; } export interface Doctor { id: string; name: string; email: string; phone?: string; password: string; profiles: string[]; speciality?: string; createdAt: Date; updatedAt: Date; }

    export interface AppointmentStatus { glossed: boolean; lost: boolean; received: boolean; draft: boolean; validated: boolean; derived: boolean; finished: boolean; } export interface Appointment { status: AppointmentStatus; related: RelatedEntities; paymentInfo: PaymentInformation; serviceInfo: ServiceInformation; procedures: Procedure[]; attachments?: Attachment[]; }

    export interface AppointmentDTO extends Appointment { id: string; createdAt: Date; updatedAt: Date; }

    export interface RelatedEntities { place: PlacesAndPayersDTO; payer: PlacesAndPayersDTO; patient: Patient; }

    export interface PlacesAndPayersDTO extends PlacesAndPayers { id: string; createdAt: Date; updatedAt: Date; } export interface AppointmentRequestDTO { id?: string; status: AppointmentStatus; related: { place?: { id: string; name: string; }; payer?: { id: string; name: string; }; patient?: { id: string; name: string; cpf?: string; _comment?: string; }; }; paymentInfo: PaymentInformation; serviceInfo: ServiceInformation; procedures: ProcedureDTO[]; attachments?: Attachment[]; createdAt?: Date; updatedAt?: Date; }

    export interface PlacesAndPayers { place: boolean; payer: boolean; name: string; cnpj?: string; email?: string; phone?: string; address?: Address; }

    export interface Address { street?: string; city?: string; state?: string; country?: string; zipcode?: string; number?: string; }

    export interface Patient extends Identifiable { name: string; cpf?: string; address?: Address; gender?: string; birthday?: string; phone?: string; email?: string; helf_info?: string; [key: string]: any; //Todos os tipos de pagamentos utilizado em algum atendimento por esse paciente payments?: string[]; }

    export interface PaymentInformation { method: "healthInsurance" | "private" | "onDuty"; info: { healthInsurance?: { cardNumber: string; }; totalSum: number; totalValues: { expected: number; glossed: number; lost: number; paid: number; }; totalProcedures: { expected: number; glossed: number; lost: number; paid: number; }; }; }

    export interface ServiceInformation { guideCode?: string; date: string; totalValue: number; }

    interface Procedure { cbhpmCode: string; // Código personalizado da CBHPM cbhpmName: string; // Nome personalizado da CBHPM expectedValue: number; // Valor Previsto glossedValue: number; // Valor Glosado lostValue: number; // Valor Perdido paidValue: number; // Valor Pago placeId: string; payerId: string; patientId: string; paymentStatus?: string[]; statusOfActivity: | "draft" | "readyToValidate" | "validated" | "toDerive" | "derived" | "finished"; attachments: Attachment[]; }

    export interface JwtPayload { id: string; sessionId: string; iat: number; exp: number; } export interface ProcedureDTO extends Procedure { id: string; createdAt: Date; updatedAt: Date; }

    export interface Attachment { id: string; fileName: string; extension: string; }

    export interface PatientDTO extends Patient { id: string; createdAt: Date; updatedAt: Date; }

    export interface Identifiable { id: string; }

    export interface IResult { success: boolean; messages?: string[]; } export interface IResultData extends IResult { data?: T; }

    export interface IResumeData { target: { [key: string]: string; }; type: string; updatedAt: Date; changedAt: Date; data: T; }

    export type List = { total: number; skipped: number; limited: number; list: T[]; };

    interface Info { type: "video" | "image" | "text" | "youtube"; value: string; }

    export interface DataItem { id: string; name: string; total: number; }

    export interface Summary { startDate: string; endDate?: string; totalProduced: number; toReceive: number; received: number; losts: number; }

    export interface TransactionSegment { info: Info; total: number; data: DataItem[]; }

    export interface SegmentData { resume: Summary; toReceive: TransactionSegment; received: TransactionSegment; losted: TransactionSegment; }

    export interface TimePeriodData { accumulated: SegmentData; past: SegmentData[]; future: SegmentData[]; }

    import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import React, { useState, useEffect } from "react"; import { useApi } from "../../lib/doctorApi"; import { AppointmentRequestDTO, ProcedureDTO } from "./types"; import DropdownSelect from "./DropdownSelect"; import CardProcedimento from "./CardProcedimento"; import { v4 as uuidv4 } from "uuid"; // Importa a função para gerar UUIDs import { toMoney } from "../utils/FormatedData"; import Anexo from "../ui/Anexo";

    const CoresInput = [ "#25AAE1", // Cor 1 "#8696BB", // Cor 2 "#39465F", // Cor 3 "#D56D98", // Cor 4 ];

    const NovoAtendimento: React.FC = () => { const updateProcedimento = (index: number, novosDados: ProcedureDTO) => { const cloneAtendimento = { ...atendimento }; cloneAtendimento.procedures[index] = novosDados; setAtendimento(cloneAtendimento); };

    const [botaoSalvar, setBotaoSalvar] = useState(""); const enviarDadosAtendimento = async () => { loading; try { const result = await api.post("appointments/create", atendimento);

      if (result?.data?.success) {
        if (
          result.data.result?.id &&
          result.data.result.id !== atendimento.id
        ) {
          const cloneAtendimento = { ...atendimento };
          cloneAtendimento.id = result.data.result.id;
          setAtendimento(cloneAtendimento);
        }
      }
      result?.data?.messages;
      setBotaoSalvar("Salvo");
    } catch (e: any) {
      e?.response?.data?.messages;
      setBotaoSalvar("Salvar");
    }
    setLoading;
    

    }; useEffect(() => { setBotaoSalvar("Salvar"); const queryParams = new URLSearchParams(location.search); const appointmentId = queryParams.get("id"); if (appointmentId) { const fetchAtendimento = async () => { try { const response = await api.get(appointments/get/${appointmentId});

          const atendimento = response.data.result;
          setAtendimento(atendimento);
        } catch (error) {
          console.error("Erro ao buscar paciente:", error);
        }
      };
    
      fetchAtendimento();
    }
    

    }, []);

    const handleAdicionarProcedimento = () => { const novoProcedimento: ProcedureDTO = { id: uuidv4(), createdAt: new Date(), updatedAt: new Date(), cbhpmCode: "", cbhpmName: "", expectedValue: 0, glossedValue: 0, lostValue: 0, paidValue: 0, placeId: atendimento.related.place?.id || "", payerId: atendimento.related.payer?.id || "", patientId: atendimento.related.patient?.id || "", statusOfActivity: "draft", attachments: [], }; const cloneAtendimento = { ...atendimento }; cloneAtendimento.procedures.push(novoProcedimento); setAtendimento(cloneAtendimento); setMostrarCard(true); };

    const handleExcluirProcedimento = (id: string) => { // Filtra o array de procedimentos, mantendo apenas aqueles cujo id não coincide. const novosProcedimentos = atendimento.procedures.filter( (proc) => proc.id !== id );

    // Cria uma cópia do estado de atendimento e atualiza a lista de procedimentos
    setAtendimento((prev) => ({
      ...prev,
      procedures: novosProcedimentos, // Atualiza a lista de procedimentos
    }));
    
    // Opcional: Se existir alguma lógica que dependa da atualização da barra gráfica, você pode chamar:
    

    };

    // Atualiza o localStorage sempre que procedimentos mudar

    const [mostrarCard, setMostrarCard] = useState(false); // Estado para expandir/recolher o Card const [anexos, setAnexos] = useState< { id: string; fileName: string; extension: string }[]

    ([]); // Estado para os arquivos anexados

    const [loading, setLoading] = useState(false); const api = useApi(); // useApi é tratado como estável

    const [atendimento, setAtendimento] = useState({ status: { glossed: false, lost: false, received: false, draft: false, validated: false, derived: false, finished: false, }, related: { place: undefined, payer: undefined, patient: undefined, }, paymentInfo: { method: "healthInsurance", info: { totalSum: 0, healthInsurance: { cardNumber: "", }, totalValues: { expected: 0, glossed: 0, lost: 0, paid: 0, }, totalProcedures: { expected: 0, glossed: 0, lost: 0, paid: 0, }, }, }, serviceInfo: { guideCode: "", date: "", totalValue: 0, }, procedures: [], });

    const atualizarValoresBarra = () => { const totalProcedures = { expected: 0, glossed: 0, lost: 0, paid: 0, }; const totalValue = { expected: 0, glossed: 0, lost: 0, paid: 0, };

    atendimento.procedures.forEach((proc) => {
      if (proc.expectedValue > 0) {
        totalProcedures.expected += 1; // Incrementa para expectedValue
        totalValue.expected += proc.expectedValue;
      }
      if (proc.glossedValue > 0) {
        totalProcedures.glossed += 1; // Incrementa para glossedValue
        totalValue.glossed += proc.glossedValue;
      }
      if (proc.lostValue > 0) {
        totalProcedures.lost += 1; // Incrementa para lostValue
        totalValue.lost += proc.lostValue;
      }
      if (proc.paidValue > 0) {
        totalProcedures.paid += 1; // Incrementa para paidValue
        totalValue.paid += proc.paidValue;
      }
    });
    const cloneAtendimento = { ...atendimento };
    cloneAtendimento.paymentInfo.info.totalProcedures = totalProcedures;
    cloneAtendimento.paymentInfo.info.totalValues = totalValue;
    cloneAtendimento.paymentInfo.info.totalSum =
      cloneAtendimento.paymentInfo.info.totalValues.expected +
      cloneAtendimento.paymentInfo.info.totalValues.glossed +
      cloneAtendimento.paymentInfo.info.totalValues.lost +
      cloneAtendimento.paymentInfo.info.totalValues.paid;
    
    setAtendimento(cloneAtendimento); // Atualiza o estado dos valores da barra
    

    };

    useEffect(() => { atualizarValoresBarra(); }, [JSON.stringify(atendimento.procedures)]);

    // Função que alterna entre expandir e recolher const alternarCard = () => { setMostrarCard(!mostrarCard); };

    const handleSaveProcedimento = async (procedimento: ProcedureDTO) => { try { const result = await api.post("appointments/procedures/update", { id: atendimento.id, // ID do atendimento procedureId: procedimento.id, // ID do procedimento procedure: procedimento, // Dados atualizados do procedimento });

      if (!result?.data?.success) {
        throw new Error(
          result?.data?.messages || "Erro ao salvar procedimento"
        );
      }
    
      const updatedProcedures = atendimento.procedures.map((proc) =>
        proc.id === procedimento.id ? procedimento : proc
      );
    
      setAtendimento((prev) => ({
        ...prev,
        procedures: updatedProcedures,
      }));
    } catch (error) {
      console.error("Erro ao salvar procedimento:", error);
      throw error;
    }
    

    };

    return ( Cadastro de Atendimento

      <form>
        <div className={EstiloNovoAtendimento.divValores}>
          <div className={EstiloNovoAtendimento.inputValores}>
            <label className={EstiloNovoAtendimento.total}>Total:</label>
            {[
              atendimento.paymentInfo.info.totalValues.expected,
              atendimento.paymentInfo.info.totalValues.glossed,
              atendimento.paymentInfo.info.totalValues.lost,
              atendimento.paymentInfo.info.totalValues.paid,
            ].map((valor, index) => (
              <div key={index}>
                <span
                  style={{
                    color: CoresInput[index],
                    fontSize: "14px",
                    marginRight: "2px",
                  }}
                >
                  R$
                </span>
                <input
                  key={index}
                  type="number"
                  value={valor.toFixed(2)}
                  placeholder="R$ 0,00"
                  style={{ color: CoresInput[index] }}
                  readOnly
                />
              </div>
            ))}
          </div>
    
          <div className={EstiloNovoAtendimento.divBarraGrafico}>
            <label className={EstiloNovoAtendimento.labelTotal}>
              R$ {toMoney(atendimento.paymentInfo.info.totalSum)}
              {/* Aqui já usará o total atualizado */}
            </label>
            <div className={EstiloNovoAtendimento.graficoRepresentativo}>
              <div className={EstiloNovoAtendimento.barraFixa}>
                {[
                  atendimento.paymentInfo.info.totalValues.expected,
                  atendimento.paymentInfo.info.totalValues.glossed,
                  atendimento.paymentInfo.info.totalValues.lost,
                  atendimento.paymentInfo.info.totalValues.paid,
                ].map((valor, index) => {
                  const totalSum = atendimento.paymentInfo.info.totalSum;
                  const isAllZero =
                    atendimento.paymentInfo.info.totalValues.expected === 0 &&
                    atendimento.paymentInfo.info.totalValues.glossed === 0 &&
                    atendimento.paymentInfo.info.totalValues.lost === 0 &&
                    atendimento.paymentInfo.info.totalValues.paid === 0;
    
                  const percentage =
                    totalSum > 0 ? (valor / totalSum) * 100 : 0;
                  const minWidth = 5; // largura mínima em percentual
    
                  // Calcula a largura, levando em conta a largura mínima
                  const width = percentage < minWidth ? minWidth : percentage;
    
                  return (
                    <div
                      key={`grafico-${index}`}
                      style={{
                        backgroundColor: isAllZero
                          ? "transparent"
                          : CoresInput[index],
                        width: `${isAllZero ? 0 : width}%`,
                        height: "100%",
                      }}
                    />
                  );
                })}
              </div>
            </div>
          </div>
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          <div className={EstiloNovoAtendimento.modalidade}>
            <label>Modalidade:</label>
            <div className={EstiloNovoAtendimento.divMargin}>
              <input
                className={EstiloNovoAtendimento.radio}
                type="radio"
                id="convenio"
                name="modalidade"
                value="convenio"
                onChange={() => {
                  setAtendimento((prev) => ({
                    ...prev,
                    paymentInfo: {
                      ...prev.paymentInfo,
                      method: "healthInsurance", // Ou qualquer método que você queira usar
                    },
                  }));
                }}
              />
              <label
                htmlFor="convenio"
                className={EstiloNovoAtendimento.labelModalidade}
              >
                Convênio
              </label>
    
              <input
                className={EstiloNovoAtendimento.radio}
                type="radio"
                id="particular"
                name="modalidade"
                value="particular"
                onChange={() => {
                  setAtendimento((prev) => ({
                    ...prev,
                    paymentInfo: {
                      ...prev.paymentInfo,
                      method: "private", // Atualize para "particular"
                    },
                  }));
                }}
              />
              <label
                htmlFor="particular"
                className={EstiloNovoAtendimento.labelModalidade}
              >
                Particular
              </label>
    
              <input
                className={EstiloNovoAtendimento.radio}
                type="radio"
                id="plantao"
                name="modalidade"
                value="plantao"
                onChange={() => {
                  setAtendimento((prev) => ({
                    ...prev,
                    paymentInfo: {
                      ...prev.paymentInfo,
                      method: "onDuty", // Atualize para "plantao"
                    },
                  }));
                }}
              />
              <label
                htmlFor="plantao"
                className={EstiloNovoAtendimento.labelModalidade}
              >
                Plantão
              </label>
            </div>
          </div>
    
          <DropdownSelect
            endpoint="places/find?skip=0&limit=2000&payer=true" // URL do endpoint
            parseData={(data) =>
              data.result.list.map((local: any) => ({
                id: local.id,
                name: local.name,
              }))
            } // Função que transforma os dados da API no formato { id, name }
            onSelect={(selectedItem) => {
              // Atualizar o estado de atendimento para incluir o payer
              setAtendimento((prev) => ({
                ...prev,
                related: {
                  ...prev.related,
                  payer: { id: selectedItem.id, name: selectedItem.name }, // Assumindo que você quer armazenar um objeto { id, name }
                },
              }));
            }} // Define o item selecionado no estado
            value={atendimento.related.payer?.id || ""} // Valor atual do dropdown
            label="Fonte Pagadora:" // Rótulo a ser exibido
          />
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          {/* TODO: O Componente paciente precisa ter um campo de busca e buscar na api do backend com limite de 10 pacientes */}
          <DropdownSelect
            endpoint="patients/find?skip=0&limit=2000" // URL do endpoint
            parseData={(data) =>
              data.result.list.map((item: any) => ({
                id: item.id,
                name: item.name,
              }))
            } // Função que transforma os dados da API no formato { id, name }
            onSelect={(selectedItem) => {
              // Atualizar o estado de atendimento para incluir o payer
              setAtendimento((prev) => ({
                ...prev,
                related: {
                  ...prev.related,
                  patient: { id: selectedItem.id, name: selectedItem.name }, // Assumindo que você quer armazenar um objeto { id, name }
                },
              }));
            }} // Define o item selecionado no estado
            value={atendimento.related.patient?.id || ""} // Valor atual do dropdown
            label="Paciente:" // Rótulo a ser exibido
          />
    
          <DropdownSelect
            endpoint="places/find?skip=0&limit=2000&place=true" // URL do endpoint para buscar locais de atendimento
            parseData={(data) =>
              data.result.list.map((local: any) => ({
                id: local.id,
                name: local.name,
              }))
            } // Função para transformar os dados da API no formato { id, name }
            onSelect={(selectedItem) => {
              // Atualizar o estado de atendimento para incluir o payer
              setAtendimento((prev) => ({
                ...prev,
                related: {
                  ...prev.related,
                  place: { id: selectedItem.id, name: selectedItem.name }, // Assumindo que você quer armazenar um objeto { id, name }
                },
              }));
            }} // Callback para atualizar o formulário com o local selecionado
            value={atendimento.related.place?.id || ""} // ID do item selecionado
            label="Local de Atendimento:" // Rótulo exibido
          />
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          <div className={EstiloNovoAtendimento.organizador}>
            <span>Código da guia(opcional)</span>
            <input
              className={EstiloNovoAtendimento.input300}
              type="text"
              name="codigo"
              placeholder="Digite"
              value={atendimento.serviceInfo.guideCode}
              onChange={(e) => {
                const codigo = e.target.value;
    
                // Atualiza o estado de atendimento com o código da guia
                setAtendimento((prev) => ({
                  ...prev,
                  serviceInfo: {
                    ...prev.serviceInfo,
                    guideCode: codigo, // Atualiza o guideCode com o valor do input
                  },
                }));
              }}
            />
          </div>
          <div className={EstiloNovoAtendimento.organizador}>
            <span>Data</span>
            <input
              className={EstiloNovoAtendimento.inputData}
              type="date"
              name="data"
              placeholder="dd/mm/yyyy"
              value={atendimento.createdAt?.toISOString()}
              onChange={(e) => {
                const data = e.target.value;
    
                setAtendimento((prev) => ({
                  ...prev,
                  serviceInfo: {
                    ...prev.serviceInfo,
                    date: data,
                  },
                }));
              }}
            />
          </div>
        </div>
      </form>
      {/* deveria ficar aqui */}
      <div className={EstiloNovoAtendimento.divbutton}>
        <button
          type="button" // tipo "button" para evitar o envio do formulário
          onClick={handleAdicionarProcedimento} // Chama a função ao clicar
          className={EstiloNovoAtendimento.buttonProcedimento}
        >
          Adicionar Procedimento
        </button>
      </div>
    
      {/* Segunda barra gráfica com funcionalidade ajustada */}
      <div className={EstiloNovoAtendimento.divValores2}>
        <div className={EstiloNovoAtendimento.inputProcedimentos}>
          {[
            atendimento.paymentInfo.info.totalProcedures.expected,
            atendimento.paymentInfo.info.totalProcedures.glossed,
            atendimento.paymentInfo.info.totalProcedures.lost,
            atendimento.paymentInfo.info.totalProcedures.paid,
          ].map((valor, index) => (
            <input
              key={index}
              type="number"
              value={valor.toFixed(0)} // Mostra a contagem
              placeholder="0"
              readOnly // Barra apenas visual, não editável
              style={{ color: CoresInput[index] }} // Cor correspondente à respectiva
            />
          ))}
        </div>
    
        <div className={EstiloNovoAtendimento.divBarraGrafico}>
          <div className={EstiloNovoAtendimento.divTotal}>
            <img
              src="/procedimento.png"
              alt=""
              className={EstiloNovoAtendimento.icone}
            />
            <label className={EstiloNovoAtendimento.labelProcedimento}>
              <label>{atendimento.procedures.length}</label> Procedimento
            </label>
          </div>
          <div className={EstiloNovoAtendimento.graficoRepresentativo}>
            <div className={EstiloNovoAtendimento.barraFixa}>
              {[
                atendimento.paymentInfo.info.totalProcedures.expected,
                atendimento.paymentInfo.info.totalProcedures.glossed,
                atendimento.paymentInfo.info.totalProcedures.lost,
                atendimento.paymentInfo.info.totalProcedures.paid,
              ].map((valor, index) => {
                const totalSum = atendimento.paymentInfo.info.totalSum;
                const isAllZero =
                  atendimento.paymentInfo.info.totalProcedures.expected === 0 &&
                  atendimento.paymentInfo.info.totalProcedures.glossed === 0 &&
                  atendimento.paymentInfo.info.totalProcedures.lost === 0 &&
                  atendimento.paymentInfo.info.totalProcedures.paid === 0;
    
                const percentage = totalSum > 0 ? (valor / totalSum) * 100 : 0;
                const minWidth = 5; // largura mínima em percentual
    
                // Calcula a largura, levando em conta a largura mínima
                const width = percentage < minWidth ? minWidth : percentage;
    
                return (
                  <div
                    key={`grafico-${index}`}
                    style={{
                      backgroundColor: isAllZero
                        ? "transparent"
                        : CoresInput[index],
                      width: `${isAllZero ? 0 : width}%`,
                      height: "100%",
                    }}
                  />
                );
              })}
            </div>
          </div>
          {/* Botão de expandir/recolher */}
          <div
            className={EstiloNovoAtendimento.expandirProcedimentos}
            onClick={alternarCard}
          >
            <img
              src="/setaBaixo.png"
              alt="Expandir/recolher"
              className={EstiloNovoAtendimento.iconSeta}
            />
            <label className={EstiloNovoAtendimento.labelExpandir}>
              {mostrarCard ? "Recolher" : "Expandir"}
            </label>
          </div>
        </div>
      </div>
    
      {/* Renderiza o Card apenas se mostrarCard for true */}
      {mostrarCard && (
        <>
          {atendimento.procedures.map((proc, index) => (
            <CardProcedimento
              key={"procedure_" + proc.id}
              index={index}
              procedure={proc}
              updateProcedimento={updateProcedimento}
              handleExcluir={handleExcluirProcedimento}
              isNewAppointment={true}
            />
          ))}
        </>
      )}
      <Anexo
        attachments={atendimento.attachments || []}
        setAttachments={(novosAnexos) => {
          setAtendimento((prev) => ({
            ...prev,
            attachments: novosAnexos,
          }));
        }}
      />
    
      <div className={EstiloNovoAtendimento.divbutton}>
        <button
          className={EstiloNovoAtendimento.buttonSalvar}
          disabled={loading}
          onClick={enviarDadosAtendimento}
        >
          {loading ? "Salvando" : "Salvar"}
        </button>
      </div>
    </div>
    

    ); };

    export default NovoAtendimento;

    // CardProcedimento.tsx import React, { useEffect, useState } from "react"; import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import { ProcedureDTO } from "./types"; import Anexo from "../ui/Anexo"; import { useApi } from "../../lib/doctorApi";

    interface Procedimento { procedure: ProcedureDTO; index: number; handleExcluir: (id: string) => void; updateProcedimento: (index: number, novosDados: ProcedureDTO) => void; isNewAppointment?: boolean; }

    const CardProcedimento: React.FC = ({ procedure, index, updateProcedimento, handleExcluir, isNewAppointment = false, }) => { const [procedimento, setProcedimento] = useState({ ...procedure, }); const [expectedValue, setExpectedValue] = useState(""); const [glossedValue, setGlossedValue] = useState(""); const [paidValue, setPaidValue] = useState(""); const [lostValue, setLostValue] = useState(""); const [isEditing, setIsEditing] = useState(false); const [tempProcedimento, setTempProcedimento] = useState({ ...procedure, });

    const api = useApi(); // useApi é tratado como estável. const [error, setError] = useState<string | null>(null);

    const dataChange: { [key: string]: Function } = { expectedValue: setExpectedValue, glossedValue: setGlossedValue, paidValue: setPaidValue, lostValue: setLostValue, };

    useEffect(() => { setProcedimento({ ...procedure }); setTempProcedimento({ ...procedure }); }, []);

    useEffect(() => { if (!isEditing && !isNewAppointment) { updateProcedimento(index, procedimento); } }, [procedimento, isEditing, isNewAppointment]);

    useEffect(() => { if (isNewAppointment) { setIsEditing(true); } }, [isNewAppointment]);

    // Mapeamento de status const statusMap: { [key: string]: string } = { draft: "Rascunho", glossed: "Glosado", validated: "Validado", toDerive: "Para Faturar", derived: "Faturado", lost: "Perdido", finished: "Finalizado", };

    const handleTextChange = (e: React.ChangeEvent) => { const { name, value } = e.target;

    if (isEditing || isNewAppointment) {
      setTempProcedimento((prev) => ({
        ...prev,
        [name]: value,
      }));
    } else {
      setProcedimento((prev) => ({
        ...prev,
        [name]: value,
      }));
    }
    

    };

    const handleValueChange = (e: React.ChangeEvent) => { const inputValue = e.target.value; const name = e.target.name;

    let numericValue = inputValue.replace(/\D/g, "");
    if (numericValue === "") {
      numericValue = "0";
    }
    
    const formattedValue = (parseFloat(numericValue) / 100)
      .toFixed(2)
      .replace(".", ",");
    
    if (dataChange[name]) {
      dataChange[name](formattedValue);
    }
    
    const parsedValue = parseFloat(
      formattedValue.toString().split(".").join("").split(",").join(".")
    );
    
    if (isEditing || isNewAppointment) {
      setTempProcedimento((prev) => ({
        ...prev,
        [name]: parsedValue,
      }));
    } else {
      setProcedimento((prev) => ({
        ...prev,
        [name]: parsedValue,
      }));
    }
    

    };

    const { statusOfActivity = [] } = procedure; // Desestruturação com valor padrão

    const handleStartEdit = () => { if (!isNewAppointment && isEditing) { handleCancelEdit(); } else { setTempProcedimento({ ...procedimento }); setIsEditing(true); } };

    const handleConfirmEdit = async () => { // Atualizando o estado local setProcedimento(tempProcedimento); updateProcedimento(index, tempProcedimento); // Atualiza a lista local

    try {
      // Preparar dados para envio na API
      const requestData = {
        id: procedure.id, // o ID do procedimento a ser atualizado
        cbhpmCode: tempProcedimento.cbhpmCode,
        cbhpmName: tempProcedimento.cbhpmName,
        expectedValue: tempProcedimento.expectedValue,
        glossedValue: tempProcedimento.glossedValue,
        lostValue: tempProcedimento.lostValue,
        paidValue: tempProcedimento.paidValue,
        paymentStatus: tempProcedimento.paymentStatus || [], // Mantenha o mesmo formato
        statusOfActivity: tempProcedimento.statusOfActivity || "",
        attachments: tempProcedimento.attachments || [], // Correspondendo à estrutura vista
        // Se precisar de outras propriedades, insira aqui conforme necessário
      };
    
      const response = await api.post(
        `procedures/${procedure.id}/update`,
        requestData
      );
    
      // Debug: Confirma a atualização e a resposta
      console.log("Procedimento atualizado com sucesso:", response.data);
      // Aqui você pode, opcionalmente, recarregar a lista de procedimentos
      // fetchAppointments(); // Descomente se necessário
    } catch (error) {
      console.error("Erro ao atualizar procedimento:", error);
      setError(error instanceof Error ? error.message : "Erro desconhecido");
    }
    
    // Finaliza o processo de edição
    setIsEditing(false);
    

    };

    const handleCancelEdit = () => { setTempProcedimento({ ...procedimento }); setIsEditing(false); };

    return ( ID {!isNewAppointment && ( <button onClick={handleStartEdit} className={isEditing ? EstiloNovoAtendimento.editing : ""} > <button onClick={() => handleExcluir(procedure.id)} disabled={isEditing} > )}

      <div className={EstiloNovoAtendimento.divDoCard}>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Código personalizado da CBHPM</span>
          <input
            className={`${EstiloNovoAtendimento.inputCard} ${
              isEditing || isNewAppointment ? EstiloNovoAtendimento.editing : ""
            }`}
            type="text"
            name="cbhpmCode"
            value={
              isEditing ? tempProcedimento.cbhpmCode : procedimento.cbhpmCode
            }
            placeholder="Digite o Código..."
            disabled={!isEditing && !isNewAppointment}
            onChange={handleTextChange}
          />
        </div>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Nome personalizado da CBHPM</span>
          <input
            className={`${EstiloNovoAtendimento.inputCard} ${
              isEditing || isNewAppointment ? EstiloNovoAtendimento.editing : ""
            }`}
            type="text"
            name="cbhpmName"
            value={
              isEditing ? tempProcedimento.cbhpmName : procedimento.cbhpmName
            }
            placeholder="Digite o Nome..."
            disabled={!isEditing && !isNewAppointment}
            onChange={handleTextChange}
          />
        </div>
    
        <div className={EstiloNovoAtendimento.divflex}>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Previsto
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="expectedValue"
              value={
                isEditing
                  ? tempProcedimento.expectedValue
                  : procedimento.expectedValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Glosado
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="glossedValue"
              value={
                isEditing
                  ? tempProcedimento.glossedValue
                  : procedimento.glossedValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Perdido
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="lostValue"
              value={
                isEditing ? tempProcedimento.lostValue : procedimento.lostValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Pago
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="paidValue"
              value={
                isEditing ? tempProcedimento.paidValue : procedimento.paidValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
        </div>
    
        <Anexo
          attachments={
            isEditing ? tempProcedimento.attachments : procedimento.attachments
          }
          setAttachments={(novosAnexos) => {
            if (isEditing) {
              setTempProcedimento((prev) => ({
                ...prev,
                attachments: novosAnexos,
              }));
            } else {
              setProcedimento((prev) => ({
                ...prev,
                attachments: novosAnexos,
              }));
            }
          }}
        />
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de pagamento:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {procedure.expectedValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Previsto
            </label>
          )}
          {procedure.glossedValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Glosado
            </label>
          )}
          {procedure.paidValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              valor Pago
            </label>
          )}
          {procedure.lostValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Valor Perdido
            </label>
          )}
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de atividade:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {Object.keys(statusMap).map((statusItem) => (
            <label
              key={statusItem}
              className={`${EstiloNovoAtendimento.labelBorda}`}
            >
              <input
                type="checkbox"
                className={EstiloNovoAtendimento.customCheckbox}
                value={statusItem}
                checked={
                  isEditing
                    ? tempProcedimento.statusOfActivity === statusItem
                    : statusOfActivity === statusItem
                }
                disabled={!isEditing && !isNewAppointment}
                onChange={(e) => {
                  const isChecked = e.target.checked;
                  if (isEditing || isNewAppointment) {
                    setTempProcedimento((prev) => ({
                      ...prev,
                      statusOfActivity: isChecked
                        ? (statusItem as ProcedureDTO["statusOfActivity"])
                        : "draft",
                    }));
                  } else {
                    setProcedimento((prev) => ({
                      ...prev,
                      statusOfActivity: isChecked
                        ? (statusItem as ProcedureDTO["statusOfActivity"])
                        : "draft",
                    }));
                    updateProcedimento(index, {
                      ...procedure,
                      statusOfActivity: isChecked
                        ? (statusItem as ProcedureDTO["statusOfActivity"])
                        : "draft",
                    });
                  }
                }}
              />
              <span
                className={`${EstiloNovoAtendimento.labelAtividade} ${
                  isEditing || isNewAppointment
                    ? EstiloNovoAtendimento.editing
                    : ""
                }`}
              >
                {statusMap[statusItem]}
              </span>
            </label>
          ))}
        </div>
      </div>
      {isEditing && !isNewAppointment && (
        <div className={EstiloNovoAtendimento.CardBotton}>
          <div className={EstiloNovoAtendimento.botoesEdicao}>
            <button
              onClick={handleConfirmEdit}
              className={EstiloNovoAtendimento.botaoConfirmar}
            >
              Confirmar
            </button>
            <button
              onClick={handleCancelEdit}
              className={EstiloNovoAtendimento.botaoCancelar}
            >
              Cancelar
            </button>
          </div>
        </div>
      )}
    </div>
    

    ); };

    export default CardProcedimento;

  4. Assistant

    O código que você compartilhou é bastante extenso e cobre várias partes de um componente React que gerencia um atendimento médico com procedimentos. Você mencionou que deseja atualizar o objeto AppointmentRequestDTO ao editar um procedimento, e precisa de uma função que será passada como uma prop e utilizada dentro do componente CardProcedimento.

    Vamos focar em adaptar o código para que você possa passar uma função para atualizar o AppointmentRequestDTO e utilizá-la ao clicar no botão de confirmar edição no CardProcedimento.

    Aqui estão os passos para implementá-lo:

    1. Defina uma prop para a função no CardProcedimento: Primeiro, você precisará adicionar uma prop para receber a função de atualização.

    2. Chame a função de atualização ao confirmar a edição: Quando o procedimento for editado e o botão de confirmação for clicado, a função passada como prop deverá ser chamada para atualizar o AppointmentRequestDTO global.

    3. Implemente a lógica no NovoAtendimento: Certifique-se de que a lógica correta seja implementada quando essa função for chamada.

    Aqui está como você pode fazer isso:

    Modificações em NovoAtendimento

    No seu componente NovoAtendimento, ao renderizar o CardProcedimento, você deve passar a função necessária para atualização:

    <CardProcedimento
      key={"procedure_" + proc.id}
      index={index}
      procedure={proc}
      updateProcedimento={updateProcedimento}
      handleExcluir={handleExcluirProcedimento}
      isNewAppointment={true}
      onConfirmEdit={(updatedProcedure) => {
        handleSaveProcedimento(updatedProcedure);
      }}
    />
    

    Modificações em CardProcedimento

    Adicione a prop onConfirmEdit para o CardProcedimento:

    interface Procedimento {
      procedure: ProcedureDTO;
      index: number;
      handleExcluir: (id: string) => void;
      updateProcedimento: (index: number, novosDados: ProcedureDTO) => void;
      onConfirmEdit: (updatedProcedure: ProcedureDTO) => void; // Nova prop
      isNewAppointment?: boolean;
    }
    

    Agora, dentro do handleConfirmEdit, chame onConfirmEdit com os novos dados do procedimento:

    const handleConfirmEdit = async () => {
      // Atualizando o estado local
      setProcedimento(tempProcedimento);
      updateProcedimento(index, tempProcedimento); // Atualiza a lista local
      
      // Chamando a função que foi passada como prop para atualizar o AppointmentRequestDTO
      props.onConfirmEdit(tempProcedimento); // Adicione isso
    
      // Lógica de envio para a API...
    };
    

    Resumo do que foi feito:

    1. Adicionamos uma nova propriedade onConfirmEdit no CardProcedimento para receber a função que fará a atualização no objeto de atendimento.

    2. Chamamos essa função no handleConfirmEdit, passando o tempProcedimento atualizado, que será utilizado para atualizar o AppointmentRequestDTO no componente pai.

    Considerações Finais:

    Este é um padrão comum ao trabalhar com componentes em React onde você deseja que componentes filhos notifiquem os pais sobre mudanças de estado. Certifique-se de que sua lógica de atualização no NovoAtendimento esteja utilizando os dados mais recentes corretamente.

    Se você tiver mais dúvidas ou precisar de algo mais, sinta-se à vontade para perguntar!

  5. User

    entao, mas para atualizar um procedimento, preciso passar o objeto inteiro de atendimento, com o id e todos os procedimentos com os ids tambem

    // CardProcedimento.tsx import React, { useEffect, useState } from "react"; import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import { ProcedureDTO } from "./types"; import Anexo from "../ui/Anexo"; import { useApi } from "../../lib/doctorApi";

    interface Procedimento { procedure: ProcedureDTO; index: number; handleExcluir: (id: string) => void; updateProcedimento: (index: number, novosDados: ProcedureDTO) => void; onConfirmEdit: (updatedProcedure: ProcedureDTO) => void; // Nova prop isNewAppointment?: boolean; }

    const CardProcedimento: React.FC = ({ procedure, index, updateProcedimento, handleExcluir, isNewAppointment = false, }) => { const [procedimento, setProcedimento] = useState({ ...procedure, }); const [expectedValue, setExpectedValue] = useState(""); const [glossedValue, setGlossedValue] = useState(""); const [paidValue, setPaidValue] = useState(""); const [lostValue, setLostValue] = useState(""); const [isEditing, setIsEditing] = useState(false); const [tempProcedimento, setTempProcedimento] = useState({ ...procedure, });

    const api = useApi(); // useApi é tratado como estável. const [error, setError] = useState<string | null>(null);

    const dataChange: { [key: string]: Function } = { expectedValue: setExpectedValue, glossedValue: setGlossedValue, paidValue: setPaidValue, lostValue: setLostValue, };

    useEffect(() => { setProcedimento({ ...procedure }); setTempProcedimento({ ...procedure }); }, []);

    useEffect(() => { if (!isEditing && !isNewAppointment) { updateProcedimento(index, procedimento); } }, [procedimento, isEditing, isNewAppointment]);

    useEffect(() => { if (isNewAppointment) { setIsEditing(true); } }, [isNewAppointment]);

    // Mapeamento de status const statusMap: { [key: string]: string } = { draft: "Rascunho", glossed: "Glosado", validated: "Validado", toDerive: "Para Faturar", derived: "Faturado", lost: "Perdido", finished: "Finalizado", };

    const handleTextChange = (e: React.ChangeEvent) => { const { name, value } = e.target;

    if (isEditing || isNewAppointment) {
      setTempProcedimento((prev) => ({
        ...prev,
        [name]: value,
      }));
    } else {
      setProcedimento((prev) => ({
        ...prev,
        [name]: value,
      }));
    }
    

    };

    const handleValueChange = (e: React.ChangeEvent) => { const inputValue = e.target.value; const name = e.target.name;

    let numericValue = inputValue.replace(/\D/g, "");
    if (numericValue === "") {
      numericValue = "0";
    }
    
    const formattedValue = (parseFloat(numericValue) / 100)
      .toFixed(2)
      .replace(".", ",");
    
    if (dataChange[name]) {
      dataChange[name](formattedValue);
    }
    
    const parsedValue = parseFloat(
      formattedValue.toString().split(".").join("").split(",").join(".")
    );
    
    if (isEditing || isNewAppointment) {
      setTempProcedimento((prev) => ({
        ...prev,
        [name]: parsedValue,
      }));
    } else {
      setProcedimento((prev) => ({
        ...prev,
        [name]: parsedValue,
      }));
    }
    

    };

    const { statusOfActivity = [] } = procedure; // Desestruturação com valor padrão

    const handleStartEdit = () => { if (!isNewAppointment && isEditing) { handleCancelEdit(); } else { setTempProcedimento({ ...procedimento }); setIsEditing(true); } };

    const handleConfirmEdit = async () => { // Atualizando o estado local setProcedimento(tempProcedimento); updateProcedimento(index, tempProcedimento); // Atualiza a lista local

    // Chamando a função que foi passada como prop para atualizar o AppointmentRequestDTO props.onConfirmEdit(tempProcedimento); // Adicione isso

    try {
      // Preparar dados para envio na API
      const requestData = {
        id: procedure.id, // o ID do procedimento a ser atualizado
        cbhpmCode: tempProcedimento.cbhpmCode,
        cbhpmName: tempProcedimento.cbhpmName,
        expectedValue: tempProcedimento.expectedValue,
        glossedValue: tempProcedimento.glossedValue,
        lostValue: tempProcedimento.lostValue,
        paidValue: tempProcedimento.paidValue,
        paymentStatus: tempProcedimento.paymentStatus || [], // Mantenha o mesmo formato
        statusOfActivity: tempProcedimento.statusOfActivity || "",
        attachments: tempProcedimento.attachments || [], // Correspondendo à estrutura vista
        // Se precisar de outras propriedades, insira aqui conforme necessário
      };
    
      const response = await api.post(
        `procedures/${procedure.id}/update`,
        requestData
      );
    
      // Debug: Confirma a atualização e a resposta
      console.log("Procedimento atualizado com sucesso:", response.data);
      // Aqui você pode, opcionalmente, recarregar a lista de procedimentos
      // fetchAppointments(); // Descomente se necessário
    } catch (error) {
      console.error("Erro ao atualizar procedimento:", error);
      setError(error instanceof Error ? error.message : "Erro desconhecido");
    }
    
    // Finaliza o processo de edição
    setIsEditing(false);
    

    };

    const handleCancelEdit = () => { setTempProcedimento({ ...procedimento }); setIsEditing(false); };

    return ( ID {!isNewAppointment && ( <button onClick={handleStartEdit} className={isEditing ? EstiloNovoAtendimento.editing : ""} > <button onClick={() => handleExcluir(procedure.id)} disabled={isEditing} > )}

      <div className={EstiloNovoAtendimento.divDoCard}>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Código personalizado da CBHPM</span>
          <input
            className={`${EstiloNovoAtendimento.inputCard} ${
              isEditing || isNewAppointment ? EstiloNovoAtendimento.editing : ""
            }`}
            type="text"
            name="cbhpmCode"
            value={
              isEditing ? tempProcedimento.cbhpmCode : procedimento.cbhpmCode
            }
            placeholder="Digite o Código..."
            disabled={!isEditing && !isNewAppointment}
            onChange={handleTextChange}
          />
        </div>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Nome personalizado da CBHPM</span>
          <input
            className={`${EstiloNovoAtendimento.inputCard} ${
              isEditing || isNewAppointment ? EstiloNovoAtendimento.editing : ""
            }`}
            type="text"
            name="cbhpmName"
            value={
              isEditing ? tempProcedimento.cbhpmName : procedimento.cbhpmName
            }
            placeholder="Digite o Nome..."
            disabled={!isEditing && !isNewAppointment}
            onChange={handleTextChange}
          />
        </div>
    
        <div className={EstiloNovoAtendimento.divflex}>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Previsto
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="expectedValue"
              value={
                isEditing
                  ? tempProcedimento.expectedValue
                  : procedimento.expectedValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Glosado
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="glossedValue"
              value={
                isEditing
                  ? tempProcedimento.glossedValue
                  : procedimento.glossedValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Perdido
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="lostValue"
              value={
                isEditing ? tempProcedimento.lostValue : procedimento.lostValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Pago
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="paidValue"
              value={
                isEditing ? tempProcedimento.paidValue : procedimento.paidValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
        </div>
    
        <Anexo
          attachments={
            isEditing ? tempProcedimento.attachments : procedimento.attachments
          }
          setAttachments={(novosAnexos) => {
            if (isEditing) {
              setTempProcedimento((prev) => ({
                ...prev,
                attachments: novosAnexos,
              }));
            } else {
              setProcedimento((prev) => ({
                ...prev,
                attachments: novosAnexos,
              }));
            }
          }}
        />
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de pagamento:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {procedure.expectedValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Previsto
            </label>
          )}
          {procedure.glossedValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Glosado
            </label>
          )}
          {procedure.paidValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              valor Pago
            </label>
          )}
          {procedure.lostValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Valor Perdido
            </label>
          )}
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de atividade:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {Object.keys(statusMap).map((statusItem) => (
            <label
              key={statusItem}
              className={`${EstiloNovoAtendimento.labelBorda}`}
            >
              <input
                type="checkbox"
                className={EstiloNovoAtendimento.customCheckbox}
                value={statusItem}
                checked={
                  isEditing
                    ? tempProcedimento.statusOfActivity === statusItem
                    : statusOfActivity === statusItem
                }
                disabled={!isEditing && !isNewAppointment}
                onChange={(e) => {
                  const isChecked = e.target.checked;
                  if (isEditing || isNewAppointment) {
                    setTempProcedimento((prev) => ({
                      ...prev,
                      statusOfActivity: isChecked
                        ? (statusItem as ProcedureDTO["statusOfActivity"])
                        : "draft",
                    }));
                  } else {
                    setProcedimento((prev) => ({
                      ...prev,
                      statusOfActivity: isChecked
                        ? (statusItem as ProcedureDTO["statusOfActivity"])
                        : "draft",
                    }));
                    updateProcedimento(index, {
                      ...procedure,
                      statusOfActivity: isChecked
                        ? (statusItem as ProcedureDTO["statusOfActivity"])
                        : "draft",
                    });
                  }
                }}
              />
              <span
                className={`${EstiloNovoAtendimento.labelAtividade} ${
                  isEditing || isNewAppointment
                    ? EstiloNovoAtendimento.editing
                    : ""
                }`}
              >
                {statusMap[statusItem]}
              </span>
            </label>
          ))}
        </div>
      </div>
      {isEditing && !isNewAppointment && (
        <div className={EstiloNovoAtendimento.CardBotton}>
          <div className={EstiloNovoAtendimento.botoesEdicao}>
            <button
              onClick={handleConfirmEdit}
              className={EstiloNovoAtendimento.botaoConfirmar}
            >
              Confirmar
            </button>
            <button
              onClick={handleCancelEdit}
              className={EstiloNovoAtendimento.botaoCancelar}
            >
              Cancelar
            </button>
          </div>
        </div>
      )}
    </div>
    

    ); };

    export default CardProcedimento;

  6. Assistant

    Entendi, você precisa atualizar não apenas o procedimento específico, mas o objeto completo AppointmentRequestDTO ao confirmar a edição de um procedimento. Para isso, você tem razão em querer passar o objeto inteiro de atendimento juntamente com o ID do procedimento, para que tudo fique atualizado.

    Passos para Passar o AppointmentRequestDTO

    1. Atualize as Props no CardProcedimento: Adicione uma nova prop chamada onConfirmEdit, que receberá a função de atualização de todas as informações do atendimento.

    2. Atualize a Função de Confirmação: No handleConfirmEdit, você chamará essa nova função passando o AppointmentRequestDTO atualizado.

    3. Gerencie o Atendimento no Componente Pai: No componente NovoAtendimento, você gerenciará o estado de atendimento, e ao confirmar a edição do CardProcedimento, você atualizará o mesmo.

    Aqui está como fazer isso:

    1. Atualize o Componente CardProcedimento

    A primeira coisa a fazer é modificar a interface Procedimento para incluir a nova prop onConfirmEdit que irá aceitar o AppointmentRequestDTO.

    interface Procedimento {
      procedure: ProcedureDTO;
      index: number;
      handleExcluir: (id: string) => void;
      updateProcedimento: (index: number, novosDados: ProcedureDTO) => void;
      onConfirmEdit: (updatedAppointment: AppointmentRequestDTO) => void; // Atualizando a função
      isNewAppointment?: boolean;
    }
    

    2. Atualize handleConfirmEdit em CardProcedimento

    Quando você confirmar a edição, você irá criar um novo AppointmentRequestDTO com todos os procedimentos que devem estar atualizados.

    const handleConfirmEdit = async () => {
      setProcedimento(tempProcedimento);
      updateProcedimento(index, tempProcedimento); // Atualiza a lista local de procedimentos
    
      // Aqui você precisa construir o AppointmentRequestDTO incluindo o as mudanças nos procedimentos
      const updatedAppointment = {
        ...appointment, // Supondo que você já tenha isso acessível
        procedures: atendimento.procedures.map((p) => 
          p.id === tempProcedimento.id ? tempProcedimento : p
        )
      };
    
      // Chame a prop pasando o objeto atualizado
      onConfirmEdit(updatedAppointment);
    
      // Continue com a lógica de envio para API
      try {
        const requestData = {
          // ... (seu código existente para montar dados do procedimento)
        };
    
        const response = await api.post(
          `procedures/${procedure.id}/update`,
          requestData
        );
    
        console.log("Procedimento atualizado com sucesso:", response.data);
      } catch (error) {
        console.error("Erro ao atualizar procedimento:", error);
        setError(error instanceof Error ? error.message : "Erro desconhecido");
      }
    
      setIsEditing(false);
    };
    

    3. Atualize o Componente NovoAtendimento

    Quando você renderiza o CardProcedimento, você precisa passar a função que manipula o objeto AppointmentRequestDTO:

    <CardProcedimento
      key={"procedure_" + proc.id}
      index={index}
      procedure={proc}
      updateProcedimento={updateProcedimento}
      handleExcluir={handleExcluirProcedimento}
      isNewAppointment={true}
      onConfirmEdit={(updatedAppointment) => {
        setAtendimento(updatedAppointment); // Aqui você atualiza seu estado de atendimento
      }}
    />
    

    Resumo

    • Prop onConfirmEdit: Adicionada para que o CardProcedimento divulgue as alterações feitas ao AppointmentRequestDTO.
    • Função de Atualização: No handleConfirmEdit, você constrói o novo AppointmentRequestDTO, garantindo que o ID e os procedimentos estejam atualizados, e o passa para o componente pai.
    • Atualização do Estado: No NovoAtendimento, você usa essa função para atualizar o estado do atendimento com os dados atualizados.

    Considerações Finais

    Essa abordagem mantém a estrutura clara e modular. Fazendo isso, você garante que todos os procedimentos e o estado do AppointmentRequestDTO estejam sempre em sincronia. Se você tiver outras perguntas ou precisar de mais assistência, fique à vontade para perguntar!

  7. User

    nao tenho essa parte acessivel

    ...appointment, // Supondo que você já tenha isso acessível procedures: atendimento.procedures.map((p) =>

  8. Assistant

    Entendi! Se você não tem acesso direto ao objeto AppointmentRequestDTO dentro do componente CardProcedimento, então você precisa garantir que essa informação seja passada para o CardProcedimento a partir do componente pai, NovoAtendimento.

    Passos para Passar o Objeto AppointmentRequestDTO

    1. Passar o Objeto atendimento para o CardProcedimento: Quando você renderiza o CardProcedimento, você deve passar o objeto atendimento atual como uma prop.

    2. Usar o Objeto na Função handleConfirmEdit: Dentro do CardProcedimento, ao confirmar a edição, você usará o objeto atendimento para construir o novo objeto AppointmentRequestDTO.

    Exemplificando com seu Código:

    Modificando o Componente CardProcedimento

    Aqui está como você pode ajustar o seu código:

    1. Adicione uma nova prop chamada atendimento:
    interface Procedimento {
      procedure: ProcedureDTO;
      index: number;
      handleExcluir: (id: string) => void;
      updateProcedimento: (index: number, novosDados: ProcedureDTO) => void;
      onConfirmEdit: (updatedAppointment: AppointmentRequestDTO) => void; 
      isNewAppointment?: boolean;
      atendimento: AppointmentRequestDTO; // Nova prop para o objeto de Atendimento
    }
    
    1. Atualize handleConfirmEdit para usar o objeto atendimento:
    const handleConfirmEdit = async () => {
      setProcedimento(tempProcedimento);
      updateProcedimento(index, tempProcedimento); // Atualiza a lista local
    
      // Construa o novo AppointmentRequestDTO com base no atendimento passado como prop
      const updatedAppointment: AppointmentRequestDTO = {
        ...atendimento,
        procedures: atendimento.procedures.map((p) => 
          p.id === tempProcedimento.id ? tempProcedimento : p
        )
      };
    
      // Chame a função para atualizar o pai
      onConfirmEdit(updatedAppointment);
    
      try {
        const requestData = {
          // seus dados de procedimento
          id: procedure.id, // o ID que você precisa para atualizar na API
          cbhpmCode: tempProcedimento.cbhpmCode,
          cbhpmName: tempProcedimento.cbhpmName,
          expectedValue: tempProcedimento.expectedValue,
          glossedValue: tempProcedimento.glossedValue,
          lostValue: tempProcedimento.lostValue,
          paidValue: tempProcedimento.paidValue,
          paymentStatus: tempProcedimento.paymentStatus || [],
          statusOfActivity: tempProcedimento.statusOfActivity || "",
          attachments: tempProcedimento.attachments || [],
        };
    
        const response = await api.post(
          `procedures/${procedure.id}/update`,
          requestData
        );
    
        console.log("Procedimento atualizado com sucesso:", response.data);
      } catch (error) {
        console.error("Erro ao atualizar procedimento:", error);
        setError(error instanceof Error ? error.message : "Erro desconhecido");
      }
    
      setIsEditing(false);
    };
    

    Modificando o Componente NovoAtendimento

    Agora, ao renderizar o CardProcedimento, passe o objeto atendimento como uma prop:

    <CardProcedimento
      key={"procedure_" + proc.id}
      index={index}
      procedure={proc}
      updateProcedimento={updateProcedimento}
      handleExcluir={handleExcluirProcedimento}
      isNewAppointment={true}
      atendimento={atendimento} // Passando o objeto de atendimento
      onConfirmEdit={(updatedAppointment) => {
        setAtendimento(updatedAppointment); // Aqui você atualiza seu estado de atendimento
      }}
    />
    

    Resumo

    • Nova Prop atendimento: Agora, o CardProcedimento recebe o objeto AppointmentRequestDTO completo como prop.
    • Uso do Objeto na Edição: Ao confirmar a edição, você usa essa prop para construir o novo objeto que inclui as alterações feitas.

    Dessa forma, você garante que todas as modificações nos procedimentos são refletidas no objeto de atendimento, mesmo que você não tenha acesso direto a ele dentro do CardProcedimento.

    Se precisar de mais assistência ou tiver outras perguntas, estou aqui para ajudar!

  9. User

    aqui preciso apenas passar o atendimento, ele ja existe quando estou editando, so preciso pegar as props do objeto inteiro to atendimento junto com id, e informar para o back qual atendimento sera atualizado, dando um pots na url e passando todo o atendimento

    const updatedAppointment: AppointmentRequestDTO = { ...atendimento, procedures: atendimento.procedures.map((p) => p.id === tempProcedimento.id ? tempProcedimento : p ), };

    const handleConfirmEdit = async () => { setProcedimento(tempProcedimento); updateProcedimento(index, tempProcedimento); // Atualiza a lista local

    // Construa o novo AppointmentRequestDTO com base no atendimento passado como prop
    const updatedAppointment: AppointmentRequestDTO = {
      ...atendimento,
      procedures: atendimento.procedures.map((p) =>
        p.id === tempProcedimento.id ? tempProcedimento : p
      ),
    };
    
    // Chame a função para atualizar o pai
    setTempProcedimento(procedimento);
    onConfirmEdit(updatedAppointment);
    
    try {
      const requestData = {
        atendimento,
        id: procedure.id, // o ID que você precisa para atualizar na API
        cbhpmCode: tempProcedimento.cbhpmCode,
        cbhpmName: tempProcedimento.cbhpmName,
        expectedValue: tempProcedimento.expectedValue,
        glossedValue: tempProcedimento.glossedValue,
        lostValue: tempProcedimento.lostValue,
        paidValue: tempProcedimento.paidValue,
        paymentStatus: tempProcedimento.paymentStatus || [],
        statusOfActivity: tempProcedimento.statusOfActivity || "",
        attachments: tempProcedimento.attachments || [],
      };
    
      const response = await api.post(
        `procedures/${procedure.id}/update`,
        requestData
      );
    
      console.log("Procedimento atualizado com sucesso:", response.data);
    } catch (error) {
      console.error("Erro ao atualizar procedimento:", error);
      setError(error instanceof Error ? error.message : "Erro desconhecido");
    }
    
    setIsEditing(false);
    

    };

  10. Assistant

    Perfeito! Entendi que seu objetivo é utilizar o objeto atendimento completo ao atualizar o procedimento e garantir que o ID do procedimento e o ID do atendimento sejam utilizados na chamada à API.

    Atualização do Código

    Abaixo está uma versão revisada do método handleConfirmEdit com as considerações que você mencionou. Vou garantir que o objeto atendimento seja passado corretamente, junto com as informações do procedimento atualizado.

    const handleConfirmEdit = async () => {
      // Atualiza o procedimento local
      setProcedimento(tempProcedimento);
      updateProcedimento(index, tempProcedimento); // Atualiza a lista local
    
      // O objeto updatedAppointment é opcional neste caso, já que você quer enviar o objeto completo de atendimento ao backend.
      const updatedAppointment: AppointmentRequestDTO = {
        ...atendimento,
        procedures: atendimento.procedures.map((p) =>
          p.id === tempProcedimento.id ? tempProcedimento : p
        ),
      };
    
      // Se necessário, você pode atualizar o estado de atendimento no componente pai aqui
      onConfirmEdit(updatedAppointment);
    
      try {
        // Envio dos dados
        const requestData = {
          ...atendimento, // Inclui todo o atendimento
          id: atendimento.id, // Passa o ID do atendimento para a URL
          procedures: updatedAppointment.procedures, // Passa os procedimentos atualizados
        };
    
        const response = await api.post(
          `appointments/${atendimento.id}/update`, // A URL que utiliza o ID do atendimento
          requestData
        );
    
        console.log("Procedimento e atendimento atualizados com sucesso:", response.data);
      } catch (error) {
        console.error("Erro ao atualizar procedimento:", error);
        setError(error instanceof Error ? error.message : "Erro desconhecido");
      }
    
      setIsEditing(false);
    };
    

    O que Mudou

    1. Atualização do Componente Local: Atualizamos o procedimento local e a lista de procedimentos.
    2. Construção do Objeto updatedAppointment: Ele foi mantido, mas você pode escolher não usá-lo em caso de não precisar.
    3. Envio da Requisição:
      • Usei o atendimento.id na URL da chamada API.
      • Passamos o objeto atendimento completo no requestData, juntamente com os procedimentos atualizados.
    4. Chamando onConfirmEdit: Isso vai permitir que o componente pai tenha a informação atualizada, caso necessário.

    Observações

    • Você não precisa do objeto updatedAppointment para a chamada à API se você já estiver usando o objeto completo de atendimento. Ele só serve para que você possa manter a informação no estado do componente pai se desejar.
    • A maneira como você estrutura a requestData pode ser ajustada conforme o que sua API espera. A estrutura atual pressupõe que sua API consegue lidar com a forma do objeto que você está enviando.
    • Verifique a URL da API para garantir que segue o formato correto.

    Se houver algo mais que precise ser ajustado ou se você tiver alguma dúvida, sinta-se à vontade para perguntar!

  11. User

    CardProcedimento.tsx:146 Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'procedures') at handleConfirmEdit (CardProcedimento.tsx:146:31) handleConfirmEdit @ CardProcedimento.tsx:146

  12. Assistant

    O erro que você está encontrando (TypeError: Cannot read properties of undefined (reading 'procedures')) sugere que, em algum ponto do seu código, a variável atendimento está undefined, o que significa que não foi passada de maneira correta para o componente CardProcedimento.

    Vamos fazer uma verificação e garantir que o objeto atendimento está sendo passado corretamente e acessado no CardProcedimento. Aqui estão algumas etapas para solucionar esse problema:

    1. Verifique a Prop atendimento

    Certifique-se de que, ao renderizar o CardProcedimento, o objeto atendimento está sendo passado corretamente:

    <CardProcedimento
      key={"procedure_" + proc.id}
      index={index}
      procedure={proc}
      updateProcedimento={updateProcedimento}
      handleExcluir={handleExcluirProcedimento}
      isNewAppointment={true}
      atendimento={atendimento} // Certifique-se de que `atendimento` não está `undefined`
      onConfirmEdit={(updatedAppointment) => {
        setAtendimento(updatedAppointment);
      }}
    />
    

    2. Adicione Verificações no CardProcedimento

    Antes de tentar acessar atendimento.procedures, adicione uma verificação para garantir que atendimento não é undefined:

    const handleConfirmEdit = async () => {
      // Verifique se atendimento não está undefined
      if (!atendimento || !atendimento.procedures) {
        console.error("O atendimento não está definido ou está faltando os procedimentos.");
        return;
      }
    
      setProcedimento(tempProcedimento);
      updateProcedimento(index, tempProcedimento); // Atualiza a lista local
    
      // Mantendo a construção do updatedAppointment
      const updatedAppointment: AppointmentRequestDTO = {
        ...atendimento,
        procedures: atendimento.procedures.map((p) =>
          p.id === tempProcedimento.id ? tempProcedimento : p
        ),
      };
    
      // Se necessário, você pode atualizar o estado de atendimento no componente pai aqui
      onConfirmEdit(updatedAppointment);
    
      try {
        const requestData = {
          ...atendimento, // Inclui todo o atendimento
          id: atendimento.id, // Passa o ID do atendimento para a URL
          procedures: updatedAppointment.procedures, // Passa os procedimentos atualizados
        };
    
        const response = await api.post(
          `appointments/${atendimento.id}/update`, // A URL que utiliza o ID do atendimento
          requestData
        );
    
        console.log("Procedimento e atendimento atualizados com sucesso:", response.data);
      } catch (error) {
        console.error("Erro ao atualizar procedimento:", error);
        setError(error instanceof Error ? error.message : "Erro desconhecido");
      }
    
      setIsEditing(false);
    };
    

    3. Certifique-se de Que a Prop atendimento Sempre Existe

    Certifique-se de que o atendimento é sempre inicializado antes de ser passado como uma prop. Você pode inicializar atendimento no componente pai (NovoAtendimento) como um objeto vazio para evitar esse tipo de erro:

    const [atendimento, setAtendimento] = useState<AppointmentRequestDTO>({
      id: "", // ou um valor padrão que faz sentido
      status: {
        glossed: false,
        lost: false,
        received: false,
        draft: false,
        validated: false,
        derived: false,
        finished: false,
      },
      related: {
        place: undefined,
        payer: undefined,
        patient: undefined,
      },
      paymentInfo: {
        method: "healthInsurance",
        info: {
          totalSum: 0,
          healthInsurance: {
            cardNumber: "",
          },
          totalValues: {
            expected: 0,
            glossed: 0,
            lost: 0,
            paid: 0,
          },
          totalProcedures: {
            expected: 0,
            glossed: 0,
            lost: 0,
            paid: 0,
          },
        },
      },
      serviceInfo: {
        guideCode: "",
        date: "",
        totalValue: 0,
      },
      procedures: [],
    });
    

    Resumo

    1. Verifique se atendimento é passado corretamente como uma prop.
    2. Adicione verificações para evitar acessar propriedades de um objeto undefined.
    3. Inicialize atendimento no componente pai para garantir que tenha uma estrutura válida.

    Verifique essas sugestões e veja se o problema é resolvido. Se ainda assim enfrentar dificuldades, sinta-se à vontade para compartilhar o que você fez, e vamos continuar a resolver isso!

  13. User

    O atendimento não está definido ou está faltando os procedimentos. handleConfirmEdit @ CardProcedimento.tsx:141 callCallback2 @ chunk-PJEEZAML.js?v=2e2b70d7:3674 invokeGuardedCallbackDev @ chunk-PJEEZAML.js?v=2e2b70d7:3699 invokeGuardedCallback @ chunk-PJEEZAML.js?v=2e2b70d7:3733 invokeGuardedCallbackAndCatchFirstError @ chunk-PJEEZAML.js?v=2e2b70d7:3736 executeDispatch @ chunk-PJEEZAML.js?v=2e2b70d7:7014 processDispatchQueueItemsInOrder @ chunk-PJEEZAML.js?v=2e2b70d7:7034 processDispatchQueue @ chunk-PJEEZAML.js?v=2e2b70d7:7043 dispatchEventsForPlugins @ chunk-PJEEZAML.js?v=2e2b70d7:7051 (anônimo) @ chunk-PJEEZAML.js?v=2e2b70d7:7174 batchedUpdates$1 @ chunk-PJEEZAML.js?v=2e2b70d7:18913 batchedUpdates @ chunk-PJEEZAML.js?v=2e2b70d7:3579 dispatchEventForPluginEventSystem @ chunk-PJEEZAML.js?v=2e2b70d7:7173 dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay @ chunk-PJEEZAML.js?v=2e2b70d7:5478 dispatchEvent @ chunk-PJEEZAML.js?v=2e2b70d7:5472 dispatchDiscreteEvent @ chunk-PJEEZAML.js?v=2e2b70d7:5449

  14. Assistant

    O erro indica que, em algum momento da execução do código no método handleConfirmEdit, o objeto atendimento não está definido ou não contém a propriedade procedures que você está tentando acessar. Vamos resolver isso verificando onde e como atendimento é inicializado e passado para o CardProcedimento.

    Passos para Solução

    1. Confirmar a Inicialização do Atendimento: Certifique-se de que o objeto atendimento está sendo inicializado corretamente no componente pai NovoAtendimento.

    2. Confirmar Qual o Estado do Atendimento no Momento da Edição: Ao obter o atendimento (talvez pela API), certifique-se de que as informações de procedures estão devidamente carregadas.

    3. Verificar o Passagem de Props: Veja se o atendimento está sendo realmente passado corretamente para o CardProcedimento quando você edita.

    4. Adicionar Logging: Para ajudar na depuração, adicione logs que mostram o estado do atendimento antes de usá-lo no CardProcedimento.

    1. Inicialização do Atendimento

    Verifique se o atendimento está sendo inicializado corretamente. Aqui está um exemplo de como deve ser feito:

    const [atendimento, setAtendimento] = useState<AppointmentRequestDTO>({
      id: "", // ou um valor padrão que faça sentido
      status: {
        glossed: false,
        lost: false,
        received: false,
        draft: false,
        validated: false,
        derived: false,
        finished: false,
      },
      related: {
        place: undefined,
        payer: undefined,
        patient: undefined,
      },
      paymentInfo: {
        method: "healthInsurance",
        info: {
          totalSum: 0,
          healthInsurance: {
            cardNumber: "",
          },
          totalValues: {
            expected: 0,
            glossed: 0,
            lost: 0,
            paid: 0,
          },
          totalProcedures: {
            expected: 0,
            glossed: 0,
            lost: 0,
            paid: 0,
          },
        },
      },
      serviceInfo: {
        guideCode: "",
        date: "",
        totalValue: 0,
      },
      procedures: [], // Certifique-se de que este campo é um array, mesmo que esteja vazio inicialmente.
    });
    

    2. Atualizando o Atendimento

    Certifique-se de que os dados estão sendo carregados corretamente quando você está editando. Quando você buscar um atendimento da API, atualize o estado com todos os dados necessários:

    useEffect(() => {
      const fetchAtendimento = async () => {
        try {
          const response = await api.get(`appointments/get/${appointmentId}`);
          const atendimentoDeAPI = response.data.result;
    
          // Certifique-se de ter o atendimento no formato correto
          setAtendimento(atendimentoDeAPI);
        } catch (error) {
          console.error("Erro ao buscar o atendimento:", error);
        }
      };
    
      if (appointmentId) {
        fetchAtendimento();
      }
    }, [appointmentId]);
    

    3. Confirmar a Passagem da Prop

    Na renderização do CardProcedimento, confira se você está passando o atendimento corretamente:

    <CardProcedimento
      key={"procedure_" + proc.id}
      index={index}
      procedure={proc}
      updateProcedimento={updateProcedimento}
      handleExcluir={handleExcluirProcedimento}
      isNewAppointment={true}
      atendimento={atendimento} // Este precisa estar definido corretamente
      onConfirmEdit={(updatedAppointment) => {
        setAtendimento(updatedAppointment);
      }}
    />
    

    4. Adicione Logging

    Adicione logs antes de o atendimento ser utilizado no handleConfirmEdit:

    const handleConfirmEdit = async () => {
      console.log("Atendimento antes da edição:", atendimento); // Debugging
    
      if (!atendimento || !atendimento.procedures) {
        console.error("O atendimento não está definido ou está faltando os procedimentos.");
        return; // Saia da função se o atendimento não estiver definido
      }
    
      // O restante do seu código
    };
    

    Considerações Finais

    Após essas alterações, execute seu código e veja os logs no console. Confira se o atendimento é exibido antes de você tentar acessá-lo, e se sim, quais são os dados que ele contém.

    Se o atendimento for undefined, você pode precisar investigar onde o estado está sendo definido e onde ele pode estar sendo perdido durante as chamadas de função. Se você continuar a ter problemas, forneça detalhes específicos sobre onde e como você está configurando e utilizando o atendimento, e podemos investigar mais a fundo!

  15. User

    esta dando atendimento indefinido, acredito que atendimento: AppointmentRequestDTO; // Nova prop para o objeto de Atendimento nao esta sendo carrecado correto do componente novo atendimento

    import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import React, { useState, useEffect } from "react"; import { useApi } from "../../lib/doctorApi"; import { AppointmentRequestDTO, ProcedureDTO } from "./types"; import DropdownSelect from "./DropdownSelect"; import CardProcedimento from "./CardProcedimento"; import { v4 as uuidv4 } from "uuid"; // Importa a função para gerar UUIDs import { toMoney } from "../utils/FormatedData"; import Anexo from "../ui/Anexo";

    const CoresInput = [ "#25AAE1", // Cor 1 "#8696BB", // Cor 2 "#39465F", // Cor 3 "#D56D98", // Cor 4 ];

    const NovoAtendimento: React.FC = () => { const updateProcedimento = (index: number, novosDados: ProcedureDTO) => { const cloneAtendimento = { ...atendimento }; cloneAtendimento.procedures[index] = novosDados; setAtendimento(cloneAtendimento); };

    const [botaoSalvar, setBotaoSalvar] = useState(""); const enviarDadosAtendimento = async () => { loading; try { const result = await api.post("appointments/create", atendimento);

      if (result?.data?.success) {
        if (
          result.data.result?.id &&
          result.data.result.id !== atendimento.id
        ) {
          const cloneAtendimento = { ...atendimento };
          cloneAtendimento.id = result.data.result.id;
          setAtendimento(cloneAtendimento);
        }
      }
      result?.data?.messages;
      setBotaoSalvar("Salvo");
    } catch (e: any) {
      e?.response?.data?.messages;
      setBotaoSalvar("Salvar");
    }
    setLoading;
    

    }; useEffect(() => { setBotaoSalvar("Salvar"); const queryParams = new URLSearchParams(location.search); const appointmentId = queryParams.get("id"); if (appointmentId) { const fetchAtendimento = async () => { try { const response = await api.get(appointments/get/${appointmentId});

          const atendimento = response.data.result;
          setAtendimento(atendimento);
        } catch (error) {
          console.error("Erro ao buscar paciente:", error);
        }
      };
    
      fetchAtendimento();
    }
    

    }, []);

    const handleAdicionarProcedimento = () => { const novoProcedimento: ProcedureDTO = { id: uuidv4(), createdAt: new Date(), updatedAt: new Date(), cbhpmCode: "", cbhpmName: "", expectedValue: 0, glossedValue: 0, lostValue: 0, paidValue: 0, placeId: atendimento.related.place?.id || "", payerId: atendimento.related.payer?.id || "", patientId: atendimento.related.patient?.id || "", statusOfActivity: "draft", attachments: [], }; const cloneAtendimento = { ...atendimento }; cloneAtendimento.procedures.push(novoProcedimento); setAtendimento(cloneAtendimento); setMostrarCard(true); };

    const handleExcluirProcedimento = (id: string) => { // Filtra o array de procedimentos, mantendo apenas aqueles cujo id não coincide. const novosProcedimentos = atendimento.procedures.filter( (proc) => proc.id !== id );

    // Cria uma cópia do estado de atendimento e atualiza a lista de procedimentos
    setAtendimento((prev) => ({
      ...prev,
      procedures: novosProcedimentos, // Atualiza a lista de procedimentos
    }));
    
    // Opcional: Se existir alguma lógica que dependa da atualização da barra gráfica, você pode chamar:
    

    };

    // Atualiza o localStorage sempre que procedimentos mudar

    const [mostrarCard, setMostrarCard] = useState(false); // Estado para expandir/recolher o Card const [anexos, setAnexos] = useState< { id: string; fileName: string; extension: string }[]

    ([]); // Estado para os arquivos anexados

    const [loading, setLoading] = useState(false); const api = useApi(); // useApi é tratado como estável

    const [atendimento, setAtendimento] = useState({ id: "", status: { glossed: false, lost: false, received: false, draft: false, validated: false, derived: false, finished: false, }, related: { place: undefined, payer: undefined, patient: undefined, }, paymentInfo: { method: "healthInsurance", info: { totalSum: 0, healthInsurance: { cardNumber: "", }, totalValues: { expected: 0, glossed: 0, lost: 0, paid: 0, }, totalProcedures: { expected: 0, glossed: 0, lost: 0, paid: 0, }, }, }, serviceInfo: { guideCode: "", date: "", totalValue: 0, }, procedures: [], });

    const atualizarValoresBarra = () => { const totalProcedures = { expected: 0, glossed: 0, lost: 0, paid: 0, }; const totalValue = { expected: 0, glossed: 0, lost: 0, paid: 0, };

    atendimento.procedures.forEach((proc) => {
      if (proc.expectedValue > 0) {
        totalProcedures.expected += 1; // Incrementa para expectedValue
        totalValue.expected += proc.expectedValue;
      }
      if (proc.glossedValue > 0) {
        totalProcedures.glossed += 1; // Incrementa para glossedValue
        totalValue.glossed += proc.glossedValue;
      }
      if (proc.lostValue > 0) {
        totalProcedures.lost += 1; // Incrementa para lostValue
        totalValue.lost += proc.lostValue;
      }
      if (proc.paidValue > 0) {
        totalProcedures.paid += 1; // Incrementa para paidValue
        totalValue.paid += proc.paidValue;
      }
    });
    const cloneAtendimento = { ...atendimento };
    cloneAtendimento.paymentInfo.info.totalProcedures = totalProcedures;
    cloneAtendimento.paymentInfo.info.totalValues = totalValue;
    cloneAtendimento.paymentInfo.info.totalSum =
      cloneAtendimento.paymentInfo.info.totalValues.expected +
      cloneAtendimento.paymentInfo.info.totalValues.glossed +
      cloneAtendimento.paymentInfo.info.totalValues.lost +
      cloneAtendimento.paymentInfo.info.totalValues.paid;
    
    setAtendimento(cloneAtendimento); // Atualiza o estado dos valores da barra
    

    };

    useEffect(() => { atualizarValoresBarra(); }, [JSON.stringify(atendimento.procedures)]);

    // Função que alterna entre expandir e recolher const alternarCard = () => { setMostrarCard(!mostrarCard); };

    const handleSaveProcedimento = async (procedimento: ProcedureDTO) => { try { const result = await api.post("appointments/procedures/update", { id: atendimento.id, // ID do atendimento procedureId: procedimento.id, // ID do procedimento procedure: procedimento, // Dados atualizados do procedimento });

      if (!result?.data?.success) {
        throw new Error(
          result?.data?.messages || "Erro ao salvar procedimento"
        );
      }
    
      const updatedProcedures = atendimento.procedures.map((proc) =>
        proc.id === procedimento.id ? procedimento : proc
      );
    
      setAtendimento((prev) => ({
        ...prev,
        procedures: updatedProcedures,
      }));
    } catch (error) {
      console.error("Erro ao salvar procedimento:", error);
      throw error;
    }
    

    };

    return ( Cadastro de Atendimento

      <form>
        <div className={EstiloNovoAtendimento.divValores}>
          <div className={EstiloNovoAtendimento.inputValores}>
            <label className={EstiloNovoAtendimento.total}>Total:</label>
            {[
              atendimento.paymentInfo.info.totalValues.expected,
              atendimento.paymentInfo.info.totalValues.glossed,
              atendimento.paymentInfo.info.totalValues.lost,
              atendimento.paymentInfo.info.totalValues.paid,
            ].map((valor, index) => (
              <div key={index}>
                <span
                  style={{
                    color: CoresInput[index],
                    fontSize: "14px",
                    marginRight: "2px",
                  }}
                >
                  R$
                </span>
                <input
                  key={index}
                  type="number"
                  value={valor.toFixed(2)}
                  placeholder="R$ 0,00"
                  style={{ color: CoresInput[index] }}
                  readOnly
                />
              </div>
            ))}
          </div>
    
          <div className={EstiloNovoAtendimento.divBarraGrafico}>
            <label className={EstiloNovoAtendimento.labelTotal}>
              R$ {toMoney(atendimento.paymentInfo.info.totalSum)}
              {/* Aqui já usará o total atualizado */}
            </label>
            <div className={EstiloNovoAtendimento.graficoRepresentativo}>
              <div className={EstiloNovoAtendimento.barraFixa}>
                {[
                  atendimento.paymentInfo.info.totalValues.expected,
                  atendimento.paymentInfo.info.totalValues.glossed,
                  atendimento.paymentInfo.info.totalValues.lost,
                  atendimento.paymentInfo.info.totalValues.paid,
                ].map((valor, index) => {
                  const totalSum = atendimento.paymentInfo.info.totalSum;
                  const isAllZero =
                    atendimento.paymentInfo.info.totalValues.expected === 0 &&
                    atendimento.paymentInfo.info.totalValues.glossed === 0 &&
                    atendimento.paymentInfo.info.totalValues.lost === 0 &&
                    atendimento.paymentInfo.info.totalValues.paid === 0;
    
                  const percentage =
                    totalSum > 0 ? (valor / totalSum) * 100 : 0;
                  const minWidth = 5; // largura mínima em percentual
    
                  // Calcula a largura, levando em conta a largura mínima
                  const width = percentage < minWidth ? minWidth : percentage;
    
                  return (
                    <div
                      key={`grafico-${index}`}
                      style={{
                        backgroundColor: isAllZero
                          ? "transparent"
                          : CoresInput[index],
                        width: `${isAllZero ? 0 : width}%`,
                        height: "100%",
                      }}
                    />
                  );
                })}
              </div>
            </div>
          </div>
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          <div className={EstiloNovoAtendimento.modalidade}>
            <label>Modalidade:</label>
            <div className={EstiloNovoAtendimento.divMargin}>
              <input
                className={EstiloNovoAtendimento.radio}
                type="radio"
                id="convenio"
                name="modalidade"
                value="convenio"
                onChange={() => {
                  setAtendimento((prev) => ({
                    ...prev,
                    paymentInfo: {
                      ...prev.paymentInfo,
                      method: "healthInsurance", // Ou qualquer método que você queira usar
                    },
                  }));
                }}
              />
              <label
                htmlFor="convenio"
                className={EstiloNovoAtendimento.labelModalidade}
              >
                Convênio
              </label>
    
              <input
                className={EstiloNovoAtendimento.radio}
                type="radio"
                id="particular"
                name="modalidade"
                value="particular"
                onChange={() => {
                  setAtendimento((prev) => ({
                    ...prev,
                    paymentInfo: {
                      ...prev.paymentInfo,
                      method: "private", // Atualize para "particular"
                    },
                  }));
                }}
              />
              <label
                htmlFor="particular"
                className={EstiloNovoAtendimento.labelModalidade}
              >
                Particular
              </label>
    
              <input
                className={EstiloNovoAtendimento.radio}
                type="radio"
                id="plantao"
                name="modalidade"
                value="plantao"
                onChange={() => {
                  setAtendimento((prev) => ({
                    ...prev,
                    paymentInfo: {
                      ...prev.paymentInfo,
                      method: "onDuty", // Atualize para "plantao"
                    },
                  }));
                }}
              />
              <label
                htmlFor="plantao"
                className={EstiloNovoAtendimento.labelModalidade}
              >
                Plantão
              </label>
            </div>
          </div>
    
          <DropdownSelect
            endpoint="places/find?skip=0&limit=2000&payer=true" // URL do endpoint
            parseData={(data) =>
              data.result.list.map((local: any) => ({
                id: local.id,
                name: local.name,
              }))
            } // Função que transforma os dados da API no formato { id, name }
            onSelect={(selectedItem) => {
              // Atualizar o estado de atendimento para incluir o payer
              setAtendimento((prev) => ({
                ...prev,
                related: {
                  ...prev.related,
                  payer: { id: selectedItem.id, name: selectedItem.name }, // Assumindo que você quer armazenar um objeto { id, name }
                },
              }));
            }} // Define o item selecionado no estado
            value={atendimento.related.payer?.id || ""} // Valor atual do dropdown
            label="Fonte Pagadora:" // Rótulo a ser exibido
          />
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          {/* TODO: O Componente paciente precisa ter um campo de busca e buscar na api do backend com limite de 10 pacientes */}
          <DropdownSelect
            endpoint="patients/find?skip=0&limit=2000" // URL do endpoint
            parseData={(data) =>
              data.result.list.map((item: any) => ({
                id: item.id,
                name: item.name,
              }))
            } // Função que transforma os dados da API no formato { id, name }
            onSelect={(selectedItem) => {
              // Atualizar o estado de atendimento para incluir o payer
              setAtendimento((prev) => ({
                ...prev,
                related: {
                  ...prev.related,
                  patient: { id: selectedItem.id, name: selectedItem.name }, // Assumindo que você quer armazenar um objeto { id, name }
                },
              }));
            }} // Define o item selecionado no estado
            value={atendimento.related.patient?.id || ""} // Valor atual do dropdown
            label="Paciente:" // Rótulo a ser exibido
          />
    
          <DropdownSelect
            endpoint="places/find?skip=0&limit=2000&place=true" // URL do endpoint para buscar locais de atendimento
            parseData={(data) =>
              data.result.list.map((local: any) => ({
                id: local.id,
                name: local.name,
              }))
            } // Função para transformar os dados da API no formato { id, name }
            onSelect={(selectedItem) => {
              // Atualizar o estado de atendimento para incluir o payer
              setAtendimento((prev) => ({
                ...prev,
                related: {
                  ...prev.related,
                  place: { id: selectedItem.id, name: selectedItem.name }, // Assumindo que você quer armazenar um objeto { id, name }
                },
              }));
            }} // Callback para atualizar o formulário com o local selecionado
            value={atendimento.related.place?.id || ""} // ID do item selecionado
            label="Local de Atendimento:" // Rótulo exibido
          />
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          <div className={EstiloNovoAtendimento.organizador}>
            <span>Código da guia(opcional)</span>
            <input
              className={EstiloNovoAtendimento.input300}
              type="text"
              name="codigo"
              placeholder="Digite"
              value={atendimento.serviceInfo.guideCode}
              onChange={(e) => {
                const codigo = e.target.value;
    
                // Atualiza o estado de atendimento com o código da guia
                setAtendimento((prev) => ({
                  ...prev,
                  serviceInfo: {
                    ...prev.serviceInfo,
                    guideCode: codigo, // Atualiza o guideCode com o valor do input
                  },
                }));
              }}
            />
          </div>
          <div className={EstiloNovoAtendimento.organizador}>
            <span>Data</span>
            <input
              className={EstiloNovoAtendimento.inputData}
              type="date"
              name="data"
              placeholder="dd/mm/yyyy"
              value={atendimento.createdAt?.toISOString()}
              onChange={(e) => {
                const data = e.target.value;
    
                setAtendimento((prev) => ({
                  ...prev,
                  serviceInfo: {
                    ...prev.serviceInfo,
                    date: data,
                  },
                }));
              }}
            />
          </div>
        </div>
      </form>
      {/* deveria ficar aqui */}
      <div className={EstiloNovoAtendimento.divbutton}>
        <button
          type="button" // tipo "button" para evitar o envio do formulário
          onClick={handleAdicionarProcedimento} // Chama a função ao clicar
          className={EstiloNovoAtendimento.buttonProcedimento}
        >
          Adicionar Procedimento
        </button>
      </div>
    
      {/* Segunda barra gráfica com funcionalidade ajustada */}
      <div className={EstiloNovoAtendimento.divValores2}>
        <div className={EstiloNovoAtendimento.inputProcedimentos}>
          {[
            atendimento.paymentInfo.info.totalProcedures.expected,
            atendimento.paymentInfo.info.totalProcedures.glossed,
            atendimento.paymentInfo.info.totalProcedures.lost,
            atendimento.paymentInfo.info.totalProcedures.paid,
          ].map((valor, index) => (
            <input
              key={index}
              type="number"
              value={valor.toFixed(0)} // Mostra a contagem
              placeholder="0"
              readOnly // Barra apenas visual, não editável
              style={{ color: CoresInput[index] }} // Cor correspondente à respectiva
            />
          ))}
        </div>
    
        <div className={EstiloNovoAtendimento.divBarraGrafico}>
          <div className={EstiloNovoAtendimento.divTotal}>
            <img
              src="/procedimento.png"
              alt=""
              className={EstiloNovoAtendimento.icone}
            />
            <label className={EstiloNovoAtendimento.labelProcedimento}>
              <label>{atendimento.procedures.length}</label> Procedimento
            </label>
          </div>
          <div className={EstiloNovoAtendimento.graficoRepresentativo}>
            <div className={EstiloNovoAtendimento.barraFixa}>
              {[
                atendimento.paymentInfo.info.totalProcedures.expected,
                atendimento.paymentInfo.info.totalProcedures.glossed,
                atendimento.paymentInfo.info.totalProcedures.lost,
                atendimento.paymentInfo.info.totalProcedures.paid,
              ].map((valor, index) => {
                const totalSum = atendimento.paymentInfo.info.totalSum;
                const isAllZero =
                  atendimento.paymentInfo.info.totalProcedures.expected === 0 &&
                  atendimento.paymentInfo.info.totalProcedures.glossed === 0 &&
                  atendimento.paymentInfo.info.totalProcedures.lost === 0 &&
                  atendimento.paymentInfo.info.totalProcedures.paid === 0;
    
                const percentage = totalSum > 0 ? (valor / totalSum) * 100 : 0;
                const minWidth = 5; // largura mínima em percentual
    
                // Calcula a largura, levando em conta a largura mínima
                const width = percentage < minWidth ? minWidth : percentage;
    
                return (
                  <div
                    key={`grafico-${index}`}
                    style={{
                      backgroundColor: isAllZero
                        ? "transparent"
                        : CoresInput[index],
                      width: `${isAllZero ? 0 : width}%`,
                      height: "100%",
                    }}
                  />
                );
              })}
            </div>
          </div>
          {/* Botão de expandir/recolher */}
          <div
            className={EstiloNovoAtendimento.expandirProcedimentos}
            onClick={alternarCard}
          >
            <img
              src="/setaBaixo.png"
              alt="Expandir/recolher"
              className={EstiloNovoAtendimento.iconSeta}
            />
            <label className={EstiloNovoAtendimento.labelExpandir}>
              {mostrarCard ? "Recolher" : "Expandir"}
            </label>
          </div>
        </div>
      </div>
    
      {/* Renderiza o Card apenas se mostrarCard for true */}
      {mostrarCard && (
        <>
          {atendimento.procedures.map((proc, index) => (
            <CardProcedimento
              key={"procedure_" + proc.id}
              index={index}
              procedure={proc}
              updateProcedimento={updateProcedimento}
              handleExcluir={handleExcluirProcedimento}
              isNewAppointment={true}
              atendimento={atendimento} // Passando o objeto de atendimento
              onConfirmEdit={(updatedAppointment) => {
                setAtendimento(updatedAppointment); // Aqui você atualiza seu estado de atendimento
              }}
            />
          ))}
        </>
      )}
      <Anexo
        attachments={atendimento.attachments || []}
        setAttachments={(novosAnexos) => {
          setAtendimento((prev) => ({
            ...prev,
            attachments: novosAnexos,
          }));
        }}
      />
    
      <div className={EstiloNovoAtendimento.divbutton}>
        <button
          className={EstiloNovoAtendimento.buttonSalvar}
          disabled={loading}
          onClick={enviarDadosAtendimento}
        >
          {loading ? "Salvando" : "Salvar"}
        </button>
      </div>
    </div>
    

    ); };

    export default NovoAtendimento;

    // CardProcedimento.tsx import React, { useEffect, useState } from "react"; import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import { AppointmentRequestDTO, ProcedureDTO } from "./types"; import Anexo from "../ui/Anexo"; import { useApi } from "../../lib/doctorApi";

    interface Procedimento { procedure: ProcedureDTO; index: number; handleExcluir: (id: string) => void; updateProcedimento: (index: number, novosDados: ProcedureDTO) => void; onConfirmEdit: (updatedAppointment: AppointmentRequestDTO) => void; // Atualizando a função isNewAppointment?: boolean; atendimento: AppointmentRequestDTO; // Nova prop para o objeto de Atendimento }

    const CardProcedimento: React.FC = ({ procedure, index, updateProcedimento, handleExcluir, onConfirmEdit, atendimento, isNewAppointment = false, }) => { const [procedimento, setProcedimento] = useState({ ...procedure, }); const [expectedValue, setExpectedValue] = useState(""); const [glossedValue, setGlossedValue] = useState(""); const [paidValue, setPaidValue] = useState(""); const [lostValue, setLostValue] = useState(""); const [isEditing, setIsEditing] = useState(false); const [tempProcedimento, setTempProcedimento] = useState({ ...procedure, });

    const api = useApi(); // useApi é tratado como estável. const [error, setError] = useState<string | null>(null);

    const dataChange: { [key: string]: Function } = { expectedValue: setExpectedValue, glossedValue: setGlossedValue, paidValue: setPaidValue, lostValue: setLostValue, };

    useEffect(() => { setProcedimento({ ...procedure }); setTempProcedimento({ ...procedure }); }, []);

    useEffect(() => { if (!isEditing && !isNewAppointment) { updateProcedimento(index, procedimento); } }, [procedimento, isEditing, isNewAppointment]);

    useEffect(() => { if (isNewAppointment) { setIsEditing(true); } }, [isNewAppointment]);

    // Mapeamento de status const statusMap: { [key: string]: string } = { draft: "Rascunho", glossed: "Glosado", validated: "Validado", toDerive: "Para Faturar", derived: "Faturado", lost: "Perdido", finished: "Finalizado", };

    const handleTextChange = (e: React.ChangeEvent) => { const { name, value } = e.target;

    if (isEditing || isNewAppointment) {
      setTempProcedimento((prev) => ({
        ...prev,
        [name]: value,
      }));
    } else {
      setProcedimento((prev) => ({
        ...prev,
        [name]: value,
      }));
    }
    

    };

    const handleValueChange = (e: React.ChangeEvent) => { const inputValue = e.target.value; const name = e.target.name;

    let numericValue = inputValue.replace(/\D/g, "");
    if (numericValue === "") {
      numericValue = "0";
    }
    
    const formattedValue = (parseFloat(numericValue) / 100)
      .toFixed(2)
      .replace(".", ",");
    
    if (dataChange[name]) {
      dataChange[name](formattedValue);
    }
    
    const parsedValue = parseFloat(
      formattedValue.toString().split(".").join("").split(",").join(".")
    );
    
    if (isEditing || isNewAppointment) {
      setTempProcedimento((prev) => ({
        ...prev,
        [name]: parsedValue,
      }));
    } else {
      setProcedimento((prev) => ({
        ...prev,
        [name]: parsedValue,
      }));
    }
    

    };

    const { statusOfActivity = [] } = procedure; // Desestruturação com valor padrão

    const handleStartEdit = () => { if (!isNewAppointment && isEditing) { handleCancelEdit(); } else { setTempProcedimento({ ...procedimento }); setIsEditing(true); } };

    const handleConfirmEdit = async () => { console.log("Atendimento antes da edição:", atendimento); // Debugging

    // Verifique se atendimento não está undefined
    if (!atendimento || !atendimento.procedures) {
      console.error(
        "O atendimento não está definido ou está faltando os procedimentos."
      );
      return;
    }
    
    setProcedimento(tempProcedimento);
    updateProcedimento(index, tempProcedimento); // Atualiza a lista local
    
    // Mantendo a construção do updatedAppointment
    const updatedAppointment: AppointmentRequestDTO = {
      ...atendimento,
      procedures: atendimento.procedures.map((p) =>
        p.id === tempProcedimento.id ? tempProcedimento : p
      ),
    };
    
    // Se necessário, você pode atualizar o estado de atendimento no componente pai aqui
    onConfirmEdit(updatedAppointment);
    
    try {
      const requestData = {
        ...atendimento, // Inclui todo o atendimento
        id: atendimento.id, // Passa o ID do atendimento para a URL
        procedures: updatedAppointment.procedures, // Passa os procedimentos atualizados
      };
    
      const response = await api.post(
        `appointments/${atendimento.id}/update`, // A URL que utiliza o ID do atendimento
        requestData
      );
    
      console.log(
        "Procedimento e atendimento atualizados com sucesso:",
        response.data
      );
    } catch (error) {
      console.error("Erro ao atualizar procedimento:", error);
      setError(error instanceof Error ? error.message : "Erro desconhecido");
    }
    
    setIsEditing(false);
    

    };

    const handleCancelEdit = () => { setTempProcedimento({ ...procedimento }); setIsEditing(false); };

    return ( ID {!isNewAppointment && ( <button onClick={handleStartEdit} className={isEditing ? EstiloNovoAtendimento.editing : ""} > <button onClick={() => handleExcluir(procedure.id)} disabled={isEditing} > )}

      <div className={EstiloNovoAtendimento.divDoCard}>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Código personalizado da CBHPM</span>
          <input
            className={`${EstiloNovoAtendimento.inputCard} ${
              isEditing || isNewAppointment ? EstiloNovoAtendimento.editing : ""
            }`}
            type="text"
            name="cbhpmCode"
            value={
              isEditing ? tempProcedimento.cbhpmCode : procedimento.cbhpmCode
            }
            placeholder="Digite o Código..."
            disabled={!isEditing && !isNewAppointment}
            onChange={handleTextChange}
          />
        </div>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Nome personalizado da CBHPM</span>
          <input
            className={`${EstiloNovoAtendimento.inputCard} ${
              isEditing || isNewAppointment ? EstiloNovoAtendimento.editing : ""
            }`}
            type="text"
            name="cbhpmName"
            value={
              isEditing ? tempProcedimento.cbhpmName : procedimento.cbhpmName
            }
            placeholder="Digite o Nome..."
            disabled={!isEditing && !isNewAppointment}
            onChange={handleTextChange}
          />
        </div>
    
        <div className={EstiloNovoAtendimento.divflex}>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Previsto
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="expectedValue"
              value={
                isEditing
                  ? tempProcedimento.expectedValue
                  : procedimento.expectedValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Glosado
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="glossedValue"
              value={
                isEditing
                  ? tempProcedimento.glossedValue
                  : procedimento.glossedValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Perdido
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="lostValue"
              value={
                isEditing ? tempProcedimento.lostValue : procedimento.lostValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Pago
            </label>
            <input
              className={`${EstiloNovoAtendimento.inputValor234} ${
                isEditing || isNewAppointment
                  ? EstiloNovoAtendimento.editing
                  : ""
              }`}
              type="text"
              name="paidValue"
              value={
                isEditing ? tempProcedimento.paidValue : procedimento.paidValue
              }
              placeholder=""
              disabled={!isEditing && !isNewAppointment}
              onChange={handleValueChange}
            />
          </div>
        </div>
    
        <Anexo
          attachments={
            isEditing ? tempProcedimento.attachments : procedimento.attachments
          }
          setAttachments={(novosAnexos) => {
            if (isEditing) {
              setTempProcedimento((prev) => ({
                ...prev,
                attachments: novosAnexos,
              }));
            } else {
              setProcedimento((prev) => ({
                ...prev,
                attachments: novosAnexos,
              }));
            }
          }}
        />
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de pagamento:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {procedure.expectedValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Previsto
            </label>
          )}
          {procedure.glossedValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Glosado
            </label>
          )}
          {procedure.paidValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              valor Pago
            </label>
          )}
          {procedure.lostValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Valor Perdido
            </label>
          )}
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de atividade:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {Object.keys(statusMap).map((statusItem) => (
            <label
              key={statusItem}
              className={`${EstiloNovoAtendimento.labelBorda}`}
            >
              <input
                type="checkbox"
                className={EstiloNovoAtendimento.customCheckbox}
                value={statusItem}
                checked={
                  isEditing
                    ? tempProcedimento.statusOfActivity === statusItem
                    : statusOfActivity === statusItem
                }
                disabled={!isEditing && !isNewAppointment}
                onChange={(e) => {
                  const isChecked = e.target.checked;
                  if (isEditing || isNewAppointment) {
                    setTempProcedimento((prev) => ({
                      ...prev,
                      statusOfActivity: isChecked
                        ? (statusItem as ProcedureDTO["statusOfActivity"])
                        : "draft",
                    }));
                  } else {
                    setProcedimento((prev) => ({
                      ...prev,
                      statusOfActivity: isChecked
                        ? (statusItem as ProcedureDTO["statusOfActivity"])
                        : "draft",
                    }));
                    updateProcedimento(index, {
                      ...procedure,
                      statusOfActivity: isChecked
                        ? (statusItem as ProcedureDTO["statusOfActivity"])
                        : "draft",
                    });
                  }
                }}
              />
              <span
                className={`${EstiloNovoAtendimento.labelAtividade} ${
                  isEditing || isNewAppointment
                    ? EstiloNovoAtendimento.editing
                    : ""
                }`}
              >
                {statusMap[statusItem]}
              </span>
            </label>
          ))}
        </div>
      </div>
      {isEditing && !isNewAppointment && (
        <div className={EstiloNovoAtendimento.CardBotton}>
          <div className={EstiloNovoAtendimento.botoesEdicao}>
            <button
              onClick={handleConfirmEdit}
              className={EstiloNovoAtendimento.botaoConfirmar}
            >
              Confirmar
            </button>
            <button
              onClick={handleCancelEdit}
              className={EstiloNovoAtendimento.botaoCancelar}
            >
              Cancelar
            </button>
          </div>
        </div>
      )}
    </div>
    

    ); };

    export default CardProcedimento;

  16. Assistant

    Se o atendimento está undefined, isso significa que há um problema em como o estado do atendimento está sendo definido ou passado para o componente CardProcedimento. Vamos revisar algumas áreas para garantir que tudo esteja funcionando corretamente:

    Passos para Diagnosticar e Resolver o Problema

    1. Verificar a Carregamento do Atendimento: Certifique-se de que o atendimento está sendo carregado corretamente da API.

    2. Adicione um Estado de Carregamento para o Atendimento: Para garantir que a aplicação não tente renderizar componentes antes que os dados tenham sido carregados, você pode usar um estado de carregamento.

    3. Verifique se o Atendimento É Passado Corretamente como Prop: Confirme que está tudo certo na passagem do atendimento como prop para o componente CardProcedimento.

    4. Adicionar Lógica de Verificação: Para garantir que não estamos tentando acessar atendimento se ele estiver indefinido.

    1. Verifique a Carregamento do Atendimento

    A função que busca o atendimento deve estar funcionando corretamente e atualizando o estado. Aqui está uma atualização na função para garantir que o estado está sendo definido:

    useEffect(() => {
      const queryParams = new URLSearchParams(location.search);
      const appointmentId = queryParams.get("id");
      if (appointmentId) {
        const fetchAtendimento = async () => {
          try {
            const response = await api.get(`appointments/get/${appointmentId}`);
            const atendimentoDeAPI = response.data.result;
    
            // Verifique se o atendimento está com a estrutura correta
            if (atendimentoDeAPI) {
              setAtendimento(atendimentoDeAPI);
            } else {
              console.error("Atendimento não encontrado na resposta da API.");
            }
          } catch (error) {
            console.error("Erro ao buscar o atendimento:", error);
          }
        };
    
        fetchAtendimento();
      }
    }, []);
    

    2. Adicione um Estado de Carregamento para o Atendimento

    É comum usar um estado de carregamento para evitar tentar renderizar componentes que dependem de dados que ainda não foram carregados:

    const [loadingAtendimento, setLoadingAtendimento] = useState(true);
    
    useEffect(() => {
      const queryParams = new URLSearchParams(location.search);
      const appointmentId = queryParams.get("id");
      if (appointmentId) {
        const fetchAtendimento = async () => {
          try {
            const response = await api.get(`appointments/get/${appointmentId}`);
            setAtendimento(response.data.result);
            setLoadingAtendimento(false); // Defina o carregamento como falso após obter os dados
          } catch (error) {
            console.error("Erro ao buscar o atendimento:", error);
            setLoadingAtendimento(false); // Pare o carregamento mesmo em caso de erro
          }
        };
    
        fetchAtendimento();
      } else {
        setLoadingAtendimento(false); // Pare o carregamento se não houver ID
      }
    }, []);
    

    3. Verifique a Passagem de Props

    Certifique-se de verificar onde o CardProcedimento é chamado e que atendimento está definido:

    {!loadingAtendimento && atendimento && 
      atendimento.procedures.map((proc, index) => (
        <CardProcedimento
          key={"procedure_" + proc.id}
          index={index}
          procedure={proc}
          updateProcedimento={updateProcedimento}
          handleExcluir={handleExcluirProcedimento}
          isNewAppointment={true}
          atendimento={atendimento} // Passando o atendimento corretamente
          onConfirmEdit={(updatedAppointment) => {
            setAtendimento(updatedAppointment);
          }}
        />
    ))}
    

    4. Adicionar Lógica de Verificação

    Adicione verificações antes de acessar as propriedades de atendimento:

    const handleConfirmEdit = async () => {
      console.log("Atendimento antes da edição:", atendimento); // Log para debug
    
      // Adicione uma verificação adicional para garantir que atendimento e procedimentos estão definidos
      if (!atendimento || !atendimento.procedures) {
        console.error("O atendimento não está definido ou não contém procedimentos.");
        return; // Não continue se não houver atendimento
      }
    
      // Continuar com o processo de confirmação da edição aqui...
    };
    

    Conclusão

    Assegurando-se de que o estado do atendimento é corretamente carregado e passando isso como prop para seus componentes, você deve conseguir evitar que atendimento seja undefined. Ao adicionar uma verificação para que o UI não tente renderizar o componente antes de os dados serem carregados, você deve prevenir erros de acesso.

    Se o problema persistir, verifique o fluxo de dados e o estado durante a sua aplicação, e sinta-se à vontade para compartilhar mais detalhes se precisar de mais ajuda!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.