920714194

Build # 920714194

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/damienbod/angular-auth-oidc-client/commit/<a class=hub.com/damienbod/angular-auth-oidc-client/commit/cdf85fe6cb5e357e75147613a44d1d46e476f3f1">cdf85fe6c<a href="https://github.com/damienbod/angular-auth-oidc-client/commit/cdf85fe6cb5e357e75147613a44d1d46e476f3f1">">Merge </a><a class="double-link" href="https://github.com/damienbod/angular-auth-oidc-client/commit/<a class="double-link" href="https://github.com/damienbod/angular-auth-oidc-client/commit/e9a13ed90b7c88487593f142f4c81868939735f7">e9a13ed90</a>">e9a13ed90</a><a href="https://github.com/damienbod/angular-auth-oidc-client/commit/cdf85fe6cb5e357e75147613a44d1d46e476f3f1"> into cc7768461">cc7768461</a>

Pull Request Pull Request #1122: Fabiangosebrink/make multiple requests possible

Run Details

1015 of 1117 branches covered (90.87%)

Branch coverage included in aggregate %.

15 of 15 new or added lines in 2 files covered. (100.0%)

2209 of 2323 relevant lines covered (95.09%)

9.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.31

/projects/angular-auth-oidc-client/src/lib/check-auth.service.ts

import { Injectable } from '@angular/core';
import { Router } from '@angular/router';
import { forkJoin, Observable, of, throwError } from 'rxjs';
import { catchError, map, switchMap, tap } from 'rxjs/operators';
import { AuthStateService } from './authState/auth-state.service';
import { AutoLoginService } from './auto-login/auto-login.service';
import { CallbackService } from './callback/callback.service';
import { PeriodicallyTokenCheckService } from './callback/periodically-token-check.service';
import { RefreshSessionService } from './callback/refresh-session.service';
import { OpenIdConfiguration } from './config/openid-configuration';
import { ConfigurationProvider } from './config/provider/config.provider';
import { CheckSessionService } from './iframe/check-session.service';
import { SilentRenewService } from './iframe/silent-renew.service';
import { LoggerService } from './logging/logger.service';
import { LoginResponse } from './login/login-response';
import { PopUpService } from './login/popup/popup.service';
import { StoragePersistenceService } from './storage/storage-persistence.service';
import { UserService } from './userData/user.service';
import { CurrentUrlService } from './utils/url/current-url.service';

@Injectable()
export class CheckAuthService {
  constructor(
    private checkSessionService: CheckSessionService,
    private currentUrlService: CurrentUrlService,
    private silentRenewService: SilentRenewService,
    private userService: UserService,
    private loggerService: LoggerService,
    private configurationProvider: ConfigurationProvider,
    private authStateService: AuthStateService,
    private callbackService: CallbackService,
    private refreshSessionService: RefreshSessionService,
    private periodicallyTokenCheckService: PeriodicallyTokenCheckService,
    private popupService: PopUpService,
    private autoLoginService: AutoLoginService,
    private router: Router,
    private storagePersistenceService: StoragePersistenceService
  ) {}

  checkAuth(passedConfigId?: string, url?: string): Observable<LoginResponse> {
    if (this.currentUrlService.currentUrlHasStateParam()) {
      const stateParamFromUrl = this.currentUrlService.getStateParamFromCurrentUrl();
      const config = this.getConfigurationWithUrlState(stateParamFromUrl);

      if (!config) {
        return throwError(`could not find matching config for state ${stateParamFromUrl}`);
      }

      return this.checkAuthWithConfig(config, url);
    }

    if (!!passedConfigId) {
      const config = this.configurationProvider.getOpenIDConfiguration(passedConfigId);
      return this.checkAuthWithConfig(config, url);
    }

    const onlyExistingConfig = this.configurationProvider.getOpenIDConfiguration();
    return this.checkAuthWithConfig(onlyExistingConfig, url);
  }

  checkAuthMultiple(passedConfigId?: string, url?: string): Observable<LoginResponse[]> {
    if (this.currentUrlService.currentUrlHasStateParam()) {
      const stateParamFromUrl = this.currentUrlService.getStateParamFromCurrentUrl();
      const config = this.getConfigurationWithUrlState(stateParamFromUrl);

      if (!config) {
        return throwError(`could not find matching config for state ${stateParamFromUrl}`);
      }

      return this.checkAuthWithConfig(config, url).pipe(map((x) => [x]));
    }

    if (!!passedConfigId) {
      const config = this.configurationProvider.getOpenIDConfiguration(passedConfigId);
      return this.checkAuthWithConfig(config, url).pipe(map((x) => [x]));
    }

    const allConfigs = this.configurationProvider.getAllConfigurations();
    const allChecks$ = allConfigs.map((x) => this.checkAuthWithConfig(x, url));

    return forkJoin(allChecks$);
  }

