Como implementar rotas autenticadas no React Router 4?


122

Eu estava tentando implementar rotas autenticadas, mas descobri que o React Router 4 agora impede que isso funcione:

<Route exact path="/" component={Index} />
<Route path="/auth" component={UnauthenticatedWrapper}>
    <Route path="/auth/login" component={LoginBotBot} />
</Route>
<Route path="/domains" component={AuthenticatedWrapper}>
    <Route exact path="/domains" component={DomainsIndex} />
</Route>

O erro é:

Atenção: Você não deve usar <Route component>e <Route children>na mesma rota; <Route children>será ignorado

Nesse caso, qual é a maneira correta de implementar isso?

Ele aparece nos react-routerdocumentos (v4) e sugere algo como

<Router>
    <div>
    <AuthButton/>
    <ul>
        <li><Link to="/public">Public Page</Link></li>
        <li><Link to="/protected">Protected Page</Link></li>
    </ul>
    <Route path="/public" component={Public}/>
    <Route path="/login" component={Login}/>
    <PrivateRoute path="/protected" component={Protected}/>
    </div>
</Router>

Mas é possível fazer isso agrupando várias rotas?


ATUALIZAR

Ok, depois de alguma pesquisa, descobri o seguinte:

import React, {PropTypes} from "react"
import {Route} from "react-router-dom"

export default class AuthenticatedRoute extends React.Component {
  render() {
    if (!this.props.isLoggedIn) {
      this.props.redirectToLogin()
      return null
    }
    return <Route {...this.props} />
  }
}

AuthenticatedRoute.propTypes = {
  isLoggedIn: PropTypes.bool.isRequired,
  component: PropTypes.element,
  redirectToLogin: PropTypes.func.isRequired
}

É correto despachar uma ação, render()pois parece errado. Realmente não parece correto com componentDidMountou algum outro gancho?


melhor fazer em componetWillMount se não estiver usando a renderização do lado do servidor.
mfahadi,

@mfahadi, obrigado pela contribuição. Ainda não estou usando o SSR, mas se quiser usar no futuro, devo mantê-lo na renderização? Além disso, se o usuário for redirecionado componentWillMount, ele conseguirá ver a saída renderizada mesmo por uma fração de segundo?
Jiew Meng,

Lamento muito dizer que componentWillMount()não é chamado no SSR, é componentDidMount()que não é chamado. como componentWillMount()é chamado antes render(), então o usuário não verá nada do novo componente. portanto, é o melhor lugar para verificar.
mfahadi,

1
você poderia apenas usar a <Redirect to="/auth"> partir dos documentos em vez de chamar a ação de despacho
Fuzail l'Corder

Respostas:


238

Você vai querer usar o Redirectcomponente. Existem algumas abordagens diferentes para esse problema. Aqui está um que eu gosto, tem um componente PrivateRoute que leva em umauthed adereço e então renderiza com base adereços.

function PrivateRoute ({component: Component, authed, ...rest}) {
  return (
    <Route
      {...rest}
      render={(props) => authed === true
        ? <Component {...props} />
        : <Redirect to={{pathname: '/login', state: {from: props.location}}} />}
    />
  )
}

Agora seus Routes podem ser parecidos com este

<Route path='/' exact component={Home} />
<Route path='/login' component={Login} />
<Route path='/register' component={Register} />
<PrivateRoute authed={this.state.authed} path='/dashboard' component={Dashboard} />

Se você ainda está confuso, escrevi este post que pode ajudar - Rotas protegidas e autenticação com React Router v4


2
Ah, isso é parecido com a minha solução, mas usa <Redirect />. O problema é <Redirect />que não parece funcionar com redux no meu caso? Preciso despachar uma ação
Jiew Meng,

3
Não sei por que, mas adicionar state: {from: props.location}}}causou a maximum call stack exceeded. Eu tive que removê-lo. Você poderia explicar por que essa opção é útil @Tyler McGinnis?
martpie de

@KeitIG ​​Isso é estranho. É útil porque mostra de onde você veio. Um exemplo seria se você quisesse que o usuário se autenticasse e, depois de autenticado, leve-o de volta à página que estava tentando acessar antes de redirecioná-lo.
Tyler McGinnis

6
@faraz Isso explica a ({component: Component, ...rest})sintaxe. Eu tinha a mesma pergunta lol! stackoverflow.com/a/43484565/6502003
protoEvangelion

