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

import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import React, {…

  1. User

    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 { error } from "console"; 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) => { console.log(index, novosDados); const cloneAtendimento = { ...atendimento }; cloneAtendimento.procedures[index] = novosDados; setAtendimento(cloneAtendimento); };

    const enviarDadosAtendimento = async () => { 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); } console.log("dados enviados", result); } result?.data?.messages; console.log("atendimento criado comm sucesso", result); } catch (e: any) { e?.response?.data?.messages; console.log("erro ao criar atendimento", e); } }; 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 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); };

    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) => (
                  <div
                    key={`grafico-${index}`}
                    style={{
                      backgroundColor: CoresInput[index],
                      width:
                        atendimento.paymentInfo.info.totalSum > 0
                          ? `${
                              (valor / atendimento.paymentInfo.info.totalSum) *
                              100
                            }%`
                          : `0%`,
                      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) => (
                <div
                  key={`grafico-segunda-${index}`}
                  style={{
                    backgroundColor: CoresInput[index],
                    width: `${(valor / atendimento.procedures.length) * 100}%`, // Ajuste a largura da barra conforme a contagem
                    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 && (
        <>
          {/* Renderiza os procedimentos adicionados */}
          {atendimento.procedures.map((proc, index) => (
            <CardProcedimento
              key={"procedure_" + proc.id}
              index={index} // Usando o índice corretamente
              procedure={proc}
              updateProcedimento={updateProcedimento}
              handleExcluir={handleExcluirProcedimento}
            />
          ))}
        </>
      )}
      <Anexo
        attachments={atendimento.attachments || []}
        setAttachments={(novosAnexos) => {
          const cloneAtendimento = { ...atendimento };
          cloneAtendimento.attachments = [
            ...(cloneAtendimento.attachments || []),
            ...novosAnexos,
          ];
          setAtendimento(cloneAtendimento);
        }}
      />
    
      <div className={EstiloNovoAtendimento.divbutton}>
        <button
          className={EstiloNovoAtendimento.buttonSalvar}
          onClick={enviarDadosAtendimento}
        >
          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";

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

    const CardProcedimento: React.FC = ({ procedure, index, updateProcedimento, handleExcluir, // Recebe a função de exclusão }) => { const [procedimento, setProcedimento] = useState({ ...procedure, }); const [expectedValue, setExpectedValue] = useState(""); const [glossedValue, setGlossedValue] = useState(""); const [paidValue, setPaidValue] = useState(""); const [lostValue, setLostValue] = useState("");

    const dataChange: { [key: string]: Function } = { expectedValue: setExpectedValue, glossedValue: setGlossedValue, paidValue: setPaidValue, lostValue: setLostValue, }; useEffect(() => { updateProcedimento(index, procedimento); console.log("card Procedimento", procedimento); }, [procedimento]); // Mapeamento de status const statusMap: { [key: string]: string } = { draft: "Rascunho", readyToValidate: "Pronto para Validação", validated: "Validado", toDerive: "Para Faturar", derived: "Faturado", finished: "Finalizado", }; const handleValueChange = (e: React.ChangeEvent) => { const inputValue = e.target.value; const name = e.target.name; // Pega o nome da propriedade do input

    // Remove tudo que não for dígito ou vírgula
    let numericValue = inputValue.replace(/\D/g, "");
    
    if (numericValue === "") {
      numericValue = "0";
    }
    
    const formattedValue = (parseFloat(numericValue) / 100)
      .toFixed(2)
      .replace(".", ",");
    
    if (dataChange[name]) {
      dataChange[name](formattedValue);
    }
    // Atualiza o estado com o valor formatado
    setProcedimento((prevProcedimento) => ({
      ...prevProcedimento,
      [name]: parseFloat(
        formattedValue.toString().split(".").join("").split(",").join(".")
      ), // Atualiza a propriedade com base no name
    }));
    

    };

    const { statusOfActivity = [] } = procedure; // Desestruturação com valor padrão return ( ID <button onClick={() => handleExcluir(procedure.id)}> {" "} {/* Chama a função de exclusão ao clicar */}

      <div className={EstiloNovoAtendimento.divDoCard}>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Código personalizado da CBHPM</span>
          <input
            className={EstiloNovoAtendimento.inputCard}
            type="text"
            value={procedimento.cbhpmCode} // Mantendo o valor armazenado
            placeholder="Digite o Código..."
            onChange={(e) => {
              const value = e.target.value;
              setProcedimento((prevProcedimento) => ({
                ...prevProcedimento,
                cbhpmCode: value,
              }));
            }}
          />
        </div>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Nome personalizado da CBHPM</span>
          <input
            className={EstiloNovoAtendimento.inputCard}
            type="text"
            value={procedimento.cbhpmName} // Mantendo o valor armazenado
            placeholder="Digite o Nome..."
            onChange={(e) => {
              const value = e.target.value;
              setProcedimento((prevProcedimento) => ({
                ...prevProcedimento,
                cbhpmName: value,
              }));
            }}
          />
        </div>
    
        <div className={EstiloNovoAtendimento.divflex}>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Previsto
            </label>
            <input
              className={EstiloNovoAtendimento.inputValor234}
              type="text"
              name="expectedValue"
              value={expectedValue} // Valor editável
              placeholder=""
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Glosado
            </label>
            <input
              className={EstiloNovoAtendimento.inputValor234}
              type="text"
              name="glossedValue"
              value={glossedValue} // Valor editável
              placeholder=""
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Perdido
            </label>
            <input
              className={EstiloNovoAtendimento.inputValor234}
              type="text"
              name="lostValue"
              value={lostValue} // Valor editável
              placeholder=""
              onChange={handleValueChange}
            />
          </div>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Pago
            </label>
            <input
              className={EstiloNovoAtendimento.inputValor234}
              type="text"
              name="paidValue"
              value={paidValue} // Valor editável
              placeholder=""
              onChange={handleValueChange}
            />
          </div>
        </div>
    
        <Anexo
          attachments={procedimento.attachments}
          setAttachments={(novosAnexos) => {
            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={statusOfActivity === statusItem} // Verifica se o status está incluído
                onChange={(e) => {
                  const isChecked = e.target.checked;
                  updateProcedimento(index, {
                    ...procedure,
                    statusOfActivity: isChecked
                      ? (statusItem as ProcedureDTO["statusOfActivity"])
                      : "draft", // Usar o valor em inglês
                  });
                }}
              />
              <span className={EstiloNovoAtendimento.labelAtividade}>
                {statusMap[statusItem]} {/* Exibe o label em português */}
              </span>
            </label>
          ))}
        </div>
      </div>
      <div className={EstiloNovoAtendimento.CardBotton}></div>
    </div>
    

    ); };

    export default CardProcedimento; 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[]; }

    preciso de um componente card de atendimentos, onde sera renderizado os dados do atendimento como patientid, place, payer, cada procedure incluido e as barras dinamicas com os valores de expectedvalue etc, com base neste modelo

    <div className={styles.cardsAtendimentos}>
        {/* Card */}
        <div className={styles.CardPai}>
          <div className={styles.CardTopPai}>
            <div className={styles.buttonCard}>
              <button>
                <img
                  src="/lapisEditor.png"
                  alt="Editar"
                  className={styles.icon}
                />
              </button>
            </div>
          </div>
          <div className={styles.divDoCardPai}>
            {/*barra*/}
            <div className={styles.divValores}>
              <div className={styles.inputValores}>
                <label className={styles.total}>Total:</label>
                {valores.map((valor, index) => (
                  <div key={index}>
                    <span
                      style={{
                        color: CoresInput[index],
                        fontSize: "14px",
                        marginRight: "2px",
                      }}
                    >
                      R$
                    </span>
                    <input
                      type="number"
                      value={valor.toFixed(2)} // Formatação inicial como "0.00"
                      placeholder="R$ 0,00" // Placeholder antes de digitar
                      style={{ color: CoresInput[index] }}
                      onChange={(e) => handleInputChange(index, e.target.value)}
                    />
                  </div>
                ))}
              </div>
              <div className={styles.divBarraGrafico}>
                <label className={styles.labelTotal}>
                  R$ {total.toFixed(2)}
                </label>
                <div className={styles.graficoRepresentativo}>
                  <div className={styles.barraFixa}>
                    {valores.map((valor, index) => (
                      <div
                        key={`grafico-${index}`}
                        style={{
                          backgroundColor: CoresInput[index],
                          width: total > 0 ? `${(valor / total) * 100}%` : `0%`,
                          height: "100%",
                        }}
                      />
                    ))}
                  </div>
                </div>
              </div>
            </div>
          </div>
          <div className={styles.divInformacoes}>
            <div className={styles.divDados}>
              <label className={styles.labelData}>03/09/2023</label>
              <label className={styles.labelPaciente}>
                José Gomes da Silva Oliveira
              </label>
            </div>
            <div className={styles.divRow}>
              <label className={styles.labelLocais}>
                <img src="cifrao.png" className={styles.icons} alt="" />
                modalidade: Convenio
              </label>
              <label className={styles.labelLocais}>
                <img src="cifrao.png" className={styles.icons} alt="" />
                Fonte Pagadora: Amil Saúde do Estado de Minas Gerais
              </label>
            </div>
            <div className={styles.divRow}>
              <label className={styles.labelLocais}>
                <img src="local-icon.png" alt="" className={styles.icons} />
                Local: Hospital das Clínicas Av Abril Bairro Saúde
              </label>
            </div>
            <div className={styles.divBarra} />
          </div>
          {/* Segunda barra gráfica com funcionalidade ajustada */}
          <div className={styles.divValores2}>
            <div className={styles.inputProcedimentos}>
              {valores.map((valor, index) => (
                <input
                  key={index}
                  type="number"
                  value={(valor > 0 ? 1 : 0).toFixed(0)} // Mostra "1" ou "0"
                  placeholder="0"
                  readOnly // Barra apenas visual, não editável
                  style={{ color: CoresInput[index] }} // Cor correspondente à respectiva
                />
              ))}
            </div>
    
            <div className={styles.divBarraGrafico}>
              <div className={styles.divTotal}>
                <img src="/procedimento.png" alt="" />
                <label>Procedimento</label>
              </div>
              <div className={styles.graficoRepresentativo}>
                <div className={styles.barraFixa}>
                  {valores.map((valor, index) => (
                    <div
                      key={`grafico-segunda-${index}`}
                      style={{
                        backgroundColor: CoresInput[index],
                        width: "25%", // Faixas fixas em 25% cada
                        height: "100%",
                      }}
                    />
                  ))}
                </div>
              </div>
              {/* Botão de expandir/recolher */}
              <div
                className={styles.expandirProcedimentos}
                onClick={alternarCard}
              >
                <img
                  src="/setaBaixo.png"
                  alt="Expandir/recolher"
                  className={styles.iconSeta}
                />
                <label className={styles.labelExpandir}>
                  {mostrarCard ? "Recolher" : "Expandir"}
                </label>
              </div>
            </div>
          </div>
          {/* Renderiza o Card apenas se mostrarCard for true */}
          {mostrarCard && (
            <>
              <div className={styles.Card}>
                <div className={styles.CardTop}>
                  <div>
                    <span>#1</span>
                  </div>
                  <div className={styles.buttonCard}>
                    <button>
                      <img
                        src="/lapisEditor.png"
                        alt="Editar"
                        className={styles.icon}
                      />
                    </button>
                    <button>
                      <img
                        src="/lixeira.png"
                        alt="Excluir"
                        className={styles.icon}
                      />
                    </button>
                  </div>
                </div>
    
                <div className={styles.divDoCard}>
                  <div className={styles.organizadorCard}>
                    <span>Código personalizado da CBHPM</span>
                    <input className={styles.inputCard}></input>
                  </div>
                  <div className={styles.organizadorCard}>
                    <span>Nome personalizado da CBHPM</span>
                    <input className={styles.inputCard}></input>
                  </div>
    
                  <div className={styles.divflex}>
                    <div className={styles.valores}>
                      <label className={styles.labelinput}>
                        Valor Previsto
                      </label>
                      <input className={styles.inputValor1}></input>
                    </div>
                    <div className={styles.valores}>
                      <label className={styles.labelinput}>Valor Glosado</label>
                      <input className={styles.inputValor234}></input>
                    </div>
                    <div className={styles.valores}>
                      <label className={styles.labelinput}>Valor Perdido</label>
                      <input className={styles.inputValor234}></input>
                    </div>
                    <div className={styles.valores}>
                      <label className={styles.labelinput}>Valor Pago</label>
                      <input className={styles.inputValor234}></input>
                    </div>
                  </div>
    
                  <div className={styles.divAnexo}>
                    <label className={styles.labelStatus}>Anexos:</label>
                    <button className={styles.anexar}>
                      <img src="/+.png" alt="" className={styles.iconAnexar} />
                      <i>Adicionar Novo Anexo</i>
                    </button>
                  </div>
    
                  <label className={styles.labelStatus}>
                    Status de pagamento:
                  </label>
                  <div className={styles.divflex}>
                    <label className={styles.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={styles.iconStatus}
                      />
                      Glosado
                    </label>
                    <label className={styles.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={styles.iconStatus}
                      />
                      Perdido
                    </label>
                    <label className={styles.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={styles.iconStatus}
                      />
                      Recebidos
                    </label>
                  </div>
    
                  <label className={styles.labelStatus}>
                    Status de atividade:
                  </label>
                  <div className={styles.divflex}>
                    <label htmlFor="validar" className={styles.labelBorda}>
                      <input
                        type="radio"
                        id="validar"
                        name="Status"
                        value="validar"
                      />
                      Pronto pra validar
                    </label>
                    <label htmlFor="Validado" className={styles.labelBorda}>
                      <input
                        type="radio"
                        id="Validado"
                        name="Status"
                        value="Validado"
                      />
                      Validado
                    </label>
                    <label htmlFor="faturar" className={styles.labelBorda}>
                      <input
                        type="radio"
                        id="faturar"
                        name="Status"
                        value="aturar"
                      />
                      À faturar
                    </label>
                    <label htmlFor="Entregue" className={styles.labelBorda}>
                      <input
                        type="radio"
                        id="Entregue"
                        name="Status"
                        value="Entregue"
                      />
                      Entregue
                    </label>
                    <label htmlFor="Finalizado" className={styles.labelBorda}>
                      <input
                        type="radio"
                        id="Finalizado"
                        name="Status"
                        value="Finalizado"
                      />
                      Finalizado
                    </label>
                  </div>
                </div>
    
                <div className={styles.CardBotton}></div>
              </div>
    
              <div className={styles.Card}>
                <div className={styles.CardTop}>
                  <div>
                    <span>#1</span>
                  </div>
                  <div className={styles.buttonCard}>
                    <button>
                      <img
                        src="/lapisEditor.png"
                        alt="Editar"
                        className={styles.icon}
                      />
                    </button>
                    <button>
                      <img
                        src="/lixeira.png"
                        alt="Excluir"
                        className={styles.icon}
                      />
                    </button>
                  </div>
                </div>
    
                <div className={styles.divDoCard}>
                  <div className={styles.organizadorCard}>
                    <span>Código personalizado da CBHPM</span>
                    <input className={styles.inputCard}></input>
                  </div>
                  <div className={styles.organizadorCard}>
                    <span>Nome personalizado da CBHPM</span>
                    <input className={styles.inputCard}></input>
                  </div>
    
                  <div className={styles.divflex}>
                    <div className={styles.valores}>
                      <label className={styles.labelinput}>
                        Valor Previsto
                      </label>
                      <input className={styles.inputValor1}></input>
                    </div>
                    <div className={styles.valores}>
                      <label className={styles.labelinput}>Valor Glosado</label>
                      <input className={styles.inputValor234}></input>
                    </div>
                    <div className={styles.valores}>
                      <label className={styles.labelinput}>Valor Perdido</label>
                      <input className={styles.inputValor234}></input>
                    </div>
                    <div className={styles.valores}>
                      <label className={styles.labelinput}>Valor Pago</label>
                      <input className={styles.inputValor234}></input>
                    </div>
                  </div>
    
                  <div className={styles.divAnexo}>
                    <label className={styles.labelStatus}>Anexos:</label>
                    <button className={styles.anexar}>
                      <img src="/+.png" alt="" className={styles.iconAnexar} />
                      <i>Adicionar Novo Anexo</i>
                    </button>
                  </div>
    
                  <label className={styles.labelStatus}>
                    Status de pagamento:
                  </label>
                  <div className={styles.divflex}>
                    <label className={styles.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={styles.iconStatus}
                      />
                      Glosado
                    </label>
                    <label className={styles.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={styles.iconStatus}
                      />
                      Perdido
                    </label>
                    <label className={styles.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={styles.iconStatus}
                      />
                      Recebidos
                    </label>
                  </div>
    
                  <label className={styles.labelStatus}>
                    Status de atividade:
                  </label>
                  <div className={styles.divflex}>
                    <label htmlFor="validar" className={styles.labelBorda}>
                      <input
                        type="radio"
                        id="validar"
                        name="Status"
                        value="validar"
                      />
                      Pronto pra validar
                    </label>
                    <label htmlFor="Validado" className={styles.labelBorda}>
                      <input
                        type="radio"
                        id="Validado"
                        name="Status"
                        value="Validado"
                      />
                      Validado
                    </label>
                    <label htmlFor="faturar" className={styles.labelBorda}>
                      <input
                        type="radio"
                        id="faturar"
                        name="Status"
                        value="aturar"
                      />
                      À faturar
                    </label>
                    <label htmlFor="Entregue" className={styles.labelBorda}>
                      <input
                        type="radio"
                        id="Entregue"
                        name="Status"
                        value="Entregue"
                      />
                      Entregue
                    </label>
                    <label htmlFor="Finalizado" className={styles.labelBorda}>
                      <input
                        type="radio"
                        id="Finalizado"
                        name="Status"
                        value="Finalizado"
                      />
                      Finalizado
                    </label>
                  </div>
                </div>
    
                <div className={styles.CardBotton}></div>
              </div>
            </>
          )}
          <div className={EstiloNovoAtendimento.divAnexos}>
            <input
              type="file"
              multiple
              disabled
              style={{ display: "none" }} // Ocultar o campo de entrada
              id="fileInput" // Adicionar id para o botão
            />
            <label htmlFor="fileInput" className={EstiloNovoAtendimento.anexar}>
              <img
                src="/+.png"
                alt=""
                className={EstiloNovoAtendimento.iconAnexar}
              />
              <i>Adicionar Novo Anexo</i>
            </label>
          </div>
    
          <div className={styles.CardBottonPai}></div>
        </div>
      </div>
    
  2. Assistant

    Para criar um componente de card de atendimentos que renderize as informações de um atendimento conforme o modelo que você mencionou, podemos seguir a estrutura que você já começou e ajustá-la conforme necessário para incluir as propriedades e funcionalidades desejadas.

    Aqui está uma sugestão para o componente de card de atendimentos:

    CardAtendimento.tsx

    import React, { useState } from "react";
    import styles from "./NovoAtendimento.module.css"; // Certifique-se de utilizar o estilo correto
    import { AppointmentRequestDTO, ProcedureDTO } from "./types"; // Importe os tipos corretos
    
    interface CardAtendimentoProps {
      atendimento: AppointmentRequestDTO; // O atendimento a ser exibido
      atualizarAtendimento: (atendimento: AppointmentRequestDTO) => void; // Função para atualizar o atendimento (opcional)
    }
    
    const CoresInput = [
      "#25AAE1", // Cor 1
      "#8696BB", // Cor 2
      "#39465F", // Cor 3
      "#D56D98", // Cor 4
    ];
    
    const CardAtendimento: React.FC<CardAtendimentoProps> = ({ atendimento, atualizarAtendimento }) => {
      const [mostrarCard, setMostrarCard] = useState(false);
    
      const totalValues = atendimento.paymentInfo.info.totalValues;
      const valuesArray = [
        totalValues.expected,
        totalValues.glossed,
        totalValues.lost,
        totalValues.paid,
      ];
    
      const totalSum = totalValues.expected + totalValues.glossed + totalValues.lost + totalValues.paid;
    
      // Alternar a visibilidade do card de detalhes
      const alternarCard = () => {
        setMostrarCard(!mostrarCard);
      };
    
      return (
        <div className={styles.cardsAtendimentos}>
          <div className={styles.CardPai}>
            <div className={styles.CardTopPai}>
              <div className={styles.buttonCard}>
                <button>
                  <img src="/lapisEditor.png" alt="Editar" className={styles.icon} />
                </button>
              </div>
            </div>
            <div className={styles.divDoCardPai}>
              <div className={styles.divValores}>
                <div className={styles.inputValores}>
                  <label className={styles.total}>Total:</label>
                  {valuesArray.map((valor, index) => (
                    <div key={index}>
                      <span style={{ color: CoresInput[index], fontSize: "14px", marginRight: "2px" }}>
                        R$
                      </span>
                      <input type="number" value={valor.toFixed(2)} readOnly style={{ color: CoresInput[index] }} />
                    </div>
                  ))}
                </div>
                <div className={styles.divBarraGrafico}>
                  <label className={styles.labelTotal}>R$ {totalSum.toFixed(2)}</label>
                  <div className={styles.graficoRepresentativo}>
                    <div className={styles.barraFixa}>
                      {valuesArray.map((valor, index) => (
                        <div
                          key={`grafico-${index}`}
                          style={{
                            backgroundColor: CoresInput[index],
                            width: totalSum > 0 ? `${(valor / totalSum) * 100}%` : `0%`,
                            height: "100%",
                          }}
                        />
                      ))}
                    </div>
                  </div>
                </div>
              </div>
              <div className={styles.divInformacoes}>
                <div className={styles.divDados}>
                  <label className={styles.labelData}>{atendimento.serviceInfo.date}</label>
                  <label className={styles.labelPaciente}>
                    {atendimento.related.patient?.name || "Paciente Desconhecido"}
                  </label>
                </div>
                <div className={styles.divRow}>
                  <label className={styles.labelLocais}>
                    Modalidade: {atendimento.paymentInfo.method}
                  </label>
                  <label className={styles.labelLocais}>
                    Fonte Pagadora: {atendimento.related.payer?.name || "Fonte Desconhecida"}
                  </label>
                </div>
                <div className={styles.divRow}>
                  <label className={styles.labelLocais}>
                    Local: {atendimento.related.place?.name || "Local Desconhecido"}
                  </label>
                </div>
                <div className={styles.divBarra} />
              </div>
              {/* Barra secundária de valores de procedimentos */}
              <div className={styles.divValores2}>
                <div className={styles.inputProcedimentos}>
                  {atendimento.procedures.map((proc: ProcedureDTO, index) => (
                    <input
                      key={index}
                      type="number"
                      value={proc.expectedValue} // Exibe o valor esperado do procedimento
                      readOnly
                      style={{ color: CoresInput[index % CoresInput.length] }} // Rotação das cores
                    />
                  ))}
                </div>
                <div className={styles.divBarraGrafico}>
                  <div className={styles.divTotal}>
                    <img src="/procedimento.png" alt="" />
                    <label>Procedimentos: {atendimento.procedures.length}</label>
                  </div>
                  <div className={styles.graficoRepresentativo}>
                    <div className={styles.barraFixa}>
                      {atendimento.procedures.map((proc: ProcedureDTO, index) => (
                        <div
                          key={`procedimento-${index}`}
                          style={{
                            backgroundColor: CoresInput[index % CoresInput.length],
                            width: "25%", // Cada procedimento ocupa 25% da largura
                            height: "100%",
                          }}
                        />
                      ))}
                    </div>
                  </div>
                  <div className={styles.expandirProcedimentos} onClick={alternarCard}>
                    <img src="/setaBaixo.png" alt="Expandir/recolher" className={styles.iconSeta} />
                    <label className={styles.labelExpandir}>{mostrarCard ? "Recolher" : "Expandir"}</label>
                  </div>
                </div>
              </div>
              {mostrarCard && (
                <div className={styles.procedimentosDetalhes}>
                  {atendimento.procedures.map((proc, index) => (
                    <div key={index} className={styles.Card}>
                      <div className={styles.divDoCard}>
                        <div className={styles.organizadorCard}>
                          <span>Código: {proc.cbhpmCode}</span>
                        </div>
                        <div className={styles.organizadorCard}>
                          <span>Nome: {proc.cbhpmName}</span>
                        </div>
                        <div className={styles.divflex}>
                          <label>Valor Previsto: R$ {proc.expectedValue.toFixed(2)}</label>
                          <label>Valor Glosado: R$ {proc.glossedValue.toFixed(2)}</label>
                          <label>Valor Perdido: R$ {proc.lostValue.toFixed(2)}</label>
                          <label>Valor Pago: R$ {proc.paidValue.toFixed(2)}</label>
                        </div>
                        {/* Aqui você pode adicionar outros detalhes, como status de pagamento, anexos, etc. */}
                      </div>
                    </div>
                  ))}
                </div>
              )}
            </div>
          </div>
        </div>
      );
    };
    
    export default CardAtendimento;
    

    Instruções:

    1. Props: O CardAtendimento aceita um objeto atendimento do tipo AppointmentRequestDTO e uma função opcional atualizarAtendimento que pode ser utilizada caso você queira atualizar os dados.

    2. Dados e Estilos: O componente renderiza informações básicas, como o paciente, o local de atendimento e a fonte pagadora. Ele também inclui barras gráficas para os valores esperados, glosados, perdidos e pagos.

    3. Expandir/Recolher: Há lógica para implementar a funcionalidade de expandir e recolher os detalhes dos procedimentos.

    4. Estilos: Certifique-se de ajustar e criar os estilos correspondentes no CSS, conforme sua nomenclatura.

    5. Uso: Você pode integrar este CardAtendimento em sua lista de atendimentos, passando os dados necessários.

    Espero que isso lhe ajude a criar um componente de card de atendimentos que atenda suas necessidades! Faça os ajustes adicionais que se fizerem necessários.

  3. User

    como posso renderizar esses dados no aqui" com essa url

    /appointments/find?skip=0&limit=40

  4. Assistant

    Para renderizar os dados dos atendimentos usando a URL /appointments/find?skip=0&limit=40, você precisará fazer uma chamada à API para obter esses dados e, em seguida, mapear esses dados para renderizar o componente CardAtendimento. Vou descrever um exemplo de como você pode integrar isso em um componente React.

    Passos para Realizar a Aquisição de Dados e Renderização

    1. Chame a API para obter os dados.
    2. Armazene os dados no estado com useState.
    3. Renderize os componentes CardAtendimento para cada atendimento obtido.

    Exemplo de Implementação

    Aqui está um exemplo de um componente que faz uma chamada à API e renderiza os cards de atendimento:

    import React, { useEffect, useState } from "react";
    import { useApi } from "../../lib/doctorApi"; // Exemplo de hook para chamada de API
    import CardAtendimento from "./CardAtendimento"; // Componente do Card que você criou
    import { AppointmentRequestDTO } from "./types"; // Tipos necessários conforme seu modelo
    
    const ListaAtendimentos: React.FC = () => {
      const [atendimentos, setAtendimentos] = useState<AppointmentRequestDTO[]>([]);
      const [loading, setLoading] = useState(true);
      const api = useApi(); // Assumindo que useApi seja um hook personalizado
    
      useEffect(() => {
        const fetchAtendimentos = async () => {
          try {
            const response = await api.get("/appointments/find?skip=0&limit=40");
            const dadosAtendimentos: AppointmentRequestDTO[] = response.data.result.list; // Ajuste conforme sua estrutura de resposta
            setAtendimentos(dadosAtendimentos);
          } catch (error) {
            console.error("Erro ao buscar atendimentos:", error);
          } finally {
            setLoading(false);
          }
        };
    
        fetchAtendimentos();
      }, [api]);
    
      if (loading) {
        return <div>Loading...</div>; // Exibe uma mensagem de carregamento
      }
    
      return (
        <div>
          {atendimentos.length > 0 ? (
            atendimentos.map((atendimento) => (
              <CardAtendimento 
                key={atendimento.id} // Assegure-se de que id seja uma propriedade única
                atendimento={atendimento}
                // Atualização opcional
                atualizarAtendimento={(newAtendimento) => {
                  setAtendimentos((current) => current.map(a => a.id === newAtendimento.id ? newAtendimento : a));
                }}
              />
            ))
          ) : (
            <div>Nenhum atendimento encontrado.</div>
          )}
        </div>
      );
    };
    
    export default ListaAtendimentos;
    

    Instruções Detalhadas

    1. useApi: Certifique-se de que o hook useApi esteja definido corretamente e que a função get esteja implementada para fazer chamadas GET à sua API.

    2. Chamada à API: A chamada para /appointments/find?skip=0&limit=40 é realizada no useEffect, que só roda uma vez quando o componente é montado.

    3. Manuseio de Dados:

      • A resposta da API é tratada para obter a lista de atendimentos a partir da estrutura da resposta (response.data.result.list).
    4. Renderização dos Cards: Os atendimentos são mapeados para componentes CardAtendimento, passando cada objeto atendimento como prop.

    5. Gerenciamento de Estado: O estado do componente é atualizado sempre que necessário, possibilitando uma abordagem reativa na interface do usuário.

    6. Loading State: Um estado de carregamento exibe uma mensagem enquanto a solicitação da API está sendo processada.

    Estilo e Estrutura

    A estrutura e os estilos de CardAtendimento e do componente ListaAtendimentos devem ser organizados adequadamente no seu projeto para garantir que tudo funcione da maneira esperada.

    Certifique-se de incluir o tratamento de erros (exibindo uma mensagem adequada para o usuário, por exemplo) e ajustar a lógica conforme a necessidade do seu projeto.