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

package/esm2022/lib/auth/basic-auth/content-auth.mjs

@@ -0,0 +1,189 @@
+/*!
+ * @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 { AdfHttpClient } from '@alfresco/adf-core/api';
+import { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';
+import { StorageService } from '../../common/services/storage.service';
+import { ReplaySubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../app-config/app-config.service";
+import * as i2 from "@alfresco/adf-core/api";
+import * as i3 from "../../common/services/storage.service";
+export class ContentAuth {
+    get basePath() {
+        const contextRootEcm = this.appConfigService.get(AppConfigValues.CONTEXTROOTECM) || 'alfresco';
+        return this.appConfigService.get(AppConfigValues.ECMHOST) + '/' + contextRootEcm + '/api/-default-/public/authentication/versions/1';
+    }
+    constructor(appConfigService, adfHttpClient, storageService) {
+        this.appConfigService = appConfigService;
+        this.adfHttpClient = adfHttpClient;
+        this.storageService = storageService;
+        this.onLogin = new ReplaySubject(1);
+        this.onLogout = new ReplaySubject(1);
+        this.onError = new Subject();
+        this.config = {
+            ticketEcm: null
+        };
+        this.authentications = {
+            basicAuth: {
+                ticket: ''
+            },
+            type: 'basic'
+        };
+        this.appConfigService.onLoad.subscribe(() => {
+            this.setConfig();
+        });
+    }
+    setConfig() {
+        if (this.storageService.getItem(AppConfigValues.CONTENT_TICKET_STORAGE_LABEL)) {
+            this.setTicket(this.storageService.getItem(AppConfigValues.CONTENT_TICKET_STORAGE_LABEL));
+        }
+    }
+    saveUsername(username) {
+        this.storageService.setItem('ACS_USERNAME', username);
+    }
+    getUsername() {
+        return this.storageService.getItem('ACS_USERNAME');
+    }
+    /**
+     * login Alfresco API
+     *
+     * @param username username to login
+     * @param password password to login
+     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.
+     */
+    login(username, password) {
+        this.authentications.basicAuth.username = username;
+        this.authentications.basicAuth.password = password;
+        const loginRequest = {};
+        loginRequest.userId = this.authentications.basicAuth.username;
+        loginRequest.password = this.authentications.basicAuth.password;
+        return new Promise((resolve, reject) => {
+            this.createTicket(loginRequest)
+                .then((data) => {
+                this.saveUsername(username);
+                this.setTicket(data.entry.id);
+                this.adfHttpClient.emit('success');
+                this.onLogin.next('success');
+                resolve(data.entry.id);
+            })
+                .catch((error) => {
+                this.saveUsername('');
+                if (error.status === 401) {
+                    this.adfHttpClient.emit('unauthorized', error);
+                    this.onError.next('unauthorized');
+                }
+                else if (error.status === 403) {
+                    this.adfHttpClient.emit('forbidden', error);
+                    this.onError.next('forbidden');
+                }
+                else {
+                    this.adfHttpClient.emit('error', error);
+                    this.onError.next('error');
+                }
+                reject(error);
+            });
+        });
+    }
+    /**
+     * logout Alfresco API
+     *
+     * @returns A promise that returns { authentication ticket} if resolved and {error} if rejected.
+     */
+    logout() {
+        this.saveUsername('');
+        return new Promise((resolve, reject) => {
+            this.deleteTicket().then(() => {
+                this.invalidateSession();
+                this.adfHttpClient.emit('logout');
+                this.onLogout.next('logout');
+                resolve('logout');
+            }, (error) => {
+                if (error.status === 401) {
+                    this.adfHttpClient.emit('unauthorized');
+                    this.onError.next('unauthorized');
+                }
+                this.adfHttpClient.emit('error');
+                this.onError.next('error');
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Set the current Ticket
+     *
+     * @param ticket a string representing the ticket
+     */
+    setTicket(ticket) {
+        this.authentications.basicAuth.username = 'ROLE_TICKET';
+        this.authentications.basicAuth.password = ticket;
+        this.config.ticketEcm = ticket;
+        this.storageService.setItem(AppConfigValues.CONTENT_TICKET_STORAGE_LABEL, ticket);
+        this.ticket = ticket;
+    }
+    /**
+     * @returns the current Ticket
+     */
+    getToken() {
+        if (!this.ticket) {
+            this.onError.next('error');
+        }
+        return this.ticket;
+    }
+    invalidateSession() {
+        this.storageService.removeItem(AppConfigValues.CONTENT_TICKET_STORAGE_LABEL);
+        this.authentications.basicAuth.username = null;
+        this.authentications.basicAuth.password = null;
+        this.config.ticketEcm = null;
+        this.ticket = null;
+    }
+    /**
+     * @returns If the client is logged in return true
+     */
+    isLoggedIn() {
+        return !!this.ticket;
+    }
+    /**
+     * @returns return the Authentication
+     */
+    getAuthentication() {
+        return this.authentications;
+    }
+    createTicket(ticketBodyCreate) {
+        if (ticketBodyCreate === null || ticketBodyCreate === undefined) {
+            this.onError.next(`Missing param ticketBodyCreate`);
+            throw new Error(`Missing param ticketBodyCreate`);
+        }
+        return this.adfHttpClient.post(this.basePath + '/tickets', { bodyParam: ticketBodyCreate });
+    }
+    async requireAlfTicket() {
+        const ticket = await this.adfHttpClient.get(this.basePath + '/tickets/-me-');
+        this.setTicket(ticket.entry.id);
+    }
+    deleteTicket() {
+        return this.adfHttpClient.delete(this.basePath + '/tickets/-me-');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentAuth, deps: [{ token: i1.AppConfigService }, { token: i2.AdfHttpClient }, { token: i3.StorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentAuth, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentAuth, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: i2.AdfHttpClient }, { type: i3.StorageService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-auth.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/basic-auth/content-auth.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 { AdfHttpClient } from '@alfresco/adf-core/api';\nimport { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';\nimport { StorageService } from '../../common/services/storage.service';\nimport { ReplaySubject, Subject } from 'rxjs';\nimport { Authentication } from '../interfaces/authentication.interface';\n\nexport interface TicketBody {\n    userId?: string;\n    password?: string;\n}\n\nexport interface TicketEntry {\n    entry: {\n        id?: string;\n        userId?: string;\n    };\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ContentAuth {\n    onLogin = new ReplaySubject<any>(1);\n    onLogout = new ReplaySubject<any>(1);\n    onError = new Subject<any>();\n\n    ticket: string;\n    config = {\n        ticketEcm: null\n    };\n\n    authentications: Authentication = {\n        basicAuth: {\n            ticket: ''\n        },\n        type: 'basic'\n    };\n\n    get basePath(): string {\n        const contextRootEcm = this.appConfigService.get<string>(AppConfigValues.CONTEXTROOTECM) || 'alfresco';\n        return this.appConfigService.get<string>(AppConfigValues.ECMHOST) + '/' + contextRootEcm + '/api/-default-/public/authentication/versions/1';\n    }\n\n    constructor(private appConfigService: AppConfigService, private adfHttpClient: AdfHttpClient, private storageService: StorageService) {\n        this.appConfigService.onLoad.subscribe(() => {\n            this.setConfig();\n        });\n    }\n\n    private setConfig() {\n        if (this.storageService.getItem(AppConfigValues.CONTENT_TICKET_STORAGE_LABEL)) {\n            this.setTicket(this.storageService.getItem(AppConfigValues.CONTENT_TICKET_STORAGE_LABEL));\n        }\n    }\n\n    saveUsername(username: string) {\n        this.storageService.setItem('ACS_USERNAME', username);\n    }\n\n    getUsername() {\n        return this.storageService.getItem('ACS_USERNAME');\n    }\n\n    /**\n     * login Alfresco API\n     *\n     * @param username username to login\n     * @param password password to login\n     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.\n     */\n    login(username: string, password: string): Promise<any> {\n        this.authentications.basicAuth.username = username;\n        this.authentications.basicAuth.password = password;\n\n        const loginRequest: any = {};\n\n        loginRequest.userId = this.authentications.basicAuth.username;\n        loginRequest.password = this.authentications.basicAuth.password;\n\n        return new Promise((resolve, reject) => {\n            this.createTicket(loginRequest)\n                .then((data: any) => {\n                    this.saveUsername(username);\n                    this.setTicket(data.entry.id);\n                    this.adfHttpClient.emit('success');\n                    this.onLogin.next('success');\n                    resolve(data.entry.id);\n                })\n                .catch((error) => {\n                    this.saveUsername('');\n                    if (error.status === 401) {\n                        this.adfHttpClient.emit('unauthorized', error);\n                        this.onError.next('unauthorized');\n                    } else if (error.status === 403) {\n                        this.adfHttpClient.emit('forbidden', error);\n                        this.onError.next('forbidden');\n                    } else {\n                        this.adfHttpClient.emit('error', error);\n                        this.onError.next('error');\n                    }\n                    reject(error);\n                });\n        });\n    }\n\n    /**\n     * logout Alfresco API\n     *\n     * @returns A promise that returns { authentication ticket} if resolved and {error} if rejected.\n     */\n    logout(): Promise<any> {\n        this.saveUsername('');\n        return new Promise((resolve, reject) => {\n            this.deleteTicket().then(\n                () => {\n                    this.invalidateSession();\n                    this.adfHttpClient.emit('logout');\n                    this.onLogout.next('logout');\n                    resolve('logout');\n                },\n                (error) => {\n                    if (error.status === 401) {\n                        this.adfHttpClient.emit('unauthorized');\n                        this.onError.next('unauthorized');\n                    }\n                    this.adfHttpClient.emit('error');\n                    this.onError.next('error');\n                    reject(error);\n                }\n            );\n        });\n    }\n\n    /**\n     * Set the current Ticket\n     *\n     * @param ticket a string representing the ticket\n     */\n    setTicket(ticket: string) {\n        this.authentications.basicAuth.username = 'ROLE_TICKET';\n        this.authentications.basicAuth.password = ticket;\n        this.config.ticketEcm = ticket;\n        this.storageService.setItem(AppConfigValues.CONTENT_TICKET_STORAGE_LABEL, ticket);\n        this.ticket = ticket;\n    }\n\n    /**\n     * @returns the current Ticket\n     */\n    getToken(): string {\n        if (!this.ticket) {\n            this.onError.next('error');\n        }\n\n        return this.ticket;\n    }\n\n    invalidateSession() {\n        this.storageService.removeItem(AppConfigValues.CONTENT_TICKET_STORAGE_LABEL);\n        this.authentications.basicAuth.username = null;\n        this.authentications.basicAuth.password = null;\n        this.config.ticketEcm = null;\n        this.ticket = null;\n    }\n\n    /**\n     * @returns If the client is logged in return true\n     */\n    isLoggedIn(): boolean {\n        return !!this.ticket;\n    }\n\n    /**\n     * @returns return the Authentication\n     */\n    getAuthentication() {\n        return this.authentications;\n    }\n\n    createTicket(ticketBodyCreate: TicketBody): Promise<TicketEntry> {\n        if (ticketBodyCreate === null || ticketBodyCreate === undefined) {\n            this.onError.next(`Missing param ticketBodyCreate`);\n\n            throw new Error(`Missing param ticketBodyCreate`);\n        }\n\n        return this.adfHttpClient.post(this.basePath + '/tickets', { bodyParam: ticketBodyCreate });\n    }\n\n    async requireAlfTicket(): Promise<void> {\n        const ticket = await this.adfHttpClient.get(this.basePath + '/tickets/-me-');\n        this.setTicket(ticket.entry.id);\n    }\n\n    deleteTicket(): Promise<any> {\n        return this.adfHttpClient.delete(this.basePath + '/tickets/-me-');\n    }\n}\n"]}

package/esm2022/lib/auth/basic-auth/process-auth.mjs

@@ -0,0 +1,193 @@
+/*!
+ * @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 { AdfHttpClient } from '@alfresco/adf-core/api';
+import { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';
+import { StorageService } from '../../common/services/storage.service';
+import { ReplaySubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../app-config/app-config.service";
+import * as i2 from "@alfresco/adf-core/api";
+import * as i3 from "../../common/services/storage.service";
+export class ProcessAuth {
+    get basePath() {
+        const contextRootBpm = this.appConfigService.get(AppConfigValues.CONTEXTROOTBPM) || 'activiti-app';
+        return this.appConfigService.get(AppConfigValues.BPMHOST) + '/' + contextRootBpm;
+    }
+    constructor(appConfigService, adfHttpClient, storageService) {
+        this.appConfigService = appConfigService;
+        this.adfHttpClient = adfHttpClient;
+        this.storageService = storageService;
+        this.onLogin = new ReplaySubject(1);
+        this.onLogout = new ReplaySubject(1);
+        this.onError = new Subject();
+        this.config = {
+            ticketBpm: null
+        };
+        this.authentications = {
+            basicAuth: { ticket: '' },
+            type: 'activiti'
+        };
+        this.appConfigService.onLoad.subscribe(() => {
+            this.setConfig();
+        });
+    }
+    setConfig() {
+        this.ticket = undefined;
+        this.setTicket(this.storageService.getItem(AppConfigValues.PROCESS_TICKET_STORAGE_LABEL));
+    }
+    saveUsername(username) {
+        this.storageService.setItem('APS_USERNAME', username);
+    }
+    getUsername() {
+        return this.storageService.getItem('APS_USERNAME');
+    }
+    /**
+     * login Activiti API
+     *
+     * @param username Username to login
+     * @param password Password to login
+     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.
+     */
+    login(username, password) {
+        this.authentications.basicAuth.username = username;
+        this.authentications.basicAuth.password = password;
+        const options = {
+            headerParams: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Cache-Control': 'no-cache'
+            },
+            formParams: {
+                j_username: this.authentications.basicAuth.username,
+                j_password: this.authentications.basicAuth.password,
+                _spring_security_remember_me: true,
+                submit: 'Login'
+            },
+            contentType: 'application/x-www-form-urlencoded',
+            accept: 'application/json'
+        };
+        const promise = new Promise((resolve, reject) => {
+            this.adfHttpClient.post(this.basePath + '/app/authentication', options).then(() => {
+                this.saveUsername(username);
+                const ticket = this.basicAuth(this.authentications.basicAuth.username, this.authentications.basicAuth.password);
+                this.setTicket(ticket);
+                this.onLogin.next('success');
+                this.adfHttpClient.emit('success');
+                this.adfHttpClient.emit('logged-in');
+                resolve(ticket);
+            }, (error) => {
+                this.saveUsername('');
+                if (error.status === 401) {
+                    this.adfHttpClient.emit('unauthorized', error);
+                    this.onError.next('unauthorized');
+                }
+                else if (error.status === 403) {
+                    this.adfHttpClient.emit('forbidden', error);
+                    this.onError.next('forbidden');
+                }
+                else {
+                    this.adfHttpClient.emit('error', error);
+                    this.onError.next('error');
+                }
+                reject(error);
+            });
+        });
+        return promise;
+    }
+    /**
+     * logout Alfresco API
+     *
+     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.
+     */
+    async logout() {
+        this.saveUsername('');
+        return new Promise((resolve, reject) => {
+            this.adfHttpClient.get(this.basePath + `/app/logout`, {}).then(() => {
+                this.invalidateSession();
+                this.onLogout.next('logout');
+                this.adfHttpClient.emit('logout');
+                resolve('logout');
+            }, (error) => {
+                if (error.status === 401) {
+                    this.adfHttpClient.emit('unauthorized');
+                    this.onError.next('unauthorized');
+                }
+                this.adfHttpClient.emit('error');
+                this.onError.next('error');
+                reject(error);
+            });
+        });
+    }
+    basicAuth(username, password) {
+        const str = username + ':' + password;
+        let base64;
+        if (typeof Buffer === 'function') {
+            base64 = Buffer.from(str.toString(), 'binary').toString('base64');
+        }
+        else {
+            base64 = btoa(str);
+        }
+        return `Basic ${base64}`;
+    }
+    /**
+     * Set the current Ticket
+     *
+     * @param ticket a string representing the ticket
+     */
+    setTicket(ticket) {
+        if (ticket && ticket !== 'null') {
+            this.authentications.basicAuth.ticket = ticket;
+            this.authentications.basicAuth.password = null;
+            this.config.ticketBpm = ticket;
+            this.storageService.setItem(AppConfigValues.PROCESS_TICKET_STORAGE_LABEL, ticket);
+            this.ticket = ticket;
+        }
+    }
+    invalidateSession() {
+        this.storageService.removeItem(AppConfigValues.PROCESS_TICKET_STORAGE_LABEL);
+        this.authentications.basicAuth.ticket = null;
+        this.authentications.basicAuth.password = null;
+        this.authentications.basicAuth.username = null;
+        this.config.ticketBpm = null;
+        this.ticket = null;
+    }
+    /**
+     * @returns the current Ticket
+     */
+    getToken() {
+        if (!this.ticket) {
+            this.onError.next('error');
+            return null;
+        }
+        return this.ticket;
+    }
+    /**
+     * @returns If the client is logged in return true
+     */
+    isLoggedIn() {
+        return !!this.ticket;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessAuth, deps: [{ token: i1.AppConfigService }, { token: i2.AdfHttpClient }, { token: i3.StorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessAuth, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessAuth, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: i2.AdfHttpClient }, { type: i3.StorageService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-auth.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/basic-auth/process-auth.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 { AdfHttpClient } from '@alfresco/adf-core/api';\nimport { Authentication } from '../interfaces/authentication.interface';\nimport { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';\nimport { StorageService } from '../../common/services/storage.service';\nimport { ReplaySubject, Subject } from 'rxjs';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ProcessAuth {\n    onLogin = new ReplaySubject<any>(1);\n    onLogout = new ReplaySubject<any>(1);\n    onError = new Subject<any>();\n\n    ticket: string;\n    config = {\n        ticketBpm: null\n    };\n\n    authentications: Authentication = {\n        basicAuth: { ticket: '' },\n        type: 'activiti'\n    };\n\n    get basePath(): string {\n        const contextRootBpm = this.appConfigService.get<string>(AppConfigValues.CONTEXTROOTBPM) || 'activiti-app';\n        return this.appConfigService.get<string>(AppConfigValues.BPMHOST) + '/' + contextRootBpm;\n    }\n\n    constructor(private appConfigService: AppConfigService, private adfHttpClient: AdfHttpClient, private storageService: StorageService) {\n        this.appConfigService.onLoad.subscribe(() => {\n            this.setConfig();\n        });\n    }\n\n    private setConfig() {\n        this.ticket = undefined;\n\n        this.setTicket(this.storageService.getItem(AppConfigValues.PROCESS_TICKET_STORAGE_LABEL));\n    }\n\n    saveUsername(username: string) {\n        this.storageService.setItem('APS_USERNAME', username);\n    }\n\n    getUsername() {\n        return this.storageService.getItem('APS_USERNAME');\n    }\n\n    /**\n     * login Activiti API\n     *\n     * @param username Username to login\n     * @param password Password to login\n     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.\n     */\n    login(username: string, password: string): Promise<any> {\n        this.authentications.basicAuth.username = username;\n        this.authentications.basicAuth.password = password;\n\n        const options = {\n            headerParams: {\n                'Content-Type': 'application/x-www-form-urlencoded',\n                'Cache-Control': 'no-cache'\n            },\n            formParams: {\n                j_username: this.authentications.basicAuth.username,\n                j_password: this.authentications.basicAuth.password,\n                _spring_security_remember_me: true,\n                submit: 'Login'\n            },\n            contentType: 'application/x-www-form-urlencoded',\n            accept: 'application/json'\n        };\n\n        const promise: any = new Promise((resolve, reject) => {\n            this.adfHttpClient.post(this.basePath + '/app/authentication', options).then(\n                () => {\n                    this.saveUsername(username);\n                    const ticket = this.basicAuth(this.authentications.basicAuth.username, this.authentications.basicAuth.password);\n                    this.setTicket(ticket);\n                    this.onLogin.next('success');\n                    this.adfHttpClient.emit('success');\n                    this.adfHttpClient.emit('logged-in');\n                    resolve(ticket);\n                },\n                (error) => {\n                    this.saveUsername('');\n                    if (error.status === 401) {\n                        this.adfHttpClient.emit('unauthorized', error);\n                        this.onError.next('unauthorized');\n                    } else if (error.status === 403) {\n                        this.adfHttpClient.emit('forbidden', error);\n                        this.onError.next('forbidden');\n                    } else {\n                        this.adfHttpClient.emit('error', error);\n                        this.onError.next('error');\n                    }\n                    reject(error);\n                }\n            );\n        });\n\n        return promise;\n    }\n\n    /**\n     * logout Alfresco API\n     *\n     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.\n     */\n    async logout(): Promise<any> {\n        this.saveUsername('');\n        return new Promise((resolve, reject) => {\n            this.adfHttpClient.get(this.basePath + `/app/logout`, {}).then(\n                () => {\n                    this.invalidateSession();\n                    this.onLogout.next('logout');\n                    this.adfHttpClient.emit('logout');\n                    resolve('logout');\n                },\n                (error) => {\n                    if (error.status === 401) {\n                        this.adfHttpClient.emit('unauthorized');\n                        this.onError.next('unauthorized');\n                    }\n                    this.adfHttpClient.emit('error');\n                    this.onError.next('error');\n                    reject(error);\n                }\n            );\n        });\n    }\n\n    basicAuth(username: string, password: string): string {\n        const str: any = username + ':' + password;\n\n        let base64;\n\n        if (typeof Buffer === 'function') {\n            base64 = Buffer.from(str.toString(), 'binary').toString('base64');\n        } else {\n            base64 = btoa(str);\n        }\n\n        return `Basic ${base64}`;\n    }\n\n    /**\n     * Set the current Ticket\n     *\n     * @param ticket a string representing the ticket\n     */\n    setTicket(ticket: string) {\n        if (ticket && ticket !== 'null') {\n            this.authentications.basicAuth.ticket = ticket;\n            this.authentications.basicAuth.password = null;\n            this.config.ticketBpm = ticket;\n            this.storageService.setItem(AppConfigValues.PROCESS_TICKET_STORAGE_LABEL, ticket);\n            this.ticket = ticket;\n        }\n    }\n\n    invalidateSession() {\n        this.storageService.removeItem(AppConfigValues.PROCESS_TICKET_STORAGE_LABEL);\n        this.authentications.basicAuth.ticket = null;\n        this.authentications.basicAuth.password = null;\n        this.authentications.basicAuth.username = null;\n        this.config.ticketBpm = null;\n        this.ticket = null;\n    }\n\n    /**\n     * @returns the current Ticket\n     */\n    getToken(): string {\n        if (!this.ticket) {\n            this.onError.next('error');\n            return null;\n        }\n\n        return this.ticket;\n    }\n\n    /**\n     * @returns If the client is logged in return true\n     */\n    isLoggedIn(): boolean {\n        return !!this.ticket;\n    }\n}\n"]}

package/esm2022/lib/auth/guard/auth-guard-bpm.service.mjs

@@ -0,0 +1,31 @@
+/*!
+ * @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 { inject } from '@angular/core';
+import { AuthenticationService } from '../services/authentication.service';
+import { AuthGuardService } from './auth-guard.service';
+export const AuthGuardBpm = async (_, state) => {
+    const authGuardBaseService = inject(AuthGuardService);
+    const authenticationService = inject(AuthenticationService);
+    if (authenticationService.isLoggedIn() && authenticationService.isOauth() && authGuardBaseService.isLoginFragmentPresent()) {
+        return authGuardBaseService.redirectSSOSuccessURL();
+    }
+    if (authenticationService.isBpmLoggedIn() || authGuardBaseService.withCredentials) {
+        return true;
+    }
+    return authGuardBaseService.redirectToUrl(state.url);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/guard/auth-guard-ecm.service.mjs

@@ -0,0 +1,31 @@
+/*!
+ * @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 { AuthenticationService } from '../services/authentication.service';
+import { AuthGuardService } from './auth-guard.service';
+import { inject } from '@angular/core';
+export const AuthGuardEcm = async (_, state) => {
+    const authGuardBaseService = inject(AuthGuardService);
+    const authenticationService = inject(AuthenticationService);
+    if (authenticationService.isLoggedIn() && authenticationService.isOauth() && authGuardBaseService.isLoginFragmentPresent()) {
+        return authGuardBaseService.redirectSSOSuccessURL();
+    }
+    if (authenticationService.isEcmLoggedIn() || authGuardBaseService.withCredentials) {
+        return true;
+    }
+    return authGuardBaseService.redirectToUrl(state.url);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/guard/auth-guard-sso-role.service.mjs

@@ -0,0 +1,57 @@
+/*!
+ * @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 { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { MatDialog } from '@angular/material/dialog';
+import { UserAccessService } from '../services/user-access.service';
+export const AuthGuardSsoRoleService = (route) => {
+    const userAccessService = inject(UserAccessService);
+    userAccessService.fetchUserAccess();
+    let hasRealmRole = false;
+    let hasClientRole = true;
+    if (route.data) {
+        if (route.data['roles']) {
+            const rolesToCheck = route.data['roles'];
+            if (rolesToCheck.length === 0) {
+                hasRealmRole = true;
+            }
+            else {
+                const excludedRoles = route.data['excludedRoles'] || [];
+                if (excludedRoles?.length > 0) {
+                    hasRealmRole = userAccessService.hasGlobalAccess(rolesToCheck) && !userAccessService.hasGlobalAccess(excludedRoles);
+                }
+                hasRealmRole = userAccessService.hasGlobalAccess(rolesToCheck);
+            }
+        }
+        if (route.data['clientRoles']) {
+            const clientRoleName = route.params[route.data['clientRoles']];
+            const rolesToCheck = route.data['roles'];
+            hasClientRole = userAccessService.hasApplicationAccess(clientRoleName, rolesToCheck);
+        }
+    }
+    const hasRole = hasRealmRole && hasClientRole;
+    if (!hasRole && route?.data?.['redirectUrl']) {
+        const router = inject(Router);
+        router.navigate(['/' + route.data['redirectUrl']]);
+    }
+    if (!hasRole) {
+        const dialog = inject(MatDialog);
+        dialog.closeAll();
+    }
+    return hasRole;
+};
+//# sourceMappingURL=data:application/json;base64,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