QUANDO DO UM RELOADING NO MEU PROJETO, ele redireciona para a tela de login, gostaria…
- User
QUANDO DO UM RELOADING NO MEU PROJETO, ele redireciona para a tela de login, gostaria que ficasse na pagina que estava, mas isso nao ocorre, mesmo ja tendo um token e tudo mais, como posso resolver isso? vou passar como esta as rotas e outros componentes que talves estejam afetando
// src/components/ProtectedRoute.tsx
import React, { useContext } from 'react'; import { Navigate } from 'react-router-dom'; import { UserContext } from './Auth/UserContext'; // Ajuste o caminho se necessário
interface ProtectedRouteProps { children: React.ReactNode; }
const ProtectedRoute: React.FC = ({ children }) => { const context = useContext(UserContext); // Obtém o usuário do contexto
// Verifica se o contexto é undefined if (!context) { throw new Error("UserContext must be used within a UserProvider"); } const { usuario } = context; // Se o usuário não estiver autenticado, redireciona para a página de login return usuario ? <>{children}</> : <Navigate to="/login" replace />;};
export default ProtectedRoute;
import { useApi } from "@/lib/doctorApi"; import React, { createContext, useCallback, useContext, useEffect, useState, } from "react"; import { Address } from "./LocalCard"; import { AxiosError, AxiosResponse } from "axios";
export interface Local { id?: string; name: string; cnpj: string; email: string; address?: Address; phone: string; place: boolean; payer: boolean; }
interface LocalContextType { locais: Local[]; addLocal: (local: Local) => Promise<{ success: boolean; messages: string[] }>; fetchLocais: () => Promise; excluirLocal: (id: number) => Promise; editarLocal: ( local: Local ) => Promise<{ success: boolean; messages: string[] }>; setLocalParaEditar: (local: Local | null) => void; localParaEditar: Local | null; }
const LocalContext = createContext<LocalContextType | undefined>(undefined);
export const LocalProvider: React.FC<{ children: React.ReactNode }> = ({ children, }) => { const [locais, setLocais] = useState<Local[]>([]); const [localParaEditar, setLocalParaEditar] = useState<Local | null>(null); const { get, post, del, put } = useApi();
// Função para buscar locais da API const fetchLocais = useCallback(async () => { console.log(fetchLocais); try { //const response = await get("places/find?skip=0&limit=2000"); // setLocais(response.data.result.list || []); // Certifique-se de que os dados retornados estão corretos } catch (error) { console.error("Erro ao buscar locais:", error); } }, [get]);
// Função para adicionar um novo local const addLocal = useCallback( async (local: Local) => { try { const result = await post("places/register", local); console.log(result); return result.data; // fetchLocais(); // Atualiza a lista após adicionar } catch (error: any) { console.error("Erro ao adicionar local:", error); return error.response.data; } }, [post, fetchLocais] );
// Função para excluir um local const excluirLocal = useCallback( async (id: number) => { try { await del(
places/${id}/delete); //fetchLocais(); // Atualiza a lista após a exclusão } catch (error) { console.error("Erro ao excluir local:", error); } }, [del, fetchLocais] );// Função para editar um local const editarLocal = useCallback( async (local: Local): Promise<{ success: boolean; messages: string[] }> => { try { const resultApi = await put(
places/${local.id}/update, local); return resultApi.data.result; // fetchLocais(); // Atualiza a lista após a edição } catch (error: any) { console.error( "Erro ao editar local.....:", error, error.response.data.messages.join("") ); return { success: false, messages: error.response.data.messages, }; } }, [put, fetchLocais] );useEffect(() => { console.log("useEffect"); fetchLocais(); }, []);
return ( <LocalContext.Provider value={{ locais, addLocal, fetchLocais, excluirLocal, editarLocal, setLocalParaEditar, localParaEditar, }} > {children} </LocalContext.Provider> ); };
export const useLocalContext = () => { const context = useContext(LocalContext); if (!context) { throw new Error("useLocalContext must be used within a LocalProvider"); } return context; };
import React, { useContext, useEffect } from "react"; import { Route, Routes, Navigate, useLocation, useNavigate, } from "react-router-dom"; import Login from "./components/Auth/Login"; import Cadastro from "./components/Auth/Cadastro"; import Dashboard from "./components/Dashboard/Dashboard"; import Home from "./components/Home/Home"; import Local from "./components/Local/Local"; import NovoLocal from "./components/Local/NovoLocal"; import Pacientes from "./components/Pacientes/Pacientes"; import NovoPaciente from "./components/Pacientes/NovoPaciente"; import Atendimentos from "./components/Atendimentos/Atendimentos"; import NovoAtendimento from "./components/Atendimentos/NovoAtendimento"; import Resumos from "./components/Resumos/Resumos"; import Analitico from "./components/Analitico/Analitico"; import LayoutPrincipal from "./components/LayoutPrincipal/LayoutPrincipal"; import { UserContext } from "./components/Auth/UserContext";
import { LocalProvider } from "./components/Local/LocalContext";
const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const context = useContext(UserContext); const location = useLocation();
if (!context) { throw new Error("UserContext must be used within a UserProvider"); }
const { usuario } = context;
useEffect(() => { if (usuario) { sessionStorage.setItem("lastPrivatePath", location.pathname); } }, [usuario, location.pathname]);
if (!usuario) { sessionStorage.setItem("redirectPath", location.pathname); return ; }
return children; };
const PublicRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const context = useContext(UserContext); const { usuario } = context ?? {};
if (usuario) { const lastPrivatePath = sessionStorage.getItem("lastPrivatePath") || "/dashboard"; ; }
return children; };
const AppRoutes: React.FC = () => { const navigate = useNavigate();
useEffect(() => { const token = localStorage.getItem("token"); if (token) { const lastPath = localStorage.getItem("lastPath") || "/dashboard"; navigate(lastPath); } else { navigate("/login"); } }, []);
return ( <Route path="/" element={}> <Route path="dashboard" element={ } /> <Route path="home" element={} /> <Route path="local" element={ } /> <Route path="localNovo" element={ } /> <Route path="pacientes" element={ } /> <Route path="pacientesNovo" element={ } /> <Route path="atendimentos" element={ } /> <Route path="atendimentosNovo" element={ } /> <Route path="resumos" element={ } /> <Route path="analitico" element={ } /> <Route path="/" element={} /> <Route path="/login" element={ } /> <Route path="/cadastro" element={ } /> ); };
export default AppRoutes;
- Assistant
O problema que você está enfrentando, onde a aplicação redireciona para a tela de login após um reload, geralmente está relacionado à forma como você está gerenciando a autenticação e o armazenamento do estado do usuário.
Aqui estão alguns pontos e sugestões para investigar e resolver o problema:
-
Armazenamento do token: Certifique-se de que o token de autenticação está sendo armazenado corretamente após o login e que está sendo recuperado corretamente após um reload. Você mencionou que está usando o
localStorage, mas é importante verificar se o token está realmente disponível quando o componente é inicializado. -
Verifique a lógica do
useEffectnoAppRoutes:useEffect(() => { const token = localStorage.getItem("token"); if (token) { const lastPath = localStorage.getItem("lastPath") || "/dashboard"; navigate(lastPath); } else { navigate("/login"); } }, [navigate]);- Assegure-se de que
localStorage.getItem("token")está retornando o token correto. - A lógica do
navigatepode estar sendo chamada antes que o contexto esteja totalmente pronto, especialmente se o estado do usuário (neste caso, ousuarionoUserContext) é acessado em umuseEffectem outro componente comoPrivateRoute.
- Assegure-se de que
-
Persistência do contexto do usuário: Quando o aplicativo é recarregado, verifique se o
UserContextestá sendo inicializado corretamente com o token. Você pode verificar isso em sua implementação doUserContext(que não foi fornecida). Algo como:const { usuario } = context; if (!usuario && token) { // Aqui você pode configurar o usuário a partir do token se necessário } -
Configuração inicial no
UserContext: Certifique-se de que o estado dousuariono seuUserContexté inicializado com os dados corretos quando o token está presente nolocalStorage. -
Evitar redirecionamentos desnecessários: No
PublicRoute, a lógica para redirecionar o usuário autenticado pode estar faltando umreturn, e isso pode causar comportamento inesperado. Por exemplo:if (usuario) { const lastPrivatePath = sessionStorage.getItem("lastPrivatePath") || "/dashboard"; return <Navigate to={lastPrivatePath} />; } -
Adicione logs: Para melhor depuração, adicione
console.log()em várias partes do seu código, especialmente onde o estado dousuarioé verificado e onde você navega para as rotas. Isso pode ajudar a identificar onde a lógica pode estar falhando. -
Verifique a lógica do
sessionStoragenoPrivateRoute:- A lógica que armazena
lastPrivatePathparece estar correta, mas você deve garantir quesessionStoragenão seja utilizado de forma que cause conflitos no estado.
- A lógica que armazena
-
Verifique a carga inicial de dados: No
LocalProvider, certifique-se de que você está lidando bem com os dados, e que os dados necessários estão disponíveis ao renderizar suas rotas úberes.
Adicional: Código de exemplo para melhor gerenciamento do contexto
Aqui está um exemplo básico de como você pode gerenciar o contexto, verificando o token na inicialização do
UserProvider.const UserProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => { const [usuario, setUsuario] = useState<User | null>(null); useEffect(() => { const token = localStorage.getItem("token"); if(token) { // Lógica para buscar informações do usuário com base no token e armazenar no estado const userData = // lógica para decodificar ou armazenar o usuário setUsuario(userData); } }, []); return ( <UserContext.Provider value={{ usuario, setUsuario }}> {children} </UserContext.Provider> ); };Seguindo estas dicas e ajustes, você deve conseguir evitar o redirecionamento ao login quando não deveria. Lembre-se de testar cada alteração e observar os logs para entender melhor onde o fluxo da aplicação pode estar falhando.
-
- User
como ficaria entao?
- Assistant
Para resolver o problema onde a aplicação redireciona para a tela de login após um reload, você deve garantir que o estado do usuário está adequadamente alimentado a partir do token presente no
localStoragedurante a inicialização do aplicativo. Vou fornecer um exemplo de como você pode ajustar o seuUserProvidere a lógica noAppRoutespara melhorar o gerenciamento do estado de autenticação.Passos para a Implementação
-
Ajuste o
UserContextpara inicializar ousuariocom base no token armazenado. -
Atualize o
PrivateRouteePublicRoutepara manusear a lógica de redirecionamento corretamente.
Exemplo do
UserContextAqui está um exemplo de como você pode estruturar seu
UserProvider:// src/components/Auth/UserContext.tsx import React, { createContext, useContext, useEffect, useState } from 'react'; interface User { id: string; name: string; // Adicione os campos necessários aqui } interface UserContextType { usuario: User | null; setUsuario: React.Dispatch<React.SetStateAction<User | null>>; } const UserContext = createContext<UserContextType | undefined>(undefined); export const UserProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => { const [usuario, setUsuario] = useState<User | null>(null); useEffect(() => { const token = localStorage.getItem("token"); if (token) { // Aqui você pode decodificar o token ou fazer uma chamada à API para obter os dados do usuário const decodedUser = /* lógica para decodificar o token e obter os dados do usuário */; setUsuario(decodedUser); } }, []); return ( <UserContext.Provider value={{ usuario, setUsuario }}> {children} </UserContext.Provider> ); }; export const useUserContext = () => { const context = useContext(UserContext); if (!context) { throw new Error("useUserContext must be used within a UserProvider"); } return context; };Ajuste suas Rotas
Aqui vai como você pode ajustar o
AppRoutese asRoutes:// src/AppRoutes.tsx import React, { useEffect } from "react"; import { Route, Routes, Navigate, useNavigate, useLocation } from "react-router-dom"; import { UserProvider, useUserContext } from "./components/Auth/UserContext"; import Login from "./components/Auth/Login"; import Cadastro from "./components/Auth/Cadastro"; import Dashboard from "./components/Dashboard/Dashboard"; // ... outros imports const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const { usuario } = useUserContext(); const location = useLocation(); if (!usuario) { // Armazene a rota que o usuário estava acessando sessionStorage.setItem("redirectPath", location.pathname); return <Navigate to="/login" />; } return children; }; const PublicRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const { usuario } = useUserContext(); if (usuario) { const lastPrivatePath = sessionStorage.getItem("lastPrivatePath") || "/dashboard"; return <Navigate to={lastPrivatePath} />; } return children; }; const AppRoutes: React.FC = () => { const navigate = useNavigate(); useEffect(() => { const token = localStorage.getItem("token"); if (token) { const lastPath = localStorage.getItem("lastPath") || "/dashboard"; navigate(lastPath); } else { navigate("/login"); } }, [navigate]); return ( <Routes> <Route path="/" element={<LayoutPrincipal />}> <Route path="dashboard" element={ <PrivateRoute> <Dashboard /> </PrivateRoute> } /> <Route path="home" element={<Home />} /> <Route path="local" element={ <PrivateRoute> <Local /> </PrivateRoute> } /> {/* Defina suas outras rotas aqui seguindo o mesmo padrão */} </Route> <Route path="/login" element={ <PublicRoute> <Login /> </PublicRoute> } /> <Route path="/cadastro" element={ <PublicRoute> <Cadastro /> </PublicRoute> } /> </Routes> ); }; const App: React.FC = () => { return ( <UserProvider> <AppRoutes /> </UserProvider> ); }; export default App;Considerações Finais
-
Decodificação do Token: Você deve implementar a lógica para decodificar o token e obter os dados do usuário. Ferramentas como
jwt-decodepodem ser úteis para isso. -
Verificação do Estado de Autenticidade: O
UserProviderdeve estar por cima doAppRoutespara garantir que o estado do usuário esteja disponível. A estrutura acima reflete isso. -
Redirecionamentos: A lógica de redirecionamento está correta e deverá funcionar conforme esperado. O redirecionamento deve levar em conta o caminho anterior que o usuário tentou acessar.
-
Armazenamento do Caminho: Certifique-se de armazenar corretamente o caminho que o usuário estava tentando acessar antes do redirecionamento.
Ao seguir essa estrutura, você deve conseguir manter o estado do usuário após o reload sem ser redirecionado para a página de login indevidamente.
-
- User
esuqeci de mostrar como esta o useContext
// src/components/Auth/UserContext.tsx
import { CONFIG } from "@/config/config"; import React, { createContext, useState, ReactNode, useEffect } from "react";
interface User { id: string; // Mude para string, pois no seu exemplo o id é uma string name: string; email: string; }
interface UserContextType { usuario: User | null; setUsuario: (user: User | null) => void; token: string | null; setToken: (token: string | null) => void; expiration: number | null; setExpiration: (expiration: number | null) => void; }
export const UserContext = createContext<UserContextType | undefined>( undefined );
export const UserProvider: React.FC<{ children: ReactNode }> = ({ children, }) => { const [usuario, setUsuario] = useState<User | null>(null); const [token, setToken] = useState<string | null>(null); const [expiration, setExpiration] = useState<number | null>(null); const [refreshing, setRefreshing] = useState(false);
const refreshAuthToken = async () => { if (refreshing) return; // Evita múltiplas requisições simultâneas setRefreshing(true);
try { const response = await fetch(CONFIG.apiUrl + "gateway/refresh-token", { method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}`, }, }); const data = await response.json(); if (data.token) { setToken(data.token); // Atualiza o token no contexto } } catch (error) { console.error("Erro ao atualizar o token:", error); } finally { setRefreshing(false); // Libera para próxima execução }};
useEffect(() => { console.log("user Context", token); if (!token) { return; } const debounceTimeout = setTimeout( () => { refreshAuthToken(); }, expiration ? expiration * 1000 : 30000 );
return () => clearTimeout(debounceTimeout);}, [token]);
return ( <UserContext.Provider value={{ usuario, setUsuario, token, setToken, expiration, setExpiration, }} > {children} </UserContext.Provider> ); };
- Assistant
Obrigado por compartilhar a implementação do seu
UserContext. Vamos fazer algumas alterações para garantir que o estado do usuário (e o token) sejam geridos adequadamente, especialmente quando o aplicativo é recarregado.Ajustes no
UserContextAgora que sabemos que você está gerenciando o token e outros estados, vamos fazer ajustes no
UserProviderpara inicializar o estado do usuário e do token a partir dolocalStorage:-
Inicialize o estado com dados do
localStorage. Assim, quando o aplicativo é recarregado, os dados dousuarioe dotokenserão puxados do armazenamento local. -
Adicione a lógica para verificar a validade do token. Para aumentar a segurança, pode ser útil verificar se o token ainda é válido quando o aplicativo é iniciado.
Aqui está como o seu
UserProviderpode ser modificado:// src/components/Auth/UserContext.tsx import { CONFIG } from "@/config/config"; import React, { createContext, useState, ReactNode, useEffect } from "react"; interface User { id: string; // Mude para string, pois no seu exemplo o id é uma string name: string; email: string; } interface UserContextType { usuario: User | null; setUsuario: (user: User | null) => void; token: string | null; setToken: (token: string | null) => void; expiration: number | null; setExpiration: (expiration: number | null) => void; } export const UserContext = createContext<UserContextType | undefined>( undefined ); export const UserProvider: React.FC<{ children: ReactNode }> = ({ children, }) => { const [usuario, setUsuario] = useState<User | null>(null); const [token, setToken] = useState<string | null>(null); const [expiration, setExpiration] = useState<number | null>(null); const [refreshing, setRefreshing] = useState(false); // Função para verificar se o token está presente no localStorage e setar no estado useEffect(() => { const storedToken = localStorage.getItem("token"); const storedUser = localStorage.getItem("user"); // ou de onde pega o usuário if (storedToken) { setToken(storedToken); } if (storedUser) { setUsuario(JSON.parse(storedUser)); } }, []); const refreshAuthToken = async () => { if (refreshing) return; // Evita múltiplas requisições simultâneas setRefreshing(true); try { const response = await fetch(CONFIG.apiUrl + "gateway/refresh-token", { method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}`, }, }); const data = await response.json(); if (data.token) { setToken(data.token); // Atualiza o token no contexto localStorage.setItem("token", data.token); // Salva o token atualizado } } catch (error) { console.error("Erro ao atualizar o token:", error); } finally { setRefreshing(false); // Libera para próxima execução } }; useEffect(() => { if (!token || !expiration) { return; } const debounceTimeout = setTimeout(() => { refreshAuthToken(); }, expiration * 1000 || 30000); return () => clearTimeout(debounceTimeout); }, [token, expiration]); return ( <UserContext.Provider value={{ usuario, setUsuario, token, setToken, expiration, setExpiration, }} > {children} </UserContext.Provider> ); };Ajustes nas Rotas
Agora que temos certeza de que o
UserContextestá alimentando o estado corretamente a partir dolocalStorage, você pode usar otokene os dados dousuarionas rotas. Aqui está como você pode fazer isso:// src/AppRoutes.tsx import React, { useEffect } from "react"; import { Route, Routes, Navigate, useNavigate } from "react-router-dom"; import { UserProvider, useUserContext } from "./components/Auth/UserContext"; import Login from "./components/Auth/Login"; import Cadastro from "./components/Auth/Cadastro"; import Dashboard from "./components/Dashboard/Dashboard"; // ... outros imports const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const { usuario } = useUserContext(); if (!usuario) { return <Navigate to="/login" />; } return children; }; const PublicRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const { usuario } = useUserContext(); if (usuario) { // Se já estiver autenticado, redireciona para a dashboard const lastPrivatePath = sessionStorage.getItem("lastPrivatePath") || "/dashboard"; return <Navigate to={lastPrivatePath} />; } return children; }; const AppRoutes: React.FC = () => { const navigate = useNavigate(); const { token } = useUserContext(); useEffect(() => { if (token) { const lastPath = localStorage.getItem("lastPath") || "/dashboard"; navigate(lastPath); } else { navigate("/login"); } }, [token, navigate]); return ( <Routes> <Route path="/" element={<LayoutPrincipal />}> <Route path="dashboard" element={ <PrivateRoute> <Dashboard /> </PrivateRoute> } /> <Route path="home" element={<Home />} /> {/* Outras rotas privadas... */} </Route> <Route path="/login" element={<PublicRoute><Login /></PublicRoute>} /> <Route path="/cadastro" element={<PublicRoute><Cadastro /></PublicRoute>} /> </Routes> ); }; const App: React.FC = () => { return ( <UserProvider> <AppRoutes /> </UserProvider> ); }; export default App;Resumo
-
Inicialização do Contexto: O estado do
usuarioe dotokené carregado dolocalStoragequando o componenteUserProvideré montado. -
Visualização dos Dados: O
PrivateRouteePublicRouteagora conferem ousuariode forma apropriada, evitando o redirecionamento para login quando um token válido está presente.
Essa configuração deve resolver o problema de redirecionamento e manter o usuário na página que estava antes de um reload, desde que o token seja válido e o usuário autenticado.
-
- User
como ficaria
import React, { useEffect } from "react"; import { Route, Routes, Navigate, useLocation, useNavigate, } from "react-router-dom"; import Login from "./components/Auth/Login"; import Cadastro from "./components/Auth/Cadastro"; import Dashboard from "./components/Dashboard/Dashboard"; import Home from "./components/Home/Home"; import Local from "./components/Local/Local"; import NovoLocal from "./components/Local/NovoLocal"; import Pacientes from "./components/Pacientes/Pacientes"; import NovoPaciente from "./components/Pacientes/NovoPaciente"; import Atendimentos from "./components/Atendimentos/Atendimentos"; import NovoAtendimento from "./components/Atendimentos/NovoAtendimento"; import Resumos from "./components/Resumos/Resumos"; import Analitico from "./components/Analitico/Analitico"; import LayoutPrincipal from "./components/LayoutPrincipal/LayoutPrincipal"; import { UserContext } from "./components/Auth/UserContext";
import { LocalProvider } from "./components/Local/LocalContext";
const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const context = useContext(UserContext); const location = useLocation();
if (!context) { throw new Error("UserContext must be used within a UserProvider"); }
const { usuario } = context;
useEffect(() => { if (usuario) { sessionStorage.setItem("lastPrivatePath", location.pathname); } }, [usuario, location.pathname]);
if (!usuario) { sessionStorage.setItem("redirectPath", location.pathname); return ; }
return children; };
const PublicRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const context = useContext(UserContext); const { usuario } = context ?? {};
if (usuario) { const lastPrivatePath = sessionStorage.getItem("lastPrivatePath") || "/dashboard"; ; }
return children; };
const AppRoutes: React.FC = () => { const navigate = useNavigate();
useEffect(() => { const token = localStorage.getItem("token"); if (token) { const lastPath = localStorage.getItem("lastPath") || "/dashboard"; navigate(lastPath); } else { navigate("/login"); } }, []);
return ( <Route path="/" element={}> <Route path="dashboard" element={ } /> <Route path="home" element={} /> <Route path="local" element={ } /> <Route path="localNovo" element={ } /> <Route path="pacientes" element={ } /> <Route path="pacientesNovo" element={ } /> <Route path="atendimentos" element={ } /> <Route path="atendimentosNovo" element={ } /> <Route path="resumos" element={ } /> <Route path="analitico" element={ } /> <Route path="/" element={} /> <Route path="/login" element={ } /> <Route path="/cadastro" element={ } /> ); };
export default AppRoutes;
- Assistant
Com a sua estrutura atual, vamos fazer algumas alterações para garantir que o gerenciamento da autenticação seja feito de forma correta, considerando os dados do
UserContext. Assim, você manterá o usuário na página que estava antes do reload, desde que o token seja válido.Ajustes no
AppRoutesAqui está como o seu código
AppRoutesdeve ficar, incluindo algumas correções e melhorias:- Garanta que
useContextseja importado. - Modifique o
PublicRoutepara retornar corretamente o JSX. - Utilize o
UserProviderno componenteApppara envolver as rotas.
Aqui está o código atualizado:
import React, { useEffect, useContext } from "react"; import { Route, Routes, Navigate, useLocation, useNavigate, } from "react-router-dom"; import Login from "./components/Auth/Login"; import Cadastro from "./components/Auth/Cadastro"; import Dashboard from "./components/Dashboard/Dashboard"; import Home from "./components/Home/Home"; import Local from "./components/Local/Local"; import NovoLocal from "./components/Local/NovoLocal"; import Pacientes from "./components/Pacientes/Pacientes"; import NovoPaciente from "./components/Pacientes/NovoPaciente"; import Atendimentos from "./components/Atendimentos/Atendimentos"; import NovoAtendimento from "./components/Atendimentos/NovoAtendimento"; import Resumos from "./components/Resumos/Resumos"; import Analitico from "./components/Analitico/Analitico"; import LayoutPrincipal from "./components/LayoutPrincipal/LayoutPrincipal"; import { UserContext } from "./components/Auth/UserContext"; // Importa o UserContext import { LocalProvider } from "./components/Local/LocalContext"; const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const context = useContext(UserContext); const location = useLocation(); if (!context) { throw new Error("UserContext must be used within a UserProvider"); } const { usuario } = context; // Armazena o caminho da última rota privada visitada useEffect(() => { if (usuario) { sessionStorage.setItem("lastPrivatePath", location.pathname); } }, [usuario, location.pathname]); // Redireciona para login se não estiver autenticado if (!usuario) { sessionStorage.setItem("redirectPath", location.pathname); return <Navigate to="/login" />; } return children; }; const PublicRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const context = useContext(UserContext); const { usuario } = context ?? {}; // Redireciona para a última rota privada se já estiver autenticado if (usuario) { const lastPrivatePath = sessionStorage.getItem("lastPrivatePath") || "/dashboard"; return <Navigate to={lastPrivatePath} />; } return children; // Retorna os filhos caso não esteja autenticado }; const AppRoutes: React.FC = () => { const navigate = useNavigate(); useEffect(() => { const token = localStorage.getItem("token"); if (token) { const lastPath = localStorage.getItem("lastPath") || "/dashboard"; navigate(lastPath); } else { navigate("/login"); } }, [navigate]); return ( <LocalProvider> <Routes> <Route path="/" element={<LayoutPrincipal />}> <Route path="dashboard" element={ <PrivateRoute> <Dashboard /> </PrivateRoute> } /> <Route path="home" element={<Home />} /> <Route path="local" element={ <PrivateRoute> <Local /> </PrivateRoute> } /> <Route path="localNovo" element={ <PrivateRoute> <NovoLocal /> </PrivateRoute> } /> <Route path="pacientes" element={ <PrivateRoute> <Pacientes /> </PrivateRoute> } /> <Route path="pacientesNovo" element={ <PrivateRoute> <NovoPaciente /> </PrivateRoute> } /> <Route path="atendimentos" element={ <PrivateRoute> <Atendimentos /> </PrivateRoute> } /> <Route path="atendimentosNovo" element={ <PrivateRoute> <NovoAtendimento /> </PrivateRoute> } /> <Route path="resumos" element={ <PrivateRoute> <Resumos /> </PrivateRoute> } /> <Route path="analitico" element={ <PrivateRoute> <Analitico /> </PrivateRoute> } /> <Route path="/" element={<Navigate to="/home" />} /> </Route> <Route path="/login" element={ <PublicRoute> <Login /> </PublicRoute> } /> <Route path="/cadastro" element={ <PublicRoute> <Cadastro /> </PublicRoute> } /> </Routes> </LocalProvider> ); }; export default AppRoutes;O que foi ajustado:
-
Inclusão do
useContext: OuseContextfoi importado, garantindo acesso ao contexto do usuário. -
Correção da lógica do
PublicRoute:- Agora,
PublicRouteretorna a renderização correta do children em vez de apenas executar a navegação quando o usuário já está autenticado.
- Agora,
-
Uso do
UserContext: Ambas as rotas públicas e privadas agora verificam corretamente o estado do usuário para determinar se devem redirecionar ou não. -
Chave da Manutenção do Estado: A persistência do caminho que o usuário estava visitando é mantida através do
sessionStorage, permitindo que o usuário retorne àquela página após o login.
Com esses ajustes, sua aplicação deve se comportar conforme desejado, mantendo o usuário na última página que ele estava antes de um recarregamento, desde que o token de autenticação ainda seja válido.
- Garanta que