2
@TylerMcGinnis E se precisarmos usar a função render para passar adereços para o componente?
C Bauer

16

Tnx Tyler McGinnis para solução. Eu faço minha ideia a partir da ideia de Tyler McGinnis.

const DecisionRoute = ({ trueComponent, falseComponent, decisionFunc, ...rest }) => {
  return (
    <Route
      {...rest}

      render={
        decisionFunc()
          ? trueComponent
          : falseComponent
      }
    />
  )
}

Você pode implementar isso assim

<DecisionRoute path="/signin" exact={true}
            trueComponent={redirectStart}
            falseComponent={SignInPage}
            decisionFunc={isAuth}
          />

decisãoFunc apenas uma função que retorna verdadeiro ou falso

const redirectStart = props => <Redirect to="/orders" />

8

(Usando Redux para gerenciamento de estado)

Se o usuário tentar acessar qualquer url, primeiro vou verificar se o token de acesso está disponível, se não redirecionar para a página de login. Assim que o usuário fizer login usando a página de login, armazenamos isso no armazenamento local e também em nosso estado de redux. (armazenamento local ou cookies ... mantemos este tópico fora do contexto por enquanto).
uma vez que redux estado como atualizado e privateroutes serão renderizados novamente. agora temos token de acesso, então vamos redirecionar para a página inicial.

Armazene os dados de carga útil de autorização decodificados também em estado redux e passe-os para o contexto de reação. (Não temos que usar contexto, mas para acessar a autorização em qualquer um de nossos componentes filhos aninhados, torna-se fácil acessar a partir do contexto, em vez de conectar cada um dos componentes filhos ao redux).

Todas as rotas que não precisam de funções especiais podem ser acessadas diretamente após o login. Se precisar de uma função como admin (fizemos uma rota protegida que verifica se ele tinha a função desejada, se não redireciona para o componente não autorizado)

da mesma forma em qualquer um dos seus componentes se você tiver que desabilitar o botão ou algo baseado na função.

simplesmente você pode fazer desta maneira

const authorization = useContext(AuthContext);
const [hasAdminRole] = checkAuth({authorization, roleType:"admin"});
const [hasLeadRole] = checkAuth({authorization, roleType:"lead"});
<Button disable={!hasAdminRole} />Admin can access</Button>
<Button disable={!hasLeadRole || !hasAdminRole} />admin or lead can access</Button>

E daí se o usuário tentar inserir um token fictício no armazenamento local. Como temos token de acesso, redirecionaremos para o componente inicial. Meu componente inicial fará uma chamada de descanso para obter dados, já que o token jwt era fictício, a chamada de descanso retornará o usuário não autorizado. Então, eu chamo o logout (que limpará localstorage e redirecionará para a página de login novamente). Se a página inicial tiver dados estáticos e não fizer nenhuma chamada de api (então você deve ter uma chamada de api de verificação de token no back-end para que possa verificar se o token é REAL antes de carregar a página inicial)

index.js

import React from 'react';
import ReactDOM from 'react-dom';
import { Router, Route, Switch } from 'react-router-dom';
import history from './utils/history';


import Store from './statemanagement/store/configureStore';
import Privateroutes from './Privateroutes';
import Logout from './components/auth/Logout';

ReactDOM.render(
  <Store>
    <Router history={history}>
      <Switch>
        <Route path="/logout" exact component={Logout} />
        <Route path="/" exact component={Privateroutes} />
        <Route path="/:someParam" component={Privateroutes} />
      </Switch>
    </Router>
  </Store>,
  document.querySelector('#root')
);

History.js

import { createBrowserHistory as history } from 'history';

export default history({});

Privateroutes.js

import React, { Fragment, useContext } from 'react';
import { Route, Switch, Redirect } from 'react-router-dom';
import { connect } from 'react-redux';
import { AuthContext, checkAuth } from './checkAuth';
import App from './components/App';
import Home from './components/home';
import Admin from './components/admin';
import Login from './components/auth/Login';
import Unauthorized from './components/Unauthorized ';
import Notfound from './components/404';

const ProtectedRoute = ({ component: Component, roleType, ...rest })=> { 
const authorization = useContext(AuthContext);
const [hasRequiredRole] = checkAuth({authorization, roleType});
return (
<Route
  {...rest}
  render={props => hasRequiredRole ? 
  <Component {...props} /> :
   <Unauthorized {...props} />  } 
/>)}; 

