@alfresco/adf-core 8.1.0-16295248176 → 8.1.0-16342534841

package/esm2022/lib/auth/services/authentication.service.mjs

@@ -0,0 +1,190 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable, Injector } from '@angular/core';
+import { OidcAuthenticationService } from '../oidc/oidc-authentication.service';
+import { BasicAlfrescoAuthService } from '../basic-auth/basic-alfresco-auth.service';
+import { Subject, from } from 'rxjs';
+import { RedirectAuthService } from '../oidc/redirect-auth.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../oidc/redirect-auth.service";
+export class AuthenticationService {
+    constructor(injector, redirectAuthService) {
+        this.injector = injector;
+        this.redirectAuthService = redirectAuthService;
+        this.onLogin = new Subject();
+        this.onLogout = new Subject();
+        this.onTokenReceived = new Subject();
+        this.redirectAuthService.onLogin.subscribe((value) => this.onLogin.next(value));
+        this.redirectAuthService.onTokenReceived.subscribe((value) => this.onTokenReceived.next(value));
+        this.basicAlfrescoAuthService.onLogin.subscribe((value) => this.onLogin.next(value));
+        if (this.isOauth()) {
+            this.oidcAuthenticationService.onLogout.subscribe((value) => this.onLogout.next(value));
+        }
+        else {
+            this.basicAlfrescoAuthService.onLogout.subscribe((value) => this.onLogout.next(value));
+        }
+    }
+    get on() {
+        return this.isOauth() ? this.oidcAuthenticationService.on : this.basicAlfrescoAuthService.on;
+    }
+    get off() {
+        return this.isOauth() ? this.oidcAuthenticationService.off : this.basicAlfrescoAuthService.off;
+    }
+    get once() {
+        return this.isOauth() ? this.oidcAuthenticationService.once : this.basicAlfrescoAuthService.once;
+    }
+    get emit() {
+        return this.isOauth() ? this.oidcAuthenticationService.emit : this.basicAlfrescoAuthService.emit;
+    }
+    get onError() {
+        return this.isOauth() ? this.oidcAuthenticationService.onError : this.basicAlfrescoAuthService.onError;
+    }
+    addTokenToHeader(requestUrl, headersArg) {
+        return this.isOauth()
+            ? this.oidcAuthenticationService.addTokenToHeader(requestUrl, headersArg)
+            : this.basicAlfrescoAuthService.addTokenToHeader(requestUrl, headersArg);
+    }
+    isECMProvider() {
+        return this.isOauth() ? this.oidcAuthenticationService.isECMProvider() : this.basicAlfrescoAuthService.isECMProvider();
+    }
+    isBPMProvider() {
+        return this.isOauth() ? this.oidcAuthenticationService.isBPMProvider() : this.basicAlfrescoAuthService.isBPMProvider();
+    }
+    isALLProvider() {
+        return this.isOauth() ? this.oidcAuthenticationService.isALLProvider() : this.basicAlfrescoAuthService.isALLProvider();
+    }
+    get oidcAuthenticationService() {
+        return this.injector.get(OidcAuthenticationService);
+    }
+    get basicAlfrescoAuthService() {
+        return this.injector.get(BasicAlfrescoAuthService);
+    }
+    getToken() {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.getToken();
+        }
+        else {
+            return this.basicAlfrescoAuthService.getToken();
+        }
+    }
+    isLoggedIn() {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.isLoggedIn();
+        }
+        else {
+            return this.basicAlfrescoAuthService.isLoggedIn();
+        }
+    }
+    logout() {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.logout();
+        }
+        else {
+            return from(this.basicAlfrescoAuthService.logout());
+        }
+    }
+    isEcmLoggedIn() {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.isEcmLoggedIn();
+        }
+        else {
+            return this.basicAlfrescoAuthService.isEcmLoggedIn();
+        }
+    }
+    isBpmLoggedIn() {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.isBpmLoggedIn();
+        }
+        else {
+            return this.basicAlfrescoAuthService.isBpmLoggedIn();
+        }
+    }
+    reset() {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.reset();
+        }
+        else {
+            return this.basicAlfrescoAuthService.reset();
+        }
+    }
+    login(username, password, rememberMe) {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.loginWithPassword(username, password);
+        }
+        else {
+            return this.basicAlfrescoAuthService.login(username, password, rememberMe);
+        }
+    }
+    /**
+     * @returns the username of the authenticated user
+     */
+    getUsername() {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.getUsername();
+        }
+        else {
+            return this.basicAlfrescoAuthService.getUsername();
+        }
+    }
+    /**
+     * @deprecated
+     * @returns the logged username
+     */
+    getEcmUsername() {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.getUsername();
+        }
+        else {
+            return this.basicAlfrescoAuthService.getEcmUsername();
+        }
+    }
+    /**
+     * @deprecated
+     * @returns the logged username
+     */
+    getBpmUsername() {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.getUsername();
+        }
+        else {
+            return this.basicAlfrescoAuthService.getBpmUsername();
+        }
+    }
+    getAuthHeaders(requestUrl, headers) {
+        if (this.isOauth()) {
+            return this.oidcAuthenticationService.getAuthHeaders(requestUrl, headers);
+        }
+        else {
+            return this.basicAlfrescoAuthService.getAuthHeaders(requestUrl, headers);
+        }
+    }
+    isOauth() {
+        return this.basicAlfrescoAuthService.isOauth();
+    }
+    isKerberosEnabled() {
+        return !this.isOauth() ? this.basicAlfrescoAuthService.isKerberosEnabled() : false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthenticationService, deps: [{ token: i0.Injector }, { token: i1.RedirectAuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthenticationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthenticationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.RedirectAuthService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authentication.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/services/authentication.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Injectable, Injector } from '@angular/core';\nimport { OidcAuthenticationService } from '../oidc/oidc-authentication.service';\nimport { BasicAlfrescoAuthService } from '../basic-auth/basic-alfresco-auth.service';\nimport { Observable, Subject, from } from 'rxjs';\nimport { HttpHeaders } from '@angular/common/http';\nimport { AuthenticationServiceInterface } from '../interfaces/authentication-service.interface';\nimport ee from 'event-emitter';\nimport { RedirectAuthService } from '../oidc/redirect-auth.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class AuthenticationService implements AuthenticationServiceInterface, ee.Emitter {\n    onLogin: Subject<any> = new Subject<any>();\n    onLogout: Subject<any> = new Subject<any>();\n    onTokenReceived: Subject<any> = new Subject<any>();\n\n    constructor(private injector: Injector, private redirectAuthService: RedirectAuthService) {\n        this.redirectAuthService.onLogin.subscribe((value) => this.onLogin.next(value));\n\n        this.redirectAuthService.onTokenReceived.subscribe((value) => this.onTokenReceived.next(value));\n\n        this.basicAlfrescoAuthService.onLogin.subscribe((value) => this.onLogin.next(value));\n\n        if (this.isOauth()) {\n            this.oidcAuthenticationService.onLogout.subscribe((value) => this.onLogout.next(value));\n        } else {\n            this.basicAlfrescoAuthService.onLogout.subscribe((value) => this.onLogout.next(value));\n        }\n    }\n\n    get on(): ee.EmitterMethod {\n        return this.isOauth() ? this.oidcAuthenticationService.on : this.basicAlfrescoAuthService.on;\n    }\n\n    get off(): ee.EmitterMethod {\n        return this.isOauth() ? this.oidcAuthenticationService.off : this.basicAlfrescoAuthService.off;\n    }\n\n    get once(): ee.EmitterMethod {\n        return this.isOauth() ? this.oidcAuthenticationService.once : this.basicAlfrescoAuthService.once;\n    }\n\n    get emit(): (type: string, ...args: any[]) => void {\n        return this.isOauth() ? this.oidcAuthenticationService.emit : this.basicAlfrescoAuthService.emit;\n    }\n\n    get onError(): Observable<any> {\n        return this.isOauth() ? this.oidcAuthenticationService.onError : this.basicAlfrescoAuthService.onError;\n    }\n\n    addTokenToHeader(requestUrl: string, headersArg?: HttpHeaders): Observable<HttpHeaders> {\n        return this.isOauth()\n            ? this.oidcAuthenticationService.addTokenToHeader(requestUrl, headersArg)\n            : this.basicAlfrescoAuthService.addTokenToHeader(requestUrl, headersArg);\n    }\n\n    isECMProvider(): boolean {\n        return this.isOauth() ? this.oidcAuthenticationService.isECMProvider() : this.basicAlfrescoAuthService.isECMProvider();\n    }\n\n    isBPMProvider(): boolean {\n        return this.isOauth() ? this.oidcAuthenticationService.isBPMProvider() : this.basicAlfrescoAuthService.isBPMProvider();\n    }\n\n    isALLProvider(): boolean {\n        return this.isOauth() ? this.oidcAuthenticationService.isALLProvider() : this.basicAlfrescoAuthService.isALLProvider();\n    }\n\n    private get oidcAuthenticationService(): OidcAuthenticationService {\n        return this.injector.get(OidcAuthenticationService);\n    }\n\n    private get basicAlfrescoAuthService(): BasicAlfrescoAuthService {\n        return this.injector.get(BasicAlfrescoAuthService);\n    }\n\n    getToken(): string {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.getToken();\n        } else {\n            return this.basicAlfrescoAuthService.getToken();\n        }\n    }\n\n    isLoggedIn(): boolean {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.isLoggedIn();\n        } else {\n            return this.basicAlfrescoAuthService.isLoggedIn();\n        }\n    }\n\n    logout(): Observable<any> {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.logout();\n        } else {\n            return from(this.basicAlfrescoAuthService.logout());\n        }\n    }\n\n    isEcmLoggedIn(): boolean {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.isEcmLoggedIn();\n        } else {\n            return this.basicAlfrescoAuthService.isEcmLoggedIn();\n        }\n    }\n\n    isBpmLoggedIn(): boolean {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.isBpmLoggedIn();\n        } else {\n            return this.basicAlfrescoAuthService.isBpmLoggedIn();\n        }\n    }\n\n    reset(): void {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.reset();\n        } else {\n            return this.basicAlfrescoAuthService.reset();\n        }\n    }\n\n    login(username: string, password: string, rememberMe?: boolean): Observable<{ type: string; ticket: any }> {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.loginWithPassword(username, password);\n        } else {\n            return this.basicAlfrescoAuthService.login(username, password, rememberMe);\n        }\n    }\n\n    /**\n     * @returns the username of the authenticated user\n     */\n    getUsername(): string {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.getUsername();\n        } else {\n            return this.basicAlfrescoAuthService.getUsername();\n        }\n    }\n\n    /**\n     * @deprecated\n     * @returns the logged username\n     */\n    getEcmUsername(): string {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.getUsername();\n        } else {\n            return this.basicAlfrescoAuthService.getEcmUsername();\n        }\n    }\n\n    /**\n     * @deprecated\n     * @returns the logged username\n     */\n    getBpmUsername(): string {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.getUsername();\n        } else {\n            return this.basicAlfrescoAuthService.getBpmUsername();\n        }\n    }\n\n    getAuthHeaders(requestUrl: string, headers: HttpHeaders): HttpHeaders {\n        if (this.isOauth()) {\n            return this.oidcAuthenticationService.getAuthHeaders(requestUrl, headers);\n        } else {\n            return this.basicAlfrescoAuthService.getAuthHeaders(requestUrl, headers);\n        }\n    }\n\n    isOauth(): boolean {\n        return this.basicAlfrescoAuthService.isOauth();\n    }\n\n    isKerberosEnabled(): boolean {\n        return !this.isOauth() ? this.basicAlfrescoAuthService.isKerberosEnabled() : false;\n    }\n}\n"]}

package/esm2022/lib/auth/services/base-authentication.service.mjs

@@ -0,0 +1,99 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { HttpHeaders } from '@angular/common/http';
+import { Observable, ReplaySubject, throwError } from 'rxjs';
+import { AppConfigValues } from '../../app-config/app-config.service';
+import ee from 'event-emitter';
+export class BaseAuthenticationService {
+    constructor(appConfig, cookie) {
+        this.appConfig = appConfig;
+        this.cookie = cookie;
+        this.redirectUrl = null;
+        this.onError = new ReplaySubject(1);
+        this.onLogin = new ReplaySubject(1);
+        this.onLogout = new ReplaySubject(1);
+        ee(this);
+    }
+    /**
+     * Adds the auth token to an HTTP header using the 'bearer' scheme.
+     *
+     * @param requestUrl the request url
+     * @param headersArg Header that will receive the token
+     * @returns The new header with the token added
+     */
+    addTokenToHeader(requestUrl, headersArg) {
+        return new Observable((observer) => {
+            let headers = headersArg;
+            if (!headers) {
+                headers = new HttpHeaders();
+            }
+            try {
+                const header = this.getAuthHeaders(requestUrl, headers);
+                observer.next(header);
+                observer.complete();
+            }
+            catch (error) {
+                observer.error(error);
+            }
+        });
+    }
+    isECMProvider() {
+        const provider = this.appConfig.get('providers');
+        return provider && provider.toUpperCase() === 'ECM';
+    }
+    /**
+     * Does the provider support BPM?
+     *
+     * @returns True if supported, false otherwise
+     */
+    isBPMProvider() {
+        const provider = this.appConfig.get('providers');
+        if (provider && (typeof provider === 'string' || provider instanceof String)) {
+            return provider.toUpperCase() === 'BPM';
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Does the provider support both ECM and BPM?
+     *
+     * @returns True if both are supported, false otherwise
+     */
+    isALLProvider() {
+        const provider = this.appConfig.get('providers');
+        return provider && provider.toUpperCase() === 'ALL';
+    }
+    isOauthConfiguration() {
+        const authType = this.appConfig.get('authType');
+        return authType === 'OAUTH';
+    }
+    /**
+     * Prints an error message in the console browser
+     *
+     * @param error Error message
+     * @returns Object representing the error message
+     */
+    handleError(error) {
+        this.onError.next(error || 'Server error');
+        return throwError(() => error || 'Server error');
+    }
+    isOauth() {
+        return this.appConfig.get(AppConfigValues.AUTHTYPE) === 'OAUTH';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-authentication.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/services/base-authentication.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAE,UAAU,EAAY,aAAa,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AACvE,OAAO,EAAoB,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAGxF,OAAO,EAAE,MAAM,eAAe,CAAC;AAE/B,MAAM,OAAgB,yBAAyB;IAY3C,YAAgC,SAA2B,EAAY,MAAqB;QAA5D,cAAS,GAAT,SAAS,CAAkB;QAAY,WAAM,GAAN,MAAM,CAAe;QANlF,gBAAW,GAAqB,IAAI,CAAC;QAE/C,YAAO,GAAG,IAAI,aAAa,CAAM,CAAC,CAAC,CAAC;QACpC,YAAO,GAAG,IAAI,aAAa,CAAM,CAAC,CAAC,CAAC;QACpC,aAAQ,GAAG,IAAI,aAAa,CAAM,CAAC,CAAC,CAAC;QAGjC,EAAE,CAAC,IAAI,CAAC,CAAC;IACb,CAAC;IAoBD;;;;;;OAMG;IACH,gBAAgB,CAAC,UAAkB,EAAE,UAAwB;QACzD,OAAO,IAAI,UAAU,CAAC,CAAC,QAAuB,EAAE,EAAE;YAC9C,IAAI,OAAO,GAAG,UAAU,CAAC;YACzB,IAAI,CAAC,OAAO,EAAE,CAAC;gBACX,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;YAChC,CAAC;YACD,IAAI,CAAC;gBACD,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBAExD,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACtB,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACxB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACb,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC1B,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED,aAAa;QACT,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAW,CAAC;QAC3D,OAAO,QAAQ,IAAI,QAAQ,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACH,aAAa;QACT,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QACjD,IAAI,QAAQ,IAAI,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,YAAY,MAAM,CAAC,EAAE,CAAC;YAC3E,OAAO,QAAQ,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC;QAC5C,CAAC;aAAM,CAAC;YACJ,OAAO,KAAK,CAAC;QACjB,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,aAAa;QACT,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAW,CAAC;QAC3D,OAAO,QAAQ,IAAI,QAAQ,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC;IACxD,CAAC;IAED,oBAAoB;QAChB,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAW,CAAC;QAC1D,OAAO,QAAQ,KAAK,OAAO,CAAC;IAChC,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,KAAU;QAClB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,cAAc,CAAC,CAAC;QAC3C,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,cAAc,CAAC,CAAC;IACrD,CAAC;IAED,OAAO;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,QAAQ,CAAC,KAAK,OAAO,CAAC;IACpE,CAAC;CACJ","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { HttpHeaders } from '@angular/common/http';\nimport { RedirectionModel } from '../models/redirection.model';\nimport { Observable, Observer, ReplaySubject, throwError } from 'rxjs';\nimport { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';\nimport { CookieService } from '../../common/services/cookie.service';\nimport { AuthenticationServiceInterface } from '../interfaces/authentication-service.interface';\nimport ee from 'event-emitter';\n\nexport abstract class BaseAuthenticationService implements AuthenticationServiceInterface, ee.Emitter {\n    on: ee.EmitterMethod;\n    off: ee.EmitterMethod;\n    once: ee.EmitterMethod;\n    emit: (type: string, ...args: any[]) => void;\n\n    protected redirectUrl: RedirectionModel = null;\n\n    onError = new ReplaySubject<any>(1);\n    onLogin = new ReplaySubject<any>(1);\n    onLogout = new ReplaySubject<any>(1);\n\n    protected constructor(protected appConfig: AppConfigService, protected cookie: CookieService) {\n        ee(this);\n    }\n\n    abstract getAuthHeaders(requestUrl: string, header: HttpHeaders): HttpHeaders;\n\n    abstract getToken(): string;\n\n    abstract isLoggedIn(): boolean;\n\n    abstract logout(): any;\n\n    abstract isEcmLoggedIn(): boolean;\n\n    abstract isBpmLoggedIn(): boolean;\n\n    abstract reset(): void;\n\n    abstract getEcmUsername(): string;\n\n    abstract getBpmUsername(): string;\n\n    /**\n     * Adds the auth token to an HTTP header using the 'bearer' scheme.\n     *\n     * @param requestUrl the request url\n     * @param headersArg Header that will receive the token\n     * @returns The new header with the token added\n     */\n    addTokenToHeader(requestUrl: string, headersArg?: HttpHeaders): Observable<HttpHeaders> {\n        return new Observable((observer: Observer<any>) => {\n            let headers = headersArg;\n            if (!headers) {\n                headers = new HttpHeaders();\n            }\n            try {\n                const header = this.getAuthHeaders(requestUrl, headers);\n\n                observer.next(header);\n                observer.complete();\n            } catch (error) {\n                observer.error(error);\n            }\n        });\n    }\n\n    isECMProvider(): boolean {\n        const provider = this.appConfig.get('providers') as string;\n        return provider && provider.toUpperCase() === 'ECM';\n    }\n\n    /**\n     * Does the provider support BPM?\n     *\n     * @returns True if supported, false otherwise\n     */\n    isBPMProvider(): boolean {\n        const provider = this.appConfig.get('providers');\n        if (provider && (typeof provider === 'string' || provider instanceof String)) {\n            return provider.toUpperCase() === 'BPM';\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * Does the provider support both ECM and BPM?\n     *\n     * @returns True if both are supported, false otherwise\n     */\n    isALLProvider(): boolean {\n        const provider = this.appConfig.get('providers') as string;\n        return provider && provider.toUpperCase() === 'ALL';\n    }\n\n    isOauthConfiguration(): boolean {\n        const authType = this.appConfig.get('authType') as string;\n        return authType === 'OAUTH';\n    }\n\n    /**\n     * Prints an error message in the console browser\n     *\n     * @param error Error message\n     * @returns Object representing the error message\n     */\n    handleError(error: any): Observable<any> {\n        this.onError.next(error || 'Server error');\n        return throwError(() => error || 'Server error');\n    }\n\n    isOauth(): boolean {\n        return this.appConfig.get(AppConfigValues.AUTHTYPE) === 'OAUTH';\n    }\n}\n"]}

package/esm2022/lib/auth/services/identity-group.service.mjs

@@ -0,0 +1,269 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { AppConfigService } from '../../app-config/app-config.service';
+import { OAuth2Service } from './oauth2.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./oauth2.service";
+import * as i2 from "../../app-config/app-config.service";
+export class IdentityGroupService {
+    constructor(oAuth2Service, appConfigService) {
+        this.oAuth2Service = oAuth2Service;
+        this.appConfigService = appConfigService;
+    }
+    get identityHost() {
+        return `${this.appConfigService.get('identityHost')}`;
+    }
+    /**
+     * Gets all groups.
+     *
+     * @returns Array of group information objects
+     */
+    getGroups() {
+        const url = `${this.identityHost}/groups`;
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Gets available roles
+     *
+     * @param groupId Id of the group.
+     * @returns Array of available roles information objects
+     */
+    getAvailableRoles(groupId) {
+        const url = `${this.identityHost}/groups/${groupId}/role-mappings/realm/available`;
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Gets assigned roles
+     *
+     * @param groupId Id of the group.
+     * @returns Array of available roles
+     */
+    getAssignedRoles(groupId) {
+        const url = `${this.identityHost}/groups/${groupId}/role-mappings/realm`;
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Assigns roles to the group
+     *
+     * @param groupId The ID of the group
+     * @param roles Array of roles to assign
+     * @returns request result
+     */
+    assignRoles(groupId, roles) {
+        const url = `${this.identityHost}/groups/${groupId}/role-mappings/realm`;
+        const bodyParam = JSON.stringify(roles);
+        return this.oAuth2Service.post({ url, bodyParam });
+    }
+    /**
+     * Removes roles from the group
+     *
+     * @param groupId The ID of the group
+     * @param roles Array of roles to remove
+     * @returns request result
+     */
+    removeRoles(groupId, roles) {
+        const url = `${this.identityHost}/groups/${groupId}/role-mappings/realm`;
+        const bodyParam = JSON.stringify(roles);
+        return this.oAuth2Service.delete({ url, bodyParam });
+    }
+    /**
+     * Get effective roles
+     *
+     * @param groupId Id of the group
+     * @returns Array of effective roles
+     */
+    getEffectiveRoles(groupId) {
+        const url = `${this.identityHost}/groups/${groupId}/role-mappings/realm/composite`;
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Queries groups.
+     *
+     * @param requestQuery query settings
+     * @returns Array of user information objects
+     */
+    queryGroups(requestQuery) {
+        const url = `${this.identityHost}/groups`;
+        const queryParams = { first: requestQuery.first || 0, max: requestQuery.max || 5 };
+        return this.getTotalGroupsCount().pipe(switchMap((totalCount) => this.oAuth2Service.get({ url, queryParams }).pipe(map((response) => ({
+            entries: response,
+            pagination: {
+                skipCount: requestQuery.first,
+                maxItems: requestQuery.max,
+                count: totalCount.count,
+                hasMoreItems: false,
+                totalItems: totalCount.count
+            }
+        })))));
+    }
+    /**
+     * Gets groups total count.
+     *
+     * @returns Number of groups count.
+     */
+    getTotalGroupsCount() {
+        const url = `${this.identityHost}/groups/count`;
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Creates new group.
+     *
+     * @param newGroup Object of containing the new group details.
+     * @returns Empty response when the group created.
+     */
+    createGroup(newGroup) {
+        const url = `${this.identityHost}/groups`;
+        const bodyParam = newGroup;
+        return this.oAuth2Service.post({ url, bodyParam });
+    }
+    /**
+     * Updates group details.
+     *
+     * @param groupId Id of the targeted group.
+     * @param updatedGroup Object of containing the group details
+     * @returns Empty response when the group updated.
+     */
+    updateGroup(groupId, updatedGroup) {
+        const url = `${this.identityHost}/groups/${groupId}`;
+        const bodyParam = JSON.stringify(updatedGroup);
+        return this.oAuth2Service.put({ url, bodyParam });
+    }
+    /**
+     * Deletes Group.
+     *
+     * @param groupId Id of the group.
+     * @returns Empty response when the group deleted.
+     */
+    deleteGroup(groupId) {
+        const url = `${this.identityHost}/groups/${groupId}`;
+        return this.oAuth2Service.delete({ url });
+    }
+    /**
+     * Finds groups filtered by name.
+     *
+     * @param searchParams Object containing the name filter string
+     * @returns List of group information
+     */
+    findGroupsByName(searchParams) {
+        if (searchParams.name === '') {
+            return of([]);
+        }
+        const url = `${this.identityHost}/groups`;
+        const queryParams = { search: searchParams.name };
+        return this.oAuth2Service.get({ url, queryParams });
+    }
+    /**
+     * Gets details for a specified group.
+     *
+     * @param groupId Id of the target group
+     * @returns Group details
+     */
+    getGroupRoles(groupId) {
+        const url = this.buildRolesUrl(groupId);
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Check that a group has one or more roles from the supplied list.
+     *
+     * @param groupId Id of the target group
+     * @param roleNames Array of role names
+     * @returns True if the group has one or more of the roles, false otherwise
+     */
+    checkGroupHasRole(groupId, roleNames) {
+        return this.getGroupRoles(groupId).pipe(map((groupRoles) => {
+            let hasRole = false;
+            if (groupRoles?.length > 0) {
+                roleNames.forEach((roleName) => {
+                    const role = groupRoles.find(({ name }) => roleName === name);
+                    if (role) {
+                        hasRole = true;
+                        return;
+                    }
+                });
+            }
+            return hasRole;
+        }));
+    }
+    /**
+     * Gets the client Id using the app name.
+     *
+     * @param applicationName Name of the app
+     * @returns client Id string
+     */
+    getClientIdByApplicationName(applicationName) {
+        const url = `${this.identityHost}/clients`;
+        const queryParams = { clientId: applicationName };
+        return this.oAuth2Service.get({ url, queryParams }).pipe(map((response) => (response && response.length > 0 ? response[0].id : '')));
+    }
+    /**
+     * Gets client roles.
+     *
+     * @param groupId Id of the target group
+     * @param clientId Id of the client
+     * @returns List of roles
+     */
+    getClientRoles(groupId, clientId) {
+        const url = `${this.identityHost}/groups/${groupId}/role-mappings/clients/${clientId}`;
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Checks if a group has a client app.
+     *
+     * @param groupId Id of the target group
+     * @param clientId Id of the client
+     * @returns True if the group has the client app, false otherwise
+     */
+    checkGroupHasClientApp(groupId, clientId) {
+        return this.getClientRoles(groupId, clientId).pipe(map((response) => response && response.length > 0));
+    }
+    /**
+     * Check if a group has any of the client app roles in the supplied list.
+     *
+     * @param groupId Id of the target group
+     * @param clientId Id of the client
+     * @param roleNames Array of role names to check
+     * @returns True if the group has one or more of the roles, false otherwise
+     */
+    checkGroupHasAnyClientAppRole(groupId, clientId, roleNames) {
+        return this.getClientRoles(groupId, clientId).pipe(map((clientRoles) => {
+            let hasRole = false;
+            if (clientRoles.length > 0) {
+                roleNames.forEach((roleName) => {
+                    const role = clientRoles.find(({ name }) => name === roleName);
+                    if (role) {
+                        hasRole = true;
+                        return;
+                    }
+                });
+            }
+            return hasRole;
+        }));
+    }
+    buildRolesUrl(groupId) {
+        return `${this.identityHost}/groups/${groupId}/role-mappings/realm/composite`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdentityGroupService, deps: [{ token: i1.OAuth2Service }, { token: i2.AppConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdentityGroupService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdentityGroupService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.OAuth2Service }, { type: i2.AppConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity-group.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/services/identity-group.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Injectable } from '@angular/core';\nimport { Observable, of } from 'rxjs';\nimport { map, switchMap } from 'rxjs/operators';\nimport { AppConfigService } from '../../app-config/app-config.service';\nimport {\n    IdentityGroupSearchParam,\n    IdentityGroupQueryCloudRequestModel,\n    IdentityGroupModel,\n    IdentityGroupQueryResponse,\n    IdentityGroupCountModel\n} from '../models/identity-group.model';\nimport { IdentityRoleModel } from '../models/identity-role.model';\nimport { IdentityGroupServiceInterface } from '../interfaces/identity-group.interface';\nimport { OAuth2Service } from './oauth2.service';\n\n@Injectable({ providedIn: 'root' })\nexport class IdentityGroupService implements IdentityGroupServiceInterface {\n    constructor(private oAuth2Service: OAuth2Service, private appConfigService: AppConfigService) {}\n\n    private get identityHost(): string {\n        return `${this.appConfigService.get('identityHost')}`;\n    }\n\n    /**\n     * Gets all groups.\n     *\n     * @returns Array of group information objects\n     */\n    getGroups(): Observable<IdentityGroupModel[]> {\n        const url = `${this.identityHost}/groups`;\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Gets available roles\n     *\n     * @param groupId Id of the group.\n     * @returns Array of available roles information objects\n     */\n    getAvailableRoles(groupId: string): Observable<IdentityRoleModel[]> {\n        const url = `${this.identityHost}/groups/${groupId}/role-mappings/realm/available`;\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Gets assigned roles\n     *\n     * @param groupId Id of the group.\n     * @returns Array of available roles\n     */\n    getAssignedRoles(groupId: string): Observable<IdentityRoleModel[]> {\n        const url = `${this.identityHost}/groups/${groupId}/role-mappings/realm`;\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Assigns roles to the group\n     *\n     * @param groupId The ID of the group\n     * @param roles Array of roles to assign\n     * @returns request result\n     */\n    assignRoles(groupId: string, roles: IdentityRoleModel[]): Observable<any> {\n        const url = `${this.identityHost}/groups/${groupId}/role-mappings/realm`;\n        const bodyParam = JSON.stringify(roles);\n\n        return this.oAuth2Service.post({ url, bodyParam });\n    }\n\n    /**\n     * Removes roles from the group\n     *\n     * @param groupId The ID of the group\n     * @param roles Array of roles to remove\n     * @returns request result\n     */\n    removeRoles(groupId: string, roles: IdentityRoleModel[]): Observable<any> {\n        const url = `${this.identityHost}/groups/${groupId}/role-mappings/realm`;\n        const bodyParam = JSON.stringify(roles);\n\n        return this.oAuth2Service.delete({ url, bodyParam });\n    }\n\n    /**\n     * Get effective roles\n     *\n     * @param groupId Id of the group\n     * @returns Array of effective roles\n     */\n    getEffectiveRoles(groupId: string): Observable<IdentityRoleModel[]> {\n        const url = `${this.identityHost}/groups/${groupId}/role-mappings/realm/composite`;\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Queries groups.\n     *\n     * @param requestQuery query settings\n     * @returns Array of user information objects\n     */\n    queryGroups(requestQuery: IdentityGroupQueryCloudRequestModel): Observable<IdentityGroupQueryResponse> {\n        const url = `${this.identityHost}/groups`;\n        const queryParams = { first: requestQuery.first || 0, max: requestQuery.max || 5 };\n\n        return this.getTotalGroupsCount().pipe(\n            switchMap((totalCount: IdentityGroupCountModel) =>\n                this.oAuth2Service.get<any[]>({ url, queryParams }).pipe(\n                    map(\n                        (response) =>\n                            ({\n                                entries: response,\n                                pagination: {\n                                    skipCount: requestQuery.first,\n                                    maxItems: requestQuery.max,\n                                    count: totalCount.count,\n                                    hasMoreItems: false,\n                                    totalItems: totalCount.count\n                                }\n                            } as IdentityGroupQueryResponse)\n                    )\n                )\n            )\n        );\n    }\n\n    /**\n     * Gets groups total count.\n     *\n     * @returns Number of groups count.\n     */\n    getTotalGroupsCount(): Observable<IdentityGroupCountModel> {\n        const url = `${this.identityHost}/groups/count`;\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Creates new group.\n     *\n     * @param newGroup Object of containing the new group details.\n     * @returns Empty response when the group created.\n     */\n    createGroup(newGroup: IdentityGroupModel): Observable<any> {\n        const url = `${this.identityHost}/groups`;\n        const bodyParam = newGroup;\n\n        return this.oAuth2Service.post({ url, bodyParam });\n    }\n\n    /**\n     * Updates group details.\n     *\n     * @param groupId Id of the targeted group.\n     * @param updatedGroup Object of containing the group details\n     * @returns Empty response when the group updated.\n     */\n    updateGroup(groupId: string, updatedGroup: IdentityGroupModel): Observable<any> {\n        const url = `${this.identityHost}/groups/${groupId}`;\n        const bodyParam = JSON.stringify(updatedGroup);\n\n        return this.oAuth2Service.put({ url, bodyParam });\n    }\n\n    /**\n     * Deletes Group.\n     *\n     * @param groupId Id of the group.\n     * @returns Empty response when the group deleted.\n     */\n    deleteGroup(groupId: string): Observable<any> {\n        const url = `${this.identityHost}/groups/${groupId}`;\n        return this.oAuth2Service.delete({ url });\n    }\n\n    /**\n     * Finds groups filtered by name.\n     *\n     * @param searchParams Object containing the name filter string\n     * @returns List of group information\n     */\n    findGroupsByName(searchParams: IdentityGroupSearchParam): Observable<IdentityGroupModel[]> {\n        if (searchParams.name === '') {\n            return of([]);\n        }\n        const url = `${this.identityHost}/groups`;\n        const queryParams = { search: searchParams.name };\n\n        return this.oAuth2Service.get({ url, queryParams });\n    }\n\n    /**\n     * Gets details for a specified group.\n     *\n     * @param groupId Id of the target group\n     * @returns Group details\n     */\n    getGroupRoles(groupId: string): Observable<IdentityRoleModel[]> {\n        const url = this.buildRolesUrl(groupId);\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Check that a group has one or more roles from the supplied list.\n     *\n     * @param groupId Id of the target group\n     * @param roleNames Array of role names\n     * @returns True if the group has one or more of the roles, false otherwise\n     */\n    checkGroupHasRole(groupId: string, roleNames: string[]): Observable<boolean> {\n        return this.getGroupRoles(groupId).pipe(\n            map((groupRoles) => {\n                let hasRole = false;\n                if (groupRoles?.length > 0) {\n                    roleNames.forEach((roleName: string) => {\n                        const role = groupRoles.find(({ name }) => roleName === name);\n                        if (role) {\n                            hasRole = true;\n                            return;\n                        }\n                    });\n                }\n                return hasRole;\n            })\n        );\n    }\n\n    /**\n     * Gets the client Id using the app name.\n     *\n     * @param applicationName Name of the app\n     * @returns client Id string\n     */\n    getClientIdByApplicationName(applicationName: string): Observable<string> {\n        const url = `${this.identityHost}/clients`;\n        const queryParams = { clientId: applicationName };\n\n        return this.oAuth2Service.get<any[]>({ url, queryParams }).pipe(map((response) => (response && response.length > 0 ? response[0].id : '')));\n    }\n\n    /**\n     * Gets client roles.\n     *\n     * @param groupId Id of the target group\n     * @param clientId Id of the client\n     * @returns List of roles\n     */\n    getClientRoles(groupId: string, clientId: string): Observable<IdentityRoleModel[]> {\n        const url = `${this.identityHost}/groups/${groupId}/role-mappings/clients/${clientId}`;\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Checks if a group has a client app.\n     *\n     * @param groupId Id of the target group\n     * @param clientId Id of the client\n     * @returns True if the group has the client app, false otherwise\n     */\n    checkGroupHasClientApp(groupId: string, clientId: string): Observable<boolean> {\n        return this.getClientRoles(groupId, clientId).pipe(map((response) => response && response.length > 0));\n    }\n\n    /**\n     * Check if a group has any of the client app roles in the supplied list.\n     *\n     * @param groupId Id of the target group\n     * @param clientId Id of the client\n     * @param roleNames Array of role names to check\n     * @returns True if the group has one or more of the roles, false otherwise\n     */\n    checkGroupHasAnyClientAppRole(groupId: string, clientId: string, roleNames: string[]): Observable<boolean> {\n        return this.getClientRoles(groupId, clientId).pipe(\n            map((clientRoles: any[]) => {\n                let hasRole = false;\n                if (clientRoles.length > 0) {\n                    roleNames.forEach((roleName) => {\n                        const role = clientRoles.find(({ name }) => name === roleName);\n\n                        if (role) {\n                            hasRole = true;\n                            return;\n                        }\n                    });\n                }\n                return hasRole;\n            })\n        );\n    }\n\n    private buildRolesUrl(groupId: string): string {\n        return `${this.identityHost}/groups/${groupId}/role-mappings/realm/composite`;\n    }\n}\n"]}