Я получил проект, в котором мне нужно работать для стажировки, но есть canActivate : [AuthGuard]
и многие другие ограничения, поэтому все маршруты перенаправляют меня на страницу входа, и у меня нет учетных данных для подключения, поэтому мне нужен способ отключить временно эти ограничения, если кто-то может мне помочь, я попытался вернуть false в canActivate()
функции, но безуспешно. Вот массив маршрутов auth.guard.ts и auth.service.ts:
Массив маршрутов:
const routes: Routes = [
{ path: '', redirectTo: '/home/dashboard', pathMatch: 'full' },
{ path: 'home', component: HomeComponent, canActivate: [AuthGuard], children: [
{ path: '', redirectTo: '/home/dashboard', pathMatch: 'full' },
{ path: 'dashboard', component: DashboardComponent, canActivate: [CaseManagerDashboardGuard] },
{ path: 'messages_board', component: MessagesBoardComponent },
{ path: 'create_organization', component: CreateOrganizationComponent, canActivate: [CreateOrganizationGuard] },
{ path: 'my_profile/:id', component: MyProfileComponent },
{ path: 'profile/:id', component: MyProfileComponent, canActivate: [ProfileGuard] },
{ path: 'create_user', component: CreateUserComponent, canActivate: [CreateUserGuard] },
{ path: 'search_user', component: SearchUserComponent, canActivate: [SearchUserGuard] },
{ path: 'create_patient', component: CreatePatientComponent, canActivate: [CreatePatientGuard], canDeactivate: [CanDeactivateGuard] },
{ path: 'search_patient', component: SearchPatientComponent, canActivate: [SearchPatientGuard] },
{ path: 'patient/:id', component: ClientDashboardComponent, canActivate: [PatientGuard] },
{ path: 'patient_profile/:id', component: ClientProfileComponent, canActivate: [PatientGuard] },
{ path: 'reports', component: ReportsComponent }
]},
{ path: 'login', component: LoginComponent },
{ path: 'first-login', component: FirstLoginComponent },
{ path: 'reset-password', component: ResetPasswordComponent },
{ path: 'new-password', component: NewPasswordComponent },
{
path: 'chat-poc',
loadChildren: () => import('./pages/poc/chat-poc.module').then(m => m.ChatPocModule)
},
// otherwise redirect to home
{ path: '**', redirectTo: '/home' }
];
auth.guard.ts:
import { Injectable } from '@angular/core';
import { Router, CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree } from '@angular/router';
import { Observable } from 'rxjs';
import { map, tap, take } from 'rxjs/operators';
import { AuthService } from './auth.service';
@Injectable({ providedIn: 'root' })
export class AuthGuard implements CanActivate {
constructor(private authService: AuthService, private router: Router) {}
canActivate(route: ActivatedRouteSnapshot, router: RouterStateSnapshot) {
console.log('canActivate - AuthGuard 1');
return this.authService.user.pipe(
take(1),
map(user => {
console.log('canActivate - AuthGuard 2');
// console.log(user, 14);
const isAuth = !!user;
if (isAuth) {
console.log('canActivate - AuthGuard 3');
return true;
}
console.log('canActivate - AuthGuard 4');
return this.router.createUrlTree(['/login']);
})
);
}
}
auth.service.ts (немного высокий)
import Swal from 'sweetalert2/dist/sweetalert2.js';
import {Injectable} from '@angular/core';
import {HttpClient, HttpErrorResponse, HttpHeaders} from '@angular/common/http';
import {catchError, tap, concatMap} from 'rxjs/operators';
import {BehaviorSubject, throwError, from} from 'rxjs';
import {Router} from '@angular/router';
import { User } from '../models/user.model';
import { environment } from 'src/environments/environment';
import { ChatThreadsService } from '../partials/chat/services/chat-threads.service';
import { TranslateService } from '@ngx-translate/core';
export interface AuthResponseData {
kind: string;
idToken: string;
email: string;
refreshToken: string;
expiresIn: string;
localId: string;
registered?: boolean;
}
export interface FirstLoginResponseData {
email: string;
}
export interface PasswordResetEmail {
email: string;
}
@Injectable({ providedIn: 'root' })
export class AuthService {
user = new BehaviorSubject<User>(null);
userExtraData = new BehaviorSubject<any>(null);
private tokenExpirationTimer: any;
constructor(
private http: HttpClient,
private router: Router,
private _chatThreadsService: ChatThreadsService,
public translate: TranslateService
) {}
firstLogin(password: string, oobCode: string) {
return this.http.post<FirstLoginResponseData>(
environment.identitytoolkit + 'accounts:resetPassword?key=' + environment.firebase.apiKey,
{
oobCode,
newPassword: password
}
).pipe(
catchError(this.handleError),
tap(resData => {
this.login(resData.email, password).subscribe(
respData => {
this.translate.get('Change_Password_completed_alert').subscribe((res: string) => {
Swal.fire({title: '', text: res, icon: 'success', showCancelButton: false, confirmButtonText: 'Ok'})
.then((result) => {
if (result.value) {
console.log(respData);
this.getUserExtData(respData.idToken).subscribe(
resp => {
this.router.navigate(['/home']);
}
);
}
});
});
},
errorMessage => {
console.log(errorMessage);
this.translate.get('Change_Password_error_alert').subscribe((res: string) => {
Swal.fire({title: '', text: res, icon: 'error', showCancelButton: false, confirmButtonText: 'Close'})
.then((result) => {
if (result.value) {
this.router.navigate(['/reset-password']);
}
});
});
}
);
})
);
}
sendPasswordResetEmail(email: string) {
return this.http.post<PasswordResetEmail>(
environment.identitytoolkit + 'accounts:sendOobCode?key=' + environment.firebase.apiKey,
{
requestType: 'PASSWORD_RESET',
email
}
).pipe(
catchError(this.handleError),
tap(resData => {
console.log('sendPasswordResetEmail Done');
})
);
}
login(email: string, password: string) {
return this.http.post<AuthResponseData>(
environment.identitytoolkit + 'accounts:signInWithPassword?key=' + environment.firebase.apiKey,
{
email,
password,
returnSecureToken: true
}
).pipe(
catchError(this.handleError),
tap(resData => {
this.handleAuthentication(resData.email, resData.localId, resData.idToken, +resData.expiresIn, resData.refreshToken);
})
);
}
autoLogin() {
const userData: {
email: string,
id: string,
_token: string,
_tokenExpirationDate: string,
refToken: string,
} = JSON.parse(localStorage.getItem('userData'));
if (!userData) {
return;
}
const loadedUser = new User(userData.email, userData.id, userData._token, new Date(userData._tokenExpirationDate), userData.refToken);
if (loadedUser.token) {
this.user.next(loadedUser);
const expirationDuration = new Date(userData._tokenExpirationDate).getTime() - new Date().getTime();
this.autoLogout(expirationDuration);
// this.refreshToken(expirationDuration, loadedUser.refreshToken);
}
}
logout() {
this._chatThreadsService.logout();
this.user.next(null);
this.userExtraData.next(null);
this.router.navigate(['/login']);
localStorage.removeItem('userData');
localStorage.removeItem('userExtData');
if (this.tokenExpirationTimer) {
clearTimeout(this.tokenExpirationTimer);
}
this.tokenExpirationTimer = null;
}
autoLogout(expirationDuration: number) {
this.tokenExpirationTimer = setTimeout(() => {
this.logout();
}, expirationDuration);
}
refreshToken(expirationDuration: number, refToken: string) {
console.log(expirationDuration);
this.tokenExpirationTimer = setTimeout(() => {
this.http.post<any>(
'https://securetoken.googleapis.com/v1/token?key=' + environment.firebase.apiKey,
{
refresh_token: refToken,
grant_type: 'refresh_token'
}
).pipe(
// catchError(this.handleError),
tap(resData => {
this.refreshToken((+resData.expires_in) * 1000, refToken);
})
).subscribe();
}, expirationDuration);
}
getUserExtData(idToken) {
const headers = { Authorization: 'Bearer ' + idToken };
return this.http.get<any>(
environment.apiURL + 'users/me', { headers }
).pipe(
tap(resExtData => {
this.userExtraData.next(resExtData);
localStorage.setItem('userExtData', JSON.stringify(resExtData));
})
);
}
userExtDataUpdate(id: string, language: string, units: string, date_format: string, week_start_day: string, idToken: string) {
const headers = { Authorization: 'Bearer ' + idToken };
return this.http.post<any>(
environment.apiURL + 'users/update',
{
id,
settings: {
language,
date_format,
units,
week_start_day
}
},
{
headers
}
).pipe(
tap(resExtData => {
this.getUserExtData(idToken).subscribe();
})
);
}
private handleAuthentication(email: string, userId: string, token: string, expiresIn: number, refreshToken: string) {
const expirationDate = new Date(new Date().getTime() + expiresIn * 1000);
const user = new User(email, userId, token, expirationDate, refreshToken);
this.user.next(user);
this.autoLogout(expiresIn * 1000);
// this.refreshToken(expiresIn * 1000, refreshToken);
localStorage.setItem('userData', JSON.stringify(user));
}
private handleError(errorRes: HttpErrorResponse) {
let errorMessage = 'An unknown error occurred!';
if (!errorRes.error || !errorRes.error.error) {
return throwError(errorMessage);
}
switch (errorRes.error.error.message) {
case 'EMAIL_EXISTS':
errorMessage = 'This email exists already';
break;
case 'EMAIL_NOT_FOUND':
// errorMessage = 'This email does not exist.';
errorMessage = 'Invalid Email';
break;
case 'INVALID_PASSWORD':
errorMessage = 'This password is not correct.';
break;
}
console.log('handleError', errorMessage);
return throwError(errorMessage);
}
}