const Privateroutes = props => {
  const { accessToken, authorization } = props.authData;
  if (accessToken) {
    return (
      <Fragment>
       <AuthContext.Provider value={authorization}>
        <App>
          <Switch>
            <Route exact path="/" component={Home} />
            <Route path="/login" render={() => <Redirect to="/" />} />
            <Route exact path="/home" component={Home} />
            <ProtectedRoute
            exact
            path="/admin"
            component={Admin}
            roleType="admin"
          />
            <Route path="/404" component={Notfound} />
            <Route path="*" render={() => <Redirect to="/404" />} />
          </Switch>
        </App>
        </AuthContext.Provider>
      </Fragment>
    );
  } else {
    return (
      <Fragment>
        <Route exact path="/login" component={Login} />
        <Route exact path="*" render={() => <Redirect to="/login" />} />
      </Fragment>
    );
  }
};

// my user reducer sample
// const accessToken = localStorage.getItem('token')
//   ? JSON.parse(localStorage.getItem('token')).accessToken
//   : false;

// const initialState = {
//   accessToken: accessToken ? accessToken : null,
//   authorization: accessToken
//     ? jwtDecode(JSON.parse(localStorage.getItem('token')).accessToken)
//         .authorization
//     : null
// };

// export default function(state = initialState, action) {
// switch (action.type) {
// case actionTypes.FETCH_LOGIN_SUCCESS:
//   let token = {
//                  accessToken: action.payload.token
//               };
//   localStorage.setItem('token', JSON.stringify(token))
//   return {
//     ...state,
//     accessToken: action.payload.token,
//     authorization: jwtDecode(action.payload.token).authorization
//   };
//    default:
//         return state;
//    }
//    }

const mapStateToProps = state => {
  const { authData } = state.user;
  return {
    authData: authData
  };
};

export default connect(mapStateToProps)(Privateroutes);

checkAuth.js

import React from 'react';

export const AuthContext = React.createContext();

export const checkAuth = ({ authorization, roleType }) => {
  let hasRequiredRole = false;

  if (authorization.roles ) {
    let roles = authorization.roles.map(item =>
      item.toLowerCase()
    );

    hasRequiredRole = roles.includes(roleType);
  }

  return [hasRequiredRole];
};

AMOSTRA DE TOKEN JWT DECODIFICADA

{
  "authorization": {
    "roles": [
      "admin",
      "operator"
    ]
  },
  "exp": 1591733170,
  "user_id": 1,
  "orig_iat": 1591646770,
  "email": "hemanthvrm@stackoverflow",
  "username": "hemanthvrm"
}

E como você lida com o acesso direto Signin? Se um usuário souber que não está conectado, ele deve ter a opção de acessar o Signin diretamente, certo?
carkod

@carkod ... Por padrão, se ele tentar acessar alguma rota, ele será redirecionado para a página de login ... (já que ele não terá token)
Hemanthvrm

@carkod .. uma vez que o usuário clica em logout ou então meu token de atualização jwt expira .. eu chamo a função de logout onde eu limpo localstorage e atualizo a janela ... portanto, localstorage não terá token .. ele irá redirecionar automaticamente para a página de login
Hemanthvrm

Eu tenho uma versão melhor para aqueles que usam o redux ... atualizarei minha resposta em alguns dias ... obrigado -
Hemanthvrm

3

instalar react-router-dom

em seguida, crie dois componentes, um para usuários válidos e outro para usuários inválidos.

tente isso no app.js

import React from 'react';

import {
BrowserRouter as Router,
Route,
Link,
Switch,
Redirect
} from 'react-router-dom';

import ValidUser from "./pages/validUser/validUser";
import InValidUser from "./pages/invalidUser/invalidUser";
const loggedin = false;

class App extends React.Component {
 render() {
    return ( 
      <Router>
      <div>
        <Route exact path="/" render={() =>(
          loggedin ? ( <Route  component={ValidUser} />)
          : (<Route component={InValidUser} />)
        )} />

        </div>
      </Router>
    )
  }
}
export default App;

4
Por rota? Isso não vai escalar.
Jim G.

3

Com base na resposta de @Tyler McGinnis . Fiz uma abordagem diferente usando a sintaxe ES6 e rotas aninhadas com componentes agrupados:

import React, { cloneElement, Children } from 'react'
import { Route, Redirect } from 'react-router-dom'

