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

estou criando uma aplicacao com login, porem quando estou dentro das rotas protegidas…

  1. User

    estou criando uma aplicacao com login, porem quando estou dentro das rotas protegidas pelo token de autenticacao, e faço o recarregamento da pagina ele direciona para o /login, como redirecionar para a pagina atual que ele recarregou?

  2. Assistant

    Para manter o usuário na mesma página após um recarregamento da página em uma aplicação com autenticação baseada em token, você pode usar algumas abordagens. Uma abordagem comum é armazenar a URL da página atual antes do redirecionamento para a página de login e depois redirecionar o usuário de volta para essa URL após o login. Aqui estão os passos a seguir:

    Passo 1: Armazenar a URL Atual

    Antes de redirecionar para a página de login, armazene a URL da página atual em algum lugar do seu aplicativo. Você pode usar o Local Storage ou o Session Storage do navegador para isso.

    // Supondo que você esteja usando React Router
    import { useEffect } from 'react';
    import { useHistory } from 'react-router-dom';
    
    const PrivateRoute = ({ component: Component, ...rest }) => {
        const history = useHistory();
    
        useEffect(() => {
            const isAuthenticated = // lógica para verificar se o usuário está autenticado
            
            if (!isAuthenticated) {
                // Armazenar a URL atual no sessionStorage antes de redirecionar
                sessionStorage.setItem('redirectPath', window.location.pathname);
                history.push('/login');
            }
        }, [history]);
    
        return <Component {...rest} />;
    };
    

    Passo 2: Redirecionar Após Login

    Quando o usuário fizer login com sucesso, você pode redirecioná-lo de volta para a URL armazenada no sessionStorage.

    const LoginPage = () => {
        const history = useHistory();
    
        const handleLogin = async () => {
            // lógica de autenticação
            const isAuthenticated = true; // Suponha que a autenticação tenha sido bem-sucedida
    
            if (isAuthenticated) {
                // Obter a URL do redirecionamento do sessionStorage
                const redirectPath = sessionStorage.getItem('redirectPath') || '/';
                // Limpar o redirectPath do sessionStorage
                sessionStorage.removeItem('redirectPath');
                // Redirecionar para a URL armazenada ou para a página inicial se não houver
                history.push(redirectPath);
            }
        };
    
        return (
            <div>
                {/* Formulário de login */}
                <button onClick={handleLogin}>Login</button>
            </div>
        );
    };
    

    Considerações Finais

    • O uso de sessionStorage garante que a URL apenas persista enquanto a aba ou janela do navegador estiver aberta. Se você usar localStorage, a URL persistirá entre diferentes sessões do navegador.
    • Certifique-se de lidar com a lógica de autenticação de maneira adequada e valide se o usuário está realmente autenticado antes de permitir o acesso às rotas protegidas.
    • Além disso, considere fazer uma verificação de token em segundo plano para evitar que um token inválido provoque um redirecionamento indesejado.

    Essas etapas devem ajudar você a redirecionar o usuário de volta à página que ele estava após o login, garantindo uma experiência mais suave na sua aplicação.

  3. User

    estou criando uma aplicacao com login, porem quando estou dentro das rotas protegidas pelo token de autenticacao, e faço o recarregamento da pagina ele direciona para o /login, como redirecionar para a pagina atual que ele recarregou?

    // src/AppRoutes.tsx import React, { useContext } from 'react'; import { Route, Routes, Navigate } 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 { PacienteProvider } from './components/Pacientes/PacienteContext'; import { LocalProvider } from './components/Local/LocalContext';

    const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const context = useContext(UserContext); if (!context) { throw new Error("UserContext must be used within a UserProvider"); } const { usuario } = context;

    return usuario ? children : <Navigate to="/login" />;
    

    };

    const AppRoutes: React.FC = () => { 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;

    user context:

    import React, { createContext, useState, ReactNode, useEffect } from 'react';

    interface UserInfo { id: string; name: string; email: string; }

    interface UserContextType { usuario: UserInfo | null; setUsuario: (userInfo: UserInfo | null) => void; token: string | null; setToken: (token: string | null) => void; expiration: Date | null; setExpiration: (date: Date | null) => void; }

    export const UserContext = createContext<UserContextType | undefined>(undefined);

    interface UserProviderProps { children: ReactNode; }

    export const UserProvider: React.FC = ({ children }) => { const [usuario, setUsuario] = useState<UserInfo | null>(null); const [token, setToken] = useState<string | null>(localStorage.getItem('token')); const [expiration, setExpiration] = useState<Date | null>(localStorage.getItem('expiration') ? new Date(localStorage.getItem('expiration') as string) : null);

    useEffect(() => {
        const currentTime = new Date();
        if (expiration && currentTime > expiration) {
            setUsuario(null);
            setToken(null);
            setExpiration(null);
            localStorage.removeItem('token');
            localStorage.removeItem('expiration');
        }
    }, [expiration]);
    
    const value = { usuario, setUsuario, token, setToken, expiration, setExpiration };
    
    return <UserContext.Provider value={value}>{children}</UserContext.Provider>;
    

    };

    login:

    // src/components/Auth/Login.tsx

    import React, { useState, useContext } from 'react'; import LoginStyles from "./Login.module.css"; import { useNavigate } from 'react-router-dom'; import { UserContext } from './UserContext';

    const Login: React.FC = () => { const [email, setEmail] = useState(''); const [senha, setSenha] = useState(''); const [message, setMessage] = useState(''); const [isLoading, setIsLoading] = useState(false); // Novo estado para loading const navigate = useNavigate(); const context = useContext(UserContext);

    if (!context) {
        throw new Error("UserContext must be used within a UserProvider");
    }
    
    const { setUsuario, setToken, setExpiration } = context;
    
    const handleLogin = () => {
        setIsLoading(true); // Começa o loading
        const loginData = {
            login: email,
            password: senha,
        };
    
        fetch('https://hermes-api-homolog-bae7z73pga-uk.a.run.app/public/auth/credentials/login', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify(loginData),
        })
        .then(response => {
            if (!response.ok) {
                throw new Error('Erro na requisição');
            }
            return response.json();
        })
        .then(data => {
            setIsLoading(false); // Encerra o loading ao receber a resposta
            if (data.success) {
                const userInfo = data.result.userInfo;
                const token = data.result.token;
                const expiration = new Date(data.result.expiration);
    
                setMessage('Login bem-sucedido!');
                console.log('Login bem-sucedido:', userInfo);
    
                setUsuario(userInfo);
                setToken(token);
                setExpiration(expiration);
    
                localStorage.setItem('token', token);
                localStorage.setItem('expiration', expiration.toISOString());
    
                // Redireciona para a tela de confirmação de e-mail
        navigate('/dashboard'); // Aqui você redireciona para confirmação
            } else {
                setMessage('E-mail ou senha inválidos.');
                console.error('E-mail ou senha inválidos.');
            }
        })
        .catch(error => {
            setIsLoading(false); // Encerra o loading em caso de erro
            const errorMessage = "Erro ao fazer login: " + error.message;
            setMessage(errorMessage);
            console.error('Erro ao fazer login:', error);
        });
    };
    
    const handleRegisterRedirect = () => {
        navigate('/cadastro'); // Redireciona para a página de cadastro
    };
    
    
    return (
        <div className={LoginStyles.loginContainer}>
            <div className={LoginStyles.logoContainer}>
                <img src="/logo_hermes.png" alt="logo Hermes" className={LoginStyles.logoImage} />
            </div>
    
            <div className={LoginStyles.buttonContainer}>
                <img src="/button prosseguir.png" alt="" className={LoginStyles.buttonImage} />
            </div>
    
            <div className={LoginStyles.container}>
                <label className={LoginStyles.label}>
                    <label className={LoginStyles.labelInput}>E-mail:</label>
                    <input 
                        className={LoginStyles.input_estilo} 
                        type="email"
                        value={email}
                        onChange={(e) => setEmail(e.target.value)}
                        placeholder="Digite seu e-mail..." 
                    />
                </label>
                
                <label className={LoginStyles.label}>
                    <label className={LoginStyles.labelInput}>Senha:</label>
                    <input 
                        className={LoginStyles.input_estilo} 
                        type="password"
                        value={senha}
                        onChange={(e) => setSenha(e.target.value)}
                        placeholder="Digite sua senha..." 
                    />
                </label>
                <div className={LoginStyles.forgotPassword}>
                    <label className={LoginStyles.fontSize18}><u>esqueci minha senha</u></label>
                </div>
            </div>
    
            <div className={LoginStyles.textCenter}>
                <button className={LoginStyles.button} onClick={handleLogin} disabled={isLoading}>
                    {isLoading ? 'Entrando...' : 'Entrar'}
                </button>
            </div>
    
            {isLoading && <p>Carregando... Por favor, aguarde...</p>} {/* Mensagem de Loading */}
    
            {message && (
                <div id="error-message" style={{ color: "red" }}>
                    <p>{message}</p>
                </div>
            )}
    
    
            <div className={LoginStyles.textCenter}>
                <label className={LoginStyles.fontSize24} onClick={handleRegisterRedirect}>
                    <u>Cadastrar</u>
                </label>
            </div>
        </div>
    );
    

    };

    export default Login;

    estrutura de pastas:

    my-project/ ├── public/ │ ├── index.html │ ├── logo_hermes.png │ ├── button prosseguir.png │ └── ... ├── src/ │ ├── assets/ │ │ └── images/ │ │ ├── logo_hermes.png │ │ ├── button prosseguir.png │ │ └── ... │ ├── components/ │ │ ├── Auth/ │ │ │ ├── Login.tsx │ │ │ ├── Login.module.css │ │ │ └── UserContext.tsx │ │ └── ... │ ├── pages/ │ │ ├── Dashboard.tsx │ │ ├── Cadastro.tsx │ │ └── ... │ ├── App.tsx │ ├── index.tsx │ ├── routes.tsx │ └── ... ├── .gitignore ├── package.json ├── tsconfig.json └── README.md

  4. Assistant

    Para redirecionar o usuário de volta à página que ele recarregou, você pode armazenar a URL atual antes de redirecionar para a página de login, e então usar essa URL para redirecioná-lo após o login com sucesso. Isso pode ser feito usando o sessionStorage ou o localStorage do navegador. Vou mostrar como você pode implementar isso em sua aplicação.

    Passo 1: Armazenar a URL da Página Atual

    Você precisa modificar seu componente PrivateRoute para que antes de redirecionar para a página de login, ele armazene a URL atual.

    // src/AppRoutes.tsx
    const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => {
        const context = useContext(UserContext);
        const { usuario } = context ?? {};
        const location = useLocation(); // Serve para obter a URL atual
    
        if (!usuario) {
            sessionStorage.setItem('redirectPath', location.pathname); // Armazena a URL atual
            return <Navigate to="/login" />;
        }
    
        return children;
    };
    

    Passo 2: Redirecionar Após o Login

    Quando o usuário realizar o login com sucesso, você deve pegar a URL armazenada e redirecioná-lo para essa URL.

    // src/components/Auth/Login.tsx
    const Login: React.FC = () => {
        const [email, setEmail] = useState('');
        const [senha, setSenha] = useState('');
        const [message, setMessage] = useState('');
        const [isLoading, setIsLoading] = useState(false);
        const navigate = useNavigate();
        const context = useContext(UserContext);
    
        if (!context) {
            throw new Error("UserContext must be used within a UserProvider");
        }
    
        const { setUsuario, setToken, setExpiration } = context;
    
        const handleLogin = () => {
            setIsLoading(true);
            const loginData = {
                login: email,
                password: senha,
            };
    
            fetch('https://hermes-api-homolog-bae7z73pga-uk.a.run.app/public/auth/credentials/login', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify(loginData),
            })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Erro na requisição');
                }
                return response.json();
            })
            .then(data => {
                setIsLoading(false);
                if (data.success) {
                    const userInfo = data.result.userInfo;
                    const token = data.result.token;
                    const expiration = new Date(data.result.expiration);
    
                    setMessage('Login bem-sucedido!');
                    setUsuario(userInfo);
                    setToken(token);
                    setExpiration(expiration);
    
                    localStorage.setItem('token', token);
                    localStorage.setItem('expiration', expiration.toISOString());
    
                    // Redireciona para a URL armazenada ou um valor padrão
                    const redirectPath = sessionStorage.getItem('redirectPath') || '/dashboard';
                    sessionStorage.removeItem('redirectPath'); // Limpa a URL armazenada
    
                    navigate(redirectPath);
                } else {
                    setMessage('E-mail ou senha inválidos.');
                }
            })
            .catch(error => {
                setIsLoading(false);
                const errorMessage = "Erro ao fazer login: " + error.message;
                setMessage(errorMessage);
            });
        };
    
        // Resto do código permanece o mesmo...
    
        return (
            <div className={LoginStyles.loginContainer}>
                {/* O resto do seu componente de login... */}
            </div>
        );
    };
    

    Considerações Finais

    • O uso de sessionStorage é apropriado, pois a informação se perderá quando a aba do navegador for fechada, enquanto localStorage persistirá entre as sessões até ser limpo.
    • Certifique-se de que o contexto do usuário (UserContext) esteja sendo corretamente preenchido e que a lógica de login funcione.
    • Adaptar a verificação do usuário e a lógica do token é crucial para garantir que as rotas protegidas estejam funcionando como esperado.

    Seguindo essas instruções, você conseguirá redirecionar o usuário de volta à página em que ele estava antes de ser redirecionado para a página de login.

  5. User

    estou criando uma aplicacao com login, porem quando estou dentro das rotas protegidas pelo token de autenticacao, e faço o recarregamento da pagina ele direciona para o /login, como redirecionar para a pagina atual que ele recarregou? me mostre as solucoes completas dos componentes inteiros e arquivos inteiros por favor

    // src/AppRoutes.tsx import React, { useContext } from 'react'; import { Route, Routes, Navigate } 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 { PacienteProvider } from './components/Pacientes/PacienteContext'; import { LocalProvider } from './components/Local/LocalContext';

    const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const context = useContext(UserContext); if (!context) { throw new Error("UserContext must be used within a UserProvider"); } const { usuario } = context;

    return usuario ? children : ; };

    const AppRoutes: React.FC = () => { return (

    ); };

    export default AppRoutes;

    user context:

    import React, { createContext, useState, ReactNode, useEffect } from 'react';

    interface UserInfo { id: string; name: string; email: string; }

    interface UserContextType { usuario: UserInfo | null; setUsuario: (userInfo: UserInfo | null) => void; token: string | null; setToken: (token: string | null) => void; expiration: Date | null; setExpiration: (date: Date | null) => void; }

    export const UserContext = createContext<UserContextType | undefined>(undefined);

    interface UserProviderProps { children: ReactNode; }

    export const UserProvider: React.FC = ({ children }) => { const [usuario, setUsuario] = useState<UserInfo | null>(null); const [token, setToken] = useState<string | null>(localStorage.getItem('token')); const [expiration, setExpiration] = useState<Date | null>(localStorage.getItem('expiration') ? new Date(localStorage.getItem('expiration') as string) : null);

    useEffect(() => { const currentTime = new Date(); if (expiration && currentTime > expiration) { setUsuario(null); setToken(null); setExpiration(null); localStorage.removeItem('token'); localStorage.removeItem('expiration'); } }, [expiration]);

    const value = { usuario, setUsuario, token, setToken, expiration, setExpiration };

    return <UserContext.Provider value={value}>{children}</UserContext.Provider>; };

    login:

    // src/components/Auth/Login.tsx

    import React, { useState, useContext } from 'react'; import LoginStyles from "./Login.module.css"; import { useNavigate } from 'react-router-dom'; import { UserContext } from './UserContext';

    const Login: React.FC = () => { const [email, setEmail] = useState(''); const [senha, setSenha] = useState(''); const [message, setMessage] = useState(''); const [isLoading, setIsLoading] = useState(false); // Novo estado para loading const navigate = useNavigate(); const context = useContext(UserContext);

    if (!context) { throw new Error("UserContext must be used within a UserProvider"); }

    const { setUsuario, setToken, setExpiration } = context;

    const handleLogin = () => { setIsLoading(true); // Começa o loading const loginData = { login: email, password: senha, };

    fetch('https://hermes-api-homolog-bae7z73pga-uk.a.run.app/public/auth/credentials/login', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify(loginData),
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('Erro na requisição');
        }
        return response.json();
    })
    .then(data => {
        setIsLoading(false); // Encerra o loading ao receber a resposta
        if (data.success) {
            const userInfo = data.result.userInfo;
            const token = data.result.token;
            const expiration = new Date(data.result.expiration);
    
            setMessage('Login bem-sucedido!');
            console.log('Login bem-sucedido:', userInfo);
    
            setUsuario(userInfo);
            setToken(token);
            setExpiration(expiration);
    
            localStorage.setItem('token', token);
            localStorage.setItem('expiration', expiration.toISOString());
    
            // Redireciona para a tela de confirmação de e-mail
    navigate('/dashboard'); // Aqui você redireciona para confirmação
        } else {
            setMessage('E-mail ou senha inválidos.');
            console.error('E-mail ou senha inválidos.');
        }
    })
    .catch(error => {
        setIsLoading(false); // Encerra o loading em caso de erro
        const errorMessage = "Erro ao fazer login: " + error.message;
        setMessage(errorMessage);
        console.error('Erro ao fazer login:', error);
    });
    

    };

    const handleRegisterRedirect = () => { navigate('/cadastro'); // Redireciona para a página de cadastro };

    return (

        <div className={LoginStyles.buttonContainer}>
            <img src="/button prosseguir.png" alt="" className={LoginStyles.buttonImage} />
        </div>
    
        <div className={LoginStyles.container}>
            <label className={LoginStyles.label}>
                <label className={LoginStyles.labelInput}>E-mail:</label>
                <input 
                    className={LoginStyles.input_estilo} 
                    type="email"
                    value={email}
                    onChange={(e) => setEmail(e.target.value)}
                    placeholder="Digite seu e-mail..." 
                />
            </label>
            
            <label className={LoginStyles.label}>
                <label className={LoginStyles.labelInput}>Senha:</label>
                <input 
                    className={LoginStyles.input_estilo} 
                    type="password"
                    value={senha}
                    onChange={(e) => setSenha(e.target.value)}
                    placeholder="Digite sua senha..." 
                />
            </label>
            <div className={LoginStyles.forgotPassword}>
                <label className={LoginStyles.fontSize18}><u>esqueci minha senha</u></label>
            </div>
        </div>
    
        <div className={LoginStyles.textCenter}>
            <button className={LoginStyles.button} onClick={handleLogin} disabled={isLoading}>
                {isLoading ? 'Entrando...' : 'Entrar'}
            </button>
        </div>
    
        {isLoading && <p>Carregando... Por favor, aguarde...</p>} {/* Mensagem de Loading */}
    
        {message && (
            <div id="error-message" style={{ color: "red" }}>
                <p>{message}</p>
            </div>
        )}
    
    
        <div className={LoginStyles.textCenter}>
            <label className={LoginStyles.fontSize24} onClick={handleRegisterRedirect}>
                <u>Cadastrar</u>
            </label>
        </div>
    </div>
    

    ); };

    export default Login;

    estrutura de pastas:

    my-project/ ├── public/ │ ├── index.html │ ├── logo_hermes.png │ ├── button prosseguir.png │ └── ... ├── src/ │ ├── assets/ │ │ └── images/ │ │ ├── logo_hermes.png │ │ ├── button prosseguir.png │ │ └── ... │ ├── components/ │ │ ├── Auth/ │ │ │ ├── Login.tsx │ │ │ ├── Login.module.css │ │ │ └── UserContext.tsx │ │ └── ... │ ├── pages/ │ │ ├── Dashboard.tsx │ │ ├── Cadastro.tsx │ │ └── ... │ ├── App.tsx │ ├── index.tsx │ ├── routes.tsx │ └── ... ├── .gitignore ├── package.json ├── tsconfig.json └── README.md

  6. Assistant

    Para resolver o problema de redirecionamento após um recarregamento da página nas rotas protegidas de sua aplicação, você vai precisar adaptar alguns componentes. Vou fornecer implementações completas dos arquivos, incluindo as alterações necessárias para armazenar a URL que o usuário estava visitando antes de ser redirecionado para a tela de login, e então redirecioná-lo de volta após um login bem-sucedido.

    1. AppRoutes.tsx

    Aqui, você armazenará a URL atual quando o usuário não estiver autenticado.

    // src/AppRoutes.tsx
    import React, { useContext } from 'react';
    import { Route, Routes, Navigate, useLocation } 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 { PacienteProvider } from './components/Pacientes/PacienteContext';
    import { LocalProvider } from './components/Local/LocalContext';
    
    const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => {
        const context = useContext(UserContext);
        const location = useLocation(); // Para obter a URL atual
    
        if (!context) {
            throw new Error("UserContext must be used within a UserProvider");
        }
    
        const { usuario } = context;
    
        if (!usuario) {
            // Armazena a URL no session storage
            sessionStorage.setItem('redirectPath', location.pathname);
            return <Navigate to="/login" />;
        }
    
        return children;
    };
    
    const AppRoutes: React.FC = () => {
        return (
            <PacienteProvider>
                <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={<Login />} />
                        <Route path="/cadastro" element={<Cadastro />} />
                    </Routes>
                </LocalProvider>
            </PacienteProvider>
        );
    };
    
    export default AppRoutes;
    

    2. UserContext.tsx

    Este arquivo não necessita de alteração para esta funcionalidade, mas aqui está sua versão completa para referência.

    // src/components/Auth/UserContext.tsx
    import React, { createContext, useState, ReactNode, useEffect } from 'react';
    
    interface UserInfo {
        id: string;
        name: string;
        email: string;
    }
    
    interface UserContextType {
        usuario: UserInfo | null;
        setUsuario: (userInfo: UserInfo | null) => void;
        token: string | null;
        setToken: (token: string | null) => void;
        expiration: Date | null;
        setExpiration: (date: Date | null) => void;
    }
    
    export const UserContext = createContext<UserContextType | undefined>(undefined);
    
    interface UserProviderProps {
        children: ReactNode;
    }
    
    export const UserProvider: React.FC<UserProviderProps> = ({ children }) => {
        const [usuario, setUsuario] = useState<UserInfo | null>(null);
        const [token, setToken] = useState<string | null>(localStorage.getItem('token'));
        const [expiration, setExpiration] = useState<Date | null>(
            localStorage.getItem('expiration') ? new Date(localStorage.getItem('expiration') as string) : null
        );
    
        useEffect(() => {
            const currentTime = new Date();
            if (expiration && currentTime > expiration) {
                setUsuario(null);
                setToken(null);
                setExpiration(null);
                localStorage.removeItem('token');
                localStorage.removeItem('expiration');
            }
        }, [expiration]);
    
        const value = { usuario, setUsuario, token, setToken, expiration, setExpiration };
    
        return <UserContext.Provider value={value}>{children}</UserContext.Provider>;
    };
    

    3. Login.tsx

    Modifique o componente de login para redirecionar de acordo com a URL que foi salva.

    // src/components/Auth/Login.tsx
    import React, { useState, useContext } from 'react';
    import LoginStyles from "./Login.module.css";
    import { useNavigate } from 'react-router-dom';
    import { UserContext } from './UserContext';
    
    const Login: React.FC = () => {
        const [email, setEmail] = useState('');
        const [senha, setSenha] = useState('');
        const [message, setMessage] = useState('');
        const [isLoading, setIsLoading] = useState(false);
        const navigate = useNavigate();
        const context = useContext(UserContext);
    
        if (!context) {
            throw new Error("UserContext must be used within a UserProvider");
        }
    
        const { setUsuario, setToken, setExpiration } = context;
    
        const handleLogin = () => {
            setIsLoading(true);
            const loginData = {
                login: email,
                password: senha,
            };
    
            fetch('https://hermes-api-homolog-bae7z73pga-uk.a.run.app/public/auth/credentials/login', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify(loginData),
            })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Erro na requisição');
                }
                return response.json();
            })
            .then(data => {
                setIsLoading(false);
                if (data.success) {
                    const userInfo = data.result.userInfo;
                    const token = data.result.token;
                    const expiration = new Date(data.result.expiration);
    
                    setUsuario(userInfo);
                    setToken(token);
                    setExpiration(expiration);
    
                    localStorage.setItem('token', token);
                    localStorage.setItem('expiration', expiration.toISOString());
    
                    // Verifica a URL armazenada e redireciona
                    const redirectPath = sessionStorage.getItem('redirectPath') || '/dashboard';
                    sessionStorage.removeItem('redirectPath'); // Limpa a URL
    
                    navigate(redirectPath);
                } else {
                    setMessage('E-mail ou senha inválidos.');
                }
            })
            .catch(error => {
                setIsLoading(false);
                setMessage("Erro ao fazer login: " + error.message);
            });
        };
    
        const handleRegisterRedirect = () => {
            navigate('/cadastro');
        };
    
        return (
            <div className={LoginStyles.loginContainer}>
                <div className={LoginStyles.logoContainer}>
                    <img src="/logo_hermes.png" alt="logo Hermes" className={LoginStyles.logoImage} />
                </div>
    
                <div className={LoginStyles.buttonContainer}>
                    <img src="/button prosseguir.png" alt="" className={LoginStyles.buttonImage} />
                </div>
    
                <div className={LoginStyles.container}>
                    <label className={LoginStyles.label}>
                        <label className={LoginStyles.labelInput}>E-mail:</label>
                        <input 
                            className={LoginStyles.input_estilo} 
                            type="email"
                            value={email}
                            onChange={(e) => setEmail(e.target.value)}
                            placeholder="Digite seu e-mail..." 
                        />
                    </label>
                    
                    <label className={LoginStyles.label}>
                        <label className={LoginStyles.labelInput}>Senha:</label>
                        <input 
                            className={LoginStyles.input_estilo} 
                            type="password"
                            value={senha}
                            onChange={(e) => setSenha(e.target.value)}
                            placeholder="Digite sua senha..." 
                        />
                    </label>
                    <div className={LoginStyles.forgotPassword}>
                        <label className={LoginStyles.fontSize18}><u>esqueci minha senha</u></label>
                    </div>
                </div>
    
                <div className={LoginStyles.textCenter}>
                    <button className={LoginStyles.button} onClick={handleLogin} disabled={isLoading}>
                        {isLoading ? 'Entrando...' : 'Entrar'}
                    </button>
                </div>
    
                {isLoading && <p>Carregando... Por favor, aguarde...</p>} 
    
                {message && (
                    <div id="error-message" style={{ color: "red" }}>
                        <p>{message}</p>
                    </div>
                )}
    
                <div className={LoginStyles.textCenter}>
                    <label className={LoginStyles.fontSize24} onClick={handleRegisterRedirect}>
                        <u>Cadastrar</u>
                    </label>
                </div>
            </div>
        );
    };
    
    export default Login;
    

    Resumo

    • AppRoutes: Armazena a URL que o usuário estava tentando acessar antes de ser redirecionado ao login.
    • UserContext: Não requer mudanças para esta funcionalidade, mas importante mantê-lo como está.
    • Login: Ao fazer login com sucesso, redireciona o usuário de volta para a URL armazenada.

    Essas modificações devem fornecer a funcionalidade que você deseja. Se um usuário tentar acessar uma rota protegida e não estiver autenticado, ele será redirecionado para a página de login, e após o login, ele será enviado de volta à página que estava tentando acessar.

  7. User

    estou criando uma aplicacao com login, porem quando estou dentro das rotas protegidas pelo token de autenticacao, e faço o recarregamento da pagina ele direciona para o /login, como redirecionar para a pagina atual que ele recarregou? me mostre as solucoes completas dos componentes inteiros e arquivos inteiros por favor. Por favor, bloqueie o redirecionamento para o /login caso o usuario ja esteja logado, caso nao esteja logado, libere o acesso

    // src/AppRoutes.tsx import React, { useContext } from 'react'; import { Route, Routes, Navigate } 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 { PacienteProvider } from './components/Pacientes/PacienteContext'; import { LocalProvider } from './components/Local/LocalContext';

    const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const context = useContext(UserContext); if (!context) { throw new Error("UserContext must be used within a UserProvider"); } const { usuario } = context;

    return usuario ? children : ; };

    const AppRoutes: React.FC = () => { return (

    ); };

    export default AppRoutes;

    user context:

    import React, { createContext, useState, ReactNode, useEffect } from 'react';

    interface UserInfo { id: string; name: string; email: string; }

    interface UserContextType { usuario: UserInfo | null; setUsuario: (userInfo: UserInfo | null) => void; token: string | null; setToken: (token: string | null) => void; expiration: Date | null; setExpiration: (date: Date | null) => void; }

    export const UserContext = createContext<UserContextType | undefined>(undefined);

    interface UserProviderProps { children: ReactNode; }

    export const UserProvider: React.FC = ({ children }) => { const [usuario, setUsuario] = useState<UserInfo | null>(null); const [token, setToken] = useState<string | null>(localStorage.getItem('token')); const [expiration, setExpiration] = useState<Date | null>(localStorage.getItem('expiration') ? new Date(localStorage.getItem('expiration') as string) : null);

    useEffect(() => { const currentTime = new Date(); if (expiration && currentTime > expiration) { setUsuario(null); setToken(null); setExpiration(null); localStorage.removeItem('token'); localStorage.removeItem('expiration'); } }, [expiration]);

    const value = { usuario, setUsuario, token, setToken, expiration, setExpiration };

    return <UserContext.Provider value={value}>{children}</UserContext.Provider>; };

    login:

    // src/components/Auth/Login.tsx

    import React, { useState, useContext } from 'react'; import LoginStyles from "./Login.module.css"; import { useNavigate } from 'react-router-dom'; import { UserContext } from './UserContext';

    const Login: React.FC = () => { const [email, setEmail] = useState(''); const [senha, setSenha] = useState(''); const [message, setMessage] = useState(''); const [isLoading, setIsLoading] = useState(false); // Novo estado para loading const navigate = useNavigate(); const context = useContext(UserContext);

    if (!context) { throw new Error("UserContext must be used within a UserProvider"); }

    const { setUsuario, setToken, setExpiration } = context;

    const handleLogin = () => { setIsLoading(true); // Começa o loading const loginData = { login: email, password: senha, };

    fetch('https://hermes-api-homolog-bae7z73pga-uk.a.run.app/public/auth/credentials/login', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify(loginData), }) .then(response => { if (!response.ok) { throw new Error('Erro na requisição'); } return response.json(); }) .then(data => { setIsLoading(false); // Encerra o loading ao receber a resposta if (data.success) { const userInfo = data.result.userInfo; const token = data.result.token; const expiration = new Date(data.result.expiration);

        setMessage('Login bem-sucedido!');
        console.log('Login bem-sucedido:', userInfo);
    
        setUsuario(userInfo);
        setToken(token);
        setExpiration(expiration);
    
        localStorage.setItem('token', token);
        localStorage.setItem('expiration', expiration.toISOString());
    
        // Redireciona para a tela de confirmação de e-mail
    

    navigate('/dashboard'); // Aqui você redireciona para confirmação } else { setMessage('E-mail ou senha inválidos.'); console.error('E-mail ou senha inválidos.'); } }) .catch(error => { setIsLoading(false); // Encerra o loading em caso de erro const errorMessage = "Erro ao fazer login: " + error.message; setMessage(errorMessage); console.error('Erro ao fazer login:', error); }); };

    const handleRegisterRedirect = () => { navigate('/cadastro'); // Redireciona para a página de cadastro };

    return (

    logo Hermes

    <div className={LoginStyles.buttonContainer}>
        <img src="/button prosseguir.png" alt="" className={LoginStyles.buttonImage} />
    </div>
    
    <div className={LoginStyles.container}>
        <label className={LoginStyles.label}>
            <label className={LoginStyles.labelInput}>E-mail:</label>
            <input 
                className={LoginStyles.input_estilo} 
                type="email"
                value={email}
                onChange={(e) => setEmail(e.target.value)}
                placeholder="Digite seu e-mail..." 
            />
        </label>
        
        <label className={LoginStyles.label}>
            <label className={LoginStyles.labelInput}>Senha:</label>
            <input 
                className={LoginStyles.input_estilo} 
                type="password"
                value={senha}
                onChange={(e) => setSenha(e.target.value)}
                placeholder="Digite sua senha..." 
            />
        </label>
        <div className={LoginStyles.forgotPassword}>
            <label className={LoginStyles.fontSize18}><u>esqueci minha senha</u></label>
        </div>
    </div>
    
    <div className={LoginStyles.textCenter}>
        <button className={LoginStyles.button} onClick={handleLogin} disabled={isLoading}>
            {isLoading ? 'Entrando...' : 'Entrar'}
        </button>
    </div>
    
    {isLoading && <p>Carregando... Por favor, aguarde...</p>} {/* Mensagem de Loading */}
    
    {message && (
        <div id="error-message" style={{ color: "red" }}>
            <p>{message}</p>
        </div>
    )}
    
    
    <div className={LoginStyles.textCenter}>
        <label className={LoginStyles.fontSize24} onClick={handleRegisterRedirect}>
            <u>Cadastrar</u>
        </label>
    </div>
    

    export default Login;

    estrutura de pastas:

    my-project/ ├── public/ │ ├── index.html │ ├── logo_hermes.png │ ├── button prosseguir.png │ └── ... ├── src/ │ ├── assets/ │ │ └── images/ │ │ ├── logo_hermes.png │ │ ├── button prosseguir.png │ │ └── ... │ ├── components/ │ │ ├── Auth/ │ │ │ ├── Login.tsx │ │ │ ├── Login.module.css │ │ │ └── UserContext.tsx │ │ └── ... │ ├── pages/ │ │ ├── Dashboard.tsx │ │ ├── Cadastro.tsx │ │ └── ... │ ├── App.tsx │ ├── index.tsx │ ├── routes.tsx │ └── ... ├── .gitignore ├── package.json ├── tsconfig.json └── README.md

  8. Assistant

    Para implementar uma solução que permita redirecionar o usuário para a página em que ele estava antes de recarregar a página e, ao mesmo tempo, evitar o redirecionamento para a página de login se ele já estiver autenticado, você pode seguir as instruções abaixo. Aqui estão as implementações completas dos componentes necessários, incluindo todas as alterações.

    1. AppRoutes.tsx

    No arquivo AppRoutes.tsx, você irá definir a lógica para redirecionar as rotas protegidas e permitir que a página de login seja acessível apenas se o usuário não estiver logado.

    // src/AppRoutes.tsx
    import React, { useContext } from 'react';
    import { Route, Routes, Navigate, useLocation } 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 { PacienteProvider } from './components/Pacientes/PacienteContext';
    import { LocalProvider } from './components/Local/LocalContext';
    
    const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => {
        const context = useContext(UserContext);
        const location = useLocation(); // Para obter a URL atual
    
        if (!context) {
            throw new Error("UserContext must be used within a UserProvider");
        }
    
        const { usuario } = context;
    
        if (!usuario) {
            // Se não está autenticado, armazena a URL atual
            sessionStorage.setItem('redirectPath', location.pathname);
            return <Navigate to="/login" />;
        }
    
        return children; // Retorna a rota protegida se o usuário estiver autenticado
    };
    
    const PublicRoute: React.FC<{ children: JSX.Element }> = ({ children }) => {
        const context = useContext(UserContext);
        const { usuario } = context ?? {};
    
        if (usuario) {
            // Se o usuário estiver logado, redireciona para o Dashboard
            return <Navigate to="/dashboard" />;
        }
    
        return children; // Deixa acessar a página de login se não estiver logado
    };
    
    const AppRoutes: React.FC = () => {
        return (
            <PacienteProvider>
                <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>
            </PacienteProvider>
        );
    };
    
    export default AppRoutes;
    

    2. UserContext.tsx

    O UserContext não requer alterações para este caso, mas aqui está a implementação completa para referência:

    // src/components/Auth/UserContext.tsx
    import React, { createContext, useState, ReactNode, useEffect } from 'react';
    
    interface UserInfo {
        id: string;
        name: string;
        email: string;
    }
    
    interface UserContextType {
        usuario: UserInfo | null;
        setUsuario: (userInfo: UserInfo | null) => void;
        token: string | null;
        setToken: (token: string | null) => void;
        expiration: Date | null;
        setExpiration: (date: Date | null) => void;
    }
    
    export const UserContext = createContext<UserContextType | undefined>(undefined);
    
    interface UserProviderProps {
        children: ReactNode;
    }
    
    export const UserProvider: React.FC<UserProviderProps> = ({ children }) => {
        const [usuario, setUsuario] = useState<UserInfo | null>(null);
        const [token, setToken] = useState<string | null>(localStorage.getItem('token'));
        const [expiration, setExpiration] = useState<Date | null>(
            localStorage.getItem('expiration') ? new Date(localStorage.getItem('expiration') as string) : null
        );
    
        useEffect(() => {
            const currentTime = new Date();
            if (expiration && currentTime > expiration) {
                setUsuario(null);
                setToken(null);
                setExpiration(null);
                localStorage.removeItem('token');
                localStorage.removeItem('expiration');
            }
        }, [expiration]);
    
        const value = { usuario, setUsuario, token, setToken, expiration, setExpiration };
    
        return <UserContext.Provider value={value}>{children}</UserContext.Provider>;
    };
    

    3. Login.tsx

    Aqui está a implementação do componente de login. Ele redireciona o usuário de volta à URL que ele estava tentando acessar.

    // src/components/Auth/Login.tsx
    import React, { useState, useContext } from 'react';
    import LoginStyles from "./Login.module.css";
    import { useNavigate } from 'react-router-dom';
    import { UserContext } from './UserContext';
    
    const Login: React.FC = () => {
        const [email, setEmail] = useState('');
        const [senha, setSenha] = useState('');
        const [message, setMessage] = useState('');
        const [isLoading, setIsLoading] = useState(false);
        const navigate = useNavigate();
        const context = useContext(UserContext);
    
        if (!context) {
            throw new Error("UserContext must be used within a UserProvider");
        }
    
        const { setUsuario, setToken, setExpiration } = context;
    
        const handleLogin = () => {
            setIsLoading(true);
            const loginData = {
                login: email,
                password: senha,
            };
    
            fetch('https://hermes-api-homolog-bae7z73pga-uk.a.run.app/public/auth/credentials/login', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify(loginData),
            })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Erro na requisição');
                }
                return response.json();
            })
            .then(data => {
                setIsLoading(false);
                if (data.success) {
                    const userInfo = data.result.userInfo;
                    const token = data.result.token;
                    const expiration = new Date(data.result.expiration);
    
                    setUsuario(userInfo);
                    setToken(token);
                    setExpiration(expiration);
    
                    localStorage.setItem('token', token);
                    localStorage.setItem('expiration', expiration.toISOString());
    
                    // Usar a URL armazenada ou redirecionar para o dashboard
                    const redirectPath = sessionStorage.getItem('redirectPath') || '/dashboard';
                    sessionStorage.removeItem('redirectPath');
    
                    navigate(redirectPath);
                } else {
                    setMessage('E-mail ou senha inválidos.');
                }
            })
            .catch(error => {
                setIsLoading(false);
                const errorMessage = "Erro ao fazer login: " + error.message;
                setMessage(errorMessage);
            });
        };
    
        const handleRegisterRedirect = () => {
            navigate('/cadastro');
        };
    
        return (
            <div className={LoginStyles.loginContainer}>
                <div className={LoginStyles.logoContainer}>
                    <img src="/logo_hermes.png" alt="logo Hermes" className={LoginStyles.logoImage} />
                </div>
    
                <div className={LoginStyles.buttonContainer}>
                    <img src="/button prosseguir.png" alt="" className={LoginStyles.buttonImage} />
                </div>
    
                <div className={LoginStyles.container}>
                    <label className={LoginStyles.label}>
                        <label className={LoginStyles.labelInput}>E-mail:</label>
                        <input 
                            className={LoginStyles.input_estilo} 
                            type="email"
                            value={email}
                            onChange={(e) => setEmail(e.target.value)}
                            placeholder="Digite seu e-mail..." 
                        />
                    </label>
    
                    <label className={LoginStyles.label}>
                        <label className={LoginStyles.labelInput}>Senha:</label>
                        <input 
                            className={LoginStyles.input_estilo} 
                            type="password"
                            value={senha}
                            onChange={(e) => setSenha(e.target.value)}
                            placeholder="Digite sua senha..." 
                        />
                    </label>
                    <div className={LoginStyles.forgotPassword}>
                        <label className={LoginStyles.fontSize18}><u>esqueci minha senha</u></label>
                    </div>
                </div>
    
                <div className={LoginStyles.textCenter}>
                    <button className={LoginStyles.button} onClick={handleLogin} disabled={isLoading}>
                        {isLoading ? 'Entrando...' : 'Entrar'}
                    </button>
                </div>
    
                {isLoading && <p>Carregando... Por favor, aguarde...</p>}
    
                {message && (
                    <div id="error-message" style={{ color: "red" }}>
                        <p>{message}</p>
                    </div>
                )}
    
                <div className={LoginStyles.textCenter}>
                    <label className={LoginStyles.fontSize24} onClick={handleRegisterRedirect}>
                        <u>Cadastrar</u>
                    </label>
                </div>
            </div>
        );
    };
    
    export default Login;
    

    Estrutura de Pastas

    Aqui está um exemplo da estrutura de pastas correta para o seu projeto:

    my-project/
    ├── public/
    │   ├── index.html
    │   ├── logo_hermes.png
    │   ├── button prosseguir.png
    │   └── ...
    ├── src/
    │   ├── assets/
    │   │   └── images/
    │   │       ├── logo_hermes.png
    │   │       ├── button prosseguir.png
    │   │       └── ...
    │   ├── components/
    │   │   ├── Auth/
    │   │   │   ├── Login.tsx
    │   │   │   ├── Login.module.css
    │   │   │   └── UserContext.tsx
    │   │   ├── Dashboard/
    │   │   │   └── Dashboard.tsx
    │   │   ├── Home/
    │   │   │   └── Home.tsx
    │   │   ├── Local/
    │   │   │   ├── Local.tsx
    │   │   │   └── NovoLocal.tsx
    │   │   ├── Pacientes/
    │   │   │   ├── Pacientes.tsx
    │   │   │   └── NovoPaciente.tsx
    │   │   ├── Atendimentos/
    │   │   │   ├── Atendimentos.tsx
    │   │   │   └── NovoAtendimento.tsx
    │   │   ├── Resumos/
    │   │   │   └── Resumos.tsx
    │   │   ├── Analitico/
    │   │   │   └── Analitico.tsx
    │   │   └── LayoutPrincipal/
    │   │       └── LayoutPrincipal.tsx
    │   ├── App.tsx
    │   ├── index.tsx
    │   ├── routes.tsx
    │   └── ...
    ├── .gitignore
    ├── package.json
    ├── tsconfig.json
    └── README.md
    

    Resumo

    • Routes Privadas: Com o PrivateRoute, você protege as rotas e redireciona para o login se o usuário não estiver logado, armazenando a URL atual no sessionStorage.
    • Routes Públicas: Com o PublicRoute, você impede o acesso à página de login se o usuário já estiver autenticado, redirecionando-o para o dashboard.

    Essas alterações garantirão que seu sistema de autenticação funcione corretamente e que os usuários sejam redirecionados para a página atual após um login bem-sucedido ou voltem ao dashboard se estiverem logados e tentarem acessar a página de login.

  9. User

    estou criando uma aplicacao com login, porem quando estou dentro das rotas protegidas pelo token de autenticacao, e faço o recarregamento da pagina ele direciona para o /login, como redirecionar para a pagina atual que ele recarregou? me mostre as solucoes completas dos componentes inteiros e arquivos inteiros por favor. Por favor, caso o usuario nao esteja logado,nao permita o acesso a rota /login somente se ele estiver deslogado.

    // src/AppRoutes.tsx import React, { useContext } from 'react'; import { Route, Routes, Navigate, useLocation } 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 { PacienteProvider } from './components/Pacientes/PacienteContext'; import { LocalProvider } from './components/Local/LocalContext';

    const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => { const context = useContext(UserContext); const location = useLocation(); // Para obter a URL atual

    if (!context) {
        throw new Error("UserContext must be used within a UserProvider");
    }
    
    const { usuario } = context;
    
    if (!usuario) {
        // Armazena a URL no session storage
        sessionStorage.setItem('redirectPath', location.pathname);
        return <Navigate to="/login" />;
    }
    
    return children;
    

    };

    const AppRoutes: React.FC = () => { 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; login:

    // src/components/Auth/Login.tsx

    // src/components/Auth/Login.tsx import React, { useState, useContext } from 'react'; import LoginStyles from "./Login.module.css"; import { useNavigate } from 'react-router-dom'; import { UserContext } from './UserContext';

    const Login: React.FC = () => { const [email, setEmail] = useState(''); const [senha, setSenha] = useState(''); const [message, setMessage] = useState(''); const [isLoading, setIsLoading] = useState(false); const navigate = useNavigate(); const context = useContext(UserContext);

    if (!context) {
        throw new Error("UserContext must be used within a UserProvider");
    }
    
    const { setUsuario, setToken, setExpiration } = context;
    
    const handleLogin = () => {
        setIsLoading(true);
        const loginData = {
            login: email,
            password: senha,
        };
    
        fetch('https://hermes-api-homolog-bae7z73pga-uk.a.run.app/public/auth/credentials/login', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify(loginData),
        })
        .then(response => {
            if (!response.ok) {
                throw new Error('Erro na requisição');
            }
            return response.json();
        })
        .then(data => {
            setIsLoading(false);
            if (data.success) {
                const userInfo = data.result.userInfo;
                const token = data.result.token;
                const expiration = new Date(data.result.expiration);
    
                setUsuario(userInfo);
                setToken(token);
                setExpiration(expiration);
    
                localStorage.setItem('token', token);
                localStorage.setItem('expiration', expiration.toISOString());
    
                // Verifica a URL armazenada e redireciona
                const redirectPath = sessionStorage.getItem('redirectPath') || '/dashboard';
                sessionStorage.removeItem('redirectPath'); // Limpa a URL
    
                navigate(redirectPath);
            } else {
                setMessage('E-mail ou senha inválidos.');
            }
        })
        .catch(error => {
            setIsLoading(false);
            setMessage("Erro ao fazer login: " + error.message);
        });
    };
    
    const handleRegisterRedirect = () => {
        navigate('/cadastro');
    };
    
    return (
        <div className={LoginStyles.loginContainer}>
            <div className={LoginStyles.logoContainer}>
                <img src="/logo_hermes.png" alt="logo Hermes" className={LoginStyles.logoImage} />
            </div>
    
            <div className={LoginStyles.buttonContainer}>
                <img src="/button prosseguir.png" alt="" className={LoginStyles.buttonImage} />
            </div>
    
            <div className={LoginStyles.container}>
                <label className={LoginStyles.label}>
                    <label className={LoginStyles.labelInput}>E-mail:</label>
                    <input 
                        className={LoginStyles.input_estilo} 
                        type="email"
                        value={email}
                        onChange={(e) => setEmail(e.target.value)}
                        placeholder="Digite seu e-mail..." 
                    />
                </label>
                
                <label className={LoginStyles.label}>
                    <label className={LoginStyles.labelInput}>Senha:</label>
                    <input 
                        className={LoginStyles.input_estilo} 
                        type="password"
                        value={senha}
                        onChange={(e) => setSenha(e.target.value)}
                        placeholder="Digite sua senha..." 
                    />
                </label>
                <div className={LoginStyles.forgotPassword}>
                    <label className={LoginStyles.fontSize18}><u>esqueci minha senha</u></label>
                </div>
            </div>
    
            <div className={LoginStyles.textCenter}>
                <button className={LoginStyles.button} onClick={handleLogin} disabled={isLoading}>
                    {isLoading ? 'Entrando...' : 'Entrar'}
                </button>
            </div>
    
            {isLoading && <p>Carregando... Por favor, aguarde...</p>} 
    
            {message && (
                <div id="error-message" style={{ color: "red" }}>
                    <p>{message}</p>
                </div>
            )}
    
            <div className={LoginStyles.textCenter}>
                <label className={LoginStyles.fontSize24} onClick={handleRegisterRedirect}>
                    <u>Cadastrar</u>
                </label>
            </div>
        </div>
    );
    

    };

    export default Login;

    userContext:

    // src/components/Auth/UserContext.tsx import React, { createContext, useState, ReactNode, useEffect } from 'react';

    interface UserInfo { id: string; name: string; email: string; }

    interface UserContextType { usuario: UserInfo | null; setUsuario: (userInfo: UserInfo | null) => void; token: string | null; setToken: (token: string | null) => void; expiration: Date | null; setExpiration: (date: Date | null) => void; }

    export const UserContext = createContext<UserContextType | undefined>(undefined);

    interface UserProviderProps { children: ReactNode; }

    export const UserProvider: React.FC = ({ children }) => { const [usuario, setUsuario] = useState<UserInfo | null>(null); const [token, setToken] = useState<string | null>(localStorage.getItem('token')); const [expiration, setExpiration] = useState<Date | null>( localStorage.getItem('expiration') ? new Date(localStorage.getItem('expiration') as string) : null );

    useEffect(() => {
        const currentTime = new Date();
        if (expiration && currentTime > expiration) {
            setUsuario(null);
            setToken(null);
            setExpiration(null);
            localStorage.removeItem('token');
            localStorage.removeItem('expiration');
        }
    }, [expiration]);
    
    const value = { usuario, setUsuario, token, setToken, expiration, setExpiration };
    
    return <UserContext.Provider value={value}>{children}</UserContext.Provider>;
    

    };

    estrutura de pastas:

    my-project/ ├── public/ │ ├── index.html │ ├── logo_hermes.png │ ├── button prosseguir.png │ └── ... ├── src/ │ ├── assets/ │ │ └── images/ │ │ ├── logo_hermes.png │ │ ├── button prosseguir.png │ │ └── ... │ ├── components/ │ │ ├── Auth/ │ │ │ ├── Login.tsx │ │ │ ├── Login.module.css │ │ │ └── UserContext.tsx │ │ └── ... │ ├── pages/ │ │ ├── Dashboard.tsx │ │ ├── Cadastro.tsx │ │ └── ... │ ├── App.tsx │ ├── index.tsx │ ├── routes.tsx │ └── ... ├── .gitignore ├── package.json ├── tsconfig.json └── README.md

  10. Assistant

    Para lidar com o problema de redirecionamento do usuário para a página de login quando ele recarrega uma página protegida, ao mesmo tempo que evita que usuários logados acessem a página de login, você pode implementar um controle mais robusto nas rotas. Abaixo estão implementações completas dos componentes AppRoutes, Login, e UserContext conforme solicitado.

    1. AppRoutes.tsx

    No arquivo AppRoutes, você deve ter a lógica para proteger as rotas privadas, armazenar a URL atual em caso de redirecionamento, e implementar o bloqueio da rota de login para usuários já autenticados.

    // src/AppRoutes.tsx
    import React, { useContext } from 'react';
    import { Route, Routes, Navigate, useLocation } 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 { PacienteProvider } from './components/Pacientes/PacienteContext';
    import { LocalProvider } from './components/Local/LocalContext';
    
    const PrivateRoute: React.FC<{ children: JSX.Element }> = ({ children }) => {
        const context = useContext(UserContext);
        const location = useLocation(); // Para obter a URL atual
    
        if (!context) {
            throw new Error("UserContext must be used within a UserProvider");
        }
    
        const { usuario } = context;
    
        if (!usuario) {
            // Armazena a URL no session storage
            sessionStorage.setItem('redirectPath', location.pathname);
            return <Navigate to="/login" />;
        }
    
        return children; // Retorna a rota protegida
    };
    
    const PublicRoute: React.FC<{ children: JSX.Element }> = ({ children }) => {
        const context = useContext(UserContext);
        const { usuario } = context ?? {};
    
        if (usuario) {
            // Se o usuário estiver logado, redireciona para o Dashboard
            return <Navigate to="/dashboard" />;
        }
    
        return children; // Permite acesso a usuários não autenticados
    };
    
    const AppRoutes: React.FC = () => {
        return (
            <PacienteProvider>
                <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>
            </PacienteProvider>
        );
    };
    
    export default AppRoutes;
    

    Alterações Realizadas:

    • PrivateRoute: Armazena a URL antes de redirecionar para /login, se o usuário não estiver autenticado.
    • PublicRoute: Impede que usuários autenticados acessem a rota de login.

    2. Login.tsx

    O componente de login deve ser capaz de lidar com o redirecionamento após o login com base na URL armazenada.

    // src/components/Auth/Login.tsx
    import React, { useState, useContext } from 'react';
    import LoginStyles from "./Login.module.css";
    import { useNavigate } from 'react-router-dom';
    import { UserContext } from './UserContext';
    
    const Login: React.FC = () => {
        const [email, setEmail] = useState('');
        const [senha, setSenha] = useState('');
        const [message, setMessage] = useState('');
        const [isLoading, setIsLoading] = useState(false);
        const navigate = useNavigate();
        const context = useContext(UserContext);
    
        if (!context) {
            throw new Error("UserContext must be used within a UserProvider");
        }
    
        const { setUsuario, setToken, setExpiration } = context;
    
        const handleLogin = () => {
            setIsLoading(true);
            const loginData = {
                login: email,
                password: senha,
            };
    
            fetch('https://hermes-api-homolog-bae7z73pga-uk.a.run.app/public/auth/credentials/login', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify(loginData),
            })
            .then(response => {
                if (!response.ok) {
                    throw new Error('Erro na requisição');
                }
                return response.json();
            })
            .then(data => {
                setIsLoading(false);
                if (data.success) {
                    const userInfo = data.result.userInfo;
                    const token = data.result.token;
                    const expiration = new Date(data.result.expiration);
    
                    setUsuario(userInfo);
                    setToken(token);
                    setExpiration(expiration);
    
                    localStorage.setItem('token', token);
                    localStorage.setItem('expiration', expiration.toISOString());
    
                    // Redireciona para a URL armazenada ou para o dashboard
                    const redirectPath = sessionStorage.getItem('redirectPath') || '/dashboard';
                    sessionStorage.removeItem('redirectPath'); // Limpa a URL
    
                    navigate(redirectPath);
                } else {
                    setMessage('E-mail ou senha inválidos.');
                }
            })
            .catch(error => {
                setIsLoading(false);
                setMessage("Erro ao fazer login: " + error.message);
            });
        };
    
        const handleRegisterRedirect = () => {
            navigate('/cadastro');
        };
    
        return (
            <div className={LoginStyles.loginContainer}>
                <div className={LoginStyles.logoContainer}>
                    <img src="/logo_hermes.png" alt="logo Hermes" className={LoginStyles.logoImage} />
                </div>
    
                <div className={LoginStyles.buttonContainer}>
                    <img src="/button prosseguir.png" alt="" className={LoginStyles.buttonImage} />
                </div>
    
                <div className={LoginStyles.container}>
                    <label className={LoginStyles.label}>
                        <label className={LoginStyles.labelInput}>E-mail:</label>
                        <input 
                            className={LoginStyles.input_estilo} 
                            type="email"
                            value={email}
                            onChange={(e) => setEmail(e.target.value)}
                            placeholder="Digite seu e-mail..." 
                        />
                    </label>
    
                    <label className={LoginStyles.label}>
                        <label className={LoginStyles.labelInput}>Senha:</label>
                        <input 
                            className={LoginStyles.input_estilo} 
                            type="password"
                            value={senha}
                            onChange={(e) => setSenha(e.target.value)}
                            placeholder="Digite sua senha..." 
                        />
                    </label>
                    <div className={LoginStyles.forgotPassword}>
                        <label className={LoginStyles.fontSize18}><u>esqueci minha senha</u></label>
                    </div>
                </div>
    
                <div className={LoginStyles.textCenter}>
                    <button className={LoginStyles.button} onClick={handleLogin} disabled={isLoading}>
                        {isLoading ? 'Entrando...' : 'Entrar'}
                    </button>
                </div>
    
                {isLoading && <p>Carregando... Por favor, aguarde...</p>}
    
                {message && (
                    <div id="error-message" style={{ color: "red" }}>
                        <p>{message}</p>
                    </div>
                )}
    
                <div className={LoginStyles.textCenter}>
                    <label className={LoginStyles.fontSize24} onClick={handleRegisterRedirect}>
                        <u>Cadastrar</u>
                    </label>
                </div>
            </div>
        );
    };
    
    export default Login;
    

    3. UserContext.tsx

    No arquivo UserContext, deve-se garantir que o estado do usuário e a expiração do token sejam tratados corretamente. Aqui está a implementação completa:

    // src/components/Auth/UserContext.tsx
    import React, { createContext, useState, ReactNode, useEffect } from 'react';
    
    interface UserInfo {
        id: string;
        name: string;
        email: string;
    }
    
    interface UserContextType {
        usuario: UserInfo | null;
        setUsuario: (userInfo: UserInfo | null) => void;
        token: string | null;
        setToken: (token: string | null) => void;
        expiration: Date | null;
        setExpiration: (date: Date | null) => void;
    }
    
    export const UserContext = createContext<UserContextType | undefined>(undefined);
    
    interface UserProviderProps {
        children: ReactNode;
    }
    
    export const UserProvider: React.FC<UserProviderProps> = ({ children }) => {
        const [usuario, setUsuario] = useState<UserInfo | null>(null);
        const [token, setToken] = useState<string | null>(localStorage.getItem('token'));
        const [expiration, setExpiration] = useState<Date | null>(
            localStorage.getItem('expiration') ? new Date(localStorage.getItem('expiration') as string) : null
        );
    
        useEffect(() => {
            const currentTime = new Date();
            if (expiration && currentTime > expiration) {
                setUsuario(null);
                setToken(null);
                setExpiration(null);
                localStorage.removeItem('token');
                localStorage.removeItem('expiration');
            }
        }, [expiration]);
    
        const value = { usuario, setUsuario, token, setToken, expiration, setExpiration };
    
        return <UserContext.Provider value={value}>{children}</UserContext.Provider>;
    };
    

    Estrutura de Pastas

    Para que todas essas implementações funcionem, a estrutura de pastas deverá seguir um padrão consistente, como:

    my-project/
    ├── public/
    │   ├── index.html
    │   ├── logo_hermes.png
    │   ├── button prosseguir.png
    │   └── ...
    ├── src/
    │   ├── assets/
    │   │   └── images/
    │   │       ├── logo_hermes.png
    │   │       ├── button prosseguir.png
    │   │       └── ...
    │   ├── components/
    │   │   ├── Auth/
    │   │   │   ├── Login.tsx
    │   │   │   ├── Login.module.css
    │   │   │   └── UserContext.tsx
    │   │   ├── Dashboard/
    │   │   │   └── Dashboard.tsx
    │   │   ├── Home/
    │   │   │   └── Home.tsx
    │   │   ├── Local/
    │   │   │   ├── Local.tsx
    │   │   │   └── NovoLocal.tsx
    │   │   ├── Pacientes/
    │   │   │   ├── Pacientes.tsx
    │   │   │   └── NovoPaciente.tsx
    │   │   ├── Atendimentos/
    │   │   │   ├── Atendimentos.tsx
    │   │   │   └── NovoAtendimento.tsx
    │   │   ├── Resumos/
    │   │   │   └── Resumos.tsx
    │   │   ├── Analitico/
    │   │   │   └── Analitico.tsx
    │   │   └── LayoutPrincipal/
    │   │       └── LayoutPrincipal.tsx
    │   ├── App.tsx
    │   ├── index.tsx
    │   ├── routes.tsx
    │   └── ...
    ├── .gitignore
    ├── package.json
    ├── tsconfig.json
    └── README.md
    

    Resumo das Alterações

    1. Customização das Rotas: O PublicRoute agora permite acesso à página de login apenas para usuários não autenticados e redireciona usuários autenticados para o dashboard.
    2. Armazenamento da URL: A URL atual é armazenada para que o usuário seja redirecionado de volta após o login.

    Essas alterações garantem uma navegação fluida e segura para o seu aplicativo, permitindo que usuários voltem às páginas em que estavam antes de serem redirecionados para a tela de login, enquanto evitam acesso não autorizado à página de login.