  checkAuthIncludingServer(configId: string): Observable<LoginResponse> {
    const config = this.configurationProvider.getOpenIDConfiguration(configId);
    return this.checkAuthWithConfig(config).pipe(
      switchMap((loginResponse) => {
        const { isAuthenticated } = loginResponse;

        if (isAuthenticated) {
          return of(loginResponse);
        }

        return this.refreshSessionService.forceRefreshSession(configId).pipe(
          tap((loginResponseAfterRefreshSession) => {
            if (loginResponseAfterRefreshSession?.isAuthenticated) {
              this.startCheckSessionAndValidation(configId);
            }
          })
        );
      })
    );
  }

  private checkAuthWithConfig(config: OpenIdConfiguration, url?: string): Observable<LoginResponse> {
    const { configId, stsServer } = config;

    if (!this.configurationProvider.hasAsLeastOneConfig()) {
      const errorMessage = 'Please provide at least one configuration before setting up the module';
      this.loggerService.logError(configId, errorMessage);

      return of({ isAuthenticated: false, errorMessage, userData: null, idToken: null, accessToken: null, configId });
    }

    const currentUrl = url || this.currentUrlService.getCurrentUrl();

    this.loggerService.logDebug(configId, `Working with config '${configId}' using ${stsServer}`);

    if (this.popupService.isCurrentlyInPopup()) {
      this.popupService.sendMessageToMainWindow(currentUrl);

      return of(null);
    }

    const isCallback = this.callbackService.isCallback(currentUrl);

    this.loggerService.logDebug(configId, 'currentUrl to check auth with: ', currentUrl);

    const callback$ = isCallback ? this.callbackService.handleCallbackAndFireEvents(currentUrl, configId) : of(null);

    return callback$.pipe(
      map(() => {
        const isAuthenticated = this.authStateService.areAuthStorageTokensValid(configId);
        if (isAuthenticated) {
          this.startCheckSessionAndValidation(configId);

          if (!isCallback) {
            this.authStateService.setAuthenticatedAndFireEvent();
            this.userService.publishUserDataIfExists(configId);
          }
        }

        this.loggerService.logDebug(configId, 'checkAuth completed - firing events now. isAuthenticated: ' + isAuthenticated);

        return {
          isAuthenticated,
          userData: this.userService.getUserDataFromStore(configId),
          accessToken: this.authStateService.getAccessToken(configId),
          idToken: this.authStateService.getIdToken(configId),
          configId,
        };
      }),
      tap(({ isAuthenticated }) => {
        if (isAuthenticated) {
          const savedRouteForRedirect = this.autoLoginService.getStoredRedirectRoute(configId);

          if (savedRouteForRedirect) {
            this.autoLoginService.deleteStoredRedirectRoute(configId);
            this.router.navigateByUrl(savedRouteForRedirect);
          }
        }
      }),
      catchError((errorMessage) => {
        this.loggerService.logError(configId, errorMessage);
        return of({ isAuthenticated: false, errorMessage, userData: null, idToken: null, accessToken: null, configId });
      })
    );
  }

  private startCheckSessionAndValidation(configId: string) {
    if (this.checkSessionService.isCheckSessionConfigured(configId)) {
      this.checkSessionService.start(configId);
    }

    this.periodicallyTokenCheckService.startTokenValidationPeriodically();

    if (this.silentRenewService.isSilentRenewConfigured(configId)) {
      this.silentRenewService.getOrCreateIframe(configId);
    }
  }

  private getConfigurationWithUrlState(stateFromUrl: string): OpenIdConfiguration {
    const allConfigs = this.configurationProvider.getAllConfigurations();

    for (const config of allConfigs) {
      const storedState = this.storagePersistenceService.read('authStateControl', config.configId);

      if (storedState === stateFromUrl) {
        return config;
      }
    }

    return null;
  }
}