const PrivateRoute = ({ children, authed, ...rest }) =>
  <Route
    {...rest}
    render={(props) => authed ?
      <div>
        {Children.map(children, child => cloneElement(child, { ...child.props }))}
      </div>
      :
      <Redirect to={{ pathname: '/', state: { from: props.location } }} />}
  />

export default PrivateRoute

E usando:

<BrowserRouter>
  <div>
    <PrivateRoute path='/home' authed={auth}>
      <Navigation>
        <Route component={Home} path="/home" />
      </Navigation>
    </PrivateRoute>

    <Route exact path='/' component={PublicHomePage} />
  </div>
</BrowserRouter>

2

Eu sei que já faz um tempo, mas estou trabalhando em um pacote npm para rotas privadas e públicas.

Veja como fazer uma rota particular:

<PrivateRoute exact path="/private" authed={true} redirectTo="/login" component={Title} text="This is a private route"/>

E você também pode fazer rotas públicas que apenas usuários não autorizados podem acessar

<PublicRoute exact path="/public" authed={false} redirectTo="/admin" component={Title} text="This route is for unauthed users"/>

Espero que ajude!


você pode fornecer mais exemplos, incluindo todas as importações e envoltórios, por exemplo em 2 rotas públicas, 2 rotas privadas e 2 PropsRoute, no App.js principal? obrigado
MH

2

Eu implementei usando-

<Route path='/dashboard' render={() => (
    this.state.user.isLoggedIn ? 
    (<Dashboard authenticate={this.authenticate} user={this.state.user} />) : 
    (<Redirect to="/login" />)
)} />

autenticar props será passado para componentes, por exemplo, inscrição usando qual estado do usuário pode ser alterado. AppRoutes completos-

import React from 'react';
import { Switch, Route } from 'react-router-dom';
import { Redirect } from 'react-router';

import Home from '../pages/home';
import Login from '../pages/login';
import Signup from '../pages/signup';
import Dashboard from '../pages/dashboard';

import { config } from '../utils/Config';

export default class AppRoutes extends React.Component {

    constructor(props) {
        super(props);

        // initially assuming that user is logged out
        let user = {
            isLoggedIn: false
        }

        // if user is logged in, his details can be found from local storage
        try {
            let userJsonString = localStorage.getItem(config.localStorageKey);
            if (userJsonString) {
                user = JSON.parse(userJsonString);
            }
        } catch (exception) {
        }

        // updating the state
        this.state = {
            user: user
        };

        this.authenticate = this.authenticate.bind(this);
    }

    // this function is called on login/logout
    authenticate(user) {
        this.setState({
            user: user
        });

        // updating user's details
        localStorage.setItem(config.localStorageKey, JSON.stringify(user));
    }

    render() {
        return (
            <Switch>
                <Route exact path='/' component={Home} />
                <Route exact path='/login' render={() => <Login authenticate={this.authenticate} />} />
                <Route exact path='/signup' render={() => <Signup authenticate={this.authenticate} />} />
                <Route path='/dashboard' render={() => (
                    this.state.user.isLoggedIn ? 
                            (<Dashboard authenticate={this.authenticate} user={this.state.user} />) : 
                            (<Redirect to="/login" />)
                )} />
            </Switch>
        );
    }
} 

Confira o projeto completo aqui: https://github.com/varunon9/hello-react


1

Parece que sua hesitação está em criar seu próprio componente e, em seguida, despachá-lo no método de renderização? Bem, você pode evitar ambos usando apenas o rendermétodo do <Route>componente. Não há necessidade de criar um <AuthenticatedRoute>componente, a menos que você realmente queira. Pode ser tão simples quanto abaixo. Observe a {...routeProps}propagação, certificando-se de continuar a enviar as propriedades do <Route>componente para o componente filho ( <MyComponent>neste caso).

