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

ola

  1. User

    ola

  2. Assistant

    Olá! Como posso ajudar você hoje?

  3. User

    preciso economizar linhas de codigo no meu componente novo atendimento, entao preciso crir um componente pra este card que seja renderizado no novoAtendimento, o nome do componente pode ser cardProcedimento.tsx

    {/* Renderiza os procedimentos adicionados */} {procedimentos.map((proc, index) => ( #{index + 1}

              <div className={EstiloNovoAtendimento.divDoCard}>
                <div className={EstiloNovoAtendimento.organizadorCard}>
                  <span>Código personalizado da CBHPM</span>
                  <input
                    className={EstiloNovoAtendimento.inputCard}
                    type="text"
                    placeholder="Digite o Código..."
                  />
                </div>
                <div className={EstiloNovoAtendimento.organizadorCard}>
                  <span>Nome personalizado da CBHPM</span>
                  <input
                    className={EstiloNovoAtendimento.inputCard}
                    type="text"
                    placeholder="Digite o Código..."
                  />
                </div>
    
                <div className={EstiloNovoAtendimento.divflex}>
                  {" "}
                  {/* Onde você tem os valores editáveis */}
                  <div className={EstiloNovoAtendimento.valores}>
                    <label className={EstiloNovoAtendimento.labelinput}>
                      Valor Previsto
                    </label>
                    <input
                      className={EstiloNovoAtendimento.inputValor234}
                      type="number"
                      value={proc.valoresEditaveis[0]} // Valor editável
                      placeholder=""
                      onChange={(e) =>
                        handleValorChange(
                          index,
                          0,
                          parseFloat(e.target.value) || 0
                        )
                      }
                      onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                    />
                  </div>
                  <div className={EstiloNovoAtendimento.valores}>
                    <label className={EstiloNovoAtendimento.labelinput}>
                      Valor Glosado
                    </label>
                    <input
                      className={EstiloNovoAtendimento.inputValor234}
                      type="number"
                      value={proc.valoresEditaveis[1]} // Valor editável
                      onChange={(e) =>
                        handleValorChange(
                          index,
                          1,
                          parseFloat(e.target.value) || 0
                        )
                      }
                      onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                    />
                  </div>
                  <div className={EstiloNovoAtendimento.valores}>
                    <label className={EstiloNovoAtendimento.labelinput}>
                      Valor Perdido
                    </label>
                    <input
                      className={EstiloNovoAtendimento.inputValor234}
                      type="number"
                      value={proc.valoresEditaveis[2]} // Valor editável
                      onChange={(e) =>
                        handleValorChange(
                          index,
                          2,
                          parseFloat(e.target.value) || 0
                        )
                      }
                      onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                    />
                  </div>
                  <div className={EstiloNovoAtendimento.valores}>
                    <label className={EstiloNovoAtendimento.labelinput}>
                      Valor Pago
                    </label>
                    <input
                      className={EstiloNovoAtendimento.inputValor234}
                      type="number"
                      value={proc.valoresEditaveis[3]} // Valor editável
                      onChange={(e) =>
                        handleValorChange(
                          index,
                          3,
                          parseFloat(e.target.value) || 0
                        )
                      }
                      onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                    />
                  </div>
                </div>
    
                <div className={EstiloNovoAtendimento.divAnexo}>
                  <label className={EstiloNovoAtendimento.labelStatus}>
                    Anexos:
                  </label>
                  <button className={EstiloNovoAtendimento.anexar}>
                    <img
                      src="/+.png"
                      alt=""
                      className={EstiloNovoAtendimento.iconAnexar}
                    />
                    <i>Adicionar Novo Anexo</i>
                  </button>
                </div>
    
                <label className={EstiloNovoAtendimento.labelStatus}>
                  Status de pagamento:
                </label>
                <div className={EstiloNovoAtendimento.divflex}>
                  {proc.valoresEditaveis[0] > 0 && (
                    <label className={EstiloNovoAtendimento.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={EstiloNovoAtendimento.iconStatus}
                      />{" "}
                      Previsto
                    </label>
                  )}
                  {proc.valoresEditaveis[1] > 0 && (
                    <label className={EstiloNovoAtendimento.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={EstiloNovoAtendimento.iconStatus}
                      />{" "}
                      Glosado
                    </label>
                  )}
                  {proc.valoresEditaveis[2] > 0 && (
                    <label className={EstiloNovoAtendimento.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={EstiloNovoAtendimento.iconStatus}
                      />{" "}
                      Perdido
                    </label>
                  )}
                  {proc.valoresEditaveis[3] > 0 && (
                    <label className={EstiloNovoAtendimento.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={EstiloNovoAtendimento.iconStatus}
                      />{" "}
                      Pago
                    </label>
                  )}
                </div>
    
                <label className={EstiloNovoAtendimento.labelStatus}>
                  Status de atividade:
                </label>
                <div className={EstiloNovoAtendimento.divflex}>
                  {[
                    "rascunho",
                    "validar",
                    "validado",
                    "faturar",
                    "entregue",
                    "finalizado",
                  ].map((status) => (
                    <label
                      key={status}
                      className={EstiloNovoAtendimento.labelBorda}
                    >
                      <input
                        type="checkbox"
                        className={EstiloNovoAtendimento.customCheckbox}
                        value={status}
                        checked={proc.status.includes(status)} // Verifica se o status está incluído
                        onChange={(e) => {
                          const isChecked = e.target.checked;
    
                          if (isChecked) {
                            // Adiciona o status se for marcado
                            updateProcedimento(index, {
                              status: [...proc.status, status], // Adiciona ao array de status
                            });
                          } else {
                            // Remove o status se for desmarcado
                            updateProcedimento(index, {
                              status: proc.status.filter((s) => s !== status), // Remove do array de status
                            });
                          }
                        }}
                      />
                      <span className={EstiloNovoAtendimento.labelAtividade}>
                        {status.charAt(0).toUpperCase() + status.slice(1)}{" "}
                        {/* Capitaliza o primeiro caractere */}
                      </span>
                    </label>
                  ))}
                </div>
              </div>
    
              <div className={EstiloNovoAtendimento.CardBotton}></div>
            </div>
    

    import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import React, { useState, useEffect } from "react"; import { useApi } from "../../lib/doctorApi"; import { AppointmentRequestDTO } from "./types"; import DropdownSelect from "./DropdownSelect"; import { useLocalContext, Local } from "../Local/LocalContext";

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

    export interface FormularioDados { pacienteId: string; total: number; payer: string; // Certifique-se de que isso está aqui pacienteNome: string; local: string; // ou 'local' se preferir; mas stable as diferenças localIdFontePagadora: string; // Esta propriedade deve estar aqui localIdAtendimento: string; // Esta propriedade também deve estar aqui modalidade: string; data: string; valores: number[]; codigo?: string; // Esta pode continuar a ser opcional }

    export interface Paciente { id?: number; name: string; cpf: string; email: string; address: string; celular: string; dataNascimento?: string; idade?: string; }

    interface Procedimento { valoresEditaveis: number[]; total?: number; // Adicione um total opcional status: string[]; // ou uma enumeração se você preferir }

    const NovoAtendimento: React.FC = () => { const [pacientes, setPacientes] = useState<Paciente[]>([]); const [locaisFontePagadora, setLocaisFontePagadora] = useState<Local[]>([]); const [locaisAtendimento, setLocaisAtendimento] = useState<Local[]>([]); const localContext = useLocalContext();

    const [procedimentos, setProcedimentos] = useState<Procedimento[]>([ { valoresEditaveis: [0, 0, 0, 0], status: [], // ou outro status inicial }, ]); // Lista de procedimentos adicionados

    const updateProcedimento = ( index: number, novosDados: Partial ) => { setProcedimentos((prev) => { const novosProcedimentos = [...prev]; novosProcedimentos[index] = { ...novosProcedimentos[index], ...novosDados, // Aqui você pode atualizar múltiplas propriedades }; return novosProcedimentos; }); };

    const handleAdicionarProcedimento = () => { const novoProcedimento = { valoresEditaveis: [0, 0, 0, 0], status: ["rascunho"], // Estado inicial }; setProcedimentos([...procedimentos, novoProcedimento]); };

    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 [valoresBarra, setValoresBarra] = useState([0, 0, 0, 0]); // Novo estado para a contagem da barra 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: { healthInsurance: { cardNumber: "", }, }, }, serviceInfo: { guideCode: "", date: "", totalValue: 0, }, procedures: [], });

    const handleFileChange = async ( event: React.ChangeEvent ) => { setLoading(true); const formData = new FormData();

    const files = event.target.files;
    if (files) {
      Array.from(files).map((file) => {
        formData.append("files", file);
      });
      const uploadResult = await api.post("files/upload", formData);
      if (uploadResult.data.success) {
        setAnexos(uploadResult.data.result);
      }
    }
    

    }; const handleDelete = async (id: string) => { await api.del(files/delete/${id}); const novosAnexos = anexos.filter((anexo) => anexo.id !== id); setAnexos(novosAnexos); };

    const atualizarValoresBarra = () => { const novosValoresBarra = [0, 0, 0, 0]; // Inicializa uma nova contagem

    procedimentos.forEach((proc) => {
      proc.valoresEditaveis.forEach((valor, index) => {
        if (valor > 0) {
          novosValoresBarra[index] += 1; // Incrementa se o valor é maior que 0
        }
      });
    });
    
    setValoresBarra(novosValoresBarra); // Atualiza o estado dos valores da barra
    

    }; const atualizarTotal = () => { const novosValoresBarra = [0, 0, 0, 0]; // Inicializa os valores da barra

    procedimentos.forEach((proc) => {
      proc.valoresEditaveis.forEach((valor, index) => {
        novosValoresBarra[index] += valor; // Acumula os valores correspondentes
      });
    });
    
    // Atualiza o total no estado do formulário
    setFormularioDados((prev) => ({
      ...prev,
      total: novosValoresBarra.reduce((a, b) => a + b, 0), // Calcula o total
      valores: novosValoresBarra, // Atualiza os valores da barra
    }));
    

    };

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

    const [formularioDados, setFormularioDados] = useState({ pacienteId: "", total: 0, pacienteNome: "", local: "", // Ajuste para o nome correto se ele for alterado localIdFontePagadora: "", // Adicione aqui localIdAtendimento: "", // Adicione aqui modalidade: "", data: "", valores: [0, 0, 0, 0], codigo: "", });

    // Funções de efeito para buscar pacientes e locais useEffect(() => { const buscarPacientes = async () => { try { const data = await api.get("patients/find?skip=0&limit=2000"); setPacientes(data.data?.result?.list || []); } catch (error) { console.error("Erro ao buscar pacientes:", error); } };

    buscarPacientes();
    

    }, []);

    const buscarLocais = async () => { try { const data = await api.get("places/find?skip=0&limit=2000"); setLocaisFontePagadora( data.data.result.list.filter((local: Local) => local.payer) ); setLocaisAtendimento( data.data.result.list.filter((local: Local) => local.place) ); } catch (error) { console.error("Erro ao buscar locais:", error); } };

    useEffect(() => { buscarLocais(); }, []);

    const handleValorChange = ( index: number, valorIndex: number, novoValor: number ) => { const novosProcedimentos = [...procedimentos]; const valorAntigo = novosProcedimentos[index].valoresEditaveis[valorIndex];

    // Atualiza o valor no procedimento correto
    novosProcedimentos[index].valoresEditaveis[valorIndex] = novoValor;
    
    setProcedimentos(novosProcedimentos);
    atualizarTotal(); // Atualiza todos os totais de acordo com a mudança
    atualizarValoresBarra(); // Atualiza a contagem dos valores na barra
    

    };

    const enviarDadosAtendimento = async () => { // Antes de realizar qualquer envio, logue o estado atendimento no console console.log("Dados do atendimento:", atendimento);

    // Simulação: Você pode substituir isso pela chamada real da API quando estiver pronta
    // Exemplo de chamada fictícia
    if (true) {
      // Simulando sucesso
      alert("Atendimento salvo com sucesso!");
    } else {
    }
    

    }; return ( Cadastro de Atendimento

      <form>
        <div className={EstiloNovoAtendimento.divValores}>
          <div className={EstiloNovoAtendimento.inputValores}>
            <label className={EstiloNovoAtendimento.total}>Total:</label>
            {formularioDados.valores.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$ {formularioDados.total.toFixed(2)}{" "}
              {/* Aqui já usará o total atualizado */}
            </label>
            <div className={EstiloNovoAtendimento.graficoRepresentativo}>
              <div className={EstiloNovoAtendimento.barraFixa}>
                {formularioDados.valores.map((valor, index) => (
                  <div
                    key={`grafico-${index}`}
                    style={{
                      backgroundColor: CoresInput[index],
                      width:
                        formularioDados.total > 0
                          ? `${(valor / formularioDados.total) * 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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "convenio",
                  }));
                  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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "particular",
                  }));
                  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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "plantao",
                  }));
                  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) => {
              setFormularioDados((prev) => ({
                ...prev,
                localIdFontePagadora: selectedItem.id,
                payer: selectedItem.name,
              }));
              // 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={formularioDados.localIdFontePagadora} // Valor atual do dropdown
            label="Fonte Pagadora:" // Rótulo a ser exibido
          />
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          <div className={EstiloNovoAtendimento.organizador}>
            <span>Paciente:</span>
            <label htmlFor="Paciente-select"></label>
            <select
              className={EstiloNovoAtendimento.input300px}
              id="Paciente-select"
              value={formularioDados.pacienteId}
              onChange={(e) => {
                const selectedOption = e.target.options[e.target.selectedIndex];
                const pacienteId = selectedOption.value;
                const pacienteNome =
                  selectedOption.getAttribute("data-name") || ""; // Extrai o nome do paciente
    
                // Atualiza tanto o formularioDados quanto o estado de atendimento
                setFormularioDados((prev) => ({
                  ...prev,
                  pacienteId,
                  pacienteNome,
                }));
    
                // Atualiza o estado de atendimento com o paciente selecionado
                setAtendimento((prev) => ({
                  ...prev,
                  related: {
                    ...prev.related,
                    patient: { id: pacienteId, name: pacienteNome },
                  },
                }));
              }}
            >
              <option value="" disabled hidden>
                Selecione um paciente
              </option>
              {pacientes.map((paciente) => (
                <option
                  key={paciente.id}
                  value={paciente.id}
                  data-name={paciente.name}
                >
                  {paciente.name}
                </option>
              ))}
            </select>
          </div>
    
          <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) => {
              setFormularioDados((prev) => ({
                ...prev,
                localIdAtendimento: selectedItem.id, // Define o ID selecionado no formulário
                place: selectedItem.name,
              }));
              // 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={formularioDados.localIdAtendimento} // 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={formularioDados.codigo}
              onChange={(e) => {
                const codigo = e.target.value;
    
                // Atualiza o estado formularioDados
                setFormularioDados({
                  ...formularioDados,
                  codigo, // Atualiza o código no formulário
                });
    
                // 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={formularioDados.data}
              onChange={(e) => {
                const data = e.target.value;
    
                setFormularioDados({
                  ...formularioDados,
                  data,
                });
    
                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}>
          {valoresBarra.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>{procedimentos.length}</label> Procedimento
            </label>
          </div>
          <div className={EstiloNovoAtendimento.graficoRepresentativo}>
            <div className={EstiloNovoAtendimento.barraFixa}>
              {valoresBarra.map((valor, index) => (
                <div
                  key={`grafico-segunda-${index}`}
                  style={{
                    backgroundColor: CoresInput[index],
                    width: `${(valor / procedimentos.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 */}
          {procedimentos.map((proc, index) => (
            <div key={index} className={EstiloNovoAtendimento.Card}>
              <div className={EstiloNovoAtendimento.CardTop}>
                <div>
                  <span>#{index + 1}</span>
                </div>
                <div className={EstiloNovoAtendimento.buttonCard}>
                  <button>
                    <img
                      src="/lapisEditor.png"
                      alt="Editar"
                      className={EstiloNovoAtendimento.icon}
                    />
                  </button>
                  <button>
                    <img
                      src="/lixeira.png"
                      alt="Excluir"
                      className={EstiloNovoAtendimento.icon}
                    />
                  </button>
                </div>
              </div>
    
              <div className={EstiloNovoAtendimento.divDoCard}>
                <div className={EstiloNovoAtendimento.organizadorCard}>
                  <span>Código personalizado da CBHPM</span>
                  <input
                    className={EstiloNovoAtendimento.inputCard}
                    type="text"
                    placeholder="Digite o Código..."
                  />
                </div>
                <div className={EstiloNovoAtendimento.organizadorCard}>
                  <span>Nome personalizado da CBHPM</span>
                  <input
                    className={EstiloNovoAtendimento.inputCard}
                    type="text"
                    placeholder="Digite o Código..."
                  />
                </div>
    
                <div className={EstiloNovoAtendimento.divflex}>
                  {" "}
                  {/* Onde você tem os valores editáveis */}
                  <div className={EstiloNovoAtendimento.valores}>
                    <label className={EstiloNovoAtendimento.labelinput}>
                      Valor Previsto
                    </label>
                    <input
                      className={EstiloNovoAtendimento.inputValor234}
                      type="number"
                      value={proc.valoresEditaveis[0]} // Valor editável
                      placeholder=""
                      onChange={(e) =>
                        handleValorChange(
                          index,
                          0,
                          parseFloat(e.target.value) || 0
                        )
                      }
                      onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                    />
                  </div>
                  <div className={EstiloNovoAtendimento.valores}>
                    <label className={EstiloNovoAtendimento.labelinput}>
                      Valor Glosado
                    </label>
                    <input
                      className={EstiloNovoAtendimento.inputValor234}
                      type="number"
                      value={proc.valoresEditaveis[1]} // Valor editável
                      onChange={(e) =>
                        handleValorChange(
                          index,
                          1,
                          parseFloat(e.target.value) || 0
                        )
                      }
                      onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                    />
                  </div>
                  <div className={EstiloNovoAtendimento.valores}>
                    <label className={EstiloNovoAtendimento.labelinput}>
                      Valor Perdido
                    </label>
                    <input
                      className={EstiloNovoAtendimento.inputValor234}
                      type="number"
                      value={proc.valoresEditaveis[2]} // Valor editável
                      onChange={(e) =>
                        handleValorChange(
                          index,
                          2,
                          parseFloat(e.target.value) || 0
                        )
                      }
                      onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                    />
                  </div>
                  <div className={EstiloNovoAtendimento.valores}>
                    <label className={EstiloNovoAtendimento.labelinput}>
                      Valor Pago
                    </label>
                    <input
                      className={EstiloNovoAtendimento.inputValor234}
                      type="number"
                      value={proc.valoresEditaveis[3]} // Valor editável
                      onChange={(e) =>
                        handleValorChange(
                          index,
                          3,
                          parseFloat(e.target.value) || 0
                        )
                      }
                      onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                    />
                  </div>
                </div>
    
                <div className={EstiloNovoAtendimento.divAnexo}>
                  <label className={EstiloNovoAtendimento.labelStatus}>
                    Anexos:
                  </label>
                  <button className={EstiloNovoAtendimento.anexar}>
                    <img
                      src="/+.png"
                      alt=""
                      className={EstiloNovoAtendimento.iconAnexar}
                    />
                    <i>Adicionar Novo Anexo</i>
                  </button>
                </div>
    
                <label className={EstiloNovoAtendimento.labelStatus}>
                  Status de pagamento:
                </label>
                <div className={EstiloNovoAtendimento.divflex}>
                  {proc.valoresEditaveis[0] > 0 && (
                    <label className={EstiloNovoAtendimento.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={EstiloNovoAtendimento.iconStatus}
                      />{" "}
                      Previsto
                    </label>
                  )}
                  {proc.valoresEditaveis[1] > 0 && (
                    <label className={EstiloNovoAtendimento.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={EstiloNovoAtendimento.iconStatus}
                      />{" "}
                      Glosado
                    </label>
                  )}
                  {proc.valoresEditaveis[2] > 0 && (
                    <label className={EstiloNovoAtendimento.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={EstiloNovoAtendimento.iconStatus}
                      />{" "}
                      Perdido
                    </label>
                  )}
                  {proc.valoresEditaveis[3] > 0 && (
                    <label className={EstiloNovoAtendimento.statusPagamento}>
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={EstiloNovoAtendimento.iconStatus}
                      />{" "}
                      Pago
                    </label>
                  )}
                </div>
    
                <label className={EstiloNovoAtendimento.labelStatus}>
                  Status de atividade:
                </label>
                <div className={EstiloNovoAtendimento.divflex}>
                  {[
                    "rascunho",
                    "validar",
                    "validado",
                    "faturar",
                    "entregue",
                    "finalizado",
                  ].map((status) => (
                    <label
                      key={status}
                      className={EstiloNovoAtendimento.labelBorda}
                    >
                      <input
                        type="checkbox"
                        className={EstiloNovoAtendimento.customCheckbox}
                        value={status}
                        checked={proc.status.includes(status)} // Verifica se o status está incluído
                        onChange={(e) => {
                          const isChecked = e.target.checked;
    
                          if (isChecked) {
                            // Adiciona o status se for marcado
                            updateProcedimento(index, {
                              status: [...proc.status, status], // Adiciona ao array de status
                            });
                          } else {
                            // Remove o status se for desmarcado
                            updateProcedimento(index, {
                              status: proc.status.filter((s) => s !== status), // Remove do array de status
                            });
                          }
                        }}
                      />
                      <span className={EstiloNovoAtendimento.labelAtividade}>
                        {status.charAt(0).toUpperCase() + status.slice(1)}{" "}
                        {/* Capitaliza o primeiro caractere */}
                      </span>
                    </label>
                  ))}
                </div>
              </div>
    
              <div className={EstiloNovoAtendimento.CardBotton}></div>
            </div>
          ))}
        </>
      )}
      <div className={EstiloNovoAtendimento.divSalvarAnexo}>
        <label className={EstiloNovoAtendimento.labelAnexo}>Anexos:</label>
        <div className={EstiloNovoAtendimento.divArquivo}>
          {anexos.length > 0
            ? anexos.map((anexo) => (
                <label key={anexo.id} className={EstiloNovoAtendimento.Arquivo}>
                  {anexo.fileName} {/* Exibir o nome do arquivo */}
                  <button onClick={() => handleDelete(anexo.id)}>
                    <img src="lixeira.png" alt="" />
                  </button>
                </label>
              ))
            : null}{" "}
          {/* Não exibe nada se não houver anexos */}
        </div>
        <div className={EstiloNovoAtendimento.divAnexosNew}>
          <input
            type="file"
            multiple
            onChange={handleFileChange}
            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>
    
      <div className={EstiloNovoAtendimento.divbutton}>
        <button
          className={EstiloNovoAtendimento.buttonSalvar}
          onClick={enviarDadosAtendimento}
        >
          Salvar
        </button>
      </div>
    </div>
    

    ); };

    export default NovoAtendimento;

  4. Assistant

    Para refatorar o código e criar o componente CardProcedimento, que pode ser utilizado dentro do seu componente NovoAtendimento, você pode seguir as etapas abaixo:

    1. Criar o Componente CardProcedimento

    Primeiro, crie um novo arquivo chamado CardProcedimento.tsx. Neste arquivo, você colocará a lógica e JSX que corresponde ao atual bloco do card de procedimento do seu código.

    // CardProcedimento.tsx
    import React from "react";
    import EstiloNovoAtendimento from "./NovoAtendimento.module.css";
    
    interface Procedimento {
      valoresEditaveis: number[];
      status: string[];
      index: number;
      handleValorChange: (index: number, valorIndex: number, novoValor: number) => void;
      updateProcedimento: (index: number, novosDados: Partial<Omit<Procedimento, 'valoresEditaveis'>>) => void;
    }
    
    const CardProcedimento: React.FC<Procedimento> = ({
      valoresEditaveis,
      status,
      index,
      handleValorChange,
      updateProcedimento,
    }) => {
      return (
        <div className={EstiloNovoAtendimento.Card}>
          <div className={EstiloNovoAtendimento.CardTop}>
            <div>
              <span>#{index + 1}</span>
            </div>
            <div className={EstiloNovoAtendimento.buttonCard}>
              <button>
                <img
                  src="/lapisEditor.png"
                  alt="Editar"
                  className={EstiloNovoAtendimento.icon}
                />
              </button>
              <button>
                <img
                  src="/lixeira.png"
                  alt="Excluir"
                  className={EstiloNovoAtendimento.icon}
                />
              </button>
            </div>
          </div>
    
          <div className={EstiloNovoAtendimento.divDoCard}>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Código personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                placeholder="Digite o Código..."
              />
            </div>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Nome personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                placeholder="Digite o Código..."
              />
            </div>
    
            <div className={EstiloNovoAtendimento.divflex}>
              {['Valor Previsto', 'Valor Glosado', 'Valor Perdido', 'Valor Pago'].map((label, valorIndex) => (
                <div className={EstiloNovoAtendimento.valores} key={label}>
                  <label className={EstiloNovoAtendimento.labelinput}>{label}</label>
                  <input
                    className={EstiloNovoAtendimento.inputValor234}
                    type="number"
                    value={valoresEditaveis[valorIndex]} // Valor editável
                    placeholder=""
                    onChange={(e) =>
                      handleValorChange(index, valorIndex, parseFloat(e.target.value) || 0)
                    }
                    onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                  />
                </div>
              ))}
            </div>
    
            <div className={EstiloNovoAtendimento.divAnexo}>
              <label className={EstiloNovoAtendimento.labelStatus}>
                Anexos:
              </label>
              <button className={EstiloNovoAtendimento.anexar}>
                <img
                  src="/+.png"
                  alt=""
                  className={EstiloNovoAtendimento.iconAnexar}
                />
                <i>Adicionar Novo Anexo</i>
              </button>
            </div>
    
            <label className={EstiloNovoAtendimento.labelStatus}>
              Status de pagamento:
            </label>
            <div className={EstiloNovoAtendimento.divflex}>
              {valoresEditaveis.map((valor, valorIndex) => (
                valor > 0 && (
                  <label className={EstiloNovoAtendimento.statusPagamento} key={valorIndex}>
                    <img
                      src="/cifrao.png"
                      alt=""
                      className={EstiloNovoAtendimento.iconStatus}
                    />
                    {['Previsto', 'Glosado', 'Perdido', 'Pago'][valorIndex]}
                  </label>
                )
              ))}
            </div>
    
            <label className={EstiloNovoAtendimento.labelStatus}>
              Status de atividade:
            </label>
            <div className={EstiloNovoAtendimento.divflex}>
              {['rascunho', 'validar', 'validado', 'faturar', 'entregue', 'finalizado'].map((statusItem) => (
                <label key={statusItem} className={EstiloNovoAtendimento.labelBorda}>
                  <input
                    type="checkbox"
                    className={EstiloNovoAtendimento.customCheckbox}
                    value={statusItem}
                    checked={status.includes(statusItem)} // Verifica se o status está incluído
                    onChange={(e) => {
                      const isChecked = e.target.checked;
                      if (isChecked) {
                        updateProcedimento(index, {
                          status: [...status, statusItem], // Adiciona ao array de status
                        });
                      } else {
                        updateProcedimento(index, {
                          status: status.filter((s) => s !== statusItem), // Remove do array de status
                        });
                      }
                    }}
                  />
                  <span className={EstiloNovoAtendimento.labelAtividade}>
                    {statusItem.charAt(0).toUpperCase() + statusItem.slice(1)} {/* Capitaliza o primeiro caractere */}
                  </span>
                </label>
              ))}
            </div>
          </div>
          <div className={EstiloNovoAtendimento.CardBotton}></div>
        </div>
      );
    };
    
    export default CardProcedimento;
    

    2. Usar o novo Componente CardProcedimento no NovoAtendimento

    Depois de criar o novo componente, você pode utilizá-lo no seu componente NovoAtendimento da seguinte maneira:

    // Dentro do seu componente NovoAtendimento
    
    import CardProcedimento from "./CardProcedimento"; // Importar o componente
    
    // Substitua a renderização dos procedimentos
    {mostrarCard && (
      <>
        {procedimentos.map((proc, index) => (
          <CardProcedimento
            key={index}
            index={index}
            valoresEditaveis={proc.valoresEditaveis}
            status={proc.status}
            handleValorChange={handleValorChange}
            updateProcedimento={updateProcedimento}
          />
        ))}
      </>
    )}
    

    Resultado

    Agora você tem o componente CardProcedimento que encapsula toda a lógica e JSX específico para cada procedimento, o que torna seu código no NovoAtendimento mais limpo e reutilizável. Além disso, qualquer alteração futura ao layout ou funcionalidade específica dos cartões pode ser feita diretamente nesse novo componente, mantendo a lógica central do NovoAtendimento mais organizada.

  5. User

    quando inicio o componente novoAtendimento ele ja inicia com um procedimento, gostaria que iniciasse sem nenhum procedimento adicionado, vazio

  6. Assistant

    Claro! Para garantir que o componente NovoAtendimento inicie sem nenhum procedimento adicionado, você precisará modificar a linha onde o estado procedimentos é inicializado.

    Atualmente, no seu código, você define o estado inicial de procedimentos como uma lista que contém um único procedimento. Você deve ajustá-lo para começar com um array vazio.

    Alterando o Estado Inicial

    Aqui está a modificação que você deve fazer:

    Antes:

    const [procedimentos, setProcedimentos] = useState<Procedimento[]>([
      {
        valoresEditaveis: [0, 0, 0, 0],
        status: [], // ou outro status inicial
      },
    ]); // Lista de procedimentos adicionados
    

    Depois:

    Altere para o seguinte:

    const [procedimentos, setProcedimentos] = useState<Procedimento[]>([]); // Inicia como um array vazio
    

    Resultado Completo

    O trecho modificado do código deve ficar assim:

    const [procedimentos, setProcedimentos] = useState<Procedimento[]>([]); // Inicia com um array vazio
    

    Com esta alteração, quando o componente NovoAtendimento for montado, procedimentos estará vazio e você não verá nenhum procedimento inicial ao carregar a página. Os usuários poderão clicar em "Adicionar Procedimento" para começar a adicionar itens quando desejarem.

    Adicionando um Procedimento

    Se você ainda desejar permitir que o usuário inicie com um procedimento ao clicar no botão "Adicionar Procedimento", essa lógica continuará funcionando normalmente. Apenas assegure-se de que essa parte do seu código permaneça inalterada para que o botão adicione um novo procedimento ao array de procedimentos.

    const handleAdicionarProcedimento = () => {
      const novoProcedimento = {
        valoresEditaveis: [0, 0, 0, 0],
        status: ["rascunho"], // Estado inicial
      };
      setProcedimentos([...procedimentos, novoProcedimento]);
    };
    

    Assim, só será adicionado um procedimento vazio após a ação explícita do usuário ao clicar no botão.

  7. User

    quando crio algum procedimento e saio do componente novoAtendimento, ele apaga tudo, gostaria que ficasse salvo e nao que fosse descartado tudo que foi adicionado no novoAtendimento, ou acha mais viavel colocar um popup ao tentar sair do componente perguntar se realmente quer sair pois perdera o que ja foi feito?

  8. Assistant

    Existem algumas abordagens para lidar com a persistência dos dados no seu componente NovoAtendimento, dependendo de como você deseja que a experiência do usuário seja. Abaixo, apresento duas soluções que você pode considerar:

    1. Persistência dos Dados

    Se você deseja que os dados permaneçam mesmo após o usuário sair do componente, você pode armazenar o estado dos procedimentos em algum lugar mais persistente, como:

    • Local Storage: Uma forma simples de armazenar dados no navegador.
    • Redux ou Context API: Se sua aplicação já usa Redux ou Context API, você pode armazenar o estado lá.
    • Back-End: Se você estiver utilizando um back-end, você pode fazer uma chamada para salvar esses dados.

    Exemplo utilizando Local Storage

    Você pode utilizar o localStorage para salvar os dados do procedimentos automaticamente e carregá-los quando o componente for montado. Aqui está como você pode implementá-lo:

    import React, { useEffect, useState } from "react";
    
    //...
    
    const NovoAtendimento: React.FC = () => {
      const [procedimentos, setProcedimentos] = useState<Procedimento[]>(() => {
        const storedProcedures = localStorage.getItem("procedimentos");
        return storedProcedures ? JSON.parse(storedProcedures) : [];
      });
    
      useEffect(() => {
        localStorage.setItem("procedimentos", JSON.stringify(procedimentos));
      }, [procedimentos]);
    
      // Restante do código...
    };
    

    Com essa abordagem, você armazena os dados dos procedimentos no localStorage sempre que eles mudam e carrega o estado dos procedimentos a partir do localStorage quando o componente é montado pela primeira vez.

    2. Pop-up de Confirmação

    Outra abordagem é exibir um pop-up de confirmação quando o usuário tenta sair do componente. Isso pode ser feito utilizando o evento beforeunload. Aqui está um exemplo básico de como implementar isso:

    useEffect(() => {
      const handleBeforeUnload = (event: BeforeUnloadEvent) => {
        if (procedimentos.length > 0) {
          const confirmationMessage = "Você tem alterações não salvas. Tem certeza que quer sair?";
          event.returnValue = confirmationMessage; // Para a maioria dos navegadores
          return confirmationMessage; // Para alguns navegadores
        }
      };
    
      window.addEventListener("beforeunload", handleBeforeUnload);
    
      return () => {
        window.removeEventListener("beforeunload", handleBeforeUnload);
      };
    }, [procedimentos]); // Executa o efeito quando procedimentos muda
    

    Com essa implementação, um alerta de confirmação aparecerá quando o usuário tentar sair ou atualizar a página, perguntando se ele tem certeza de que deseja sair sem salvar as alterações.

    Conclusão

    • Persistência Usando localStorage: Essa é uma solução mais conveniente, pois mantém os dados entre as sessões e evita que o usuário perca informações quando retornar.
    • Pop-up de Confirmação: Essa abordagem é útil se você deseja garantir que os usuários estejam cientes das alterações não salvas, mas pode ser considerado intrusivo em algumas situações.

    Você pode optar por uma das duas abordagens, dependendo do comportamento que deseja que a aplicação tenha e da experiência do usuário que pretende proporcionar. Uma combinação das duas também é uma possibilidade, onde os dados são salvos automaticamente e ainda há um предупреждение se o usuário tentar sair com alterações não salvas.

  9. User

    acho que quero começar de outra forma, como adiciono um id, pra cada card de procedimento que adiciono?

  10. Assistant

    Adicionar um ID único a cada card de procedimento é uma prática comum que ajuda a identificar de forma única cada item na lista. Você pode gerar o ID de várias formas, dependendo de suas necessidades. Uma abordagem simples é usar um contador baseado no comprimento da lista ou utilizar bibliotecas específicas para geração de IDs únicos.

    1. Adicionando um ID com um Contador

    Aqui está como você pode fazer isso:

    1. Adicione um contador como parte do estado do seu componente NovoAtendimento.
    2. Ao adicionar um novo procedimento, crie um ID baseado nesse contador.
    3. Incremento o contador a cada novo procedimento adicionado.

    Exemplo de Implementação

    import React, { useState } from "react";
    
    // Defina a interface do procedimento com um ID
    interface Procedimento {
      id: number; // ID único para cada procedimento
      valoresEditaveis: number[];
      status: string[];
    }
    
    const NovoAtendimento: React.FC = () => {
      const [procedimentos, setProcedimentos] = useState<Procedimento[]>([]);
      const [idCounter, setIdCounter] = useState(0); // Contador para IDs
    
      const handleAdicionarProcedimento = () => {
        const novoProcedimento: Procedimento = {
          id: idCounter, // Use o contador como ID
          valoresEditaveis: [0, 0, 0, 0],
          status: ["rascunho"], // Estado inicial
        };
        
        // Adicione o novo procedimento e incremente o contador
        setProcedimentos((prev) => [...prev, novoProcedimento]);
        setIdCounter(prevCounter => prevCounter + 1); // Incrementa o contador
      };
    
      return (
        <div>
          <h1>Novo Atendimento</h1>
          <button onClick={handleAdicionarProcedimento}>Adicionar Procedimento</button>
          
          {procedimentos.map((proc) => (
            <div key={proc.id}>
              <h2>Procedimento ID: {proc.id}</h2>
              {/* Renderize seu card de procedimento aqui */}
            </div>
          ))}
        </div>
      );
    };
    
    export default NovoAtendimento;
    

    2. Usando UUIDs

    Se você preferir um ID único global que não dependa de um contador, outra abordagem é utilizar uma biblioteca para gerar IDs, como uuid. Esta abordagem é útil especialmente quando você pode ter problemas com IDs duplicados se os procedimentos forem colocados em diferentes componentes ou páginas.

    Exemplo Usando UUID

    Primeiro, instale o pacote uuid:

    npm install uuid
    

    Depois, você pode usá-lo:

    import React, { useState } from "react";
    import { v4 as uuidv4 } from "uuid"; // Importa a função para gerar UUIDs
    
    interface Procedimento {
      id: string; // ID único como string
      valoresEditaveis: number[];
      status: string[];
    }
    
    const NovoAtendimento: React.FC = () => {
      const [procedimentos, setProcedimentos] = useState<Procedimento[]>([]);
    
      const handleAdicionarProcedimento = () => {
        const novoProcedimento: Procedimento = {
          id: uuidv4(), // Gera um UUID como ID
          valoresEditaveis: [0, 0, 0, 0],
          status: ["rascunho"], // Estado inicial
        };
        
        setProcedimentos((prev) => [...prev, novoProcedimento]);
      };
    
      return (
        <div>
          <h1>Novo Atendimento</h1>
          <button onClick={handleAdicionarProcedimento}>Adicionar Procedimento</button>
          
          {procedimentos.map((proc) => (
            <div key={proc.id}>
              <h2>Procedimento ID: {proc.id}</h2>
              {/* Renderize seu card de procedimento aqui */}
            </div>
          ))}
        </div>
      );
    };
    
    export default NovoAtendimento;
    

    Conclusão

    • Contador Simples: É fácil de implementar, mas os IDs são sequenciais e podem ser duplicados se o estado do componente for redefinido (por exemplo, se o componente for desmontado e montado novamente).

    • UUIDs: São únicos por padrão e evitam a possibilidade de conflitos em ambientes onde os dados possam ser gerados em paralelo ou em diferentes momentos, tornando-os mais adequados em muitos casos.

    Escolha a abordagem que melhor se adequa às suas necessidades. Uma vez que você tenha IDs únicos para cada procedimento, você pode realizar operações como edição ou exclusão de maneira mais eficiente.

  11. User

    e como deixo no card // CardProcedimento.tsx import React from "react"; import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import { v4 as uuidv4 } from "uuid"; // Importa a função para gerar UUIDs

    interface Procedimento { id: string;

    valoresEditaveis: number[]; status: string[]; index: number; handleValorChange: ( index: number, valorIndex: number, novoValor: number ) => void; updateProcedimento: ( index: number, novosDados: Partial<Omit<Procedimento, "valoresEditaveis">> ) => void; }

    const CardProcedimento: React.FC = ({ id,

    valoresEditaveis, status, index, handleValorChange, updateProcedimento, }) => { return ( ID:{proc.id}

      <div className={EstiloNovoAtendimento.divDoCard}>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Código personalizado da CBHPM</span>
          <input
            className={EstiloNovoAtendimento.inputCard}
            type="text"
            placeholder="Digite o Código..."
          />
        </div>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Nome personalizado da CBHPM</span>
          <input
            className={EstiloNovoAtendimento.inputCard}
            type="text"
            placeholder="Digite o Código..."
          />
        </div>
    
        <div className={EstiloNovoAtendimento.divflex}>
          {[
            "Valor Previsto",
            "Valor Glosado",
            "Valor Perdido",
            "Valor Pago",
          ].map((label, valorIndex) => (
            <div className={EstiloNovoAtendimento.valores} key={label}>
              <label className={EstiloNovoAtendimento.labelinput}>
                {label}
              </label>
              <input
                className={EstiloNovoAtendimento.inputValor234}
                type="number"
                value={valoresEditaveis[valorIndex]} // Valor editável
                placeholder=""
                onChange={(e) =>
                  handleValorChange(
                    index,
                    valorIndex,
                    parseFloat(e.target.value) || 0
                  )
                }
                onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
              />
            </div>
          ))}
        </div>
    
        <div className={EstiloNovoAtendimento.divAnexo}>
          <label className={EstiloNovoAtendimento.labelStatus}>Anexos:</label>
          <button className={EstiloNovoAtendimento.anexar}>
            <img
              src="/+.png"
              alt=""
              className={EstiloNovoAtendimento.iconAnexar}
            />
            <i>Adicionar Novo Anexo</i>
          </button>
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de pagamento:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {valoresEditaveis.map(
            (valor, valorIndex) =>
              valor > 0 && (
                <label
                  className={EstiloNovoAtendimento.statusPagamento}
                  key={valorIndex}
                >
                  <img
                    src="/cifrao.png"
                    alt=""
                    className={EstiloNovoAtendimento.iconStatus}
                  />
                  {["Previsto", "Glosado", "Perdido", "Pago"][valorIndex]}
                </label>
              )
          )}
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de atividade:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {[
            "rascunho",
            "validar",
            "validado",
            "faturar",
            "entregue",
            "finalizado",
          ].map((statusItem) => (
            <label
              key={statusItem}
              className={EstiloNovoAtendimento.labelBorda}
            >
              <input
                type="checkbox"
                className={EstiloNovoAtendimento.customCheckbox}
                value={statusItem}
                checked={status.includes(statusItem)} // Verifica se o status está incluído
                onChange={(e) => {
                  const isChecked = e.target.checked;
                  if (isChecked) {
                    updateProcedimento(index, {
                      status: [...status, statusItem], // Adiciona ao array de status
                    });
                  } else {
                    updateProcedimento(index, {
                      status: status.filter((s) => s !== statusItem), // Remove do array de status
                    });
                  }
                }}
              />
              <span className={EstiloNovoAtendimento.labelAtividade}>
                {statusItem.charAt(0).toUpperCase() + statusItem.slice(1)}{" "}
                {/* Capitaliza o primeiro caractere */}
              </span>
            </label>
          ))}
        </div>
      </div>
      <div className={EstiloNovoAtendimento.CardBotton}></div>
    </div>
    

    ); };

    export default CardProcedimento;

  12. Assistant

    Para exibir o ID do procedimento em cada card do componente CardProcedimento, a primeira coisa que você precisa fazer é garantir que o ID está sendo passado corretamente como uma prop para o componente.

    Ajustes no Componente CardProcedimento

    1. Certifique-se de que você está recebendo o parâmetro id nos props.
    2. Use o id para renderizar corretamente o valor no card.

    Vou ajustar o seu código do componente CardProcedimento para que você possa usá-lo corretamente:

    // CardProcedimento.tsx
    import React from "react";
    import EstiloNovoAtendimento from "./NovoAtendimento.module.css";
    
    interface Procedimento {
      id: string; // ID único para cada procedimento
      valoresEditaveis: number[];
      status: string[];
      index: number;
      handleValorChange: (
        index: number,
        valorIndex: number,
        novoValor: number
      ) => void;
      updateProcedimento: (
        index: number,
        novosDados: Partial<Omit<Procedimento, "valoresEditaveis">>
      ) => void;
    }
    
    const CardProcedimento: React.FC<Procedimento> = ({
      id, // ID passa como prop
      valoresEditaveis,
      status,
      index,
      handleValorChange,
      updateProcedimento,
    }) => {
      return (
        <div className={EstiloNovoAtendimento.Card}>
          <div className={EstiloNovoAtendimento.CardTop}>
            <div>
              <span>ID: {id}</span>  {/* Renderizando o ID aqui */}
            </div>
            <div className={EstiloNovoAtendimento.buttonCard}>
              <button>
                <img
                  src="/lapisEditor.png"
                  alt="Editar"
                  className={EstiloNovoAtendimento.icon}
                />
              </button>
              <button>
                <img
                  src="/lixeira.png"
                  alt="Excluir"
                  className={EstiloNovoAtendimento.icon}
                />
              </button>
            </div>
          </div>
    
          <div className={EstiloNovoAtendimento.divDoCard}>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Código personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                placeholder="Digite o Código..."
              />
            </div>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Nome personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                placeholder="Digite o Código..."
              />
            </div>
    
            <div className={EstiloNovoAtendimento.divflex}>
              {["Valor Previsto", "Valor Glosado", "Valor Perdido", "Valor Pago"].map((label, valorIndex) => (
                <div className={EstiloNovoAtendimento.valores} key={label}>
                  <label className={EstiloNovoAtendimento.labelinput}>
                    {label}
                  </label>
                  <input
                    className={EstiloNovoAtendimento.inputValor234}
                    type="number"
                    value={valoresEditaveis[valorIndex]} // Valor editável
                    placeholder=""
                    onChange={(e) =>
                      handleValorChange(index, valorIndex, parseFloat(e.target.value) || 0)
                    }
                    onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                  />
                </div>
              ))}
            </div>
    
            <div className={EstiloNovoAtendimento.divAnexo}>
              <label className={EstiloNovoAtendimento.labelStatus}>Anexos:</label>
              <button className={EstiloNovoAtendimento.anexar}>
                <img
                  src="/+.png"
                  alt=""
                  className={EstiloNovoAtendimento.iconAnexar}
                />
                <i>Adicionar Novo Anexo</i>
              </button>
            </div>
    
            <label className={EstiloNovoAtendimento.labelStatus}>
              Status de pagamento:
            </label>
            <div className={EstiloNovoAtendimento.divflex}>
              {valoresEditaveis.map(
                (valor, valorIndex) =>
                  valor > 0 && (
                    <label
                      className={EstiloNovoAtendimento.statusPagamento}
                      key={valorIndex}
                    >
                      <img
                        src="/cifrao.png"
                        alt=""
                        className={EstiloNovoAtendimento.iconStatus}
                      />
                      {["Previsto", "Glosado", "Perdido", "Pago"][valorIndex]}
                    </label>
                  )
              )}
            </div>
    
            <label className={EstiloNovoAtendimento.labelStatus}>
              Status de atividade:
            </label>
            <div className={EstiloNovoAtendimento.divflex}>
              {["rascunho", "validar", "validado", "faturar", "entregue", "finalizado"].map((statusItem) => (
                <label key={statusItem} className={EstiloNovoAtendimento.labelBorda}>
                  <input
                    type="checkbox"
                    className={EstiloNovoAtendimento.customCheckbox}
                    value={statusItem}
                    checked={status.includes(statusItem)} // Verifica se o status está incluído
                    onChange={(e) => {
                      const isChecked = e.target.checked;
                      if (isChecked) {
                        updateProcedimento(index, {
                          status: [...status, statusItem], // Adiciona ao array de status
                        });
                      } else {
                        updateProcedimento(index, {
                          status: status.filter((s) => s !== statusItem), // Remove do array de status
                        });
                      }
                    }}
                  />
                  <span className={EstiloNovoAtendimento.labelAtividade}>
                    {statusItem.charAt(0).toUpperCase() + statusItem.slice(1)} {/* Capitaliza o primeiro caractere */}
                  </span>
                </label>
              ))}
            </div>
          </div>
          <div className={EstiloNovoAtendimento.CardBotton}></div>
        </div>
      );
    };
    
    export default CardProcedimento;
    

    O que foi modificado:

    • Adicionei a renderização do ID: Usei ID: {id} no lugar onde a ID do procedimento será exibida. Agora, quando você renderizar o componente CardProcedimento, o ID de cada procedimento será mostrado na parte superior do card.
    • Removi a importação do uuidv4: A importação do uuid não é necessária no CardProcedimento, pois a geração do UUID deve ocorrer onde o procedimento é criado, no componente NovoAtendimento.

    Verificação ao Adicionar Procedimento

    Certifique-se de que você está passando o id corretamente ao componente CardProcedimento nos props, conforme você faz a iteracão sobre o array de procedimentos em NovoAtendimento:

    {procedimentos.map((proc) => (
      <CardProcedimento
        key={proc.id}
        id={proc.id} // Passando o ID correto
        valoresEditaveis={proc.valoresEditaveis}
        status={proc.status}
        index={index}
        handleValorChange={handleValorChange}
        updateProcedimento={updateProcedimento}
      />
    ))}
    

    Com essas alterações, o ID único de cada procedimento agora será exibido corretamente no seu card de procedimentos.

  13. User

    gostaria de poder excluir o card ao clicar no por id, tanto do front quanto da api, mas da api ainda nao tenho a url, entao preciso testar sem ter url pra mandar pro backend

  14. Assistant

    Para implementar a funcionalidade de exclusão do card ao clicar no botão de "Excluir", você pode seguir as etapas abaixo. Neste exemplo, vamos lidar apenas com a remoção do card na interface (frente) e depois adicionaremos o código para a chamada à API assim que você tiver a URL.

    1. Modificações no Componente NovoAtendimento

    Primeiramente, você precisa criar uma função de exclusão e passá-la como prop para o componente CardProcedimento.

    Exemplo de Implementação

    const NovoAtendimento: React.FC = () => {
      const [procedimentos, setProcedimentos] = useState<Procedimento[]>([]);
      const [idCounter, setIdCounter] = useState(0);
    
      const handleAdicionarProcedimento = () => {
        const novoProcedimento: Procedimento = {
          id: uuidv4(), // Gera um UUID como ID
          valoresEditaveis: [0, 0, 0, 0],
          status: ["rascunho"],
        };
        
        setProcedimentos((prev) => [...prev, novoProcedimento]);
      };
    
      const handleExcluirProcedimento = (id: string) => {
        // Filtra os procedimentos para remover o que tem o ID correspondente
        setProcedimentos((prev) => prev.filter((proc) => proc.id !== id));
      };
    
      return (
        <div>
          <h1>Novo Atendimento</h1>
          <button onClick={handleAdicionarProcedimento}>Adicionar Procedimento</button>
          
          {procedimentos.map((proc) => (
            <CardProcedimento
              key={proc.id}
              id={proc.id} 
              valoresEditaveis={proc.valoresEditaveis}
              status={proc.status}
              index={procedimentos.findIndex(p => p.id === proc.id)} // Usando o índice corretamente
              handleValorChange={handleValorChange}
              updateProcedimento={updateProcedimento}
              handleExcluir={handleExcluirProcedimento} // Passa a função de exclusão
            />
          ))}
        </div>
      );
    };
    

    2. Modificações no Componente CardProcedimento

    Agora, no componente CardProcedimento, você vai usar a função de exclusão que foi passada como propriedade ao clicar no botão de lixeira:

    const CardProcedimento: React.FC<Procedimento> = ({
      id,
      valoresEditaveis,
      status,
      index,
      handleValorChange,
      updateProcedimento,
      handleExcluir, // Recebe a função de exclusão
    }) => {
      return (
        <div className={EstiloNovoAtendimento.Card}>
          <div className={EstiloNovoAtendimento.CardTop}>
            <div>
              <span>ID: {id}</span>
            </div>
            <div className={EstiloNovoAtendimento.buttonCard}>
              <button onClick={() => handleExcluir(id)}> {/* Chama a função de exclusão ao clicar */}
                <img
                  src="/lixeira.png"
                  alt="Excluir"
                  className={EstiloNovoAtendimento.icon}
                />
              </button>
            </div>
          </div>
    
          {/* O restante do seu card... */}
        </div>
      );
    };
    

    Explicações

    1. Função handleExcluirProcedimento: Essa função recebe um id como parâmetro e usa a função filter para criar um novo array que não inclui o procedimento cujo ID corresponde ao ID passado. Essa nova lista é então definida no estado procedimentos.

    2. Botão de Excluir: No componente CardProcedimento, ao clicar no botão de lixeira, a função handleExcluir é chamada com o ID do procedimento associado.

    Testando sem uma URL de API

    Como você mencionou que ainda não tem uma URL de API, você pode fazer a exclusão apenas no estado local como mostrado acima. Quando você obtiver a URL da API, você pode implementar a lógica de exclusão correspondente por meio de uma requisição à API na função handleExcluirProcedimento.

    Futuras Implementações

    Quando estiver pronto para integrar com a API, você pode modificar a função handleExcluirProcedimento para incluir um fetch ou axios para fazer uma requisição DELETE com o ID do procedimento, além de manter a lógica de atualização do estado local.

    Exemplo de Integração com API (quando disponível)

    const handleExcluirProcedimento = async (id: string) => {
      try {
        await api.delete(`/procedimentos/${id}`); // Substitua pela sua URL correta
        setProcedimentos((prev) => prev.filter((proc) => proc.id !== id));
      } catch (error) {
        console.error("Erro ao excluir procedimento:", error);
      }
    };
    

    Dessa forma, você terá tanto o gerenciamento local quanto a integração futura com a API prontos.

  15. User

    agora sim, vamos a tarefa de manter os dados inseridos e os cards de procedimentos mesmo se sair do componente NovoAtendimento, como podemos fazer isto?

  16. Assistant

    Para manter os dados inseridos e os procedimentos mesmo se o usuário sair do componente NovoAtendimento, você pode utilizar o localStorage do navegador. O localStorage permite que você armazene dados persistentes que podem ser acessados mesmo após a página ser recarregada ou o navegador ser fechado.

    Implementação com localStorage

    Aqui está como você pode implementar isso no seu componente NovoAtendimento:

    1. Salvar os dados dos procedimentos no localStorage sempre que houver uma alteração.
    2. Carregar os dados do localStorage quando o componente for montado.

    Exemplo de Código

    import React, { useEffect, useState } from "react";
    import { v4 as uuidv4 } from "uuid";
    import CardProcedimento from "./CardProcedimento"; // Certifique-se de importar corretamente
    
    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
    }
    
    const NovoAtendimento: React.FC = () => {
      // Inicializa o estado com dados do localStorage ou um array vazio
      const [procedimentos, setProcedimentos] = useState<Procedimento[]>(() => {
        const storedProcedures = localStorage.getItem("procedimentos");
        return storedProcedures ? JSON.parse(storedProcedures) : [];
      });
    
      // Função para adicionar um novo procedimento
      const handleAdicionarProcedimento = () => {
        const novoProcedimento: Procedimento = {
          id: uuidv4(), // Gera um UUID como ID
          valoresEditaveis: [0, 0, 0, 0],
          status: ["rascunho"], // Estado inicial
        };
        
        const novosProcedimentos = [...procedimentos, novoProcedimento];
        setProcedimentos(novosProcedimentos);
        localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Salva no localStorage
      };
    
      // Função para excluir um procedimento
      const handleExcluirProcedimento = (id: string) => {
        const novosProcedimentos = procedimentos.filter(proc => proc.id !== id);
        setProcedimentos(novosProcedimentos);
        localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
      };
    
      // Atualiza o localStorage sempre que procedimentos mudar
      useEffect(() => {
        localStorage.setItem("procedimentos", JSON.stringify(procedimentos));
      }, [procedimentos]);
    
      // Função para atualizar valores editáveis
      const handleValorChange = (index: number, valorIndex: number, novoValor: number) => {
        const novosProcedimentos = [...procedimentos];
        novosProcedimentos[index].valoresEditaveis[valorIndex] = novoValor;
        setProcedimentos(novosProcedimentos);
      };
    
      return (
        <div>
          <h1>Novo Atendimento</h1>
          <button onClick={handleAdicionarProcedimento}>Adicionar Procedimento</button>
          
          {procedimentos.map((proc, index) => (
            <CardProcedimento
              key={proc.id}
              id={proc.id}
              valoresEditaveis={proc.valoresEditaveis}
              status={proc.status}
              index={index}
              handleValorChange={handleValorChange}
              handleExcluir={handleExcluirProcedimento}
            />
          ))}
        </div>
      );
    };
    
    export default NovoAtendimento;
    

    Explicações do Código

    1. Inicializando o Estado:

      • Quando o componente é montado, o estado procedimentos é pré-carregado a partir do localStorage. Se não houver nada armazenado, ele inicializa como um array vazio.
      const [procedimentos, setProcedimentos] = useState<Procedimento[]>(() => {
        const storedProcedures = localStorage.getItem("procedimentos");
        return storedProcedures ? JSON.parse(storedProcedures) : [];
      });
      
    2. Adicionando Procedimentos:

      • Quando um novo procedimento é adicionado, ele é salvo tanto no estado procedimentos quanto no localStorage.
      const novosProcedimentos = [...procedimentos, novoProcedimento];
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos));
      
    3. Excluindo Procedimentos:

      • Semelhante à adição, quando um procedimento é excluído, a lista é filtrada para remover o item correspondente, e o novo estado atual é salvo no localStorage.
    4. Atualizando o localStorage Dinamicamente:

      • O useEffect monitora as alterações no estado procedimentos e atualiza automaticamente o localStorage sempre que a lista de procedimentos for modificada.
      useEffect(() => {
        localStorage.setItem("procedimentos", JSON.stringify(procedimentos));
      }, [procedimentos]);
      

    Teste

    1. Adicionar Procedimentos: Tente adicionar alguns procedimentos e veja que eles são armazenados e permanecem na interface mesmo se você recarregar a página.
    2. Excluir Procedimentos: Informe-se de que você pode excluir procedimentos, e a lista será atualizada de acordo com isso.

    Considerações Futuras

    Essa implementação é uma solução simples e eficaz para manter o estado entre as sessões do navegador. Assim que você estiver pronto para conectar à sua API, você pode substituir a parte do localStorage por chamadas relevantes à API, garantindo que a persistência no lado do servidor seja implementada também.

  17. User

    mas o meu valorchange ta assim

    const handleValorChange = ( index: number, valorIndex: number, novoValor: number ) => { const novosProcedimentos = [...procedimentos]; const valorAntigo = novosProcedimentos[index].valoresEditaveis[valorIndex];

    // Atualiza o valor no procedimento correto
    novosProcedimentos[index].valoresEditaveis[valorIndex] = novoValor;
    
    setProcedimentos(novosProcedimentos);
    atualizarTotal(); // Atualiza todos os totais de acordo com a mudança
    atualizarValoresBarra(); // Atualiza a contagem dos valores na barra
    

    };

  18. Assistant

    Para integrar o handleValorChange corretamente com o armazenamento no localStorage, você pode fazer algumas modificações para persistir os dados sempre que um novo valor for definido. Além disso, é importante garantir que todas as atualizações de estado sejam sincronizadas com o localStorage.

    Vou demonstrar como ajustar o seu handleValorChange para incluir a atualização no localStorage após a modificação dos valores editáveis dos procedimentos:

    Ajuste no handleValorChange

    Modifique a função handleValorChange para que, após a atualização dos valores editáveis, ela também atualize o localStorage. Aqui está como isso pode ser feito:

    const handleValorChange = (
      index: number,
      valorIndex: number,
      novoValor: number
    ) => {
      const novosProcedimentos = [...procedimentos];
    
      // Atualiza o valor no procedimento correto
      novosProcedimentos[index].valoresEditaveis[valorIndex] = novoValor;
    
      // Atualiza o estado local
      setProcedimentos(novosProcedimentos);
    
      // Atualiza o localStorage com a nova lista de procedimentos
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos));
      
      // Se você tiver funções para atualizar totais e barra, mantenha conforme necessário
      atualizarTotal(); // Atualiza todos os totais de acordo com a mudança (se aplicável)
      atualizarValoresBarra(); // Atualiza a contagem dos valores na barra (se aplicável)
    };
    

    Resumo dos Passos

    1. Clonagem do Estado: Você continua a usar a abordagem de clonagem do estado existente (const novosProcedimentos = [...procedimentos];) para garantir que você está manipulando uma cópia do estado.

    2. Atualização do Valor: O novo valor é atualizado no array correspondente (novosProcedimentos[index].valoresEditaveis[valorIndex] = novoValor).

    3. Atualização do Estado: O estado atualizado é definido usando setProcedimentos.

    4. Atualização do localStorage: O localStorage é atualizado imediatamente após a alteração no estado usando localStorage.setItem.

    5. Funções de Atualização (Opcional): Você pode manter chamadas para funções como atualizarTotal() e atualizarValoresBarra() conforme necessário.

    Teste

    Agora, sempre que você alterar o valor em um input no card de procedimento, o novo valor será atualizado tanto no estado da aplicação quanto no localStorage, garantindo que os dados persistam mesmo se o usuário sair do componente ou recarregar a página.

    Exemplo Completo do Componente NovoAtendimento

    Aqui está como a seção relevante do seu componente NovoAtendimento ficaria com o método handleValorChange atualizado:

    const NovoAtendimento: React.FC = () => {
      const [procedimentos, setProcedimentos] = useState<Procedimento[]>(() => {
        const storedProcedures = localStorage.getItem("procedimentos");
        return storedProcedures ? JSON.parse(storedProcedures) : [];
      });
    
      const handleAdicionarProcedimento = () => {
        const novoProcedimento: Procedimento = {
          id: uuidv4(),
          valoresEditaveis: [0, 0, 0, 0],
          status: ["rascunho"],
        };
        
        const novosProcedimentos = [...procedimentos, novoProcedimento];
        setProcedimentos(novosProcedimentos);
        localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos));
      };
    
      const handleExcluirProcedimento = (id: string) => {
        const novosProcedimentos = procedimentos.filter(proc => proc.id !== id);
        setProcedimentos(novosProcedimentos);
        localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos));
      };
    
      const handleValorChange = (index: number, valorIndex: number, novoValor: number) => {
        const novosProcedimentos = [...procedimentos];
        novosProcedimentos[index].valoresEditaveis[valorIndex] = novoValor;
    
        setProcedimentos(novosProcedimentos);
        localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
        atualizarTotal(); // Atualiza todos os totais de acordo com a mudança
        atualizarValoresBarra(); // Atualiza a contagem dos valores na barra
      };
    
      return (
        <div>
          <h1>Novo Atendimento</h1>
          <button onClick={handleAdicionarProcedimento}>Adicionar Procedimento</button>
          
          {procedimentos.map((proc, index) => (
            <CardProcedimento
              key={proc.id}
              id={proc.id}
              valoresEditaveis={proc.valoresEditaveis}
              status={proc.status}
              index={index}
              handleValorChange={handleValorChange}
              handleExcluir={handleExcluirProcedimento}
            />
          ))}
        </div>
      );
    };
    
    export default NovoAtendimento;
    

    Conclusão

    Com essas alterações, você garante que qualquer alteração nos valores dos procedimentos também se refletem no armazenamento local, permitindo que os dados sejam mantidos mesmo que o usuário saia do componente ou recarregue a página. Assim, a experiência do usuário é aprimorada.

  19. User

    deu certo mas queria que os valores desses inputs tambem fossem salvo e fossem pra interface do procedimento

    Código personalizado da CBHPM Nome personalizado da CBHPM na interface pode ficar codeCBHPM e nameCBHPM

  20. Assistant

    Para armazenar e exibir os valores dos inputs de "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" na interface do procedimento, você precisará expandir o estado do procedimento para incluir essas novas propriedades e atualizar o processo de manipulação de mudança de valor.

    Adjustando o Procedimento

    1. Atualize a Interface do Procedimento: Adicione propriedades para armazenar o código e o nome ao seu tipo de Procedimento.
    2. Atualize os Handlers: Crie funções para lidar com as alterações nos novos campos de entrada.
    3. Renderize os Novos Valores: Atualize o componente CardProcedimento para exibir essas informações.

    Exemplo de Implementação

    1. Atualize a Interface do Procedimento

    Adicione as propriedades codigoCBHPM e nomeCBHPM à sua interface:

    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
      codigoCBHPM?: string; // Código personalizado da CBHPM
      nomeCBHPM?: string;    // Nome personalizado da CBHPM
    }
    

    2. Atualize a Função handleValorChange

    Adicione uma nova função para lidar com as mudanças nos inputs de texto:

    const handleInputChange = (index: number, field: string, value: string) => {
      const novosProcedimentos = [...procedimentos];
      novosProcedimentos[index][field] = value; // Atualiza o campo apropriado
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    };
    

    3. Renderize os Novos Inputs no Componente CardProcedimento

    Abaixo está o exemplo atualizado do componente CardProcedimento para incluir os novos inputs e manipular as alterações:

    const CardProcedimento: React.FC<Procedimento> = ({
      id,
      valoresEditaveis,
      status,
      index,
      handleValorChange,
      handleExcluir,
      codigoCBHPM,
      nomeCBHPM,
      handleInputChange,
    }) => {
      return (
        <div className={EstiloNovoAtendimento.Card}>
          <div className={EstiloNovoAtendimento.CardTop}>
            <div>
              <span>ID: {id}</span>
            </div>
            <div className={EstiloNovoAtendimento.buttonCard}>
              <button onClick={() => handleExcluir(id)}>
                <img
                  src="/lixeira.png"
                  alt="Excluir"
                  className={EstiloNovoAtendimento.icon}
                />
              </button>
            </div>
          </div>
    
          <div className={EstiloNovoAtendimento.divDoCard}>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Código personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={codigoCBHPM} // Valor armazenado
                placeholder="Digite o Código..."
                onChange={(e) => handleInputChange(index, 'codigoCBHPM', e.target.value)} // Chamada para atualizar o código
              />
            </div>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Nome personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={nomeCBHPM} // Valor armazenado
                placeholder="Digite o Nome..."
                onChange={(e) => handleInputChange(index, 'nomeCBHPM', e.target.value)} // Chamada para atualizar o nome
              />
            </div>
    
            {/* Continue com o restante do card e valores editáveis */}
            <div className={EstiloNovoAtendimento.divflex}>
              {["Valor Previsto", "Valor Glosado", "Valor Perdido", "Valor Pago"].map((label, valorIndex) => (
                <div className={EstiloNovoAtendimento.valores} key={label}>
                  <label className={EstiloNovoAtendimento.labelinput}>
                    {label}
                  </label>
                  <input
                    className={EstiloNovoAtendimento.inputValor234}
                    type="number"
                    value={valoresEditaveis[valorIndex]} // Valor editável
                    placeholder=""
                    onChange={(e) =>
                      handleValorChange(
                        index,
                        valorIndex,
                        parseFloat(e.target.value) || 0
                      )
                    }
                    onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                  />
                </div>
              ))}
            </div>
    
            <div className={EstiloNovoAtendimento.divAnexo}>
              <label className={EstiloNovoAtendimento.labelStatus}>Anexos:</label>
              <button className={EstiloNovoAtendimento.anexar}>
                <img
                  src="/+.png"
                  alt=""
                  className={EstiloNovoAtendimento.iconAnexar}
                />
                <i>Adicionar Novo Anexo</i>
              </button>
            </div>
    
            {/* Outros elementos do card... */}
          </div>
        </div>
      );
    };
    

    4. Passar o Código e Nome do Procedimento

    Ao instanciar o CardProcedimento no componente NovoAtendimento, você terá que garantir que os novos valores codigoCBHPM e nomeCBHPM sejam passados corretamente:

    {procedimentos.map((proc, index) => (
      <CardProcedimento
        key={proc.id}
        id={proc.id}
        valoresEditaveis={proc.valoresEditaveis}
        status={proc.status}
        index={index}
        codigoCBHPM={proc.codigoCBHPM} // Passa o código
        nomeCBHPM={proc.nomeCBHPM} // Passa o nome
        handleValorChange={handleValorChange}
        handleExcluir={handleExcluirProcedimento}
        handleInputChange={handleInputChange} // Passa a função para lidar com entradas
      />
    ))}
    

    Resumo

    Agora, o código e o nome personalizados da CBHPM serão armazenados e exibidos corretamente:

    • Adicionamos novos campos codigoCBHPM e nomeCBHPM na interface do Procedimento.
    • Criamos a lógica para lidar com a alteração desses campos no handleInputChange.
    • Atualizamos o componente CardProcedimento para permitir que os usuários digitem e vejam os valores desses novos campos.
    • Os valores são salvos no localStorage a cada alteração.

    Com essas alterações, a interface do procedimento exibirá e manterá os novos inputs e seus valores.

  21. User

    O elemento implicitamente tem um tipo 'any' porque a expressão do tipo 'string' não pode ser usada para o tipo de índice 'Procedimento'. Nenhuma assinatura de índice com um parâmetro do tipo 'string' foi localizada no tipo 'Procedimento'.ts(7053) const novosProcedimentos: Procedimento[]

    import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import React, { useState, useEffect } from "react"; import { useApi } from "../../lib/doctorApi"; import { AppointmentRequestDTO } from "./types"; import DropdownSelect from "./DropdownSelect"; import { useLocalContext, Local } from "../Local/LocalContext"; import CardProcedimento from "./cardProcedimento"; import { v4 as uuidv4 } from "uuid"; // Importa a função para gerar UUIDs

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

    export interface FormularioDados { pacienteId: string; total: number; payer: string; // Certifique-se de que isso está aqui pacienteNome: string; local: string; // ou 'local' se preferir; mas stable as diferenças localIdFontePagadora: string; // Esta propriedade deve estar aqui localIdAtendimento: string; // Esta propriedade também deve estar aqui modalidade: string; data: string; valores: number[]; codigo?: string; // Esta pode continuar a ser opcional }

    export interface Paciente { id?: number; name: string; cpf: string; email: string; address: string; celular: string; dataNascimento?: string; idade?: string; }

    interface Procedimento { id: string; valoresEditaveis: number[]; total?: number; // Adicione um total opcional status: string[]; // ou uma enumeração se você preferir codigoCBHPM?: string; // Código personalizado da CBHPM nomeCBHPM?: string; }

    const NovoAtendimento: React.FC = () => { const [pacientes, setPacientes] = useState<Paciente[]>([]); const [locaisFontePagadora, setLocaisFontePagadora] = useState<Local[]>([]); const [locaisAtendimento, setLocaisAtendimento] = useState<Local[]>([]); const localContext = useLocalContext();

    const [procedimentos, setProcedimentos] = useState<Procedimento[]>(() => { const storedProcedures = localStorage.getItem("procedimentos"); return storedProcedures ? JSON.parse(storedProcedures) : []; }); const [idCounter, setIdCounter] = useState(0);

    const updateProcedimento = ( index: number, novosDados: Partial ) => { setProcedimentos((prev) => { const novosProcedimentos = [...prev]; novosProcedimentos[index] = { ...novosProcedimentos[index], ...novosDados, // Aqui você pode atualizar múltiplas propriedades }; return novosProcedimentos; }); };

    const handleAdicionarProcedimento = () => { const novoProcedimento: Procedimento = { id: uuidv4(), // Gera um UUID como ID valoresEditaveis: [0, 0, 0, 0], status: ["rascunho"], // Estado inicial };

    const novosProcedimentos = [...procedimentos, novoProcedimento];
    setProcedimentos(novosProcedimentos);
    localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Salva no localStorage
    

    };

    const handleExcluirProcedimento = (id: string) => { const novosProcedimentos = procedimentos.filter((proc) => proc.id !== id); setProcedimentos(novosProcedimentos); localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage };

    const handleValorChange = ( index: number, valorIndex: number, novoValor: number ) => { const novosProcedimentos = [...procedimentos]; novosProcedimentos[index].valoresEditaveis[valorIndex] = novoValor;

    setProcedimentos(novosProcedimentos);
    localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    atualizarTotal(); // Atualiza todos os totais de acordo com a mudança
    atualizarValoresBarra(); // Atualiza a contagem dos valores na barra
    

    };

    const handleInputChange = (index: number, field: string, value: string) => { const novosProcedimentos = [...procedimentos]; novosProcedimentos[index][field] = value; // Atualiza o campo apropriado setProcedimentos(novosProcedimentos); localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage };

    // Atualiza o localStorage sempre que procedimentos mudar useEffect(() => { localStorage.setItem("procedimentos", JSON.stringify(procedimentos)); }, [procedimentos]);

    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 [valoresBarra, setValoresBarra] = useState([0, 0, 0, 0]); // Novo estado para a contagem da barra 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: { healthInsurance: { cardNumber: "", }, }, }, serviceInfo: { guideCode: "", date: "", totalValue: 0, }, procedures: [], });

    const handleFileChange = async ( event: React.ChangeEvent ) => { setLoading(true); const formData = new FormData();

    const files = event.target.files;
    if (files) {
      Array.from(files).map((file) => {
        formData.append("files", file);
      });
      const uploadResult = await api.post("files/upload", formData);
      if (uploadResult.data.success) {
        setAnexos(uploadResult.data.result);
      }
    }
    

    }; const handleDelete = async (id: string) => { await api.del(files/delete/${id}); const novosAnexos = anexos.filter((anexo) => anexo.id !== id); setAnexos(novosAnexos); };

    const atualizarValoresBarra = () => { const novosValoresBarra = [0, 0, 0, 0]; // Inicializa uma nova contagem

    procedimentos.forEach((proc) => {
      proc.valoresEditaveis.forEach((valor, index) => {
        if (valor > 0) {
          novosValoresBarra[index] += 1; // Incrementa se o valor é maior que 0
        }
      });
    });
    
    setValoresBarra(novosValoresBarra); // Atualiza o estado dos valores da barra
    

    }; const atualizarTotal = () => { const novosValoresBarra = [0, 0, 0, 0]; // Inicializa os valores da barra

    procedimentos.forEach((proc) => {
      proc.valoresEditaveis.forEach((valor, index) => {
        novosValoresBarra[index] += valor; // Acumula os valores correspondentes
      });
    });
    
    // Atualiza o total no estado do formulário
    setFormularioDados((prev) => ({
      ...prev,
      total: novosValoresBarra.reduce((a, b) => a + b, 0), // Calcula o total
      valores: novosValoresBarra, // Atualiza os valores da barra
    }));
    

    };

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

    const [formularioDados, setFormularioDados] = useState({ pacienteId: "", total: 0, pacienteNome: "", local: "", // Ajuste para o nome correto se ele for alterado localIdFontePagadora: "", // Adicione aqui localIdAtendimento: "", // Adicione aqui modalidade: "", data: "", valores: [0, 0, 0, 0], codigo: "", });

    // Funções de efeito para buscar pacientes e locais useEffect(() => { const buscarPacientes = async () => { try { const data = await api.get("patients/find?skip=0&limit=2000"); setPacientes(data.data?.result?.list || []); } catch (error) { console.error("Erro ao buscar pacientes:", error); } };

    buscarPacientes();
    

    }, []);

    const buscarLocais = async () => { try { const data = await api.get("places/find?skip=0&limit=2000"); setLocaisFontePagadora( data.data.result.list.filter((local: Local) => local.payer) ); setLocaisAtendimento( data.data.result.list.filter((local: Local) => local.place) ); } catch (error) { console.error("Erro ao buscar locais:", error); } };

    useEffect(() => { buscarLocais(); }, []);

    const enviarDadosAtendimento = async () => { // Antes de realizar qualquer envio, logue o estado atendimento no console console.log("Dados do atendimento:", atendimento);

    // Simulação: Você pode substituir isso pela chamada real da API quando estiver pronta
    // Exemplo de chamada fictícia
    if (true) {
      // Simulando sucesso
      alert("Atendimento salvo com sucesso!");
    } else {
    }
    

    }; return ( Cadastro de Atendimento

      <form>
        <div className={EstiloNovoAtendimento.divValores}>
          <div className={EstiloNovoAtendimento.inputValores}>
            <label className={EstiloNovoAtendimento.total}>Total:</label>
            {formularioDados.valores.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$ {formularioDados.total.toFixed(2)}{" "}
              {/* Aqui já usará o total atualizado */}
            </label>
            <div className={EstiloNovoAtendimento.graficoRepresentativo}>
              <div className={EstiloNovoAtendimento.barraFixa}>
                {formularioDados.valores.map((valor, index) => (
                  <div
                    key={`grafico-${index}`}
                    style={{
                      backgroundColor: CoresInput[index],
                      width:
                        formularioDados.total > 0
                          ? `${(valor / formularioDados.total) * 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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "convenio",
                  }));
                  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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "particular",
                  }));
                  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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "plantao",
                  }));
                  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) => {
              setFormularioDados((prev) => ({
                ...prev,
                localIdFontePagadora: selectedItem.id,
                payer: selectedItem.name,
              }));
              // 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={formularioDados.localIdFontePagadora} // Valor atual do dropdown
            label="Fonte Pagadora:" // Rótulo a ser exibido
          />
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          <div className={EstiloNovoAtendimento.organizador}>
            <span>Paciente:</span>
            <label htmlFor="Paciente-select"></label>
            <select
              className={EstiloNovoAtendimento.input300px}
              id="Paciente-select"
              value={formularioDados.pacienteId}
              onChange={(e) => {
                const selectedOption = e.target.options[e.target.selectedIndex];
                const pacienteId = selectedOption.value;
                const pacienteNome =
                  selectedOption.getAttribute("data-name") || ""; // Extrai o nome do paciente
    
                // Atualiza tanto o formularioDados quanto o estado de atendimento
                setFormularioDados((prev) => ({
                  ...prev,
                  pacienteId,
                  pacienteNome,
                }));
    
                // Atualiza o estado de atendimento com o paciente selecionado
                setAtendimento((prev) => ({
                  ...prev,
                  related: {
                    ...prev.related,
                    patient: { id: pacienteId, name: pacienteNome },
                  },
                }));
              }}
            >
              <option value="" disabled hidden>
                Selecione um paciente
              </option>
              {pacientes.map((paciente) => (
                <option
                  key={paciente.id}
                  value={paciente.id}
                  data-name={paciente.name}
                >
                  {paciente.name}
                </option>
              ))}
            </select>
          </div>
    
          <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) => {
              setFormularioDados((prev) => ({
                ...prev,
                localIdAtendimento: selectedItem.id, // Define o ID selecionado no formulário
                place: selectedItem.name,
              }));
              // 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={formularioDados.localIdAtendimento} // 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={formularioDados.codigo}
              onChange={(e) => {
                const codigo = e.target.value;
    
                // Atualiza o estado formularioDados
                setFormularioDados({
                  ...formularioDados,
                  codigo, // Atualiza o código no formulário
                });
    
                // 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={formularioDados.data}
              onChange={(e) => {
                const data = e.target.value;
    
                setFormularioDados({
                  ...formularioDados,
                  data,
                });
    
                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}>
          {valoresBarra.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>{procedimentos.length}</label> Procedimento
            </label>
          </div>
          <div className={EstiloNovoAtendimento.graficoRepresentativo}>
            <div className={EstiloNovoAtendimento.barraFixa}>
              {valoresBarra.map((valor, index) => (
                <div
                  key={`grafico-segunda-${index}`}
                  style={{
                    backgroundColor: CoresInput[index],
                    width: `${(valor / procedimentos.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 */}
          {procedimentos.map((proc, index) => (
            <CardProcedimento
              key={proc.id}
              id={proc.id}
              index={procedimentos.findIndex((p) => p.id === proc.id)} // Usando o índice corretamente
              valoresEditaveis={proc.valoresEditaveis}
              status={proc.status}
              handleValorChange={handleValorChange}
              updateProcedimento={updateProcedimento}
              handleExcluir={handleExcluirProcedimento} // Passa a função de exclusão
              handleInputChange={handleInputChange} // Passa a função para lidar com entradas
    
            />
          ))}
        </>
      )}
      <div className={EstiloNovoAtendimento.divSalvarAnexo}>
        <label className={EstiloNovoAtendimento.labelAnexo}>Anexos:</label>
        <div className={EstiloNovoAtendimento.divArquivo}>
          {anexos.length > 0
            ? anexos.map((anexo) => (
                <label key={anexo.id} className={EstiloNovoAtendimento.Arquivo}>
                  {anexo.fileName} {/* Exibir o nome do arquivo */}
                  <button onClick={() => handleDelete(anexo.id)}>
                    <img src="lixeira.png" alt="" />
                  </button>
                </label>
              ))
            : null}{" "}
          {/* Não exibe nada se não houver anexos */}
        </div>
        <div className={EstiloNovoAtendimento.divAnexosNew}>
          <input
            type="file"
            multiple
            onChange={handleFileChange}
            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>
    
      <div className={EstiloNovoAtendimento.divbutton}>
        <button
          className={EstiloNovoAtendimento.buttonSalvar}
          onClick={enviarDadosAtendimento}
        >
          Salvar
        </button>
      </div>
    </div>
    

    ); };

    export default NovoAtendimento;

  22. Assistant

    A mensagem de erro que você está enfrentando, "O elemento implicitamente tem um tipo 'any' porque a expressão do tipo 'string' não pode ser usada para o tipo de índice 'Procedimento'", indica que o TypeScript não consegue garantir que a variável field na sua função handleInputChange seja uma chave do tipo Procedimento.

    Resolvendo o Problema

    Para corrigir esse erro, você pode usar um tipo de índice específico para garantir que somente chaves válidas do tipo Procedimento sejam passadas para a função handleInputChange. Ao invés de utilizar um string genérico, você pode definir o tipo field como uma união de string das chaves da interface Procedimento.

    Atualizando a Interface e a Função

    1. Atualize a interface do Procedimento (caso ainda não tenha feito):
    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
      codigoCBHPM?: string; // Código personalizado da CBHPM
      nomeCBHPM?: string;   // Nome personalizado da CBHPM
    }
    
    1. Mude a função handleInputChange para que ela aceite apenas chaves válidas:
    const handleInputChange = (index: number, field: keyof Procedimento, value: string) => {
      const novosProcedimentos = [...procedimentos];
      novosProcedimentos[index][field] = value; // Atualiza o campo apropriado
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    };
    

    Implementação Completa

    Aqui está como a seção do seu componente NovoAtendimento e o CardProcedimento ficam:

    // NovoAtendimento.tsx
    
    const handleInputChange = (index: number, field: keyof Procedimento, value: string) => {
      const novosProcedimentos = [...procedimentos];
      novosProcedimentos[index][field] = value; // Atualiza o campo apropriado
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    };
    
    // Dentro do return...
    {procedimentos.map((proc, index) => (
      <CardProcedimento
        key={proc.id}
        id={proc.id}
        valoresEditaveis={proc.valoresEditaveis}
        status={proc.status}
        index={index}
        handleValorChange={handleValorChange}
        handleExcluir={handleExcluirProcedimento}
        handleInputChange={handleInputChange} // Passa a função para lidar com entradas
        codigoCBHPM={proc.codigoCBHPM} // Passa o código
        nomeCBHPM={proc.nomeCBHPM} // Passa o nome
      />
    ))}
    
    // CardProcedimento.tsx
    
    <input
      className={EstiloNovoAtendimento.inputCard}
      type="text"
      value={codigoCBHPM} // Mantendo o valor armazenado
      placeholder="Digite o Código..."
      onChange={(e) => handleInputChange(index, 'codigoCBHPM', e.target.value)} // Lida com a mudança
    />
    
    <input
      className={EstiloNovoAtendimento.inputCard}
      type="text"
      value={nomeCBHPM} // Mantendo o valor armazenado
      placeholder="Digite o Nome..."
      onChange={(e) => handleInputChange(index, 'nomeCBHPM', e.target.value)} // Lida com a mudança
    />
    

    Explicações

    • Tipo keyof Procedimento: keyof Procedimento é um tipo de TypeScript que representa todas as chaves da interface Procedimento, permitindo que apenas essas chaves sejam passadas para a função.
    • Atualização do localStorage: O localStorage é atualizado sempre que os valores dos inputs mudam, garantindo que os dados persistam mesmo se o usuário sair do componente ou recarregar a página.

    Resultado Esperado

    Com essas alterações, agora você deve conseguir armazenar os valores dos inputs "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" corretamente no estado e no localStorage. Quando o componente for recriado, esses dados devem ser recuperados e exibidos nos respectivos campos, permitindo que o usuário veja e edite suas informações sem perda de dados.

  23. User

    // CardProcedimento.tsx import React from "react"; import EstiloNovoAtendimento from "./NovoAtendimento.module.css";

    interface Procedimento { id: string; valoresEditaveis: number[]; status: string[]; index: number; codigoCBHPM?: string; nomeCBHPM?: string; handleValorChange: ( index: number, valorIndex: number, novoValor: number ) => void; handleExcluir: (id: string) => void; handleInputChange: (codigoCBHPM: string, nomeCBHPM: string) => void; updateProcedimento: ( index: number, novosDados: Partial<Omit<Procedimento, "valoresEditaveis">> ) => void; }

    const CardProcedimento: React.FC = ({ id, valoresEditaveis, status, index, handleValorChange, updateProcedimento, handleExcluir, // Recebe a função de exclusão codigoCBHPM, nomeCBHPM, handleInputChange, }) => { return ( ID: {id} <button onClick={() => handleExcluir(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={codigoCBHPM} // Mantendo o valor armazenado
            placeholder="Digite o Código..."
            onChange={(e) =>
              handleInputChange(index, "codigoCBHPM", e.target.value)
            } // Lida com a mudança
          />
        </div>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Nome personalizado da CBHPM</span>
          <input
            className={EstiloNovoAtendimento.inputCard}
            type="text"
            value={nomeCBHPM} // Mantendo o valor armazenado
            placeholder="Digite o Nome..."
            onChange={(e) =>
              handleInputChange(index, "nomeCBHPM", e.target.value)
            } // Lida com a mudança
          />
        </div>
    
        <div className={EstiloNovoAtendimento.divflex}>
          {[
            "Valor Previsto",
            "Valor Glosado",
            "Valor Perdido",
            "Valor Pago",
          ].map((label, valorIndex) => (
            <div className={EstiloNovoAtendimento.valores} key={label}>
              <label className={EstiloNovoAtendimento.labelinput}>
                {label}
              </label>
              <input
                className={EstiloNovoAtendimento.inputValor234}
                type="number"
                value={valoresEditaveis[valorIndex]} // Valor editável
                placeholder=""
                onChange={(e) =>
                  handleValorChange(
                    index,
                    valorIndex,
                    parseFloat(e.target.value) || 0
                  )
                }
                onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
              />
            </div>
          ))}
        </div>
    
        <div className={EstiloNovoAtendimento.divAnexo}>
          <label className={EstiloNovoAtendimento.labelStatus}>Anexos:</label>
          <button className={EstiloNovoAtendimento.anexar}>
            <img
              src="/+.png"
              alt=""
              className={EstiloNovoAtendimento.iconAnexar}
            />
            <i>Adicionar Novo Anexo</i>
          </button>
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de pagamento:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {valoresEditaveis.map(
            (valor, valorIndex) =>
              valor > 0 && (
                <label
                  className={EstiloNovoAtendimento.statusPagamento}
                  key={valorIndex}
                >
                  <img
                    src="/cifrao.png"
                    alt=""
                    className={EstiloNovoAtendimento.iconStatus}
                  />
                  {["Previsto", "Glosado", "Perdido", "Pago"][valorIndex]}
                </label>
              )
          )}
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de atividade:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {[
            "rascunho",
            "validar",
            "validado",
            "faturar",
            "entregue",
            "finalizado",
          ].map((statusItem) => (
            <label
              key={statusItem}
              className={EstiloNovoAtendimento.labelBorda}
            >
              <input
                type="checkbox"
                className={EstiloNovoAtendimento.customCheckbox}
                value={statusItem}
                checked={status.includes(statusItem)} // Verifica se o status está incluído
                onChange={(e) => {
                  const isChecked = e.target.checked;
                  if (isChecked) {
                    updateProcedimento(index, {
                      status: [...status, statusItem], // Adiciona ao array de status
                    });
                  } else {
                    updateProcedimento(index, {
                      status: status.filter((s) => s !== statusItem), // Remove do array de status
                    });
                  }
                }}
              />
              <span className={EstiloNovoAtendimento.labelAtividade}>
                {statusItem.charAt(0).toUpperCase() + statusItem.slice(1)}{" "}
                {/* Capitaliza o primeiro caractere */}
              </span>
            </label>
          ))}
        </div>
      </div>
      <div className={EstiloNovoAtendimento.CardBotton}></div>
    </div>
    

    ); };

    export default CardProcedimento;

  24. Assistant

    A partir do que você forneceu, parece que você deseja implementar uma funcionalidade que permita que os campos de entrada "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" no componente CardProcedimento sejam atualizados corretamente e armazenados no estado, bem como no localStorage.

    No código atual que você forneceu, parece que há uma pequena confusão sobre o tipo esperado dos parâmetros em handleInputChange. Vamos corrigi-lo.

    Atualizando a Função handleInputChange

    Atualmente, o handleInputChange espera que você passe apenas dois parâmetros: codigoCBHPM e nomeCBHPM, mas o que você realmente precisa é de um parâmetro para identificar qual campo ao qual está se referindo (no seu caso, você pode usar uma chave como "codigoCBHPM" ou "nomeCBHPM", além do índice do procedimento).

    Código Atualizado

    Aqui está a versão atualizada do seu CardProcedimento.tsx e como você deve organizar o handleInputChange.

    // CardProcedimento.tsx
    import React from "react";
    import EstiloNovoAtendimento from "./NovoAtendimento.module.css";
    
    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
      index: number;
      codigoCBHPM?: string;
      nomeCBHPM?: string;
      handleValorChange: (
        index: number,
        valorIndex: number,
        novoValor: number
      ) => void;
      handleExcluir: (id: string) => void;
      handleInputChange: (index: number, field: keyof Procedimento, value: string) => void;
    }
    
    const CardProcedimento: React.FC<Procedimento> = ({
      id,
      valoresEditaveis,
      status,
      index,
      handleValorChange,
      handleExcluir,
      codigoCBHPM,
      nomeCBHPM,
      handleInputChange,
    }) => {
      return (
        <div className={EstiloNovoAtendimento.Card}>
          <div className={EstiloNovoAtendimento.CardTop}>
            <div>
              <span className={EstiloNovoAtendimento.id}>ID: {id}</span>
            </div>
            <div className={EstiloNovoAtendimento.buttonCard}>
              <button>
                <img
                  src="/lapisEditor.png"
                  alt="Editar"
                  className={EstiloNovoAtendimento.icon}
                />
              </button>
              <button onClick={() => handleExcluir(id)}>
                <img
                  src="/lixeira.png"
                  alt="Excluir"
                  className={EstiloNovoAtendimento.icon}
                />
              </button>
            </div>
          </div>
    
          <div className={EstiloNovoAtendimento.divDoCard}>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Código personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={codigoCBHPM} // Mantém o valor armazenado
                placeholder="Digite o Código..."
                onChange={(e) =>
                  handleInputChange(index, "codigoCBHPM", e.target.value) // Atualiza o campo correspondente
                }
              />
            </div>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Nome personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={nomeCBHPM} // Mantém o valor armazenado
                placeholder="Digite o Nome..."
                onChange={(e) =>
                  handleInputChange(index, "nomeCBHPM", e.target.value) // Atualiza o campo correspondente
                }
              />
            </div>
    
            <div className={EstiloNovoAtendimento.divflex}>
              {["Valor Previsto", "Valor Glosado", "Valor Perdido", "Valor Pago"].map((label, valorIndex) => (
                <div className={EstiloNovoAtendimento.valores} key={label}>
                  <label className={EstiloNovoAtendimento.labelinput}>
                    {label}
                  </label>
                  <input
                    className={EstiloNovoAtendimento.inputValor234}
                    type="number"
                    value={valoresEditaveis[valorIndex]} // Valor editável
                    placeholder=""
                    onChange={(e) =>
                      handleValorChange(
                        index,
                        valorIndex,
                        parseFloat(e.target.value) || 0
                      )
                    }
                    onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                  />
                </div>
              ))}
            </div>
    
            {/* Resto do componente... */}
          </div>
        </div>
      );
    };
    
    export default CardProcedimento;
    

    Atualizando a Função handleInputChange em NovoAtendimento

    A função handleInputChange deve agora aceitar o índice do procedimento como o primeiro parâmetro, o campo como o segundo e o novo valor como o terceiro:

    const handleInputChange = (index: number, field: keyof Procedimento, value: string) => {
      const novosProcedimentos = [...procedimentos];
      novosProcedimentos[index][field] = value; // Atualiza o campo apropriado
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    };
    

    Integração no NovoAtendimento

    Quando você chamar CardProcedimento, garanta que você está passando codigoCBHPM e nomeCBHPM:

    {procedimentos.map((proc, index) => (
      <CardProcedimento
        key={proc.id}
        id={proc.id}
        valoresEditaveis={proc.valoresEditaveis}
        status={proc.status}
        index={index}
        handleValorChange={handleValorChange}
        handleExcluir={handleExcluirProcedimento}
        handleInputChange={handleInputChange}  // Passar a função de entrada
        codigoCBHPM={proc.codigoCBHPM} // Passa o código
        nomeCBHPM={proc.nomeCBHPM} // Passa o nome
      />
    ))}
    

    Conclusão

    Essas adaptações permitirão que você armazene os valores do "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" no estado do seu componente, além de mantê-los sincronizados com o localStorage. Assim, quando o usuário sair do componente, os dados ainda estarão acessíveis quando ele voltar.

  25. User

    O tipo 'string' não pode ser atribuído ao tipo 'string & number[] & string[]'. O tipo 'string' não pode ser atribuído ao tipo 'number[]'.ts(2322) O tipo 'string' não pode ser atribuído ao tipo 'string & number[] & string[]'. O tipo 'string' não pode ser atribuído ao tipo 'number[]'.ts(2322) (parameter) index: number

  26. Assistant

    A mensagem de erro que você está recebendo indica que há algum problema com a atribuição de tipos, especialmente em relação ao parâmetro field na função handleInputChange. Parece que o TypeScript está tendo dificuldades em reconhecer que field deve ser uma das chaves do tipo Procedimento.

    Para resolver esse problema, você deve garantir que o field esteja corretamente tipado como um dos possíveis campos do tipo Procedimento, que incluem codigoCBHPM e nomeCBHPM, entre outros.

    Correção da Tipagem para handleInputChange

    1. Certifique-se que o campo field seja do tipo correto. O tipo de field deve ser uma chave de Procedimento, que você já definiu anteriormente.

    Código Atualizado

    Aqui está a implementação revisada do método handleInputChange e a definição da interface Procedimento, juntamente com o código do seu componente NovoAtendimento:

    Definições da Interface

    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
      codigoCBHPM?: string; // Código personalizado da CBHPM
      nomeCBHPM?: string;   // Nome personalizado da CBHPM
    }
    

    Atualizando handleInputChange

    Aqui está a versão corrigida da função handleInputChange:

    const handleInputChange = (
      index: number,
      field: keyof Procedimento, // O tipo deve ser uma chave da interface Procedimento
      value: string
    ) => {
      const novosProcedimentos = [...procedimentos];
    
      // Atualiza o campo apropriado
      novosProcedimentos[index][field] = value; 
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    };
    

    Usando a Função handleInputChange no Componente CardProcedimento

    Aqui está como você deve utilizar handleInputChange em CardProcedimento.tsx:

    <input
      className={EstiloNovoAtendimento.inputCard}
      type="text"
      value={codigoCBHPM} // Mantendo o valor armazenado
      placeholder="Digite o Código..."
      onChange={(e) =>
        handleInputChange(index, "codigoCBHPM", e.target.value) // Atualiza o campo
      }
    />
    <input
      className={EstiloNovoAtendimento.inputCard}
      type="text"
      value={nomeCBHPM} // Mantendo o valor armazenado
      placeholder="Digite o Nome..."
      onChange={(e) =>
        handleInputChange(index, "nomeCBHPM", e.target.value) // Atualiza o campo
      }
    />
    

    Passando a Função em NovoAtendimento

    Quando você utiliza o CardProcedimento em NovoAtendimento, verifique se você está passando a função handleInputChange e os valores de codigoCBHPM e nomeCBHPM corretamente:

    {procedimentos.map((proc, index) => (
      <CardProcedimento
        key={proc.id}
        id={proc.id}
        valoresEditaveis={proc.valoresEditaveis}
        status={proc.status}
        index={index}
        handleValorChange={handleValorChange}
        handleExcluir={handleExcluirProcedimento}
        handleInputChange={handleInputChange}  // Passar a função para lidar com entradas
        codigoCBHPM={proc.codigoCBHPM} // Passa o código
        nomeCBHPM={proc.nomeCBHPM} // Passa o nome
      />
    ))}
    

    Conclusão

    Com essas correções, o erro de tipo deve ser resolvido, e a manipulação do estado para os campos de "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" deve funcionar conforme esperado. O TypeScript irá garantir que você está passando os tipos corretos nas suas chamadas de função.

  27. User

    import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import React, { useState, useEffect } from "react"; import { useApi } from "../../lib/doctorApi"; import { AppointmentRequestDTO } from "./types"; import DropdownSelect from "./DropdownSelect"; import { useLocalContext, Local } from "../Local/LocalContext"; import CardProcedimento from "./cardProcedimento"; import { v4 as uuidv4 } from "uuid"; // Importa a função para gerar UUIDs

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

    export interface FormularioDados { pacienteId: string; total: number; payer: string; // Certifique-se de que isso está aqui pacienteNome: string; local: string; // ou 'local' se preferir; mas stable as diferenças localIdFontePagadora: string; // Esta propriedade deve estar aqui localIdAtendimento: string; // Esta propriedade também deve estar aqui modalidade: string; data: string; valores: number[]; codigo?: string; // Esta pode continuar a ser opcional }

    export interface Paciente { id?: number; name: string; cpf: string; email: string; address: string; celular: string; dataNascimento?: string; idade?: string; }

    interface Procedimento { id: string; valoresEditaveis: number[]; status: string[]; codigoCBHPM?: string; // Código personalizado da CBHPM nomeCBHPM?: string; // Nome personalizado da CBHPM }

    const NovoAtendimento: React.FC = () => { const [pacientes, setPacientes] = useState<Paciente[]>([]); const [locaisFontePagadora, setLocaisFontePagadora] = useState<Local[]>([]); const [locaisAtendimento, setLocaisAtendimento] = useState<Local[]>([]); const localContext = useLocalContext();

    const [procedimentos, setProcedimentos] = useState<Procedimento[]>(() => { const storedProcedures = localStorage.getItem("procedimentos"); return storedProcedures ? JSON.parse(storedProcedures) : []; }); const [idCounter, setIdCounter] = useState(0);

    const updateProcedimento = ( index: number, novosDados: Partial ) => { setProcedimentos((prev) => { const novosProcedimentos = [...prev]; novosProcedimentos[index] = { ...novosProcedimentos[index], ...novosDados, // Aqui você pode atualizar múltiplas propriedades }; return novosProcedimentos; }); };

    const handleAdicionarProcedimento = () => { const novoProcedimento: Procedimento = { id: uuidv4(), // Gera um UUID como ID valoresEditaveis: [0, 0, 0, 0], status: ["rascunho"], // Estado inicial };

    const novosProcedimentos = [...procedimentos, novoProcedimento];
    setProcedimentos(novosProcedimentos);
    localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Salva no localStorage
    

    };

    const handleExcluirProcedimento = (id: string) => { const novosProcedimentos = procedimentos.filter((proc) => proc.id !== id); setProcedimentos(novosProcedimentos); localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage };

    const handleValorChange = ( index: number, valorIndex: number, novoValor: number ) => { const novosProcedimentos = [...procedimentos]; novosProcedimentos[index].valoresEditaveis[valorIndex] = novoValor;

    setProcedimentos(novosProcedimentos);
    localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    atualizarTotal(); // Atualiza todos os totais de acordo com a mudança
    atualizarValoresBarra(); // Atualiza a contagem dos valores na barra
    

    };

    const handleInputChange = ( index: number, field: keyof Procedimento, // O tipo deve ser uma chave da interface Procedimento value: string ) => { const novosProcedimentos = [...procedimentos];

    // Atualiza o campo apropriado
    novosProcedimentos[index][field] = value;
    setProcedimentos(novosProcedimentos);
    localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    

    };

    // Atualiza o localStorage sempre que procedimentos mudar useEffect(() => { localStorage.setItem("procedimentos", JSON.stringify(procedimentos)); }, [procedimentos]);

    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 [valoresBarra, setValoresBarra] = useState([0, 0, 0, 0]); // Novo estado para a contagem da barra 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: { healthInsurance: { cardNumber: "", }, }, }, serviceInfo: { guideCode: "", date: "", totalValue: 0, }, procedures: [], });

    const handleFileChange = async ( event: React.ChangeEvent ) => { setLoading(true); const formData = new FormData();

    const files = event.target.files;
    if (files) {
      Array.from(files).map((file) => {
        formData.append("files", file);
      });
      const uploadResult = await api.post("files/upload", formData);
      if (uploadResult.data.success) {
        setAnexos(uploadResult.data.result);
      }
    }
    

    }; const handleDelete = async (id: string) => { await api.del(files/delete/${id}); const novosAnexos = anexos.filter((anexo) => anexo.id !== id); setAnexos(novosAnexos); };

    const atualizarValoresBarra = () => { const novosValoresBarra = [0, 0, 0, 0]; // Inicializa uma nova contagem

    procedimentos.forEach((proc) => {
      proc.valoresEditaveis.forEach((valor, index) => {
        if (valor > 0) {
          novosValoresBarra[index] += 1; // Incrementa se o valor é maior que 0
        }
      });
    });
    
    setValoresBarra(novosValoresBarra); // Atualiza o estado dos valores da barra
    

    }; const atualizarTotal = () => { const novosValoresBarra = [0, 0, 0, 0]; // Inicializa os valores da barra

    procedimentos.forEach((proc) => {
      proc.valoresEditaveis.forEach((valor, index) => {
        novosValoresBarra[index] += valor; // Acumula os valores correspondentes
      });
    });
    
    // Atualiza o total no estado do formulário
    setFormularioDados((prev) => ({
      ...prev,
      total: novosValoresBarra.reduce((a, b) => a + b, 0), // Calcula o total
      valores: novosValoresBarra, // Atualiza os valores da barra
    }));
    

    };

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

    const [formularioDados, setFormularioDados] = useState({ pacienteId: "", total: 0, pacienteNome: "", local: "", // Ajuste para o nome correto se ele for alterado localIdFontePagadora: "", // Adicione aqui localIdAtendimento: "", // Adicione aqui modalidade: "", data: "", valores: [0, 0, 0, 0], codigo: "", });

    // Funções de efeito para buscar pacientes e locais useEffect(() => { const buscarPacientes = async () => { try { const data = await api.get("patients/find?skip=0&limit=2000"); setPacientes(data.data?.result?.list || []); } catch (error) { console.error("Erro ao buscar pacientes:", error); } };

    buscarPacientes();
    

    }, []);

    const buscarLocais = async () => { try { const data = await api.get("places/find?skip=0&limit=2000"); setLocaisFontePagadora( data.data.result.list.filter((local: Local) => local.payer) ); setLocaisAtendimento( data.data.result.list.filter((local: Local) => local.place) ); } catch (error) { console.error("Erro ao buscar locais:", error); } };

    useEffect(() => { buscarLocais(); }, []);

    const enviarDadosAtendimento = async () => { // Antes de realizar qualquer envio, logue o estado atendimento no console console.log("Dados do atendimento:", atendimento);

    // Simulação: Você pode substituir isso pela chamada real da API quando estiver pronta
    // Exemplo de chamada fictícia
    if (true) {
      // Simulando sucesso
      alert("Atendimento salvo com sucesso!");
    } else {
    }
    

    }; return ( Cadastro de Atendimento

      <form>
        <div className={EstiloNovoAtendimento.divValores}>
          <div className={EstiloNovoAtendimento.inputValores}>
            <label className={EstiloNovoAtendimento.total}>Total:</label>
            {formularioDados.valores.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$ {formularioDados.total.toFixed(2)}{" "}
              {/* Aqui já usará o total atualizado */}
            </label>
            <div className={EstiloNovoAtendimento.graficoRepresentativo}>
              <div className={EstiloNovoAtendimento.barraFixa}>
                {formularioDados.valores.map((valor, index) => (
                  <div
                    key={`grafico-${index}`}
                    style={{
                      backgroundColor: CoresInput[index],
                      width:
                        formularioDados.total > 0
                          ? `${(valor / formularioDados.total) * 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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "convenio",
                  }));
                  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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "particular",
                  }));
                  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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "plantao",
                  }));
                  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) => {
              setFormularioDados((prev) => ({
                ...prev,
                localIdFontePagadora: selectedItem.id,
                payer: selectedItem.name,
              }));
              // 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={formularioDados.localIdFontePagadora} // Valor atual do dropdown
            label="Fonte Pagadora:" // Rótulo a ser exibido
          />
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          <div className={EstiloNovoAtendimento.organizador}>
            <span>Paciente:</span>
            <label htmlFor="Paciente-select"></label>
            <select
              className={EstiloNovoAtendimento.input300px}
              id="Paciente-select"
              value={formularioDados.pacienteId}
              onChange={(e) => {
                const selectedOption = e.target.options[e.target.selectedIndex];
                const pacienteId = selectedOption.value;
                const pacienteNome =
                  selectedOption.getAttribute("data-name") || ""; // Extrai o nome do paciente
    
                // Atualiza tanto o formularioDados quanto o estado de atendimento
                setFormularioDados((prev) => ({
                  ...prev,
                  pacienteId,
                  pacienteNome,
                }));
    
                // Atualiza o estado de atendimento com o paciente selecionado
                setAtendimento((prev) => ({
                  ...prev,
                  related: {
                    ...prev.related,
                    patient: { id: pacienteId, name: pacienteNome },
                  },
                }));
              }}
            >
              <option value="" disabled hidden>
                Selecione um paciente
              </option>
              {pacientes.map((paciente) => (
                <option
                  key={paciente.id}
                  value={paciente.id}
                  data-name={paciente.name}
                >
                  {paciente.name}
                </option>
              ))}
            </select>
          </div>
    
          <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) => {
              setFormularioDados((prev) => ({
                ...prev,
                localIdAtendimento: selectedItem.id, // Define o ID selecionado no formulário
                place: selectedItem.name,
              }));
              // 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={formularioDados.localIdAtendimento} // 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={formularioDados.codigo}
              onChange={(e) => {
                const codigo = e.target.value;
    
                // Atualiza o estado formularioDados
                setFormularioDados({
                  ...formularioDados,
                  codigo, // Atualiza o código no formulário
                });
    
                // 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={formularioDados.data}
              onChange={(e) => {
                const data = e.target.value;
    
                setFormularioDados({
                  ...formularioDados,
                  data,
                });
    
                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}>
          {valoresBarra.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>{procedimentos.length}</label> Procedimento
            </label>
          </div>
          <div className={EstiloNovoAtendimento.graficoRepresentativo}>
            <div className={EstiloNovoAtendimento.barraFixa}>
              {valoresBarra.map((valor, index) => (
                <div
                  key={`grafico-segunda-${index}`}
                  style={{
                    backgroundColor: CoresInput[index],
                    width: `${(valor / procedimentos.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 */}
          {procedimentos.map((proc, index) => (
            <CardProcedimento
              key={proc.id}
              id={proc.id}
              valoresEditaveis={proc.valoresEditaveis}
              status={proc.status}
              index={index}
              handleValorChange={handleValorChange}
              handleExcluir={handleExcluirProcedimento}
              handleInputChange={handleInputChange} // Passar a função para lidar com entradas
              codigoCBHPM={proc.codigoCBHPM} // Passa o código
              nomeCBHPM={proc.nomeCBHPM} // Passa o nome
            />
          ))}
        </>
      )}
      <div className={EstiloNovoAtendimento.divSalvarAnexo}>
        <label className={EstiloNovoAtendimento.labelAnexo}>Anexos:</label>
        <div className={EstiloNovoAtendimento.divArquivo}>
          {anexos.length > 0
            ? anexos.map((anexo) => (
                <label key={anexo.id} className={EstiloNovoAtendimento.Arquivo}>
                  {anexo.fileName} {/* Exibir o nome do arquivo */}
                  <button onClick={() => handleDelete(anexo.id)}>
                    <img src="lixeira.png" alt="" />
                  </button>
                </label>
              ))
            : null}{" "}
          {/* Não exibe nada se não houver anexos */}
        </div>
        <div className={EstiloNovoAtendimento.divAnexosNew}>
          <input
            type="file"
            multiple
            onChange={handleFileChange}
            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>
    
      <div className={EstiloNovoAtendimento.divbutton}>
        <button
          className={EstiloNovoAtendimento.buttonSalvar}
          onClick={enviarDadosAtendimento}
        >
          Salvar
        </button>
      </div>
    </div>
    

    ); };

    export default NovoAtendimento; // CardProcedimento.tsx import React from "react"; import EstiloNovoAtendimento from "./NovoAtendimento.module.css";

    interface Procedimento { id: string; valoresEditaveis: number[]; status: string[]; index: number; codigoCBHPM?: string; nomeCBHPM?: string; handleValorChange: ( index: number, valorIndex: number, novoValor: number ) => void; handleExcluir: (id: string) => void; handleInputChange: ( index: number, field: keyof Procedimento, value: string ) => void; updateProcedimento: ( index: number, novosDados: Partial<Omit<Procedimento, "valoresEditaveis">> ) => void; }

    const CardProcedimento: React.FC = ({ id, valoresEditaveis, status, index, handleValorChange, updateProcedimento, handleExcluir, // Recebe a função de exclusão codigoCBHPM, nomeCBHPM, handleInputChange, }) => { return ( ID: {id} <button onClick={() => handleExcluir(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={codigoCBHPM} // Mantendo o valor armazenado
            placeholder="Digite o Código..."
            onChange={
              (e) => handleInputChange(index, "codigoCBHPM", e.target.value) // Atualiza o campo
            }
          />
        </div>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Nome personalizado da CBHPM</span>
          <input
            className={EstiloNovoAtendimento.inputCard}
            type="text"
            value={nomeCBHPM} // Mantendo o valor armazenado
            placeholder="Digite o Nome..."
            onChange={
              (e) => handleInputChange(index, "nomeCBHPM", e.target.value) // Atualiza o campo
            }
          />
        </div>
    
        <div className={EstiloNovoAtendimento.divflex}>
          {[
            "Valor Previsto",
            "Valor Glosado",
            "Valor Perdido",
            "Valor Pago",
          ].map((label, valorIndex) => (
            <div className={EstiloNovoAtendimento.valores} key={label}>
              <label className={EstiloNovoAtendimento.labelinput}>
                {label}
              </label>
              <input
                className={EstiloNovoAtendimento.inputValor234}
                type="number"
                value={valoresEditaveis[valorIndex]} // Valor editável
                placeholder=""
                onChange={(e) =>
                  handleValorChange(
                    index,
                    valorIndex,
                    parseFloat(e.target.value) || 0
                  )
                }
                onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
              />
            </div>
          ))}
        </div>
    
        <div className={EstiloNovoAtendimento.divAnexo}>
          <label className={EstiloNovoAtendimento.labelStatus}>Anexos:</label>
          <button className={EstiloNovoAtendimento.anexar}>
            <img
              src="/+.png"
              alt=""
              className={EstiloNovoAtendimento.iconAnexar}
            />
            <i>Adicionar Novo Anexo</i>
          </button>
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de pagamento:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {valoresEditaveis.map(
            (valor, valorIndex) =>
              valor > 0 && (
                <label
                  className={EstiloNovoAtendimento.statusPagamento}
                  key={valorIndex}
                >
                  <img
                    src="/cifrao.png"
                    alt=""
                    className={EstiloNovoAtendimento.iconStatus}
                  />
                  {["Previsto", "Glosado", "Perdido", "Pago"][valorIndex]}
                </label>
              )
          )}
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de atividade:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {[
            "rascunho",
            "validar",
            "validado",
            "faturar",
            "entregue",
            "finalizado",
          ].map((statusItem) => (
            <label
              key={statusItem}
              className={EstiloNovoAtendimento.labelBorda}
            >
              <input
                type="checkbox"
                className={EstiloNovoAtendimento.customCheckbox}
                value={statusItem}
                checked={status.includes(statusItem)} // Verifica se o status está incluído
                onChange={(e) => {
                  const isChecked = e.target.checked;
                  if (isChecked) {
                    updateProcedimento(index, {
                      status: [...status, statusItem], // Adiciona ao array de status
                    });
                  } else {
                    updateProcedimento(index, {
                      status: status.filter((s) => s !== statusItem), // Remove do array de status
                    });
                  }
                }}
              />
              <span className={EstiloNovoAtendimento.labelAtividade}>
                {statusItem.charAt(0).toUpperCase() + statusItem.slice(1)}{" "}
                {/* Capitaliza o primeiro caractere */}
              </span>
            </label>
          ))}
        </div>
      </div>
      <div className={EstiloNovoAtendimento.CardBotton}></div>
    </div>
    

    ); };

    export default CardProcedimento; O tipo 'string' não pode ser atribuído ao tipo 'string & number[] & string[]'. O tipo 'string' não pode ser atribuído ao tipo 'number[]'.ts(2322) const novosProcedimentos: Procedimento[] O tipo 'string' não pode ser atribuído ao tipo 'string & number[] & string[]'. O tipo 'string' não pode ser atribuído ao tipo 'number[]'.ts(2322) (parameter) index: number O tipo 'string' não pode ser atribuído ao tipo 'string & number[] & string[]'. O tipo 'string' não pode ser atribuído ao tipo 'number[]'.ts(2322) (parameter) field: keyof Procedimento

  28. Assistant

    Parece que o TypeScript está interpretando o parâmetro field de forma que ele não está convencido de que você está passando uma chave válida para a interface Procedimento. Essa situação ocorre quando você não tem certeza das chaves que está usando.

    Quando você usa keyof Procedimento, você deve garantir que o campo corresponde a uma das chaves que a interface Procedimento aceita. O problema que você está enfrentando parece estar relacionado ao tipo que você está usando para o campo field na função handleInputChange.

    Correção do Código

    Vamos ajustar o código para garantir que o tipo do field e seus valores estejam corretos.

    1. Atualizando o handleInputChange

    Certifique-se de que a função handleInputChange aceita as chaves da interface Procedimento e que você está passando corretamente os parâmetros:

    const handleInputChange = (
      index: number,
      field: keyof Procedimento, // Isso agora é uma chave válida
      value: string
    ) => {
      const novosProcedimentos = [...procedimentos];
      novosProcedimentos[index][field] = value; // Isso deve funcionar corretamente agora
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos));
    };
    

    2. Modificando o CardProcedimento

    Quando você chama handleInputChange, certifique-se de que está passando a chave correta:

    <input
      className={EstiloNovoAtendimento.inputCard}
      type="text"
      value={codigoCBHPM} // Mantém o valor armazenado
      placeholder="Digite o Código..."
      onChange={(e) => handleInputChange(index, "codigoCBHPM", e.target.value)} // Passando o campo corretamente
    />
    
    <input
      className={EstiloNovoAtendimento.inputCard}
      type="text"
      value={nomeCBHPM} // Mantém o valor armazenado
      placeholder="Digite o Nome..."
      onChange={(e) => handleInputChange(index, "nomeCBHPM", e.target.value)} // Passando o campo corretamente
    />
    

    Verificação do Código

    Com essas adaptações, seu código deve estar assim:

    Componente NovoAtendimento

    // NovoAtendimento.tsx
    
    // ... o restante do seu código
    
    const handleInputChange = (
      index: number,
      field: keyof Procedimento,
      value: string
    ) => {
      const novosProcedimentos = [...procedimentos];
      novosProcedimentos[index][field] = value; // Atualiza o campo apropriado
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    };
    
    // ... o restante do seu código
    
    {procedimentos.map((proc, index) => (
      <CardProcedimento
        key={proc.id}
        id={proc.id}
        valoresEditaveis={proc.valoresEditaveis}
        status={proc.status}
        index={index}
        handleValorChange={handleValorChange}
        handleExcluir={handleExcluirProcedimento}
        handleInputChange={handleInputChange} // Passar a função para lidar com entradas
        codigoCBHPM={proc.codigoCBHPM} // Passa o código
        nomeCBHPM={proc.nomeCBHPM} // Passa o nome
      />
    ))}
    

    Componente CardProcedimento

    // CardProcedimento.tsx
    
    const CardProcedimento: React.FC<Procedimento> = ({
      id,
      valoresEditaveis,
      status,
      index,
      handleValorChange,
      handleExcluir,
      codigoCBHPM,
      nomeCBHPM,
      handleInputChange,
    }) => {
      return (
        <div className={EstiloNovoAtendimento.Card}>
          <div className={EstiloNovoAtendimento.CardTop}>
            <div>
              <span className={EstiloNovoAtendimento.id}>ID: {id}</span>
            </div>
            <div className={EstiloNovoAtendimento.buttonCard}>
              <button onClick={() => handleExcluir(id)}>
                <img
                  src="/lixeira.png"
                  alt="Excluir"
                  className={EstiloNovoAtendimento.icon}
                />
              </button>
            </div>
          </div>
    
          <div className={EstiloNovoAtendimento.divDoCard}>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Código personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={codigoCBHPM} // Mantém o valor armazenado
                placeholder="Digite o Código..."
                onChange={(e) => 
                  handleInputChange(index, "codigoCBHPM", e.target.value)} // Passando corretamente
              />
            </div>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Nome personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={nomeCBHPM} // Mantém o valor armazenado
                placeholder="Digite o Nome..."
                onChange={(e) => 
                  handleInputChange(index, "nomeCBHPM", e.target.value)} // Passando corretamente
              />
            </div>
    
            <div className={EstiloNovoAtendimento.divflex}>
              {["Valor Previsto", "Valor Glosado", "Valor Perdido", "Valor Pago"].map((label, valorIndex) => (
                <div className={EstiloNovoAtendimento.valores} key={label}>
                  <label className={EstiloNovoAtendimento.labelinput}>
                    {label}
                  </label>
                  <input
                    className={EstiloNovoAtendimento.inputValor234}
                    type="number"
                    value={valoresEditaveis[valorIndex]} // Valor editável
                    placeholder=""
                    onChange={(e) =>
                      handleValorChange(
                        index,
                        valorIndex,
                        parseFloat(e.target.value) || 0
                      )
                    }
                    onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                  />
                </div>
              ))}
            </div>
            
            {/* Continue com o resto do componente */}
          </div>
        </div>
      );
    };
    
    export default CardProcedimento;
    

    Conclusão

    Com essas correções, o TypeScript deve agora entender que os valores que você está atribuindo a um campo da interface Procedimento são válidos. Você deve conseguir manipular corretamente os inputs e mantê-los sincronizados tanto na interface quanto no localStorage. Se ainda houver erros, certifique-se de que todos os tipos e usos de chave estão consistentes em todo o seu código.

  29. User

    como faço pra guardar os dados desses inputs

    <input className={EstiloNovoAtendimento.inputCard} type="text" value={codigoCBHPM} // Mantendo o valor armazenado placeholder="Digite o Código..." /> Nome personalizado da CBHPM <input className={EstiloNovoAtendimento.inputCard} type="text" value={nomeCBHPM} // Mantendo o valor armazenado placeholder="Digite o Nome..." />

    pra que fiquem salvos no localStorage tambem pra ficarem guardados no card de procedimento quando saio do componente NovoAtendimento

    import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import React, { useState, useEffect } from "react"; import { useApi } from "../../lib/doctorApi"; import { AppointmentRequestDTO } from "./types"; import DropdownSelect from "./DropdownSelect"; import { useLocalContext, Local } from "../Local/LocalContext"; import CardProcedimento from "./cardProcedimento"; import { v4 as uuidv4 } from "uuid"; // Importa a função para gerar UUIDs

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

    export interface FormularioDados { pacienteId: string; total: number; payer: string; // Certifique-se de que isso está aqui pacienteNome: string; local: string; // ou 'local' se preferir; mas stable as diferenças localIdFontePagadora: string; // Esta propriedade deve estar aqui localIdAtendimento: string; // Esta propriedade também deve estar aqui modalidade: string; data: string; valores: number[]; codigo?: string; // Esta pode continuar a ser opcional }

    export interface Paciente { id?: number; name: string; cpf: string; email: string; address: string; celular: string; dataNascimento?: string; idade?: string; }

    interface Procedimento { id: string; valoresEditaveis: number[]; total?: number; // Adicione um total opcional status: string[]; // ou uma enumeração se você preferir codigoCBHPM?: string; // Código personalizado da CBHPM nomeCBHPM?: string; }

    const NovoAtendimento: React.FC = () => { const [pacientes, setPacientes] = useState<Paciente[]>([]); const [locaisFontePagadora, setLocaisFontePagadora] = useState<Local[]>([]); const [locaisAtendimento, setLocaisAtendimento] = useState<Local[]>([]); const localContext = useLocalContext();

    const [procedimentos, setProcedimentos] = useState<Procedimento[]>(() => { const storedProcedures = localStorage.getItem("procedimentos"); return storedProcedures ? JSON.parse(storedProcedures) : []; }); const [idCounter, setIdCounter] = useState(0);

    const updateProcedimento = ( index: number, novosDados: Partial ) => { setProcedimentos((prev) => { const novosProcedimentos = [...prev]; novosProcedimentos[index] = { ...novosProcedimentos[index], ...novosDados, // Aqui você pode atualizar múltiplas propriedades }; return novosProcedimentos; }); };

    const handleAdicionarProcedimento = () => { const novoProcedimento: Procedimento = { id: uuidv4(), // Gera um UUID como ID valoresEditaveis: [0, 0, 0, 0], status: ["rascunho"], // Estado inicial };

    const novosProcedimentos = [...procedimentos, novoProcedimento];
    setProcedimentos(novosProcedimentos);
    localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Salva no localStorage
    

    };

    const handleExcluirProcedimento = (id: string) => { const novosProcedimentos = procedimentos.filter((proc) => proc.id !== id); setProcedimentos(novosProcedimentos); localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage };

    const handleValorChange = ( index: number, valorIndex: number, novoValor: number ) => { const novosProcedimentos = [...procedimentos]; novosProcedimentos[index].valoresEditaveis[valorIndex] = novoValor;

    setProcedimentos(novosProcedimentos);
    localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    atualizarTotal(); // Atualiza todos os totais de acordo com a mudança
    atualizarValoresBarra(); // Atualiza a contagem dos valores na barra
    

    };

    // Atualiza o localStorage sempre que procedimentos mudar useEffect(() => { localStorage.setItem("procedimentos", JSON.stringify(procedimentos)); }, [procedimentos]);

    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 [valoresBarra, setValoresBarra] = useState([0, 0, 0, 0]); // Novo estado para a contagem da barra 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: { healthInsurance: { cardNumber: "", }, }, }, serviceInfo: { guideCode: "", date: "", totalValue: 0, }, procedures: [], });

    const handleFileChange = async ( event: React.ChangeEvent ) => { setLoading(true); const formData = new FormData();

    const files = event.target.files;
    if (files) {
      Array.from(files).map((file) => {
        formData.append("files", file);
      });
      const uploadResult = await api.post("files/upload", formData);
      if (uploadResult.data.success) {
        setAnexos(uploadResult.data.result);
      }
    }
    

    }; const handleDelete = async (id: string) => { await api.del(files/delete/${id}); const novosAnexos = anexos.filter((anexo) => anexo.id !== id); setAnexos(novosAnexos); };

    const atualizarValoresBarra = () => { const novosValoresBarra = [0, 0, 0, 0]; // Inicializa uma nova contagem

    procedimentos.forEach((proc) => {
      proc.valoresEditaveis.forEach((valor, index) => {
        if (valor > 0) {
          novosValoresBarra[index] += 1; // Incrementa se o valor é maior que 0
        }
      });
    });
    
    setValoresBarra(novosValoresBarra); // Atualiza o estado dos valores da barra
    

    }; const atualizarTotal = () => { const novosValoresBarra = [0, 0, 0, 0]; // Inicializa os valores da barra

    procedimentos.forEach((proc) => {
      proc.valoresEditaveis.forEach((valor, index) => {
        novosValoresBarra[index] += valor; // Acumula os valores correspondentes
      });
    });
    
    // Atualiza o total no estado do formulário
    setFormularioDados((prev) => ({
      ...prev,
      total: novosValoresBarra.reduce((a, b) => a + b, 0), // Calcula o total
      valores: novosValoresBarra, // Atualiza os valores da barra
    }));
    

    };

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

    const [formularioDados, setFormularioDados] = useState({ pacienteId: "", total: 0, pacienteNome: "", local: "", // Ajuste para o nome correto se ele for alterado localIdFontePagadora: "", // Adicione aqui localIdAtendimento: "", // Adicione aqui modalidade: "", data: "", valores: [0, 0, 0, 0], codigo: "", });

    // Funções de efeito para buscar pacientes e locais useEffect(() => { const buscarPacientes = async () => { try { const data = await api.get("patients/find?skip=0&limit=2000"); setPacientes(data.data?.result?.list || []); } catch (error) { console.error("Erro ao buscar pacientes:", error); } };

    buscarPacientes();
    

    }, []);

    const buscarLocais = async () => { try { const data = await api.get("places/find?skip=0&limit=2000"); setLocaisFontePagadora( data.data.result.list.filter((local: Local) => local.payer) ); setLocaisAtendimento( data.data.result.list.filter((local: Local) => local.place) ); } catch (error) { console.error("Erro ao buscar locais:", error); } };

    useEffect(() => { buscarLocais(); }, []);

    const enviarDadosAtendimento = async () => { // Antes de realizar qualquer envio, logue o estado atendimento no console console.log("Dados do atendimento:", atendimento);

    // Simulação: Você pode substituir isso pela chamada real da API quando estiver pronta
    // Exemplo de chamada fictícia
    if (true) {
      // Simulando sucesso
      alert("Atendimento salvo com sucesso!");
    } else {
    }
    

    }; return ( Cadastro de Atendimento

      <form>
        <div className={EstiloNovoAtendimento.divValores}>
          <div className={EstiloNovoAtendimento.inputValores}>
            <label className={EstiloNovoAtendimento.total}>Total:</label>
            {formularioDados.valores.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$ {formularioDados.total.toFixed(2)}{" "}
              {/* Aqui já usará o total atualizado */}
            </label>
            <div className={EstiloNovoAtendimento.graficoRepresentativo}>
              <div className={EstiloNovoAtendimento.barraFixa}>
                {formularioDados.valores.map((valor, index) => (
                  <div
                    key={`grafico-${index}`}
                    style={{
                      backgroundColor: CoresInput[index],
                      width:
                        formularioDados.total > 0
                          ? `${(valor / formularioDados.total) * 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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "convenio",
                  }));
                  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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "particular",
                  }));
                  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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "plantao",
                  }));
                  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) => {
              setFormularioDados((prev) => ({
                ...prev,
                localIdFontePagadora: selectedItem.id,
                payer: selectedItem.name,
              }));
              // 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={formularioDados.localIdFontePagadora} // Valor atual do dropdown
            label="Fonte Pagadora:" // Rótulo a ser exibido
          />
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          <div className={EstiloNovoAtendimento.organizador}>
            <span>Paciente:</span>
            <label htmlFor="Paciente-select"></label>
            <select
              className={EstiloNovoAtendimento.input300px}
              id="Paciente-select"
              value={formularioDados.pacienteId}
              onChange={(e) => {
                const selectedOption = e.target.options[e.target.selectedIndex];
                const pacienteId = selectedOption.value;
                const pacienteNome =
                  selectedOption.getAttribute("data-name") || ""; // Extrai o nome do paciente
    
                // Atualiza tanto o formularioDados quanto o estado de atendimento
                setFormularioDados((prev) => ({
                  ...prev,
                  pacienteId,
                  pacienteNome,
                }));
    
                // Atualiza o estado de atendimento com o paciente selecionado
                setAtendimento((prev) => ({
                  ...prev,
                  related: {
                    ...prev.related,
                    patient: { id: pacienteId, name: pacienteNome },
                  },
                }));
              }}
            >
              <option value="" disabled hidden>
                Selecione um paciente
              </option>
              {pacientes.map((paciente) => (
                <option
                  key={paciente.id}
                  value={paciente.id}
                  data-name={paciente.name}
                >
                  {paciente.name}
                </option>
              ))}
            </select>
          </div>
    
          <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) => {
              setFormularioDados((prev) => ({
                ...prev,
                localIdAtendimento: selectedItem.id, // Define o ID selecionado no formulário
                place: selectedItem.name,
              }));
              // 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={formularioDados.localIdAtendimento} // 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={formularioDados.codigo}
              onChange={(e) => {
                const codigo = e.target.value;
    
                // Atualiza o estado formularioDados
                setFormularioDados({
                  ...formularioDados,
                  codigo, // Atualiza o código no formulário
                });
    
                // 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={formularioDados.data}
              onChange={(e) => {
                const data = e.target.value;
    
                setFormularioDados({
                  ...formularioDados,
                  data,
                });
    
                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}>
          {valoresBarra.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>{procedimentos.length}</label> Procedimento
            </label>
          </div>
          <div className={EstiloNovoAtendimento.graficoRepresentativo}>
            <div className={EstiloNovoAtendimento.barraFixa}>
              {valoresBarra.map((valor, index) => (
                <div
                  key={`grafico-segunda-${index}`}
                  style={{
                    backgroundColor: CoresInput[index],
                    width: `${(valor / procedimentos.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 */}
          {procedimentos.map((proc, index) => (
            <CardProcedimento
              key={proc.id}
              id={proc.id}
              index={procedimentos.findIndex((p) => p.id === proc.id)} // Usando o índice corretamente
              valoresEditaveis={proc.valoresEditaveis}
              status={proc.status}
              handleValorChange={handleValorChange}
              updateProcedimento={updateProcedimento}
              handleExcluir={handleExcluirProcedimento} // Passa a função de exclusão
            />
          ))}
        </>
      )}
      <div className={EstiloNovoAtendimento.divSalvarAnexo}>
        <label className={EstiloNovoAtendimento.labelAnexo}>Anexos:</label>
        <div className={EstiloNovoAtendimento.divArquivo}>
          {anexos.length > 0
            ? anexos.map((anexo) => (
                <label key={anexo.id} className={EstiloNovoAtendimento.Arquivo}>
                  {anexo.fileName} {/* Exibir o nome do arquivo */}
                  <button onClick={() => handleDelete(anexo.id)}>
                    <img src="lixeira.png" alt="" />
                  </button>
                </label>
              ))
            : null}{" "}
          {/* Não exibe nada se não houver anexos */}
        </div>
        <div className={EstiloNovoAtendimento.divAnexosNew}>
          <input
            type="file"
            multiple
            onChange={handleFileChange}
            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>
    
      <div className={EstiloNovoAtendimento.divbutton}>
        <button
          className={EstiloNovoAtendimento.buttonSalvar}
          onClick={enviarDadosAtendimento}
        >
          Salvar
        </button>
      </div>
    </div>
    

    ); };

    export default NovoAtendimento;

    // CardProcedimento.tsx import React from "react"; import EstiloNovoAtendimento from "./NovoAtendimento.module.css";

    interface Procedimento { id: string; valoresEditaveis: number[]; status: string[]; index: number; codigoCBHPM?: string; nomeCBHPM?: string; handleValorChange: ( index: number, valorIndex: number, novoValor: number ) => void; handleExcluir: (id: string) => void; updateProcedimento: ( index: number, novosDados: Partial<Omit<Procedimento, "valoresEditaveis">> ) => void; }

    const CardProcedimento: React.FC = ({ id, valoresEditaveis, status, index, handleValorChange, updateProcedimento, handleExcluir, // Recebe a função de exclusão codigoCBHPM, nomeCBHPM, }) => { return ( ID: {id} <button onClick={() => handleExcluir(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={codigoCBHPM} // Mantendo o valor armazenado
            placeholder="Digite o Código..."
          />
        </div>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Nome personalizado da CBHPM</span>
          <input
            className={EstiloNovoAtendimento.inputCard}
            type="text"
            value={nomeCBHPM} // Mantendo o valor armazenado
            placeholder="Digite o Nome..."
          />
        </div>
    
        <div className={EstiloNovoAtendimento.divflex}>
          {[
            "Valor Previsto",
            "Valor Glosado",
            "Valor Perdido",
            "Valor Pago",
          ].map((label, valorIndex) => (
            <div className={EstiloNovoAtendimento.valores} key={label}>
              <label className={EstiloNovoAtendimento.labelinput}>
                {label}
              </label>
              <input
                className={EstiloNovoAtendimento.inputValor234}
                type="number"
                value={valoresEditaveis[valorIndex]} // Valor editável
                placeholder=""
                onChange={(e) =>
                  handleValorChange(
                    index,
                    valorIndex,
                    parseFloat(e.target.value) || 0
                  )
                }
                onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
              />
            </div>
          ))}
        </div>
    
        <div className={EstiloNovoAtendimento.divAnexo}>
          <label className={EstiloNovoAtendimento.labelStatus}>Anexos:</label>
          <button className={EstiloNovoAtendimento.anexar}>
            <img
              src="/+.png"
              alt=""
              className={EstiloNovoAtendimento.iconAnexar}
            />
            <i>Adicionar Novo Anexo</i>
          </button>
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de pagamento:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {valoresEditaveis.map(
            (valor, valorIndex) =>
              valor > 0 && (
                <label
                  className={EstiloNovoAtendimento.statusPagamento}
                  key={valorIndex}
                >
                  <img
                    src="/cifrao.png"
                    alt=""
                    className={EstiloNovoAtendimento.iconStatus}
                  />
                  {["Previsto", "Glosado", "Perdido", "Pago"][valorIndex]}
                </label>
              )
          )}
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de atividade:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {[
            "rascunho",
            "validar",
            "validado",
            "faturar",
            "entregue",
            "finalizado",
          ].map((statusItem) => (
            <label
              key={statusItem}
              className={EstiloNovoAtendimento.labelBorda}
            >
              <input
                type="checkbox"
                className={EstiloNovoAtendimento.customCheckbox}
                value={statusItem}
                checked={status.includes(statusItem)} // Verifica se o status está incluído
                onChange={(e) => {
                  const isChecked = e.target.checked;
                  if (isChecked) {
                    updateProcedimento(index, {
                      status: [...status, statusItem], // Adiciona ao array de status
                    });
                  } else {
                    updateProcedimento(index, {
                      status: status.filter((s) => s !== statusItem), // Remove do array de status
                    });
                  }
                }}
              />
              <span className={EstiloNovoAtendimento.labelAtividade}>
                {statusItem.charAt(0).toUpperCase() + statusItem.slice(1)}{" "}
                {/* Capitaliza o primeiro caractere */}
              </span>
            </label>
          ))}
        </div>
      </div>
      <div className={EstiloNovoAtendimento.CardBotton}></div>
    </div>
    

    ); };

    export default CardProcedimento;

  30. Assistant

    Para garantir que os valores dos inputs "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" sejam armazenados e persistam no localStorage, você precisará fazer algumas alterações na forma como você lida com esses inputs no seu componente NovoAtendimento e CardProcedimento.

    Vou implementar as seguintes etapas:

    1. Certifique-se de que os campos "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" estejam vinculados ao estado.
    2. Utilize o handleInputChange para atualizar o estado e o localStorage sempre que o valor dos inputs mudar.
    3. Atualize o CardProcedimento para refletir corretamente as mudanças nos dados.

    Implementação

    1. Adicionar Campos na Interface Procedimento

    No seu arquivo, você já possui:

    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
      codigoCBHPM?: string; // Código personalizado da CBHPM
      nomeCBHPM?: string;   // Nome personalizado da CBHPM
    }
    

    2. Atualizar NovoAtendimento

    No seu componente NovoAtendimento, você precisa implementar o método handleInputChange para permitir que você possa editar o codigoCBHPM e o nomeCBHPM.

    Aqui está a parte que você deverá ter no NovoAtendimento:

    const handleInputChange = (
      index: number,
      field: keyof Procedimento, // Usar keyof para restringir a apenas chaves válidas
      value: string
    ) => {
      const novosProcedimentos = [...procedimentos];
      novosProcedimentos[index][field] = value; // Atualiza o campo apropriado
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    };
    
    // Você já tem a parte do useEffect para inicializar procedimentos do localStorage
    

    3. Atualizar o CardProcedimento.tsx

    No componente CardProcedimento, ajuste os inputs para que eles usem o handleInputChange corretamente:

    // CardProcedimento.tsx
    
    const CardProcedimento: React.FC<Procedimento> = ({
      id,
      valoresEditaveis,
      status,
      index,
      handleValorChange,
      handleExcluir,
      codigoCBHPM,
      nomeCBHPM,
      handleInputChange,
    }) => {
      return (
        <div className={EstiloNovoAtendimento.Card}>
          <div className={EstiloNovoAtendimento.CardTop}>
            <div>
              <span className={EstiloNovoAtendimento.id}>ID: {id}</span>
            </div>
            <div className={EstiloNovoAtendimento.buttonCard}>
              <button onClick={() => handleExcluir(id)}>
                <img src="/lixeira.png" alt="Excluir" className={EstiloNovoAtendimento.icon} />
              </button>
            </div>
          </div>
    
          <div className={EstiloNovoAtendimento.divDoCard}>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Código personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={codigoCBHPM} // Mantendo o valor armazenado
                placeholder="Digite o Código..."
                onChange={(e) => handleInputChange(index, "codigoCBHPM", e.target.value)} // Atualiza o campo
              />
            </div>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Nome personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={nomeCBHPM} // Mantendo o valor armazenado
                placeholder="Digite o Nome..."
                onChange={(e) => handleInputChange(index, "nomeCBHPM", e.target.value)} // Atualiza o campo
              />
            </div>
    
            <div className={EstiloNovoAtendimento.divflex}>
              {["Valor Previsto", "Valor Glosado", "Valor Perdido", "Valor Pago"].map((label, valorIndex) => (
                <div className={EstiloNovoAtendimento.valores} key={label}>
                  <label className={EstiloNovoAtendimento.labelinput}>{label}</label>
                  <input
                    className={EstiloNovoAtendimento.inputValor234}
                    type="number"
                    value={valoresEditaveis[valorIndex]} // Valor editável
                    placeholder=""
                    onChange={(e) =>
                      handleValorChange(
                        index,
                        valorIndex,
                        parseFloat(e.target.value) || 0
                      )
                    }
                    onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                  />
                </div>
              ))}
            </div>
    
            {/* Resto do componente se mantém o mesmo */}
          </div>
        </div>
      );
    };
    
    export default CardProcedimento;
    

    O que foi Modificado

    1. handleInputChange é utilizado para alterar o valor do texto que o usuário insere para codigoCBHPM e nomeCBHPM. Isso garante que qualquer alteração será refletida no state e, consequentemente, no localStorage.

    2. Os valores dos inputs (codigoCBHPM e nomeCBHPM) mostrados no componente CardProcedimento agora estão vinculados a esses dados, garantindo que, ao sair do componente e voltar, o que foi preenchido não será perdido.

    Testando

    • Adicione um ou mais procedimentos e preencha os campos de código e nome.
    • Saia do componente e volte a acessá-lo — os valores preenchidos devem estar lá.
    • Verifique o localStorage para ver se os dados estão sendo armazenados e seriados corretamente.

    Conclusão

    Com essas alterações, os dados dos inputs "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" estarão salvos e persistentes, permitindo uma melhor experiência do usuário. Se você tiver mais alguma dúvida ou precisar de mais assistência, sinta-se à vontade para perguntar!

  31. User

    A propriedade 'handleInputChange' não existe no tipo 'Procedimento'.ts(2339) (parameter) handleInputChange: any

  32. Assistant

    A mensagem de erro "A propriedade 'handleInputChange' não existe no tipo 'Procedimento'" indica que, na interface Procedimento, você não definiu a propriedade handleInputChange. Para resolver isso, você precisa ajustar a definição da interface Procedimento para incluir handleInputChange e garantir que a função seja passada corretamente entre os componentes.

    Atualizando a Interface Procedimento

    Vamos incluir a função handleInputChange na interface Procedimento e garantir que ela esteja utilizando os tipos corretos.

    Aqui está a atualização da interface que você precisa fazer:

    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
      codigoCBHPM?: string; // Código personalizado da CBHPM
      nomeCBHPM?: string;   // Nome personalizado da CBHPM
      handleValorChange: (
        index: number,
        valorIndex: number,
        novoValor: number
      ) => void;
      handleExcluir: (id: string) => void;
      handleInputChange: (
        index: number,
        field: keyof Omit<Procedimento, 'handleValorChange' | 'handleExcluir' | 'handleInputChange'>, // Define que field pode ser somente códigoCBHPM ou nomeCBHPM
        value: string
      ) => void; // Adiciona a função de manipulação de entrada
    }
    

    Ajustes na Chamada do Componente CardProcedimento

    Assegure-se de que, ao chamar o componente CardProcedimento no NovoAtendimento, você esteja passando a função handleInputChange corretamente:

    {procedimentos.map((proc, index) => (
      <CardProcedimento
        key={proc.id}
        id={proc.id}
        valoresEditaveis={proc.valoresEditaveis}
        status={proc.status}
        index={index}
        handleValorChange={handleValorChange}
        handleExcluir={handleExcluirProcedimento}
        handleInputChange={handleInputChange}  // Passa a função de entrada
        codigoCBHPM={proc.codigoCBHPM} // Passa o código
        nomeCBHPM={proc.nomeCBHPM} // Passa o nome
      />
    ))}
    

    Atualização no CardProcedimento

    Certifique-se de que CardProcedimento utilize handleInputChange corretamente:

    const CardProcedimento: React.FC<Procedimento> = ({
      id,
      valoresEditaveis,
      status,
      index,
      handleValorChange,
      handleExcluir,
      codigoCBHPM,
      nomeCBHPM,
      handleInputChange, // Recebe a função de manipulação de entrada
    }) => {
      return (
        <div className={EstiloNovoAtendimento.Card}>
          <div className={EstiloNovoAtendimento.CardTop}>
            <div>
              <span className={EstiloNovoAtendimento.id}>ID: {id}</span>
            </div>
            <div className={EstiloNovoAtendimento.buttonCard}>
              <button onClick={() => handleExcluir(id)}>
                <img src="/lixeira.png" alt="Excluir" className={EstiloNovoAtendimento.icon} />
              </button>
            </div>
          </div>
    
          <div className={EstiloNovoAtendimento.divDoCard}>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Código personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={codigoCBHPM} // Mantendo o valor armazenado
                placeholder="Digite o Código..."
                onChange={(e) =>
                  handleInputChange(index, "codigoCBHPM", e.target.value) // Atualiza o campo
                }
              />
            </div>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Nome personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={nomeCBHPM} // Mantendo o valor armazenado
                placeholder="Digite o Nome..."
                onChange={(e) =>
                  handleInputChange(index, "nomeCBHPM", e.target.value) // Atualiza o campo
                }
              />
            </div>
    
            {/* Continue com o restante do seu card... */}
          </div>
        </div>
      );
    };
    

    Resumo

    • Adicione a Propriedade: A propriedade handleInputChange deve ser adicionada à interface Procedimento.
    • Tipo Correto para field: O tipo do parâmetro field em handleInputChange deve ser restringido a chaves válidas da interface Procedimento.
    • Verifique a Passagem de Props: Certifique-se de que, ao passar as props para CardProcedimento, a função handleInputChange está sendo passada corretamente.

    Com isso, você deve ser capaz de manipular e armazenar os valores dos inputs de forma correta e persistente. Se você ainda tiver erros ou problemas, sinta-se à vontade para perguntar!

  33. User

    e pq voce tira o updateProcedimento

  34. Assistant

    Peço desculpas pela confusão anterior. O método updateProcedimento é uma função importante e deve ser mantido, especialmente se você tem a intenção de usá-lo para atualizar os dados do procedimento em estados que não são de entrada (como quando você quer atualizar o status do procedimento ou outras propriedades do procedimento).

    Vamos corrigir isso, mantendo updateProcedimento e assegurando que ele funcione bem junto com a handleInputChange.

    Atualização Completa

    Vou fornecer um resumo de como você deve implementar tudo para garantir que todos os campos estejam corretamente geridos e que os tipos estejam corretos. Mantenha a função updateProcedimento e use-a quando apropriado.

    1. Interface Procedimento

    A interface deve incluir todas as propriedades relevantes:

    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
      codigoCBHPM?: string; // Código personalizado da CBHPM
      nomeCBHPM?: string;   // Nome personalizado da CBHPM
    }
    

    2. Funções em NovoAtendimento

    Mantenha tanto handleValorChange quanto handleInputChange, garantindo que cada função tenha sua própria responsabilidade:

    const handleInputChange = (index: number, field: keyof Procedimento, value: string) => {
      const novosProcedimentos = [...procedimentos];
      novosProcedimentos[index][field] = value; // Atualiza o campo apropriado
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    };
    
    const updateProcedimento = (index: number, novosDados: Partial<Procedimento>) => {
      setProcedimentos((prev) => {
        const novosProcedimentos = [...prev];
        novosProcedimentos[index] = {
          ...novosProcedimentos[index],
          ...novosDados, // Atualiza os dados do procedimento
        };
        localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
        return novosProcedimentos;
      });
    };
    

    3. CardProcedimento

    No componente CardProcedimento, certifique-se de que você passe corretamente as props e use as funções adequadas:

    const CardProcedimento: React.FC<Procedimento> = ({
      id,
      valoresEditaveis,
      status,
      index,
      handleValorChange,
      handleExcluir,
      handleInputChange,
      codigoCBHPM,
      nomeCBHPM,
    }) => {
      return (
        <div className={EstiloNovoAtendimento.Card}>
          <div className={EstiloNovoAtendimento.CardTop}>
            <div>
              <span className={EstiloNovoAtendimento.id}>ID: {id}</span>
            </div>
            <div className={EstiloNovoAtendimento.buttonCard}>
              <button onClick={() => handleExcluir(id)}>
                <img src="/lixeira.png" alt="Excluir" className={EstiloNovoAtendimento.icon} />
              </button>
            </div>
          </div>
    
          <div className={EstiloNovoAtendimento.divDoCard}>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Código personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={codigoCBHPM || ""} // Mantém o valor armazenado
                placeholder="Digite o Código..."
                onChange={(e) =>
                  handleInputChange(index, "codigoCBHPM", e.target.value) // Atualiza o campo
                }
              />
            </div>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Nome personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={nomeCBHPM || ""} // Mantém o valor armazenado
                placeholder="Digite o Nome..."
                onChange={(e) =>
                  handleInputChange(index, "nomeCBHPM", e.target.value) // Atualiza o campo
                }
              />
            </div>
    
            {/* Continue com o restante do componente */}
            <div className={EstiloNovoAtendimento.divflex}>
              {["Valor Previsto", "Valor Glosado", "Valor Perdido", "Valor Pago"].map((label, valorIndex) => (
                <div className={EstiloNovoAtendimento.valores} key={label}>
                  <label className={EstiloNovoAtendimento.labelinput}>{label}</label>
                  <input
                    className={EstiloNovoAtendimento.inputValor234}
                    type="number"
                    value={valoresEditaveis[valorIndex]} // Valor editável
                    placeholder=""
                    onChange={(e) =>
                      handleValorChange(
                        index,
                        valorIndex,
                        parseFloat(e.target.value) || 0
                      )
                    }
                    onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                  />
                </div>
              ))}
            </div>
    
            {/* Resto do card... */}
          </div>
        </div>
      );
    };
    

    4. Chamada em NovoAtendimento

    Quando você renderiza o CardProcedimento, você deve passar todas as funções corretamente:

    {procedimentos.map((proc, index) => (
      <CardProcedimento
        key={proc.id}
        id={proc.id}
        valoresEditaveis={proc.valoresEditaveis}
        status={proc.status}
        index={index}
        handleValorChange={handleValorChange}
        handleExcluir={handleExcluirProcedimento}
        handleInputChange={handleInputChange} // Passa a função de manipulação de entrada
        codigoCBHPM={proc.codigoCBHPM} // Passa o código
        nomeCBHPM={proc.nomeCBHPM} // Passa o nome
      />
    ))}
    

    Conclusão

    Agora, com essas modificações:

    • Os campos "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" estão corretamente ligados a um estado.
    • Qualquer alteração feita nesses campos atualiza tanto os dados no componente quanto no localStorage.
    • A funcionalidade de excluir, atualizar valores e lidar com entradas está totalmente trabalhando em conjunto.

    Se você ainda encontrar algum problema ou tiver mais perguntas, sinta-se à vontade para perguntar!

  35. User

    mas tem um erro nesta linha

    novosProcedimentos[index][field] = value; // Atualiza o campo apropriado
    

    O tipo 'string' não pode ser atribuído ao tipo 'never'.ts(2322) const novosProcedimentos: Procedimento[]

  36. Assistant

    O erro "O tipo 'string' não pode ser atribuído ao tipo 'never'" geralmente indica que o TypeScript não consegue inferir corretamente o tipo do campo em questão. Isso acontece porque, quando você usa novosProcedimentos[index][field], o TypeScript não tem certeza se field é um tipo que pode ser usado para atribuição.

    Solução para o Erro

    Para corrigir isso, você precisa garantir que o TypeScript reconheça que o campo field realmente corresponde a uma chave que aceita uma string no Procedimento.

    A solução é usar Type Assertion (ou afirmação de tipo) junto com a exclusão dos campos que não podem ser modificados. Vamos corrigir isso.

    Ajuste na Função handleInputChange

    Modifique sua função handleInputChange para incluir uma verificação clara de tipo, afirmando que novosProcedimentos[index][field] é um string usando um tipo:

    const handleInputChange = (
      index: number,
      field: keyof Omit<Procedimento, 'valoresEditaveis' | 'status' | 'handleValorChange' | 'handleExcluir' | 'updateProcedimento'>, // Somente as chaves que podem ser alteradas
      value: string
    ) => {
      const novosProcedimentos = [...procedimentos];
      
      // Usando as chaves válidas apenas
      novosProcedimentos[index][field] = value as any; // Casting explícito, aqui como `any` ou `string`
      
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    };
    

    Como Funciona

    • keyof Omit: Isso significa que field só pode ser um dos campos que realmente podem ser alterados (codigoCBHPM ou nomeCBHPM).
    • Casting: O as any é uma forma de dizer ao TypeScript "confie em mim, eu sei que isso está correto". Isso deve ser usado com cautela, pois você precisa garantir que a lógica do aplicativo permanece intacta.

    Passo Completo

    Certifique-se de usar esse handleInputChange na parte do CardProcedimento:

    <input
      className={EstiloNovoAtendimento.inputCard}
      type="text"
      value={codigoCBHPM} // Mantém o valor armazenado
      placeholder="Digite o Código..."
      onChange={(e) =>
        handleInputChange(index, "codigoCBHPM", e.target.value) // Atualiza o campo
      }
    />
    <input
      className={EstiloNovoAtendimento.inputCard}
      type="text"
      value={nomeCBHPM} // Mantém o valor armazenado
      placeholder="Digite o Nome..."
      onChange={(e) =>
        handleInputChange(index, "nomeCBHPM", e.target.value) // Atualiza o campo
      }
    />
    

    Conclusão

    A correção aplicada deve resolver o erro que você está vendo. Com essas alterações, suas entradas para "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" devem funcionar corretamente, atualizando tanto o estado do componente quanto o localStorage sem problemas de tipo. Se você tiver mais perguntas ou continuar enfrentando problemas, fique à vontade para perguntar!

  37. User

    O tipo 'any' não pode ser atribuído ao tipo 'never'.ts(2322) const novosProcedimentos: Procedimento[]

  38. Assistant

    A mensagem de erro "O tipo 'any' não pode ser atribuído ao tipo 'never'" indica que TypeScript não identifica corretamente o tipo esperado na linha em que você está tentando atribuir um valor a novosProcedimentos[index][field].

    Isso geralmente ocorre quando o TypeScript não consegue inferir o tipo de field de uma maneira que corresponda ao tipo de Procedimento. Vamos corrigir isso.

    Solução

    Você pode resolver o problema ajustando o tipo para garantir que apenas os campos válidos de Procedimento possam ser acessados. Aqui está um passo a passo para corrigir o seu código:

    1. Defina a Interface Corretamente

    Primeiro, certifique-se de que a interface Procedimento esteja definida da seguinte forma:

    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
      codigoCBHPM?: string; // Código personalizado da CBHPM
      nomeCBHPM?: string;   // Nome personalizado da CBHPM
    }
    

    2. Atualize a Função handleInputChange

    Ao invés de usar any, você deve utilizar o tipo string para a variável field. Aqui está a versão ajustada:

    const handleInputChange = (
      index: number,
      field: 'codigoCBHPM' | 'nomeCBHPM', // Somente definições concretas de strings
      value: string
    ) => {
      const novosProcedimentos = [...procedimentos];
    
      // Atualiza o campo apropriado
      novosProcedimentos[index][field] = value; 
      setProcedimentos(novosProcedimentos);
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    };
    

    Uso em CardProcedimento

    3. Passagem do Campo na Alteração do Input

    Certifique-se de passar a propriedade correta para o handleInputChange no CardProcedimento:

    <input
      className={EstiloNovoAtendimento.inputCard}
      type="text"
      value={codigoCBHPM || ""} // Mantém o valor armazenado
      placeholder="Digite o Código..."
      onChange={(e) => handleInputChange(index, "codigoCBHPM", e.target.value)} // Atualiza o campo
    />
    <input
      className={EstiloNovoAtendimento.inputCard}
      type="text"
      value={nomeCBHPM || ""} // Mantém o valor armazenado
      placeholder="Digite o Nome..."
      onChange={(e) => handleInputChange(index, "nomeCBHPM", e.target.value)} // Atualiza o campo
    />
    

    4. Exemplo Completo do Componente NovoAtendimento

    Aqui está como a parte relevante do seu componente NovoAtendimento ficará:

    const NovoAtendimento: React.FC = () => {
      const [procedimentos, setProcedimentos] = useState<Procedimento[]>(() => {
        const storedProcedures = localStorage.getItem("procedimentos");
        return storedProcedures ? JSON.parse(storedProcedures) : [];
      });
    
      const handleInputChange = (
        index: number,
        field: 'codigoCBHPM' | 'nomeCBHPM', // Especifica os campos
        value: string
      ) => {
        const novosProcedimentos = [...procedimentos];
        novosProcedimentos[index][field] = value; // Atualiza o campo correto
        setProcedimentos(novosProcedimentos);
        localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
      };
    
      // Outras funções e componentes seguem aqui...
    };
    

    Conclusão

    Ao especificar claramente os campos possíveis dentro da função handleInputChange, o TypeScript não deve mais apresentar erros de tipo e deve permitir que você armazene e atualize os valores corretamente. Assim, quando os usuários digitarem os valores nos campos "Código personalizado da CBHPM" e "Nome personalizado da CBHPM", essas informações serão salvas e persistidas conforme esperado. Se você continuar enfrentando problemas, por favor, informe!

  39. User

    O tipo '(index: number, field: "codigoCBHPM" | "nomeCBHPM", value: string) => void' não pode ser atribuído ao tipo '(index: number, field: "valoresEditaveis" | "id" | "status" | "index" | "codigoCBHPM" | "nomeCBHPM" | "updateProcedimento", value: string) => void'. Os tipos de parâmetros 'field' e 'field' são incompatíveis. O tipo '"valoresEditaveis" | "id" | "status" | "index" | "codigoCBHPM" | "nomeCBHPM" | "updateProcedimento"' não pode ser atribuído ao tipo '"codigoCBHPM" | "nomeCBHPM"'. O tipo '"valoresEditaveis"' não pode ser atribuído ao tipo '"codigoCBHPM" | "nomeCBHPM"'.ts(2322) cardProcedimento.tsx(22, 3): O tipo esperado vem da propriedade 'handleInputChange', que é declarada aqui no tipo 'IntrinsicAttributes & Procedimento

    import EstiloNovoAtendimento from "./NovoAtendimento.module.css"; import React, { useState, useEffect } from "react"; import { useApi } from "../../lib/doctorApi"; import { AppointmentRequestDTO } from "./types"; import DropdownSelect from "./DropdownSelect"; import { useLocalContext, Local } from "../Local/LocalContext"; import CardProcedimento from "./cardProcedimento"; import { v4 as uuidv4 } from "uuid"; // Importa a função para gerar UUIDs

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

    export interface FormularioDados { pacienteId: string; total: number; payer: string; // Certifique-se de que isso está aqui pacienteNome: string; local: string; // ou 'local' se preferir; mas stable as diferenças localIdFontePagadora: string; // Esta propriedade deve estar aqui localIdAtendimento: string; // Esta propriedade também deve estar aqui modalidade: string; data: string; valores: number[]; codigo?: string; // Esta pode continuar a ser opcional }

    export interface Paciente { id?: number; name: string; cpf: string; email: string; address: string; celular: string; dataNascimento?: string; idade?: string; }

    interface Procedimento { id: string; valoresEditaveis: number[]; status: string[]; codigoCBHPM?: string; // Código personalizado da CBHPM nomeCBHPM?: string; // Nome personalizado da CBHPM }

    const NovoAtendimento: React.FC = () => { const [pacientes, setPacientes] = useState<Paciente[]>([]); const [locaisFontePagadora, setLocaisFontePagadora] = useState<Local[]>([]); const [locaisAtendimento, setLocaisAtendimento] = useState<Local[]>([]); const localContext = useLocalContext();

    const [procedimentos, setProcedimentos] = useState<Procedimento[]>(() => { const storedProcedures = localStorage.getItem("procedimentos"); return storedProcedures ? JSON.parse(storedProcedures) : []; }); const [idCounter, setIdCounter] = useState(0);

    const updateProcedimento = ( index: number, novosDados: Partial ) => { setProcedimentos((prev) => { const novosProcedimentos = [...prev]; novosProcedimentos[index] = { ...novosProcedimentos[index], ...novosDados, // Aqui você pode atualizar múltiplas propriedades }; return novosProcedimentos; }); };

    const handleAdicionarProcedimento = () => { const novoProcedimento: Procedimento = { id: uuidv4(), // Gera um UUID como ID valoresEditaveis: [0, 0, 0, 0], status: ["rascunho"], // Estado inicial };

    const novosProcedimentos = [...procedimentos, novoProcedimento];
    setProcedimentos(novosProcedimentos);
    localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Salva no localStorage
    

    };

    const handleExcluirProcedimento = (id: string) => { const novosProcedimentos = procedimentos.filter((proc) => proc.id !== id); setProcedimentos(novosProcedimentos); localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage };

    const handleValorChange = ( index: number, valorIndex: number, novoValor: number ) => { const novosProcedimentos = [...procedimentos]; novosProcedimentos[index].valoresEditaveis[valorIndex] = novoValor;

    setProcedimentos(novosProcedimentos);
    localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage
    atualizarTotal(); // Atualiza todos os totais de acordo com a mudança
    atualizarValoresBarra(); // Atualiza a contagem dos valores na barra
    

    };

    const handleInputChange = ( index: number, field: "codigoCBHPM" | "nomeCBHPM", // Especifica os campos value: string ) => { const novosProcedimentos = [...procedimentos]; novosProcedimentos[index][field] = value; // Atualiza o campo correto setProcedimentos(novosProcedimentos); localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos)); // Atualiza o localStorage };

    // Atualiza o localStorage sempre que procedimentos mudar useEffect(() => { localStorage.setItem("procedimentos", JSON.stringify(procedimentos)); }, [procedimentos]);

    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 [valoresBarra, setValoresBarra] = useState([0, 0, 0, 0]); // Novo estado para a contagem da barra 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: { healthInsurance: { cardNumber: "", }, }, }, serviceInfo: { guideCode: "", date: "", totalValue: 0, }, procedures: [], });

    const handleFileChange = async ( event: React.ChangeEvent ) => { setLoading(true); const formData = new FormData();

    const files = event.target.files;
    if (files) {
      Array.from(files).map((file) => {
        formData.append("files", file);
      });
      const uploadResult = await api.post("files/upload", formData);
      if (uploadResult.data.success) {
        setAnexos(uploadResult.data.result);
      }
    }
    

    }; const handleDelete = async (id: string) => { await api.del(files/delete/${id}); const novosAnexos = anexos.filter((anexo) => anexo.id !== id); setAnexos(novosAnexos); };

    const atualizarValoresBarra = () => { const novosValoresBarra = [0, 0, 0, 0]; // Inicializa uma nova contagem

    procedimentos.forEach((proc) => {
      proc.valoresEditaveis.forEach((valor, index) => {
        if (valor > 0) {
          novosValoresBarra[index] += 1; // Incrementa se o valor é maior que 0
        }
      });
    });
    
    setValoresBarra(novosValoresBarra); // Atualiza o estado dos valores da barra
    

    }; const atualizarTotal = () => { const novosValoresBarra = [0, 0, 0, 0]; // Inicializa os valores da barra

    procedimentos.forEach((proc) => {
      proc.valoresEditaveis.forEach((valor, index) => {
        novosValoresBarra[index] += valor; // Acumula os valores correspondentes
      });
    });
    
    // Atualiza o total no estado do formulário
    setFormularioDados((prev) => ({
      ...prev,
      total: novosValoresBarra.reduce((a, b) => a + b, 0), // Calcula o total
      valores: novosValoresBarra, // Atualiza os valores da barra
    }));
    

    };

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

    const [formularioDados, setFormularioDados] = useState({ pacienteId: "", total: 0, pacienteNome: "", local: "", // Ajuste para o nome correto se ele for alterado localIdFontePagadora: "", // Adicione aqui localIdAtendimento: "", // Adicione aqui modalidade: "", data: "", valores: [0, 0, 0, 0], codigo: "", });

    // Funções de efeito para buscar pacientes e locais useEffect(() => { const buscarPacientes = async () => { try { const data = await api.get("patients/find?skip=0&limit=2000"); setPacientes(data.data?.result?.list || []); } catch (error) { console.error("Erro ao buscar pacientes:", error); } };

    buscarPacientes();
    

    }, []);

    const buscarLocais = async () => { try { const data = await api.get("places/find?skip=0&limit=2000"); setLocaisFontePagadora( data.data.result.list.filter((local: Local) => local.payer) ); setLocaisAtendimento( data.data.result.list.filter((local: Local) => local.place) ); } catch (error) { console.error("Erro ao buscar locais:", error); } };

    useEffect(() => { buscarLocais(); }, []);

    const enviarDadosAtendimento = async () => { // Antes de realizar qualquer envio, logue o estado atendimento no console console.log("Dados do atendimento:", atendimento);

    // Simulação: Você pode substituir isso pela chamada real da API quando estiver pronta
    // Exemplo de chamada fictícia
    if (true) {
      // Simulando sucesso
      alert("Atendimento salvo com sucesso!");
    } else {
    }
    

    }; return ( Cadastro de Atendimento

      <form>
        <div className={EstiloNovoAtendimento.divValores}>
          <div className={EstiloNovoAtendimento.inputValores}>
            <label className={EstiloNovoAtendimento.total}>Total:</label>
            {formularioDados.valores.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$ {formularioDados.total.toFixed(2)}{" "}
              {/* Aqui já usará o total atualizado */}
            </label>
            <div className={EstiloNovoAtendimento.graficoRepresentativo}>
              <div className={EstiloNovoAtendimento.barraFixa}>
                {formularioDados.valores.map((valor, index) => (
                  <div
                    key={`grafico-${index}`}
                    style={{
                      backgroundColor: CoresInput[index],
                      width:
                        formularioDados.total > 0
                          ? `${(valor / formularioDados.total) * 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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "convenio",
                  }));
                  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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "particular",
                  }));
                  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={() => {
                  setFormularioDados((prev) => ({
                    ...prev,
                    modalidade: "plantao",
                  }));
                  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) => {
              setFormularioDados((prev) => ({
                ...prev,
                localIdFontePagadora: selectedItem.id,
                payer: selectedItem.name,
              }));
              // 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={formularioDados.localIdFontePagadora} // Valor atual do dropdown
            label="Fonte Pagadora:" // Rótulo a ser exibido
          />
        </div>
    
        <div className={EstiloNovoAtendimento.container}>
          <div className={EstiloNovoAtendimento.organizador}>
            <span>Paciente:</span>
            <label htmlFor="Paciente-select"></label>
            <select
              className={EstiloNovoAtendimento.input300px}
              id="Paciente-select"
              value={formularioDados.pacienteId}
              onChange={(e) => {
                const selectedOption = e.target.options[e.target.selectedIndex];
                const pacienteId = selectedOption.value;
                const pacienteNome =
                  selectedOption.getAttribute("data-name") || ""; // Extrai o nome do paciente
    
                // Atualiza tanto o formularioDados quanto o estado de atendimento
                setFormularioDados((prev) => ({
                  ...prev,
                  pacienteId,
                  pacienteNome,
                }));
    
                // Atualiza o estado de atendimento com o paciente selecionado
                setAtendimento((prev) => ({
                  ...prev,
                  related: {
                    ...prev.related,
                    patient: { id: pacienteId, name: pacienteNome },
                  },
                }));
              }}
            >
              <option value="" disabled hidden>
                Selecione um paciente
              </option>
              {pacientes.map((paciente) => (
                <option
                  key={paciente.id}
                  value={paciente.id}
                  data-name={paciente.name}
                >
                  {paciente.name}
                </option>
              ))}
            </select>
          </div>
    
          <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) => {
              setFormularioDados((prev) => ({
                ...prev,
                localIdAtendimento: selectedItem.id, // Define o ID selecionado no formulário
                place: selectedItem.name,
              }));
              // 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={formularioDados.localIdAtendimento} // 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={formularioDados.codigo}
              onChange={(e) => {
                const codigo = e.target.value;
    
                // Atualiza o estado formularioDados
                setFormularioDados({
                  ...formularioDados,
                  codigo, // Atualiza o código no formulário
                });
    
                // 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={formularioDados.data}
              onChange={(e) => {
                const data = e.target.value;
    
                setFormularioDados({
                  ...formularioDados,
                  data,
                });
    
                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}>
          {valoresBarra.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>{procedimentos.length}</label> Procedimento
            </label>
          </div>
          <div className={EstiloNovoAtendimento.graficoRepresentativo}>
            <div className={EstiloNovoAtendimento.barraFixa}>
              {valoresBarra.map((valor, index) => (
                <div
                  key={`grafico-segunda-${index}`}
                  style={{
                    backgroundColor: CoresInput[index],
                    width: `${(valor / procedimentos.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 */}
          {procedimentos.map((proc, index) => (
            <CardProcedimento
              key={proc.id}
              id={proc.id}
              valoresEditaveis={proc.valoresEditaveis}
              status={proc.status}
              index={index}
              handleValorChange={handleValorChange}
              handleExcluir={handleExcluirProcedimento}
              handleInputChange={handleInputChange} // Passa a função de manipulação de entrada
              codigoCBHPM={proc.codigoCBHPM} // Passa o código
              nomeCBHPM={proc.nomeCBHPM} // Passa o nome
            />
          ))}
        </>
      )}
      <div className={EstiloNovoAtendimento.divSalvarAnexo}>
        <label className={EstiloNovoAtendimento.labelAnexo}>Anexos:</label>
        <div className={EstiloNovoAtendimento.divArquivo}>
          {anexos.length > 0
            ? anexos.map((anexo) => (
                <label key={anexo.id} className={EstiloNovoAtendimento.Arquivo}>
                  {anexo.fileName} {/* Exibir o nome do arquivo */}
                  <button onClick={() => handleDelete(anexo.id)}>
                    <img src="lixeira.png" alt="" />
                  </button>
                </label>
              ))
            : null}{" "}
          {/* Não exibe nada se não houver anexos */}
        </div>
        <div className={EstiloNovoAtendimento.divAnexosNew}>
          <input
            type="file"
            multiple
            onChange={handleFileChange}
            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>
    
      <div className={EstiloNovoAtendimento.divbutton}>
        <button
          className={EstiloNovoAtendimento.buttonSalvar}
          onClick={enviarDadosAtendimento}
        >
          Salvar
        </button>
      </div>
    </div>
    

    ); };

    export default NovoAtendimento;

  40. Assistant

    Para garantir que os dados dos inputs "Código personalizado da CBHPM" e "Nome personalizado da CBHPM" sejam armazenados corretamente e persistam no localStorage, você deve garantir que a função handleInputChange seja aplicada de forma adequada, além de garantir que esses dados sejam salvos na lista de procedimentos.

    Atualização do Código

    Vamos implementar as mudanças necessárias para garantir que os valores dos inputs sejam corretamente gerenciados e persistidos.

    1. Atualizar a Interface Procedimento

    Verifique se a interface Procedimento está corretamente configurada para conter os campos que você deseja salvar:

    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
      codigoCBHPM?: string; // Código personalizado da CBHPM
      nomeCBHPM?: string;   // Nome personalizado da CBHPM
    }
    

    2. Atualizar o Componente NovoAtendimento

    Aqui está a versão finalizada da função handleInputChange, que deve manipular a atualização dos novos campos e também garantir que os dados são salvos no localStorage:

    const handleInputChange = (
      index: number,
      field: keyof Procedimento, // Tipo: somente as chaves do tipo Procedimento
      value: string
    ) => {
      const novosProcedimentos = [...procedimentos];
      novosProcedimentos[index][field] = value; // Atualiza o campo correspondente
      setProcedimentos(novosProcedimentos);
      
      // Atualiza o localStorage com a lista atualizada de procedimentos
      localStorage.setItem("procedimentos", JSON.stringify(novosProcedimentos));
    };
    

    3. Atualizar o Componente CardProcedimento

    No seu componente CardProcedimento, você deve garantir que os inputs estão utilizando handleInputChange corretamente para atualizar os dados diretamente no estado.

    import React from "react";
    import EstiloNovoAtendimento from "./NovoAtendimento.module.css";
    
    interface Procedimento {
      id: string;
      valoresEditaveis: number[];
      status: string[];
      codigoCBHPM?: string;
      nomeCBHPM?: string;
      handleValorChange: (
        index: number,
        valorIndex: number,
        novoValor: number
      ) => void;
      handleExcluir: (id: string) => void;
      handleInputChange: (
        index: number,
        field: keyof Procedimento,
        value: string
      ) => void;
    }
    
    const CardProcedimento: React.FC<Procedimento> = ({
      id,
      valoresEditaveis,
      status,
      index,
      handleValorChange,
      handleExcluir,
      handleInputChange,
      codigoCBHPM,
      nomeCBHPM,
    }) => {
      return (
        <div className={EstiloNovoAtendimento.Card}>
          <div className={EstiloNovoAtendimento.CardTop}>
            <div>
              <span className={EstiloNovoAtendimento.id}>ID: {id}</span>
            </div>
            <div className={EstiloNovoAtendimento.buttonCard}>
              <button onClick={() => handleExcluir(id)}>
                <img src="/lixeira.png" alt="Excluir" className={EstiloNovoAtendimento.icon} />
              </button>
            </div>
          </div>
    
          <div className={EstiloNovoAtendimento.divDoCard}>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Código personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={codigoCBHPM || ""} // Mantendo o valor armazenado
                placeholder="Digite o Código..."
                onChange={(e) =>
                  handleInputChange(index, "codigoCBHPM", e.target.value) // Atualiza o campo
                }
              />
            </div>
            <div className={EstiloNovoAtendimento.organizadorCard}>
              <span>Nome personalizado da CBHPM</span>
              <input
                className={EstiloNovoAtendimento.inputCard}
                type="text"
                value={nomeCBHPM || ""} // Mantendo o valor armazenado
                placeholder="Digite o Nome..."
                onChange={(e) =>
                  handleInputChange(index, "nomeCBHPM", e.target.value) // Atualiza o campo
                }
              />
            </div>
    
            <div className={EstiloNovoAtendimento.divflex}>
              {["Valor Previsto", "Valor Glosado", "Valor Perdido", "Valor Pago"].map((label, valorIndex) => (
                <div className={EstiloNovoAtendimento.valores} key={label}>
                  <label className={EstiloNovoAtendimento.labelinput}>{label}</label>
                  <input
                    className={EstiloNovoAtendimento.inputValor234}
                    type="number"
                    value={valoresEditaveis[valorIndex]} // Valor editável
                    onChange={(e) =>
                      handleValorChange(index, valorIndex, parseFloat(e.target.value) || 0)
                    }
                    onWheel={(e) => e.preventDefault()} // Previne a alteração do valor com rolagem
                  />
                </div>
              ))}
            </div>
            
            {/* Resto do componente... */}
          </div>
        </div>
      );
    };
    
    export default CardProcedimento;
    

    Verificações e Garantias

    • Persistência de Dados: Após as implementações acima, os valores dos inputs devem ser persistentes no localStorage, permitindo que eles sejam recuperados automaticamente quando o componente NovoAtendimento for montado novamente.

    • Teste de Desempenho: Adicione um ou mais procedimentos, preencha os campos "Código personalizado da CBHPM" e "Nome personalizado da CBHPM". Em seguida, saia do componente e volte a acessá-lo para garantir que os dados estão salvos.

    • Manutenção do Estado: Este código está configurado para manter facilmente o estado por meio do localStorage, e qualquer alteração nos campos de entrada deve ser registrada corretamente no estado do componente e no armazenamento local.

    Sinta-se à vontade para perguntar se precisar de mais ajuda ou se houver outros aspectos que você gostaria de explorar!

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