angular-auth-oidc-client
Version:
Angular Lib for OpenID Connect & OAuth2
394 lines • 59.7 kB
JavaScript
import { Injectable } from '@angular/core';
import { BehaviorSubject, throwError } from 'rxjs';
import { catchError, map, switchMap, tap } from 'rxjs/operators';
import * as i0 from "@angular/core";
import * as i1 from "./iframe/check-session.service";
import * as i2 from "./auth-state/check-auth.service";
import * as i3 from "./user-data/user.service";
import * as i4 from "./utils/tokenHelper/token-helper.service";
import * as i5 from "./config/config.service";
import * as i6 from "./auth-state/auth-state.service";
import * as i7 from "./flows/flows-data.service";
import * as i8 from "./callback/callback.service";
import * as i9 from "./logoff-revoke/logoff-revocation.service";
import * as i10 from "./login/login.service";
import * as i11 from "./callback/refresh-session.service";
import * as i12 from "./utils/url/url.service";
import * as i13 from "./config/auth-well-known/auth-well-known.service";
export class OidcSecurityService {
constructor(checkSessionService, checkAuthService, userService, tokenHelperService, configurationService, authStateService, flowsDataService, callbackService, logoffRevocationService, loginService, refreshSessionService, urlService, authWellKnownService) {
this.checkSessionService = checkSessionService;
this.checkAuthService = checkAuthService;
this.userService = userService;
this.tokenHelperService = tokenHelperService;
this.configurationService = configurationService;
this.authStateService = authStateService;
this.flowsDataService = flowsDataService;
this.callbackService = callbackService;
this.logoffRevocationService = logoffRevocationService;
this.loginService = loginService;
this.refreshSessionService = refreshSessionService;
this.urlService = urlService;
this.authWellKnownService = authWellKnownService;
this.isLoading = new BehaviorSubject(true);
this.finishLoading = () => {
this.isLoading.next(false);
};
this.finishLoadingOnError = (err) => {
this.isLoading.next(false);
return throwError(() => err);
};
}
/**
* Provides information about the user after they have logged in.
*
* @returns Returns an object containing either the user data directly (single config) or
* the user data per config in case you are running with multiple configs
*/
get userData$() {
return this.userService.userData$;
}
/**
* Emits each time an authorization event occurs.
*
* @returns Returns an object containing if you are authenticated or not.
* Single Config: true if config is authenticated, false if not.
* Multiple Configs: true is all configs are authenticated, false if only one of them is not
*
* The `allConfigsAuthenticated` property contains the auth information _per config_.
*/
get isAuthenticated$() {
return this.authStateService.authenticated$;
}
/**
* Emits each time the server sends a CheckSession event and the value changed. This property will always return
* true.
*/
get checkSessionChanged$() {
return this.checkSessionService.checkSessionChanged$;
}
/**
* Emits on a Security Token Service callback. The observable will never contain a value.
*/
get stsCallback$() {
return this.callbackService.stsCallback$;
}
/**
* @deprecated This property should not be used. Please use the `PublicEventsService` instead. This property is removed in future versions
* Emits false when the observable, returned by one of the checkAuth() methods, emits a value, or errors. Initial value: true.
*/
get isLoading$() {
return this.isLoading.asObservable();
}
preloadAuthWellKnownDocument(configId) {
return this.configurationService
.getOpenIDConfiguration(configId)
.pipe(switchMap((config) => this.authWellKnownService.queryAndStoreAuthWellKnownEndPoints(config)));
}
/**
* Returns the currently active OpenID configurations.
*
* @returns an array of OpenIdConfigurations.
*/
getConfigurations() {
return this.configurationService.getAllConfigurations();
}
/**
* Returns a single active OpenIdConfiguration.
*
* @param configId The configId to identify the config. If not passed, the first one is being returned
*/
getConfiguration(configId) {
return this.configurationService.getOpenIDConfiguration(configId);
}
/**
* Returns the userData for a configuration
*
* @param configId The configId to identify the config. If not passed, the first one is being used
*/
getUserData(configId) {
return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => this.userService.getUserDataFromStore(config)));
}
/**
* Starts the complete setup flow for one configuration. Calling will start the entire authentication flow, and the returned observable
* will denote whether the user was successfully authenticated including the user data, the access token, the configId and
* an error message in case an error happened
*
* @param url The URL to perform the authorization on the behalf of.
* @param configId The configId to perform the authorization on the behalf of. If not passed, the first configs will be taken
*
* @returns An object `LoginResponse` containing all information about the login
*/
checkAuth(url, configId) {
return this.configurationService.getOpenIDConfigurations(configId).pipe(switchMap(({ allConfigs, currentConfig }) => this.checkAuthService.checkAuth(currentConfig, allConfigs, url)), tap(this.finishLoading), catchError(this.finishLoadingOnError));
}
/**
* Starts the complete setup flow for multiple configurations.
* Calling will start the entire authentication flow, and the returned observable
* will denote whether the user was successfully authenticated including the user data, the access token, the configId and
* an error message in case an error happened in an array for each config which was provided
*
* @param url The URL to perform the authorization on the behalf of.
* @param configId The configId to perform the authorization on the behalf of. If not passed, all of the current
* configured ones will be used to check.
*
* @returns An array of `LoginResponse` objects containing all information about the logins
*/
checkAuthMultiple(url) {
return this.configurationService.getOpenIDConfigurations().pipe(switchMap(({ allConfigs }) => this.checkAuthService.checkAuthMultiple(allConfigs, url)), tap(this.finishLoading), catchError(this.finishLoadingOnError));
}
/**
* Provides information about the current authenticated state
*
* @param configId The configId to check the information for. If not passed, the first configs will be taken
*
* @returns A boolean whether the config is authenticated or not.
*/
isAuthenticated(configId) {
return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => this.authStateService.isAuthenticated(config)));
}
/**
* Checks the server for an authenticated session using the iframe silent renew if not locally authenticated.
*/
checkAuthIncludingServer(configId) {
return this.configurationService.getOpenIDConfigurations(configId).pipe(switchMap(({ allConfigs, currentConfig }) => this.checkAuthService.checkAuthIncludingServer(currentConfig, allConfigs)), tap(this.finishLoading), catchError(this.finishLoadingOnError));
}
/**
* Returns the access token for the login scenario.
*
* @param configId The configId to check the information for. If not passed, the first configs will be taken
*
* @returns A string with the access token.
*/
getAccessToken(configId) {
return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => this.authStateService.getAccessToken(config)));
}
/**
* Returns the ID token for the sign-in.
*
* @param configId The configId to check the information for. If not passed, the first configs will be taken
*
* @returns A string with the id token.
*/
getIdToken(configId) {
return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => this.authStateService.getIdToken(config)));
}
/**
* Returns the refresh token, if present, for the sign-in.
*
* @param configId The configId to check the information for. If not passed, the first configs will be taken
*
* @returns A string with the refresh token.
*/
getRefreshToken(configId) {
return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => this.authStateService.getRefreshToken(config)));
}
/**
* Returns the authentication result, if present, for the sign-in.
*
* @param configId The configId to check the information for. If not passed, the first configs will be taken
*
* @returns A object with the authentication result
*/
getAuthenticationResult(configId) {
return this.configurationService
.getOpenIDConfiguration(configId)
.pipe(map((config) => this.authStateService.getAuthenticationResult(config)));
}
/**
* Returns the payload from the ID token.
*
* @param encode Set to true if the payload is base64 encoded
* @param configId The configId to check the information for. If not passed, the first configs will be taken
*
* @returns The payload from the id token.
*/
getPayloadFromIdToken(encode = false, configId) {
return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => {
const token = this.authStateService.getIdToken(config);
return this.tokenHelperService.getPayloadFromToken(token, encode, config);
}));
}
/**
* Returns the payload from the access token.
*
* @param encode Set to true if the payload is base64 encoded
* @param configId The configId to check the information for. If not passed, the first configs will be taken
*
* @returns The payload from the access token.
*/
getPayloadFromAccessToken(encode = false, configId) {
return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => {
const token = this.authStateService.getAccessToken(config);
return this.tokenHelperService.getPayloadFromToken(token, encode, config);
}));
}
/**
* Sets a custom state for the authorize request.
*
* @param state The state to set.
* @param configId The configId to check the information for. If not passed, the first configs will be taken
*/
setState(state, configId) {
return this.configurationService
.getOpenIDConfiguration(configId)
.pipe(map((config) => this.flowsDataService.setAuthStateControl(state, config)));
}
/**
* Gets the state value used for the authorize request.
*
* @param configId The configId to check the information for. If not passed, the first configs will be taken
*
* @returns The state value used for the authorize request.
*/
getState(configId) {
return this.configurationService
.getOpenIDConfiguration(configId)
.pipe(map((config) => this.flowsDataService.getAuthStateControl(config)));
}
/**
* Redirects the user to the Security Token Service to begin the authentication process.
*
* @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken
* @param authOptions The custom options for the the authentication request.
*/
authorize(configId, authOptions) {
this.configurationService.getOpenIDConfiguration(configId).subscribe((config) => this.loginService.login(config, authOptions));
}
/**
* Opens the Security Token Service in a new window to begin the authentication process.
*
* @param authOptions The custom options for the authentication request.
* @param popupOptions The configuration for the popup window.
* @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken
*
* @returns An `Observable<LoginResponse>` containing all information about the login
*/
authorizeWithPopUp(authOptions, popupOptions, configId) {
return this.configurationService
.getOpenIDConfigurations(configId)
.pipe(switchMap(({ allConfigs, currentConfig }) => this.loginService.loginWithPopUp(currentConfig, allConfigs, authOptions, popupOptions)));
}
/**
* Manually refreshes the session.
*
* @param customParams Custom parameters to pass to the refresh request.
* @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken
*
* @returns An `Observable<LoginResponse>` containing all information about the login
*/
forceRefreshSession(customParams, configId) {
return this.configurationService
.getOpenIDConfigurations(configId)
.pipe(switchMap(({ allConfigs, currentConfig }) => this.refreshSessionService.userForceRefreshSession(currentConfig, allConfigs, customParams)));
}
/**
* Revokes the refresh token (if present) and the access token on the server and then performs the logoff operation.
* The refresh token and and the access token are revoked on the server. If the refresh token does not exist
* only the access token is revoked. Then the logout run.
*
* @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken
* @param authOptions The custom options for the request.
*
* @returns An observable when the action is finished
*/
logoffAndRevokeTokens(configId, authOptions) {
return this.configurationService
.getOpenIDConfigurations(configId)
.pipe(switchMap(({ allConfigs, currentConfig }) => this.logoffRevocationService.logoffAndRevokeTokens(currentConfig, allConfigs, authOptions)));
}
/**
* Logs out on the server and the local client. If the server state has changed, confirmed via check session,
* then only a local logout is performed.
*
* @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken
* @param authOptions with custom parameters and/or an custom url handler
*/
logoff(configId, authOptions) {
this.configurationService
.getOpenIDConfigurations(configId)
.subscribe(({ allConfigs, currentConfig }) => this.logoffRevocationService.logoff(currentConfig, allConfigs, authOptions));
}
/**
* Logs the user out of the application without logging them out of the server.
* Use this method if you have _one_ config enabled.
*
* @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken
*/
logoffLocal(configId) {
this.configurationService
.getOpenIDConfigurations(configId)
.subscribe(({ allConfigs, currentConfig }) => this.logoffRevocationService.logoffLocal(currentConfig, allConfigs));
}
/**
* Logs the user out of the application for all configs without logging them out of the server.
* Use this method if you have _multiple_ configs enabled.
*/
logoffLocalMultiple() {
this.configurationService
.getOpenIDConfigurations()
.subscribe(({ allConfigs }) => this.logoffRevocationService.logoffLocalMultiple(allConfigs));
}
/**
* Revokes an access token on the Security Token Service. This is only required in the code flow with refresh tokens. If no token is
* provided, then the token from the storage is revoked. You can pass any token to revoke.
* https://tools.ietf.org/html/rfc7009
*
* @param accessToken The access token to revoke.
* @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken
*
* @returns An observable when the action is finished
*/
revokeAccessToken(accessToken, configId) {
return this.configurationService
.getOpenIDConfiguration(configId)
.pipe(switchMap((config) => this.logoffRevocationService.revokeAccessToken(config, accessToken)));
}
/**
* Revokes a refresh token on the Security Token Service. This is only required in the code flow with refresh tokens. If no token is
* provided, then the token from the storage is revoked. You can pass any token to revoke.
* https://tools.ietf.org/html/rfc7009
*
* @param refreshToken The access token to revoke.
* @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken
*
* @returns An observable when the action is finished
*/
revokeRefreshToken(refreshToken, configId) {
return this.configurationService
.getOpenIDConfiguration(configId)
.pipe(switchMap((config) => this.logoffRevocationService.revokeRefreshToken(config, refreshToken)));
}
/**
* Creates the end session URL which can be used to implement an alternate server logout.
*
* @param customParams
* @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken
*
* @returns A string with the end session url or null
*/
getEndSessionUrl(customParams, configId) {
return this.configurationService
.getOpenIDConfiguration(configId)
.pipe(map((config) => this.logoffRevocationService.getEndSessionUrl(config, customParams)));
}
/**
* Creates the authorize URL based on your flow
*
* @param customParams
* @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken
*
* @returns A string with the authorize URL or null
*/
getAuthorizeUrl(customParams, configId) {
return this.configurationService
.getOpenIDConfiguration(configId)
.pipe(switchMap((config) => this.urlService.getAuthorizeUrl(config, customParams ? { customParams } : undefined)));
}
}
OidcSecurityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: OidcSecurityService, deps: [{ token: i1.CheckSessionService }, { token: i2.CheckAuthService }, { token: i3.UserService }, { token: i4.TokenHelperService }, { token: i5.ConfigurationService }, { token: i6.AuthStateService }, { token: i7.FlowsDataService }, { token: i8.CallbackService }, { token: i9.LogoffRevocationService }, { token: i10.LoginService }, { token: i11.RefreshSessionService }, { token: i12.UrlService }, { token: i13.AuthWellKnownService }], target: i0.ɵɵFactoryTarget.Injectable });
OidcSecurityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: OidcSecurityService });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: OidcSecurityService, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i1.CheckSessionService }, { type: i2.CheckAuthService }, { type: i3.UserService }, { type: i4.TokenHelperService }, { type: i5.ConfigurationService }, { type: i6.AuthStateService }, { type: i7.FlowsDataService }, { type: i8.CallbackService }, { type: i9.LogoffRevocationService }, { type: i10.LoginService }, { type: i11.RefreshSessionService }, { type: i12.UrlService }, { type: i13.AuthWellKnownService }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oidc.security.service.js","sourceRoot":"","sources":["../../../../projects/angular-auth-oidc-client/src/lib/oidc.security.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { BehaviorSubject, Observable, throwError } from 'rxjs';\r\nimport { catchError, map, switchMap, tap } from 'rxjs/operators';\r\nimport { AuthOptions } from './auth-options';\r\nimport { AuthenticatedResult } from './auth-state/auth-result';\r\nimport { AuthStateService } from './auth-state/auth-state.service';\r\nimport { CheckAuthService } from './auth-state/check-auth.service';\r\nimport { CallbackService } from './callback/callback.service';\r\nimport { RefreshSessionService } from './callback/refresh-session.service';\r\nimport { AuthWellKnownEndpoints } from './config/auth-well-known/auth-well-known-endpoints';\r\nimport { AuthWellKnownService } from './config/auth-well-known/auth-well-known.service';\r\nimport { ConfigurationService } from './config/config.service';\r\nimport { OpenIdConfiguration } from './config/openid-configuration';\r\nimport { FlowsDataService } from './flows/flows-data.service';\r\nimport { CheckSessionService } from './iframe/check-session.service';\r\nimport { LoginResponse } from './login/login-response';\r\nimport { LoginService } from './login/login.service';\r\nimport { PopupOptions } from './login/popup/popup-options';\r\nimport { LogoffRevocationService } from './logoff-revoke/logoff-revocation.service';\r\nimport { UserService } from './user-data/user.service';\r\nimport { UserDataResult } from './user-data/userdata-result';\r\nimport { TokenHelperService } from './utils/tokenHelper/token-helper.service';\r\nimport { UrlService } from './utils/url/url.service';\r\n\r\n@Injectable()\r\nexport class OidcSecurityService {\r\n  /**\r\n   * Provides information about the user after they have logged in.\r\n   *\r\n   * @returns Returns an object containing either the user data directly (single config) or\r\n   * the user data per config in case you are running with multiple configs\r\n   */\r\n  get userData$(): Observable<UserDataResult> {\r\n    return this.userService.userData$;\r\n  }\r\n\r\n  /**\r\n   * Emits each time an authorization event occurs.\r\n   *\r\n   * @returns Returns an object containing if you are authenticated or not.\r\n   * Single Config: true if config is authenticated, false if not.\r\n   * Multiple Configs: true is all configs are authenticated, false if only one of them is not\r\n   *\r\n   * The `allConfigsAuthenticated` property contains the auth information _per config_.\r\n   */\r\n  get isAuthenticated$(): Observable<AuthenticatedResult> {\r\n    return this.authStateService.authenticated$;\r\n  }\r\n\r\n  /**\r\n   * Emits each time the server sends a CheckSession event and the value changed. This property will always return\r\n   * true.\r\n   */\r\n  get checkSessionChanged$(): Observable<boolean> {\r\n    return this.checkSessionService.checkSessionChanged$;\r\n  }\r\n\r\n  /**\r\n   * Emits on a Security Token Service callback. The observable will never contain a value.\r\n   */\r\n  get stsCallback$(): Observable<any> {\r\n    return this.callbackService.stsCallback$;\r\n  }\r\n\r\n  /**\r\n   * @deprecated This property should not be used. Please use the `PublicEventsService` instead. This property is removed in future versions\r\n   * Emits false when the observable, returned by one of the checkAuth() methods, emits a value, or errors. Initial value: true.\r\n   */\r\n  get isLoading$(): Observable<boolean> {\r\n    return this.isLoading.asObservable();\r\n  }\r\n\r\n  private readonly isLoading: BehaviorSubject<boolean> = new BehaviorSubject(true);\r\n\r\n  constructor(\r\n    private readonly checkSessionService: CheckSessionService,\r\n    private readonly checkAuthService: CheckAuthService,\r\n    private readonly userService: UserService,\r\n    private readonly tokenHelperService: TokenHelperService,\r\n    private readonly configurationService: ConfigurationService,\r\n    private readonly authStateService: AuthStateService,\r\n    private readonly flowsDataService: FlowsDataService,\r\n    private readonly callbackService: CallbackService,\r\n    private readonly logoffRevocationService: LogoffRevocationService,\r\n    private readonly loginService: LoginService,\r\n    private readonly refreshSessionService: RefreshSessionService,\r\n    private readonly urlService: UrlService,\r\n    private readonly authWellKnownService: AuthWellKnownService\r\n  ) {}\r\n\r\n  preloadAuthWellKnownDocument(configId?: string): Observable<AuthWellKnownEndpoints> {\r\n    return this.configurationService\r\n      .getOpenIDConfiguration(configId)\r\n      .pipe(switchMap((config) => this.authWellKnownService.queryAndStoreAuthWellKnownEndPoints(config)));\r\n  }\r\n\r\n  /**\r\n   * Returns the currently active OpenID configurations.\r\n   *\r\n   * @returns an array of OpenIdConfigurations.\r\n   */\r\n  getConfigurations(): OpenIdConfiguration[] {\r\n    return this.configurationService.getAllConfigurations();\r\n  }\r\n\r\n  /**\r\n   * Returns a single active OpenIdConfiguration.\r\n   *\r\n   * @param configId The configId to identify the config. If not passed, the first one is being returned\r\n   */\r\n  getConfiguration(configId?: string): Observable<OpenIdConfiguration> {\r\n    return this.configurationService.getOpenIDConfiguration(configId);\r\n  }\r\n\r\n  /**\r\n   * Returns the userData for a configuration\r\n   *\r\n   * @param configId The configId to identify the config. If not passed, the first one is being used\r\n   */\r\n  getUserData(configId?: string): Observable<any> {\r\n    return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => this.userService.getUserDataFromStore(config)));\r\n  }\r\n\r\n  /**\r\n   * Starts the complete setup flow for one configuration. Calling will start the entire authentication flow, and the returned observable\r\n   * will denote whether the user was successfully authenticated including the user data, the access token, the configId and\r\n   * an error message in case an error happened\r\n   *\r\n   * @param url The URL to perform the authorization on the behalf of.\r\n   * @param configId The configId to perform the authorization on the behalf of. If not passed, the first configs will be taken\r\n   *\r\n   * @returns An object `LoginResponse` containing all information about the login\r\n   */\r\n  checkAuth(url?: string, configId?: string): Observable<LoginResponse> {\r\n    return this.configurationService.getOpenIDConfigurations(configId).pipe(\r\n      switchMap(({ allConfigs, currentConfig }) => this.checkAuthService.checkAuth(currentConfig, allConfigs, url)),\r\n      tap(this.finishLoading),\r\n      catchError(this.finishLoadingOnError)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Starts the complete setup flow for multiple configurations.\r\n   * Calling will start the entire authentication flow, and the returned observable\r\n   * will denote whether the user was successfully authenticated including the user data, the access token, the configId and\r\n   * an error message in case an error happened in an array for each config which was provided\r\n   *\r\n   * @param url The URL to perform the authorization on the behalf of.\r\n   * @param configId The configId to perform the authorization on the behalf of. If not passed, all of the current\r\n   * configured ones will be used to check.\r\n   *\r\n   * @returns An array of `LoginResponse` objects containing all information about the logins\r\n   */\r\n  checkAuthMultiple(url?: string): Observable<LoginResponse[]> {\r\n    return this.configurationService.getOpenIDConfigurations().pipe(\r\n      switchMap(({ allConfigs }) => this.checkAuthService.checkAuthMultiple(allConfigs, url)),\r\n      tap(this.finishLoading),\r\n      catchError(this.finishLoadingOnError)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Provides information about the current authenticated state\r\n   *\r\n   * @param configId The configId to check the information for. If not passed, the first configs will be taken\r\n   *\r\n   * @returns A boolean whether the config is authenticated or not.\r\n   */\r\n  isAuthenticated(configId?: string): Observable<boolean> {\r\n    return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => this.authStateService.isAuthenticated(config)));\r\n  }\r\n\r\n  /**\r\n   * Checks the server for an authenticated session using the iframe silent renew if not locally authenticated.\r\n   */\r\n  checkAuthIncludingServer(configId?: string): Observable<LoginResponse> {\r\n    return this.configurationService.getOpenIDConfigurations(configId).pipe(\r\n      switchMap(({ allConfigs, currentConfig }) => this.checkAuthService.checkAuthIncludingServer(currentConfig, allConfigs)),\r\n      tap(this.finishLoading),\r\n      catchError(this.finishLoadingOnError)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Returns the access token for the login scenario.\r\n   *\r\n   * @param configId The configId to check the information for. If not passed, the first configs will be taken\r\n   *\r\n   * @returns A string with the access token.\r\n   */\r\n  getAccessToken(configId?: string): Observable<string> {\r\n    return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => this.authStateService.getAccessToken(config)));\r\n  }\r\n\r\n  /**\r\n   * Returns the ID token for the sign-in.\r\n   *\r\n   * @param configId The configId to check the information for. If not passed, the first configs will be taken\r\n   *\r\n   * @returns A string with the id token.\r\n   */\r\n  getIdToken(configId?: string): Observable<string> {\r\n    return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => this.authStateService.getIdToken(config)));\r\n  }\r\n\r\n  /**\r\n   * Returns the refresh token, if present, for the sign-in.\r\n   *\r\n   * @param configId The configId to check the information for. If not passed, the first configs will be taken\r\n   *\r\n   * @returns A string with the refresh token.\r\n   */\r\n  getRefreshToken(configId?: string): Observable<string> {\r\n    return this.configurationService.getOpenIDConfiguration(configId).pipe(map((config) => this.authStateService.getRefreshToken(config)));\r\n  }\r\n\r\n  /**\r\n   * Returns the authentication result, if present, for the sign-in.\r\n   *\r\n   * @param configId The configId to check the information for. If not passed, the first configs will be taken\r\n   *\r\n   * @returns A object with the authentication result\r\n   */\r\n  getAuthenticationResult(configId?: string): Observable<any> {\r\n    return this.configurationService\r\n      .getOpenIDConfiguration(configId)\r\n      .pipe(map((config) => this.authStateService.getAuthenticationResult(config)));\r\n  }\r\n\r\n  /**\r\n   * Returns the payload from the ID token.\r\n   *\r\n   * @param encode Set to true if the payload is base64 encoded\r\n   * @param configId The configId to check the information for. If not passed, the first configs will be taken\r\n   *\r\n   * @returns The payload from the id token.\r\n   */\r\n  getPayloadFromIdToken(encode = false, configId?: string): Observable<any> {\r\n    return this.configurationService.getOpenIDConfiguration(configId).pipe(\r\n      map((config) => {\r\n        const token = this.authStateService.getIdToken(config);\r\n\r\n        return this.tokenHelperService.getPayloadFromToken(token, encode, config);\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Returns the payload from the access token.\r\n   *\r\n   * @param encode Set to true if the payload is base64 encoded\r\n   * @param configId The configId to check the information for. If not passed, the first configs will be taken\r\n   *\r\n   * @returns The payload from the access token.\r\n   */\r\n  getPayloadFromAccessToken(encode = false, configId?: string): Observable<any> {\r\n    return this.configurationService.getOpenIDConfiguration(configId).pipe(\r\n      map((config) => {\r\n        const token = this.authStateService.getAccessToken(config);\r\n\r\n        return this.tokenHelperService.getPayloadFromToken(token, encode, config);\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Sets a custom state for the authorize request.\r\n   *\r\n   * @param state The state to set.\r\n   * @param configId The configId to check the information for. If not passed, the first configs will be taken\r\n   */\r\n  setState(state: string, configId?: string): Observable<boolean> {\r\n    return this.configurationService\r\n      .getOpenIDConfiguration(configId)\r\n      .pipe(map((config) => this.flowsDataService.setAuthStateControl(state, config)));\r\n  }\r\n\r\n  /**\r\n   * Gets the state value used for the authorize request.\r\n   *\r\n   * @param configId The configId to check the information for. If not passed, the first configs will be taken\r\n   *\r\n   * @returns The state value used for the authorize request.\r\n   */\r\n  getState(configId?: string): Observable<string> {\r\n    return this.configurationService\r\n      .getOpenIDConfiguration(configId)\r\n      .pipe(map((config) => this.flowsDataService.getAuthStateControl(config)));\r\n  }\r\n\r\n  /**\r\n   * Redirects the user to the Security Token Service to begin the authentication process.\r\n   *\r\n   * @param configId The configId to perform the action in behalf of. If not passed, the first configs will be taken\r\n   * @param authOptions The custom options for the the authentication request.\r\n   */\r\n  authorize(configId?: string, authOptions?: AuthOptions): void {\r\n    this.configurationService.getOpenIDConfiguration(configId).subscribe((config) => this.loginService.login(config, authOptions));\r\n  }\r\n\r\n  /**\r\n   * Opens the Security Token Service in a new window to begin the authentication process.\r\n   *\r\n   * @param authOptions The custom options for the authentication request.\r\n   * @param popupOptions The configuration for th