<Route path='/someprivatepath' render={routeProps => {

   if (!this.props.isLoggedIn) {
      this.props.redirectToLogin()
      return null
    }
    return <MyComponent {...routeProps} anotherProp={somevalue} />

} />

Consulte a documentação de renderização do React Router V4

Se você deseja criar um componente dedicado, parece que está no caminho certo. Como o React Router V4 é um roteamento puramente declarativo (isso está escrito na descrição), não acho que você se safará colocando seu código de redirecionamento fora do ciclo de vida normal do componente. Olhando para o código do próprio React Router , eles executam o redirecionamento em um componentWillMountou componentDidMountdependendo se é ou não renderização do lado do servidor. Aqui está o código abaixo, que é muito simples e pode ajudá-lo a se sentir mais confortável com onde colocar sua lógica de redirecionamento.

import React, { PropTypes } from 'react'

/**
 * The public API for updating the location programatically
 * with a component.
 */
class Redirect extends React.Component {
  static propTypes = {
    push: PropTypes.bool,
    from: PropTypes.string,
    to: PropTypes.oneOfType([
      PropTypes.string,
      PropTypes.object
    ])
  }

  static defaultProps = {
    push: false
  }

  static contextTypes = {
    router: PropTypes.shape({
      history: PropTypes.shape({
        push: PropTypes.func.isRequired,
        replace: PropTypes.func.isRequired
      }).isRequired,
      staticContext: PropTypes.object
    }).isRequired
  }

  isStatic() {
    return this.context.router && this.context.router.staticContext
  }

  componentWillMount() {
    if (this.isStatic())
      this.perform()
  }

  componentDidMount() {
    if (!this.isStatic())
      this.perform()
  }

  perform() {
    const { history } = this.context.router
    const { push, to } = this.props

    if (push) {
      history.push(to)
    } else {
      history.replace(to)
    }
  }

  render() {
    return null
  }
}

export default Redirect

1

Minha resposta anterior não é escalonável. Aqui está o que considero uma boa abordagem-

Suas Rotas-

<Switch>
  <Route
    exact path="/"
    component={matchStateToProps(InitialAppState, {
      routeOpen: true // no auth is needed to access this route
    })} />
  <Route
    exact path="/profile"
    component={matchStateToProps(Profile, {
      routeOpen: false // can set it false or just omit this key
    })} />
  <Route
    exact path="/login"
    component={matchStateToProps(Login, {
      routeOpen: true
    })} />
  <Route
    exact path="/forgot-password"
    component={matchStateToProps(ForgotPassword, {
      routeOpen: true
    })} />
  <Route
    exact path="/dashboard"
    component={matchStateToProps(DashBoard)} />
</Switch>

A ideia é usar um wrapper em componentadereços que retornaria o componente original se nenhuma autenticação for necessária ou já autenticado, caso contrário, retornaria o componente padrão, por exemplo, Login.

const matchStateToProps = function(Component, defaultProps) {
  return (props) => {
    let authRequired = true;

    if (defaultProps && defaultProps.routeOpen) {
      authRequired = false;
    }

    if (authRequired) {
      // check if loginState key exists in localStorage (Your auth logic goes here)
      if (window.localStorage.getItem(STORAGE_KEYS.LOGIN_STATE)) {
        return <Component { ...defaultProps } />; // authenticated, good to go
      } else {
        return <InitialAppState { ...defaultProps } />; // not authenticated
      }
    }
    return <Component { ...defaultProps } />; // no auth is required
  };
};

se a autenticação não for necessária, não passe o componente para a função matchStateToProps, com isso você eliminaria a necessidade do sinalizador
routeOpen

1

Aqui está a rota limpa e protegida simples

const ProtectedRoute 
  = ({ isAllowed, ...props }) => 
     isAllowed 
     ? <Route {...props}/> 
     : <Redirect to="/authentificate"/>;
const _App = ({ lastTab, isTokenVerified })=> 
    <Switch>
      <Route exact path="/authentificate" component={Login}/>
      <ProtectedRoute 
         isAllowed={isTokenVerified} 
         exact 
         path="/secrets" 
         component={Secrets}/>
      <ProtectedRoute 
         isAllowed={isTokenVerified} 
         exact 
         path="/polices" 
         component={Polices}/>
      <ProtectedRoute 
         isAllowed={isTokenVerified} 
         exact 
         path="/grants" component={Grants}/>
      <Redirect from="/" to={lastTab}/>
    </Switch>

isTokenVerified é uma chamada de método para verificar o token de autorização basicamente retorna booleano.


Esta é a única solução aqui que descobri que funciona se você estiver passando um Componente ou Filhos para a rota.
Shawn

Observação: acabei de chamar meu isTokenVerified () em minha função ProtectedRoute e não precisei passar o prop isAllowed em todas as rotas.
Shawn

1

Veja como resolvi isso com React e Typescript. Espero que ajude !

import * as React from 'react';
import { Route, RouteComponentProps, RouteProps, Redirect } from 'react-router';

const PrivateRoute: React.SFC<RouteProps> = ({ component: Component, ...rest }) => {
    if (!Component) {
      return null;
    }
    const isLoggedIn = true; // Add your provider here
    return (
      <Route
        {...rest}
            render={(props: RouteComponentProps<{}>) => isLoggedIn ? (<Component {...props} />) : (<Redirect to={{ pathname: '/', state: { from: props.location } }} />)}
      />
    );
  };

export default PrivateRoute;








<PrivateRoute component={SignIn} path="/signin" />


0
const Root = ({ session }) => {
  const isLoggedIn = session && session.getCurrentUser
  return (
    <Router>
      {!isLoggedIn ? (
        <Switch>
          <Route path="/signin" component={<Signin />} />
          <Redirect to="/signin" />
        </Switch>
      ) : (
        <Switch>
          <Route path="/" exact component={Home} />
          <Route path="/about" component={About} />
          <Route path="/something-else" component={SomethingElse} />
          <Redirect to="/" />
        </Switch>
      )}
    </Router>
  )
}

0

Eu também estava procurando uma resposta. Aqui todas as respostas são muito boas, mas nenhuma delas dá respostas sobre como podemos usá-lo se o usuário iniciar o aplicativo depois de abri-lo novamente. (Eu quis dizer usando cookies juntos).

Não há necessidade de criar nenhum componente privateRoute diferente. Abaixo está o meu código

    import React, { Component }  from 'react';
    import { Route, Switch, BrowserRouter, Redirect } from 'react-router-dom';
    import { Provider } from 'react-redux';
    import store from './stores';
    import requireAuth from './components/authentication/authComponent'
    import SearchComponent from './components/search/searchComponent'
    import LoginComponent from './components/login/loginComponent'
    import ExampleContainer from './containers/ExampleContainer'
    class App extends Component {
    state = {
     auth: true
    }


   componentDidMount() {
     if ( ! Cookies.get('auth')) {
       this.setState({auth:false });
     }
    }
    render() {
     return (
      <Provider store={store}>
       <BrowserRouter>
        <Switch>
         <Route exact path="/searchComponent" component={requireAuth(SearchComponent)} />
         <Route exact path="/login" component={LoginComponent} />
         <Route exact path="/" component={requireAuth(ExampleContainer)} />
         {!this.state.auth &&  <Redirect push to="/login"/> }
        </Switch>
       </BrowserRouter>
      </Provider>);
      }
     }
    }
    export default App;

E aqui está authComponent

import React  from 'react';
import { withRouter } from 'react-router';
import * as Cookie from "js-cookie";
export default function requireAuth(Component) {
class AuthenticatedComponent extends React.Component {
 constructor(props) {
  super(props);
  this.state = {
   auth: Cookie.get('auth')
  }
 }
 componentDidMount() {
  this.checkAuth();
 }
 checkAuth() {
  const location = this.props.location;
  const redirect = location.pathname + location.search;
  if ( ! Cookie.get('auth')) {
   this.props.history.push(`/login?redirect=${redirect}`);
  }
 }
render() {
  return Cookie.get('auth')
   ? <Component { ...this.props } />
   : null;
  }
 }
 return  withRouter(AuthenticatedComponent)
}

Abaixo eu escrevi um blog, você pode obter uma explicação mais detalhada lá também.

Crie rotas protegidas no ReactJS


0

A solução que funcionou melhor para minha organização é detalhada a seguir; ela apenas adiciona uma verificação na renderização para a rota sysadmin e redireciona o usuário para um caminho principal diferente do aplicativo se ele não tiver permissão para estar na página.

SysAdminRoute.tsx

import React from 'react';
import { Route, Redirect, RouteProps } from 'react-router-dom';
import AuthService from '../services/AuthService';
import { appSectionPageUrls } from './appSectionPageUrls';
interface IProps extends RouteProps {}
export const SysAdminRoute = (props: IProps) => {
    var authService = new AuthService();
    if (!authService.getIsSysAdmin()) { //example
        authService.logout();
        return (<Redirect to={{
            pathname: appSectionPageUrls.site //front-facing
        }} />);
    }
    return (<Route {...props} />);
}

Existem 3 rotas principais para nossa implementação, o público / site, o cliente / aplicativo conectado e as ferramentas de administração de sistema em / sysadmin. Você é redirecionado com base na sua 'autoridade' e esta é a página em / sysadmin.

SysAdminNav.tsx

<Switch>
    <SysAdminRoute exact path={sysadminUrls.someSysAdminUrl} render={() => <SomeSysAdminUrl/> } />
    //etc
</Switch>
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.