1	import { Injectable } from '@angular/core';
2	import { Router } from '@angular/router';
3	import { forkJoin, Observable, of, throwError } from 'rxjs';
4	import { catchError, map, switchMap, tap } from 'rxjs/operators';
5	import { AuthStateService } from './authState/auth-state.service';
6	import { AutoLoginService } from './auto-login/auto-login.service';
7	import { CallbackService } from './callback/callback.service';
8	import { PeriodicallyTokenCheckService } from './callback/periodically-token-check.service';
9	import { RefreshSessionService } from './callback/refresh-session.service';
10	import { OpenIdConfiguration } from './config/openid-configuration';
11	import { ConfigurationProvider } from './config/provider/config.provider';
12	import { CheckSessionService } from './iframe/check-session.service';
13	import { SilentRenewService } from './iframe/silent-renew.service';
14	import { LoggerService } from './logging/logger.service';
15	import { LoginResponse } from './login/login-response';
16	import { PopUpService } from './login/popup/popup.service';
17	import { StoragePersistenceService } from './storage/storage-persistence.service';
18	import { UserService } from './userData/user.service';
19	import { CurrentUrlService } from './utils/url/current-url.service';
20
21	@Injectable()
22	export class CheckAuthService {	1✔
23	constructor(
24	private checkSessionService: CheckSessionService,	24✔
25	private currentUrlService: CurrentUrlService,	24✔
26	private silentRenewService: SilentRenewService,	24✔
27	private userService: UserService,	24✔
28	private loggerService: LoggerService,	24✔
29	private configurationProvider: ConfigurationProvider,	24✔
30	private authStateService: AuthStateService,	24✔
31	private callbackService: CallbackService,	24✔
32	private refreshSessionService: RefreshSessionService,	24✔
33	private periodicallyTokenCheckService: PeriodicallyTokenCheckService,	24✔
34	private popupService: PopUpService,	24✔
35	private autoLoginService: AutoLoginService,	24✔
36	private router: Router,	24✔
37	private storagePersistenceService: StoragePersistenceService	24✔
38	) {}
39
40	checkAuth(passedConfigId?: string, url?: string): Observable<LoginResponse> {
41	if (this.currentUrlService.currentUrlHasStateParam()) {	18✔
42	const stateParamFromUrl = this.currentUrlService.getStateParamFromCurrentUrl();	2✔
43	const config = this.getConfigurationWithUrlState(stateParamFromUrl);	2✔
44
45	if (!config) {	2✔
46	return throwError(`could not find matching config for state ${stateParamFromUrl}`);	1✔
47	}
48
49	return this.checkAuthWithConfig(config, url);	1✔
50	}
51
52	if (!!passedConfigId) {	16✔
53	const config = this.configurationProvider.getOpenIDConfiguration(passedConfigId);	15✔
54	return this.checkAuthWithConfig(config, url);	15✔
55	}
56
57	const onlyExistingConfig = this.configurationProvider.getOpenIDConfiguration();	1✔
58	return this.checkAuthWithConfig(onlyExistingConfig, url);	1✔
59	}
60
61	checkAuthMultiple(passedConfigId?: string, url?: string): Observable<LoginResponse[]> {
62	if (this.currentUrlService.currentUrlHasStateParam()) {	3✔
63	const stateParamFromUrl = this.currentUrlService.getStateParamFromCurrentUrl();	1✔
64	const config = this.getConfigurationWithUrlState(stateParamFromUrl);	1✔
65
66	if (!config) {	1!
67	return throwError(`could not find matching config for state ${stateParamFromUrl}`);	×
68	}
69
70	return this.checkAuthWithConfig(config, url).pipe(map((x) => [x]));	1✔
71	}
72
73	if (!!passedConfigId) {	2✔
74	const config = this.configurationProvider.getOpenIDConfiguration(passedConfigId);	1✔
75	return this.checkAuthWithConfig(config, url).pipe(map((x) => [x]));	1✔
76	}
77
78	const allConfigs = this.configurationProvider.getAllConfigurations();	1✔
79	const allChecks$ = allConfigs.map((x) => this.checkAuthWithConfig(x, url));	2✔
80
81	return forkJoin(allChecks$);	1✔
82	}
83
84	checkAuthIncludingServer(configId: string): Observable<LoginResponse> {
85	const config = this.configurationProvider.getOpenIDConfiguration(configId);	2✔
86	return this.checkAuthWithConfig(config).pipe(	2✔
87	switchMap((loginResponse) => {
88	const { isAuthenticated } = loginResponse;	2✔
89
90	if (isAuthenticated) {	2✔
91	return of(loginResponse);	1✔
92	}
93
94	return this.refreshSessionService.forceRefreshSession(configId).pipe(	1✔
95	tap((loginResponseAfterRefreshSession) => {
96	if (loginResponseAfterRefreshSession?.isAuthenticated) {	1!
97	this.startCheckSessionAndValidation(configId);	×
98	}
99	})
100	);
101	})
102	);
103	}
104
105	private checkAuthWithConfig(config: OpenIdConfiguration, url?: string): Observable<LoginResponse> {
106	const { configId, stsServer } = config;	23✔
107
108	if (!this.configurationProvider.hasAsLeastOneConfig()) {	23✔
109	const errorMessage = 'Please provide at least one configuration before setting up the module';	1✔
110	this.loggerService.logError(configId, errorMessage);	1✔
111
112	return of({ isAuthenticated: false, errorMessage, userData: null, idToken: null, accessToken: null, configId });	1✔
113	}
114
115	const currentUrl = url \|\| this.currentUrlService.getCurrentUrl();	22✔
116
117	this.loggerService.logDebug(configId, `Working with config '${configId}' using ${stsServer}`);	22✔
118
119	if (this.popupService.isCurrentlyInPopup()) {	22✔
120	this.popupService.sendMessageToMainWindow(currentUrl);	1✔
121
122	return of(null);	1✔
123	}
124
125	const isCallback = this.callbackService.isCallback(currentUrl);	21✔
126
127	this.loggerService.logDebug(configId, 'currentUrl to check auth with: ', currentUrl);	21✔
128
129	const callback$ = isCallback ? this.callbackService.handleCallbackAndFireEvents(currentUrl, configId) : of(null);	21✔
130
131	return callback$.pipe(	21✔
132	map(() => {
133	const isAuthenticated = this.authStateService.areAuthStorageTokensValid(configId);	20✔
134	if (isAuthenticated) {	20✔
135	this.startCheckSessionAndValidation(configId);	17✔
136
137	if (!isCallback) {	17✔
138	this.authStateService.setAuthenticatedAndFireEvent();	16✔
139	this.userService.publishUserDataIfExists(configId);	16✔
140	}
141	}
142
143	this.loggerService.logDebug(configId, 'checkAuth completed - firing events now. isAuthenticated: ' + isAuthenticated);	20✔
144
145	return {	20✔
146	isAuthenticated,
147	userData: this.userService.getUserDataFromStore(configId),
148	accessToken: this.authStateService.getAccessToken(configId),
149	idToken: this.authStateService.getIdToken(configId),
150	configId,
151	};
152	}),
153	tap(({ isAuthenticated }) => {
154	if (isAuthenticated) {	20✔
155	const savedRouteForRedirect = this.autoLoginService.getStoredRedirectRoute(configId);	17✔
156
157	if (savedRouteForRedirect) {	15✔
158	this.autoLoginService.deleteStoredRedirectRoute(configId);	1✔
159	this.router.navigateByUrl(savedRouteForRedirect);	1✔
160	}
161	}
162	}),
163	catchError((errorMessage) => {
164	this.loggerService.logError(configId, errorMessage);	3✔
165	return of({ isAuthenticated: false, errorMessage, userData: null, idToken: null, accessToken: null, configId });	3✔
166	})
167	);
168	}
169
170	private startCheckSessionAndValidation(configId: string) {
171	if (this.checkSessionService.isCheckSessionConfigured(configId)) {	17✔
172	this.checkSessionService.start(configId);	1✔
173	}
174
175	this.periodicallyTokenCheckService.startTokenValidationPeriodically();	17✔
176
177	if (this.silentRenewService.isSilentRenewConfigured(configId)) {	17!
178	this.silentRenewService.getOrCreateIframe(configId);	17✔
179	}
180	}
181
182	private getConfigurationWithUrlState(stateFromUrl: string): OpenIdConfiguration {
183	const allConfigs = this.configurationProvider.getAllConfigurations();	3✔
184
185	for (const config of allConfigs) {	3✔
186	const storedState = this.storagePersistenceService.read('authStateControl', config.configId);	3✔
187
188	if (storedState === stateFromUrl) {	3✔
189	return config;	2✔
190	}
191	}
192
193	return null;	1✔
194	}
195	}

damienbod / angular-auth-oidc-client / 920714194

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous