angular-auth-oidc-client
Version:
Angular Lib for OpenID Connect & OAuth2
149 lines • 29.2 kB
JavaScript
import { Injectable } from '@angular/core';
import { forkJoin, of, throwError } from 'rxjs';
import { catchError, map, switchMap, tap } from 'rxjs/operators';
import { EventTypes } from '../public-events/event-types';
import * as i0 from "@angular/core";
import * as i1 from "../iframe/check-session.service";
import * as i2 from "../utils/url/current-url.service";
import * as i3 from "../iframe/silent-renew.service";
import * as i4 from "../user-data/user.service";
import * as i5 from "../logging/logger.service";
import * as i6 from "../auth-state/auth-state.service";
import * as i7 from "../callback/callback.service";
import * as i8 from "../callback/refresh-session.service";
import * as i9 from "../callback/periodically-token-check.service";
import * as i10 from "../login/popup/popup.service";
import * as i11 from "../auto-login/auto-login.service";
import * as i12 from "../storage/storage-persistence.service";
import * as i13 from "../public-events/public-events.service";
export class CheckAuthService {
constructor(checkSessionService, currentUrlService, silentRenewService, userService, loggerService, authStateService, callbackService, refreshSessionService, periodicallyTokenCheckService, popupService, autoLoginService, storagePersistenceService, publicEventsService) {
this.checkSessionService = checkSessionService;
this.currentUrlService = currentUrlService;
this.silentRenewService = silentRenewService;
this.userService = userService;
this.loggerService = loggerService;
this.authStateService = authStateService;
this.callbackService = callbackService;
this.refreshSessionService = refreshSessionService;
this.periodicallyTokenCheckService = periodicallyTokenCheckService;
this.popupService = popupService;
this.autoLoginService = autoLoginService;
this.storagePersistenceService = storagePersistenceService;
this.publicEventsService = publicEventsService;
}
checkAuth(configuration, allConfigs, url) {
this.publicEventsService.fireEvent(EventTypes.CheckingAuth);
if (this.currentUrlService.currentUrlHasStateParam()) {
const stateParamFromUrl = this.currentUrlService.getStateParamFromCurrentUrl();
configuration = this.getConfigurationWithUrlState([configuration], stateParamFromUrl);
if (!configuration) {
return throwError(() => new Error(`could not find matching config for state ${stateParamFromUrl}`));
}
}
return this.checkAuthWithConfig(configuration, allConfigs, url);
}
checkAuthMultiple(allConfigs, url) {
if (this.currentUrlService.currentUrlHasStateParam()) {
const stateParamFromUrl = this.currentUrlService.getStateParamFromCurrentUrl();
const config = this.getConfigurationWithUrlState(allConfigs, stateParamFromUrl);
if (!config) {
return throwError(() => new Error(`could not find matching config for state ${stateParamFromUrl}`));
}
return this.composeMultipleLoginResults(allConfigs, config, url);
}
const configs = allConfigs;
const allChecks$ = configs.map((x) => this.checkAuthWithConfig(x, configs, url));
return forkJoin(allChecks$);
}
checkAuthIncludingServer(configuration, allConfigs) {
return this.checkAuthWithConfig(configuration, allConfigs).pipe(switchMap((loginResponse) => {
const { isAuthenticated } = loginResponse;
if (isAuthenticated) {
return of(loginResponse);
}
return this.refreshSessionService.forceRefreshSession(configuration, allConfigs).pipe(tap((loginResponseAfterRefreshSession) => {
if (loginResponseAfterRefreshSession?.isAuthenticated) {
this.startCheckSessionAndValidation(configuration, allConfigs);
}
}));
}));
}
checkAuthWithConfig(config, allConfigs, url) {
if (!config) {
const errorMessage = 'Please provide at least one configuration before setting up the module';
this.loggerService.logError(config, errorMessage);
return of({ isAuthenticated: false, errorMessage, userData: null, idToken: null, accessToken: null, configId: null });
}
const currentUrl = url || this.currentUrlService.getCurrentUrl();
const { configId, authority } = config;
this.loggerService.logDebug(config, `Working with config '${configId}' using ${authority}`);
if (this.popupService.isCurrentlyInPopup()) {
this.popupService.sendMessageToMainWindow(currentUrl);
return of(null);
}
const isCallback = this.callbackService.isCallback(currentUrl);
this.loggerService.logDebug(config, 'currentUrl to check auth with: ', currentUrl);
const callback$ = isCallback ? this.callbackService.handleCallbackAndFireEvents(currentUrl, config, allConfigs) : of(null);
return callback$.pipe(map(() => {
const isAuthenticated = this.authStateService.areAuthStorageTokensValid(config);
if (isAuthenticated) {
this.startCheckSessionAndValidation(config, allConfigs);
if (!isCallback) {
this.authStateService.setAuthenticatedAndFireEvent(allConfigs);
this.userService.publishUserDataIfExists(config, allConfigs);
}
}
this.loggerService.logDebug(config, 'checkAuth completed - firing events now. isAuthenticated: ' + isAuthenticated);
return {
isAuthenticated,
userData: this.userService.getUserDataFromStore(config),
accessToken: this.authStateService.getAccessToken(config),
idToken: this.authStateService.getIdToken(config),
configId,
};
}), tap(({ isAuthenticated }) => {
this.publicEventsService.fireEvent(EventTypes.CheckingAuthFinished);
if (isAuthenticated) {
this.autoLoginService.checkSavedRedirectRouteAndNavigate(config);
}
}), catchError(({ message }) => {
this.loggerService.logError(config, message);
this.publicEventsService.fireEvent(EventTypes.CheckingAuthFinishedWithError, message);
return of({ isAuthenticated: false, errorMessage: message, userData: null, idToken: null, accessToken: null, configId });
}));
}
startCheckSessionAndValidation(config, allConfigs) {
if (this.checkSessionService.isCheckSessionConfigured(config)) {
this.checkSessionService.start(config);
}
this.periodicallyTokenCheckService.startTokenValidationPeriodically(allConfigs, config);
if (this.silentRenewService.isSilentRenewConfigured(config)) {
this.silentRenewService.getOrCreateIframe(config);
}
}
getConfigurationWithUrlState(configurations, stateFromUrl) {
for (const config of configurations) {
const storedState = this.storagePersistenceService.read('authStateControl', config);
if (storedState === stateFromUrl) {
return config;
}
}
return null;
}
composeMultipleLoginResults(configurations, activeConfig, url) {
const allOtherConfigs = configurations.filter((x) => x.configId !== activeConfig.configId);
const currentConfigResult = this.checkAuthWithConfig(activeConfig, configurations, url);
const allOtherConfigResults = allOtherConfigs.map((config) => {
const { redirectUrl } = config;
return this.checkAuthWithConfig(config, configurations, redirectUrl);
});
return forkJoin([currentConfigResult, ...allOtherConfigResults]);
}
}
CheckAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: CheckAuthService, deps: [{ token: i1.CheckSessionService }, { token: i2.CurrentUrlService }, { token: i3.SilentRenewService }, { token: i4.UserService }, { token: i5.LoggerService }, { token: i6.AuthStateService }, { token: i7.CallbackService }, { token: i8.RefreshSessionService }, { token: i9.PeriodicallyTokenCheckService }, { token: i10.PopUpService }, { token: i11.AutoLoginService }, { token: i12.StoragePersistenceService }, { token: i13.PublicEventsService }], target: i0.ɵɵFactoryTarget.Injectable });
CheckAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: CheckAuthService });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: CheckAuthService, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i1.CheckSessionService }, { type: i2.CurrentUrlService }, { type: i3.SilentRenewService }, { type: i4.UserService }, { type: i5.LoggerService }, { type: i6.AuthStateService }, { type: i7.CallbackService }, { type: i8.RefreshSessionService }, { type: i9.PeriodicallyTokenCheckService }, { type: i10.PopUpService }, { type: i11.AutoLoginService }, { type: i12.StoragePersistenceService }, { type: i13.PublicEventsService }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check-auth.service.js","sourceRoot":"","sources":["../../../../../projects/angular-auth-oidc-client/src/lib/auth-state/check-auth.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAc,EAAE,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAYjE,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;;;;;;;;;;;;;;;AAO1D,MAAM,OAAO,gBAAgB;IAC3B,YACmB,mBAAwC,EACxC,iBAAoC,EACpC,kBAAsC,EACtC,WAAwB,EACxB,aAA4B,EAC5B,gBAAkC,EAClC,eAAgC,EAChC,qBAA4C,EAC5C,6BAA4D,EAC5D,YAA0B,EAC1B,gBAAkC,EAClC,yBAAoD,EACpD,mBAAwC;QAZxC,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,gBAAW,GAAX,WAAW,CAAa;QACxB,kBAAa,GAAb,aAAa,CAAe;QAC5B,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,oBAAe,GAAf,eAAe,CAAiB;QAChC,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,kCAA6B,GAA7B,6BAA6B,CAA+B;QAC5D,iBAAY,GAAZ,YAAY,CAAc;QAC1B,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,8BAAyB,GAAzB,yBAAyB,CAA2B;QACpD,wBAAmB,GAAnB,mBAAmB,CAAqB;IACxD,CAAC;IAEJ,SAAS,CAAC,aAAkC,EAAE,UAAiC,EAAE,GAAY;QAC3F,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;QAE5D,IAAI,IAAI,CAAC,iBAAiB,CAAC,uBAAuB,EAAE,EAAE;YACpD,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,2BAA2B,EAAE,CAAC;YAE/E,aAAa,GAAG,IAAI,CAAC,4BAA4B,CAAC,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC,CAAC;YAEtF,IAAI,CAAC,aAAa,EAAE;gBAClB,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,4CAA4C,iBAAiB,EAAE,CAAC,CAAC,CAAC;aACrG;SACF;QAED,OAAO,IAAI,CAAC,mBAAmB,CAAC,aAAa,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IAClE,CAAC;IAED,iBAAiB,CAAC,UAAiC,EAAE,GAAY;QAC/D,IAAI,IAAI,CAAC,iBAAiB,CAAC,uBAAuB,EAAE,EAAE;YACpD,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,2BAA2B,EAAE,CAAC;YAC/E,MAAM,MAAM,GAAG,IAAI,CAAC,4BAA4B,CAAC,UAAU,EAAE,iBAAiB,CAAC,CAAC;YAEhF,IAAI,CAAC,MAAM,EAAE;gBACX,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,4CAA4C,iBAAiB,EAAE,CAAC,CAAC,CAAC;aACrG;YAED,OAAO,IAAI,CAAC,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;SAClE;QAED,MAAM,OAAO,GAAG,UAAU,CAAC;QAC3B,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;QAEjF,OAAO,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC9B,CAAC;IAED,wBAAwB,CAAC,aAAkC,EAAE,UAAiC;QAC5F,OAAO,IAAI,CAAC,mBAAmB,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC,IAAI,CAC7D,SAAS,CAAC,CAAC,aAAa,EAAE,EAAE;YAC1B,MAAM,EAAE,eAAe,EAAE,GAAG,aAAa,CAAC;YAE1C,IAAI,eAAe,EAAE;gBACnB,OAAO,EAAE,CAAC,aAAa,CAAC,CAAC;aAC1B;YAED,OAAO,IAAI,CAAC,qBAAqB,CAAC,mBAAmB,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC,IAAI,CACnF,GAAG,CAAC,CAAC,gCAAgC,EAAE,EAAE;gBACvC,IAAI,gCAAgC,EAAE,eAAe,EAAE;oBACrD,IAAI,CAAC,8BAA8B,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;iBAChE;YACH,CAAC,CAAC,CACH,CAAC;QACJ,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEO,mBAAmB,CAAC,MAA2B,EAAE,UAAiC,EAAE,GAAY;QACtG,IAAI,CAAC,MAAM,EAAE;YACX,MAAM,YAAY,GAAG,wEAAwE,CAAC;YAE9F,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;YAElD,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;SACvH;QAED,MAAM,UAAU,GAAG,GAAG,IAAI,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;QACjE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;QAEvC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,wBAAwB,QAAQ,WAAW,SAAS,EAAE,CAAC,CAAC;QAE5F,IAAI,IAAI,CAAC,YAAY,CAAC,kBAAkB,EAAE,EAAE;YAC1C,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,UAAU,CAAC,CAAC;YAEtD,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;SACjB;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAE/D,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,iCAAiC,EAAE,UAAU,CAAC,CAAC;QAEnF,MAAM,SAAS,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;QAE3H,OAAO,SAAS,CAAC,IAAI,CACnB,GAAG,CAAC,GAAG,EAAE;YACP,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,yBAAyB,CAAC,MAAM,CAAC,CAAC;YAEhF,IAAI,eAAe,EAAE;gBACnB,IAAI,CAAC,8BAA8B,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;gBAExD,IAAI,CAAC,UAAU,EAAE;oBACf,IAAI,CAAC,gBAAgB,CAAC,4BAA4B,CAAC,UAAU,CAAC,CAAC;oBAC/D,IAAI,CAAC,WAAW,CAAC,uBAAuB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;iBAC9D;aACF;YAED,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,4DAA4D,GAAG,eAAe,CAAC,CAAC;YAEpH,OAAO;gBACL,eAAe;gBACf,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,oBAAoB,CAAC,MAAM,CAAC;gBACvD,WAAW,EAAE,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,MAAM,CAAC;gBACzD,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC;gBACjD,QAAQ;aACT,CAAC;QACJ,CAAC,CAAC,EACF,GAAG,CAAC,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE;YAC1B,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC;YAEpE,IAAI,eAAe,EAAE;gBACnB,IAAI,CAAC,gBAAgB,CAAC,kCAAkC,CAAC,MAAM,CAAC,CAAC;aAClE;QACH,CAAC,CAAC,EACF,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;YACzB,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAC7C,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,UAAU,CAAC,6BAA6B,EAAE,OAAO,CAAC,CAAC;YAEtF,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3H,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEO,8BAA8B,CAAC,MAA2B,EAAE,UAAiC;QACnG,IAAI,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,MAAM,CAAC,EAAE;YAC7D,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;SACxC;QAED,IAAI,CAAC,6BAA6B,CAAC,gCAAgC,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QAExF,IAAI,IAAI,CAAC,kBAAkB,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE;YAC3D,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;SACnD;IACH,CAAC;IAEO,4BAA4B,CAAC,cAAqC,EAAE,YAAoB;QAC9F,KAAK,MAAM,MAAM,IAAI,cAAc,EAAE;YACnC,MAAM,WAAW,GAAG,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;YAEpF,IAAI,WAAW,KAAK,YAAY,EAAE;gBAChC,OAAO,MAAM,CAAC;aACf;SACF;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,2BAA2B,CACjC,cAAqC,EACrC,YAAiC,EACjC,GAAY;QAEZ,MAAM,eAAe,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,YAAY,CAAC,QAAQ,CAAC,CAAC;QAE3F,MAAM,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,cAAc,EAAE,GAAG,CAAC,CAAC;QAExF,MAAM,qBAAqB,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;YAC3D,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC;YAE/B,OAAO,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,CAAC,CAAC;QACvE,CAAC,CAAC,CAAC;QAEH,OAAO,QAAQ,CAAC,CAAC,mBAAmB,EAAE,GAAG,qBAAqB,CAAC,CAAC,CAAC;IACnE,CAAC;;6GAhLU,gBAAgB;iHAAhB,gBAAgB;2FAAhB,gBAAgB;kBAD5B,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { forkJoin, Observable, of, throwError } from 'rxjs';\r\nimport { catchError, map, switchMap, tap } from 'rxjs/operators';\r\nimport { AuthStateService } from '../auth-state/auth-state.service';\r\nimport { AutoLoginService } from '../auto-login/auto-login.service';\r\nimport { CallbackService } from '../callback/callback.service';\r\nimport { PeriodicallyTokenCheckService } from '../callback/periodically-token-check.service';\r\nimport { RefreshSessionService } from '../callback/refresh-session.service';\r\nimport { OpenIdConfiguration } from '../config/openid-configuration';\r\nimport { CheckSessionService } from '../iframe/check-session.service';\r\nimport { SilentRenewService } from '../iframe/silent-renew.service';\r\nimport { LoggerService } from '../logging/logger.service';\r\nimport { LoginResponse } from '../login/login-response';\r\nimport { PopUpService } from '../login/popup/popup.service';\r\nimport { EventTypes } from '../public-events/event-types';\r\nimport { PublicEventsService } from '../public-events/public-events.service';\r\nimport { StoragePersistenceService } from '../storage/storage-persistence.service';\r\nimport { UserService } from '../user-data/user.service';\r\nimport { CurrentUrlService } from '../utils/url/current-url.service';\r\n\r\n@Injectable()\r\nexport class CheckAuthService {\r\n  constructor(\r\n    private readonly checkSessionService: CheckSessionService,\r\n    private readonly currentUrlService: CurrentUrlService,\r\n    private readonly silentRenewService: SilentRenewService,\r\n    private readonly userService: UserService,\r\n    private readonly loggerService: LoggerService,\r\n    private readonly authStateService: AuthStateService,\r\n    private readonly callbackService: CallbackService,\r\n    private readonly refreshSessionService: RefreshSessionService,\r\n    private readonly periodicallyTokenCheckService: PeriodicallyTokenCheckService,\r\n    private readonly popupService: PopUpService,\r\n    private readonly autoLoginService: AutoLoginService,\r\n    private readonly storagePersistenceService: StoragePersistenceService,\r\n    private readonly publicEventsService: PublicEventsService\r\n  ) {}\r\n\r\n  checkAuth(configuration: OpenIdConfiguration, allConfigs: OpenIdConfiguration[], url?: string): Observable<LoginResponse> {\r\n    this.publicEventsService.fireEvent(EventTypes.CheckingAuth);\r\n\r\n    if (this.currentUrlService.currentUrlHasStateParam()) {\r\n      const stateParamFromUrl = this.currentUrlService.getStateParamFromCurrentUrl();\r\n\r\n      configuration = this.getConfigurationWithUrlState([configuration], stateParamFromUrl);\r\n\r\n      if (!configuration) {\r\n        return throwError(() => new Error(`could not find matching config for state ${stateParamFromUrl}`));\r\n      }\r\n    }\r\n\r\n    return this.checkAuthWithConfig(configuration, allConfigs, url);\r\n  }\r\n\r\n  checkAuthMultiple(allConfigs: OpenIdConfiguration[], url?: string): Observable<LoginResponse[]> {\r\n    if (this.currentUrlService.currentUrlHasStateParam()) {\r\n      const stateParamFromUrl = this.currentUrlService.getStateParamFromCurrentUrl();\r\n      const config = this.getConfigurationWithUrlState(allConfigs, stateParamFromUrl);\r\n\r\n      if (!config) {\r\n        return throwError(() => new Error(`could not find matching config for state ${stateParamFromUrl}`));\r\n      }\r\n\r\n      return this.composeMultipleLoginResults(allConfigs, config, url);\r\n    }\r\n\r\n    const configs = allConfigs;\r\n    const allChecks$ = configs.map((x) => this.checkAuthWithConfig(x, configs, url));\r\n\r\n    return forkJoin(allChecks$);\r\n  }\r\n\r\n  checkAuthIncludingServer(configuration: OpenIdConfiguration, allConfigs: OpenIdConfiguration[]): Observable<LoginResponse> {\r\n    return this.checkAuthWithConfig(configuration, allConfigs).pipe(\r\n      switchMap((loginResponse) => {\r\n        const { isAuthenticated } = loginResponse;\r\n\r\n        if (isAuthenticated) {\r\n          return of(loginResponse);\r\n        }\r\n\r\n        return this.refreshSessionService.forceRefreshSession(configuration, allConfigs).pipe(\r\n          tap((loginResponseAfterRefreshSession) => {\r\n            if (loginResponseAfterRefreshSession?.isAuthenticated) {\r\n              this.startCheckSessionAndValidation(configuration, allConfigs);\r\n            }\r\n          })\r\n        );\r\n      })\r\n    );\r\n  }\r\n\r\n  private checkAuthWithConfig(config: OpenIdConfiguration, allConfigs: OpenIdConfiguration[], url?: string): Observable<LoginResponse> {\r\n    if (!config) {\r\n      const errorMessage = 'Please provide at least one configuration before setting up the module';\r\n\r\n      this.loggerService.logError(config, errorMessage);\r\n\r\n      return of({ isAuthenticated: false, errorMessage, userData: null, idToken: null, accessToken: null, configId: null });\r\n    }\r\n\r\n    const currentUrl = url || this.currentUrlService.getCurrentUrl();\r\n    const { configId, authority } = config;\r\n\r\n    this.loggerService.logDebug(config, `Working with config '${configId}' using ${authority}`);\r\n\r\n    if (this.popupService.isCurrentlyInPopup()) {\r\n      this.popupService.sendMessageToMainWindow(currentUrl);\r\n\r\n      return of(null);\r\n    }\r\n\r\n    const isCallback = this.callbackService.isCallback(currentUrl);\r\n\r\n    this.loggerService.logDebug(config, 'currentUrl to check auth with: ', currentUrl);\r\n\r\n    const callback$ = isCallback ? this.callbackService.handleCallbackAndFireEvents(currentUrl, config, allConfigs) : of(null);\r\n\r\n    return callback$.pipe(\r\n      map(() => {\r\n        const isAuthenticated = this.authStateService.areAuthStorageTokensValid(config);\r\n\r\n        if (isAuthenticated) {\r\n          this.startCheckSessionAndValidation(config, allConfigs);\r\n\r\n          if (!isCallback) {\r\n            this.authStateService.setAuthenticatedAndFireEvent(allConfigs);\r\n            this.userService.publishUserDataIfExists(config, allConfigs);\r\n          }\r\n        }\r\n\r\n        this.loggerService.logDebug(config, 'checkAuth completed - firing events now. isAuthenticated: ' + isAuthenticated);\r\n\r\n        return {\r\n          isAuthenticated,\r\n          userData: this.userService.getUserDataFromStore(config),\r\n          accessToken: this.authStateService.getAccessToken(config),\r\n          idToken: this.authStateService.getIdToken(config),\r\n          configId,\r\n        };\r\n      }),\r\n      tap(({ isAuthenticated }) => {\r\n        this.publicEventsService.fireEvent(EventTypes.CheckingAuthFinished);\r\n\r\n        if (isAuthenticated) {\r\n          this.autoLoginService.checkSavedRedirectRouteAndNavigate(config);\r\n        }\r\n      }),\r\n      catchError(({ message }) => {\r\n        this.loggerService.logError(config, message);\r\n        this.publicEventsService.fireEvent(EventTypes.CheckingAuthFinishedWithError, message);\r\n\r\n        return of({ isAuthenticated: false, errorMessage: message, userData: null, idToken: null, accessToken: null, configId });\r\n      })\r\n    );\r\n  }\r\n\r\n  private startCheckSessionAndValidation(config: OpenIdConfiguration, allConfigs: OpenIdConfiguration[]): void {\r\n    if (this.checkSessionService.isCheckSessionConfigured(config)) {\r\n      this.checkSessionService.start(config);\r\n    }\r\n\r\n    this.periodicallyTokenCheckService.startTokenValidationPeriodically(allConfigs, config);\r\n\r\n    if (this.silentRenewService.isSilentRenewConfigured(config)) {\r\n      this.silentRenewService.getOrCreateIframe(config);\r\n    }\r\n  }\r\n\r\n  private getConfigurationWithUrlState(configurations: OpenIdConfiguration[], stateFromUrl: string): OpenIdConfiguration {\r\n    for (const config of configurations) {\r\n      const storedState = this.storagePersistenceService.read('authStateControl', config);\r\n\r\n      if (storedState === stateFromUrl) {\r\n        return config;\r\n      }\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  private composeMultipleLoginResults(\r\n    configurations: OpenIdConfiguration[],\r\n    activeConfig: OpenIdConfiguration,\r\n    url?: string\r\n  ): Observable<LoginResponse[]> {\r\n    const allOtherConfigs = configurations.filter((x) => x.configId !== activeConfig.configId);\r\n\r\n    const currentConfigResult = this.checkAuthWithConfig(activeConfig, configurations, url);\r\n\r\n    const allOtherConfigResults = allOtherConfigs.map((config) => {\r\n      const { redirectUrl } = config;\r\n\r\n      return this.checkAuthWithConfig(config, configurations, redirectUrl);\r\n    });\r\n\r\n    return forkJoin([currentConfigResult, ...allOtherConfigResults]);\r\n  }\r\n}\r\n"]}