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

porqur os valores da minha barra nao atualizam automatico so quando do crl s const…

  1. User

    porqur os valores da minha barra nao atualizam automatico so quando do crl s

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

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

    };

    useEffect(() => { atualizarValoresBarra(); }, atendimento.procedures);

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

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

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

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

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

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

    };

    // Atualiza o localStorage sempre que procedimentos mudar

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

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

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

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

    const 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 totalProcedures = { expected: 0, glossed: 0, lost: 0, paid: 0, }; const totalValue = { expected: 0, glossed: 0, lost: 0, paid: 0, };

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

    };

    useEffect(() => { atualizarValoresBarra(); }, atendimento.procedures);

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

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

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

    const CardProcedimento: React.FC = ({ procedure, index, updateProcedimento, handleExcluir, // Recebe a função de exclusão atualizarValoresBarra, }) => { // Mapeamento de status const statusMap: { [key: string]: string } = { draft: "Rascunho", readyToValidate: "Pronto para Validação", validated: "Validado", toDerive: "Para Faturar", derived: "Faturado", finished: "Finalizado", }; const handleExpectedValueChange = ( e: React.ChangeEvent ) => { const newValue = parseFloat(e.target.value) || 0; updateProcedimento(index, { ...procedure, expectedValue: newValue }); atualizarValoresBarra(); };

    const handleGlossedValueChange = (e: React.ChangeEvent) => { const newValue = parseFloat(e.target.value) || 0; updateProcedimento(index, { ...procedure, glossedValue: newValue }); };

    const handleLostValueChange = (e: React.ChangeEvent) => { const newValue = parseFloat(e.target.value) || 0; updateProcedimento(index, { ...procedure, lostValue: newValue }); };

    const handlePaidValueChange = (e: React.ChangeEvent) => { const newValue = parseFloat(e.target.value) || 0; updateProcedimento(index, { ...procedure, paidValue: newValue }); };

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

      <div className={EstiloNovoAtendimento.divDoCard}>
        <div className={EstiloNovoAtendimento.organizadorCard}>
          <span>Código personalizado da CBHPM</span>
          <input
            className={EstiloNovoAtendimento.inputCard}
            type="text"
            value={procedure.cbhpmCode} // 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={procedure.cbhpmName} // Mantendo o valor armazenado
            placeholder="Digite o Nome..."
          />
        </div>
    
        <div className={EstiloNovoAtendimento.divflex}>
          <div className={EstiloNovoAtendimento.valores}>
            <label className={EstiloNovoAtendimento.labelinput}>
              Valor Previsto
            </label>
            <input
              className={EstiloNovoAtendimento.inputValor234}
              type="number"
              value={procedure.expectedValue} // Valor editável
              placeholder=""
              onChange={handleExpectedValueChange}
              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={procedure.glossedValue} // Valor editável
              placeholder=""
              onChange={handleGlossedValueChange}
              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={procedure.lostValue} // Valor editável
              placeholder=""
              onChange={handleLostValueChange}
              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={procedure.paidValue} // Valor editável
              placeholder=""
              onChange={handlePaidValueChange}
              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}>
          {procedure.expectedValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Previsto
            </label>
          )}
          {procedure.glossedValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Glosado
            </label>
          )}
          {procedure.paidValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              valor Pago
            </label>
          )}
          {procedure.lostValue > 0 && (
            <label className={EstiloNovoAtendimento.statusPagamento}>
              <img
                src="/cifrao.png"
                alt=""
                className={EstiloNovoAtendimento.iconStatus}
              />
              Valor Perdido
            </label>
          )}
        </div>
    
        <label className={EstiloNovoAtendimento.labelStatus}>
          Status de atividade:
        </label>
        <div className={EstiloNovoAtendimento.divflex}>
          {Object.keys(statusMap).map((statusItem) => (
            <label
              key={statusItem}
              className={EstiloNovoAtendimento.labelBorda}
            >
              <input
                type="checkbox"
                className={EstiloNovoAtendimento.customCheckbox}
                value={statusItem}
                checked={statusOfActivity === statusItem} // Verifica se o status está incluído
                onChange={(e) => {
                  const isChecked = e.target.checked;
                  updateProcedimento(index, {
                    ...procedure,
                    statusOfActivity: isChecked
                      ? (statusItem as ProcedureDTO["statusOfActivity"])
                      : "draft", // Usar o valor em inglês
                  });
                }}
              />
              <span className={EstiloNovoAtendimento.labelAtividade}>
                {statusMap[statusItem]} {/* Exibe o label em português */}
              </span>
            </label>
          ))}
        </div>
      </div>
      <div className={EstiloNovoAtendimento.CardBotton}></div>
    </div>
    

    ); };

    export default CardProcedimento;

  2. Assistant

    Parece que o problema com a atualização automática dos valores da barra gráfica no seu código está relacionado à maneira como o useEffect está sendo utilizado para monitorar as mudanças nos procedimentos.

    Problemas Encontrados

    1. Dependência do useEffect: A linha useEffect(() => { atualizarValoresBarra(); }, atendimento.procedures); não está adequada. Você não pode passar um array diretamente como dependência, pois isso não funcionará. O useEffect verifica se a referência do array mudou e não se o conteúdo mudou. Alterações em objetos não vão disparar uma re-renderização a menos que a referência do objeto mudar.

    2. Atualização dos Valores: Você deve garantir que atualizarValoresBarra é chamado em todos os momentos que os procedimentos são alterados. Isso inclui adicionar, remover ou editar procedimentos.

    Solução

    Você pode seguir as etapas abaixo para corrigir o problema:

    1. Utilizar JSON.stringify para Monitorar Mudanças: Para assegurar que qualquer alteração no array de procedimentos dispare uma função de atualização, você pode usar JSON.stringify na dependência do useEffect para forçar a reatividade.

    2. Chamar atualizarValoresBarra nas funções de manipulação de procedimentos: Além disso, você deve garantir que atualizarValoresBarra seja chamado dentro das funções onde os procedimentos são manipulados, como adicionar ou excluir.

    Exemplo Correto de useEffect

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

    Atualizações em Funções de Manipulação

    Adicione chamadas para atualizarValoresBarra:

    1. Adicionar Procedimento:
    const handleAdicionarProcedimento = () => {
        // ... (código existente)
        setAtendimento(cloneAtendimento);
        atualizarValoresBarra(); // Chama para atualizar os valores após a adição
    };
    
    1. Excluir Procedimento:
    const handleExcluirProcedimento = (id: string) => {
        const novosProcedimentos = atendimento.procedures.filter(
          (proc) => proc.id !== id
        );
    
        setAtendimento((prev) => ({
          ...prev,
          procedures: novosProcedimentos,
        }));
        atualizarValoresBarra(); // Atualiza os valores da barra
    };
    
    1. Atualizar Procedimento (todos os onChange para os valores):
    const handleExpectedValueChange = (e: React.ChangeEvent<HTMLInputElement>) => {
        const newValue = parseFloat(e.target.value) || 0;
        updateProcedimento(index, { ...procedure, expectedValue: newValue });
        atualizarValoresBarra(); // Chama a função para atualizar a barra após alteração
    };
    

    Resumo

    Ao garantir que a função atualizarValoresBarra é chamada sempre que há uma alteração nas informações relevantes, você deve ver que os valores da barra agora se atualizam automaticamente, sem a necessidade de pressionar CTRL + S.

    Essas mudanças permitirão que seu componente reaja corretamente às alterações nos dados da aplicação.

  3. User

    meu input muda os valor ao scrolar quando selecionado e scrolo pra cima ou pra baixo porque?

  4. Assistant

    O comportamento que você está observando, em que o valor de um campo de entrada (input) muda ao rolar para cima ou para baixo do mouse, é um comportamento padrão em campos de entrada do tipo number no HTML. Isso ocorre porque, por padrão, os campos de entrada numéricos permitem que o usuário aumente ou diminua rapidamente o valor ao usar a roda do mouse.

    Como Funciona:

    • Quando um campo de entrada é focado (ou seja, você clica nele) e você usa a roda do mouse, o navegador interpreta isso como um comando para aumentar ou diminuir o valor do campo numérico.
    • Cada "click" da roda do mouse (para cima ou para baixo) resulta em uma alteração de um número predefinido (geralmente 1) no valor do campo.

    Solução

    Se você não quer que esse comportamento ocorra, você pode desabilitar essa funcionalidade. Aqui estão algumas maneiras de fazer isso:

    1. Prevenir o Comportamento com onWheel

    Você pode adicionar um manipulador de evento que previne a alteração do valor quando a roda do mouse é utilizada:

    const handleWheel = (e: React.WheelEvent<HTMLInputElement>) => {
      e.preventDefault(); // Previne a mudança de valor
    };
    
    // Dentro do seu input
    <input
      type="number"
      value={procedure.expectedValue} // Valor editável
      placeholder=""
      onChange={handleExpectedValueChange}
      onWheel={handleWheel} // Adiciona o manipulador
    />
    

    2. Usar Um Input de Tipo Diferente

    Se o comportamento não é desejado e você não está lidando com números específicos, pode considerar usar um campo de texto (input com type="text") e, em seguida, lidar com a conversão para número no seu código:

    <input
      type="text"
      value={procedure.expectedValue} // Valor a ser ajustado
      placeholder=""
      onChange={(e) => handleExpectedValueChange(e)} // Mantém a lógica de alteração
    />
    

    Exemplo Completo

    Aqui está um exemplo de como você pode implementar a prevenção da alteração ao usar a roda do mouse no seu campo de entrada:

    // Dentro do seu componente
    const handleExpectedValueChange = (
      e: React.ChangeEvent<HTMLInputElement>
    ) => {
      const newValue = parseFloat(e.target.value) || 0;
      updateProcedimento(index, { ...procedure, expectedValue: newValue });
    };
    
    const handleWheel = (e: React.WheelEvent<HTMLInputElement>) => {
      e.preventDefault(); // Previne a alteração do valor ao rolar
    };
    
    // Dentro do seu input
    <input
      type="number"
      value={procedure.expectedValue}
      placeholder=""
      onChange={handleExpectedValueChange}
      onWheel={handleWheel} // Adiciona o manipulador
      onBlur={() => {
        // Aqui você pode adicionar lógica se precisar validar ou tratar ao perder foco
      }}
    />
    

    Conclusão

    Dessa forma, você pode evitar que os campos de entrada numéricos mudem de valor quando o usuário rola a roda do mouse enquanto o campo está focado. O evento onWheel é uma solução útil para esse comportamento específico.