@alfresco/adf-content-services 8.1.0-16116688508 → 8.1.0-16117584844

package/esm2022/lib/common/services/nodes-api.service.mjs

@@ -0,0 +1,251 @@
+/*!
+ * @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 { UserPreferencesService } from '@alfresco/adf-core';
+import { NodesApi, TrashcanApi } from '@alfresco/js-api';
+import { Injectable } from '@angular/core';
+import { from, Subject, throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { NodeMetadata } from '../models/node-metadata.model';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/alfresco-api.service";
+import * as i2 from "@alfresco/adf-core";
+export class NodesApiService {
+    get trashcanApi() {
+        this._trashcanApi = this._trashcanApi ?? new TrashcanApi(this.apiService.getInstance());
+        return this._trashcanApi;
+    }
+    get nodesApi() {
+        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());
+        return this._nodesApi;
+    }
+    constructor(apiService, preferences) {
+        this.apiService = apiService;
+        this.preferences = preferences;
+        /**
+         * Publish/subscribe to events related to node updates.
+         */
+        this.nodeUpdated = new Subject();
+    }
+    getEntryFromEntity(entity) {
+        return entity.entry;
+    }
+    /**
+     * Gets the stored information about a node.
+     *
+     * @param nodeId ID of the target node
+     * @param options Optional parameters supported by JS-API
+     * @returns Node information
+     */
+    getNode(nodeId, options = {}) {
+        const defaults = {
+            include: ['path', 'properties', 'allowableOperations', 'permissions']
+        };
+        const queryOptions = Object.assign(defaults, options);
+        return from(this.nodesApi.getNode(nodeId, queryOptions)).pipe(map(this.getEntryFromEntity), catchError((err) => throwError(err)));
+    }
+    /**
+     * Gets the items contained in a folder node.
+     *
+     * @param nodeId ID of the target node
+     * @param options Optional parameters supported by JS-API
+     * @returns List of child items from the folder
+     */
+    getNodeChildren(nodeId, options = {}) {
+        const defaults = {
+            maxItems: this.preferences.paginationSize,
+            skipCount: 0,
+            include: ['path', 'properties', 'allowableOperations', 'permissions']
+        };
+        const queryOptions = Object.assign(defaults, options);
+        return from(this.nodesApi.listNodeChildren(nodeId, queryOptions)).pipe(catchError((err) => throwError(err)));
+    }
+    /**
+     * Creates a new document node inside a folder.
+     *
+     * @param parentNodeId ID of the parent folder node
+     * @param nodeBody Data for the new node
+     * @param options Optional parameters supported by JS-API
+     * @returns Details of the new node
+     */
+    createNode(parentNodeId, nodeBody, options = {}) {
+        return from(this.nodesApi.createNode(parentNodeId, nodeBody, options)).pipe(map(this.getEntryFromEntity), catchError((err) => throwError(err)));
+    }
+    /**
+     * Creates a new folder node inside a parent folder.
+     *
+     * @param parentNodeId ID of the parent folder node
+     * @param nodeBody Data for the new folder
+     * @param options Optional parameters supported by JS-API
+     * @returns Details of the new folder
+     */
+    createFolder(parentNodeId, nodeBody, options = {}) {
+        const body = Object.assign({ nodeType: 'cm:folder' }, nodeBody);
+        return this.createNode(parentNodeId, body, options);
+    }
+    /**
+     * Updates the information about a node.
+     *
+     * @param nodeId ID of the target node
+     * @param nodeBody New data for the node
+     * @param options Optional parameters supported by JS-API
+     * @returns Updated node information
+     */
+    updateNode(nodeId, nodeBody, options = {}) {
+        const defaults = {
+            include: ['path', 'properties', 'allowableOperations', 'permissions', 'definition']
+        };
+        const queryOptions = Object.assign(defaults, options);
+        return from(this.nodesApi.updateNode(nodeId, nodeBody, queryOptions)).pipe(map(this.getEntryFromEntity), catchError((err) => throwError(err)));
+    }
+    /**
+     * Moves a node to the trashcan.
+     *
+     * @param nodeId ID of the target node
+     * @param options Optional parameters supported by JS-API
+     * @returns Empty result that notifies when the deletion is complete
+     */
+    deleteNode(nodeId, options = {}) {
+        return from(this.nodesApi.deleteNode(nodeId, options)).pipe(catchError((err) => throwError(err)));
+    }
+    /**
+     * Restores a node previously moved to the trashcan.
+     *
+     * @param nodeId ID of the node to restore
+     * @returns Details of the restored node
+     */
+    restoreNode(nodeId) {
+        return from(this.trashcanApi.restoreDeletedNode(nodeId)).pipe(map(this.getEntryFromEntity), catchError((err) => throwError(err)));
+    }
+    /**
+     * Get the metadata and the nodeType for a nodeId cleaned by the prefix.
+     *
+     * @param nodeId ID of the target node
+     * @returns Node metadata
+     */
+    getNodeMetadata(nodeId) {
+        return from(this.nodesApi.getNode(nodeId)).pipe(map(this.cleanMetadataFromSemicolon));
+    }
+    /**
+     * Gets the list of holds assigned to the node.
+     *
+     * @param nodeId ID of the target node
+     * @param options Optional parameters supported by JS-API
+     * @param options.includeSource Also include **source** (in addition to **entries**) with folder information on **nodeId**
+     * @returns List of assigned holds Observable<Hold[]>
+     */
+    getNodeAssignedHolds(nodeId, options) {
+        const queryOptions = Object.assign({ where: `(assocType='rma:frozenContent')` }, options);
+        return from(this.nodesApi.listParents(nodeId, queryOptions)).pipe(map(({ list }) => list.entries?.map(({ entry }) => ({
+            id: entry.id,
+            name: entry.name
+        }))));
+    }
+    /**
+     * Gets content for the given node.
+     *
+     * @param nodeId ID of the target node
+     * @returns Content data
+     */
+    getNodeContent(nodeId) {
+        return from(this.nodesApi.getNodeContent(nodeId)).pipe(catchError((err) => throwError(err)));
+    }
+    /**
+     * Create a new Node inside `-root-` folder
+     *
+     * @param name Node name
+     * @param nodeType Node type
+     * @param properties Node body properties
+     * @param path Path to the node
+     * @returns The created node
+     */
+    createNodeInsideRoot(name, nodeType, properties, path) {
+        const body = {
+            name,
+            nodeType,
+            properties,
+            relativePath: path
+        };
+        return from(this.nodesApi.createNode('-root-', body, {}));
+    }
+    /**
+     * Create a new Node from form metadata.
+     *
+     * @param nodeType Node type
+     * @param nameSpace Namespace for properties
+     * @param data Property data to store in the node under namespace
+     * @param path Path to the node
+     * @param name Node name
+     * @returns The created node
+     */
+    createNodeMetadata(nodeType, nameSpace, data, path, name) {
+        const properties = {};
+        for (const key in data) {
+            if (data[key]) {
+                properties[nameSpace + ':' + key] = data[key];
+            }
+        }
+        return this.createNodeInsideRoot(name || this.randomNodeName(), nodeType, properties, path);
+    }
+    /**
+     * Initiate a new request to calculate folder size.
+     *
+     * @param nodeId Node Id
+     * @returns The job id which can be used to track request status
+     */
+    initiateFolderSizeCalculation(nodeId) {
+        return from(this.nodesApi.initiateFolderSizeCalculation(nodeId));
+    }
+    /**
+     * Gets the size of a folder.
+     *
+     * @param nodeId Node Id
+     * @param jobId Job Id
+     * @returns Folder details
+     */
+    getFolderSizeInfo(nodeId, jobId) {
+        return from(this.nodesApi.getFolderSizeInfo(nodeId, jobId));
+    }
+    randomNodeName() {
+        return `node_${Date.now()}`;
+    }
+    cleanMetadataFromSemicolon(nodeEntry) {
+        const metadata = {};
+        if (nodeEntry?.entry.properties) {
+            for (const key in nodeEntry.entry.properties) {
+                if (key) {
+                    if (key.indexOf(':') !== -1) {
+                        metadata[key.split(':')[1]] = nodeEntry.entry.properties[key];
+                    }
+                    else {
+                        metadata[key] = nodeEntry.entry.properties[key];
+                    }
+                }
+            }
+        }
+        return new NodeMetadata(metadata, nodeEntry.entry.nodeType);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodesApiService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.UserPreferencesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodesApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodesApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.UserPreferencesService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodes-api.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/common/services/nodes-api.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 { UserPreferencesService } from '@alfresco/adf-core';\nimport {\n    ContentPagingQuery,\n    Node,\n    NodeAssignedHold,\n    NodeEntry,\n    NodePaging,\n    NodesApi,\n    NodesIncludeQuery,\n    TrashcanApi,\n    SizeDetailsEntry,\n    JobIdBodyEntry\n} from '@alfresco/js-api';\nimport { Injectable } from '@angular/core';\nimport { from, Observable, Subject, throwError } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport { NodeMetadata } from '../models/node-metadata.model';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class NodesApiService {\n    /**\n     * Publish/subscribe to events related to node updates.\n     */\n    nodeUpdated = new Subject<Node>();\n\n    private _trashcanApi: TrashcanApi;\n    get trashcanApi(): TrashcanApi {\n        this._trashcanApi = this._trashcanApi ?? new TrashcanApi(this.apiService.getInstance());\n        return this._trashcanApi;\n    }\n\n    private _nodesApi: NodesApi;\n    get nodesApi(): NodesApi {\n        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());\n        return this._nodesApi;\n    }\n\n    constructor(private apiService: AlfrescoApiService, private preferences: UserPreferencesService) {}\n\n    private getEntryFromEntity(entity: NodeEntry): Node {\n        return entity.entry;\n    }\n\n    /**\n     * Gets the stored information about a node.\n     *\n     * @param nodeId ID of the target node\n     * @param options Optional parameters supported by JS-API\n     * @returns Node information\n     */\n    getNode(nodeId: string, options: any = {}): Observable<Node> {\n        const defaults = {\n            include: ['path', 'properties', 'allowableOperations', 'permissions']\n        };\n        const queryOptions = Object.assign(defaults, options);\n\n        return from(this.nodesApi.getNode(nodeId, queryOptions)).pipe(\n            map(this.getEntryFromEntity),\n            catchError((err) => throwError(err))\n        );\n    }\n\n    /**\n     * Gets the items contained in a folder node.\n     *\n     * @param nodeId ID of the target node\n     * @param options Optional parameters supported by JS-API\n     * @returns List of child items from the folder\n     */\n    getNodeChildren(nodeId: string, options: any = {}): Observable<NodePaging> {\n        const defaults = {\n            maxItems: this.preferences.paginationSize,\n            skipCount: 0,\n            include: ['path', 'properties', 'allowableOperations', 'permissions']\n        };\n        const queryOptions = Object.assign(defaults, options);\n\n        return from(this.nodesApi.listNodeChildren(nodeId, queryOptions)).pipe(catchError((err) => throwError(err)));\n    }\n\n    /**\n     * Creates a new document node inside a folder.\n     *\n     * @param parentNodeId ID of the parent folder node\n     * @param nodeBody Data for the new node\n     * @param options Optional parameters supported by JS-API\n     * @returns Details of the new node\n     */\n    createNode(parentNodeId: string, nodeBody: any, options: any = {}): Observable<Node> {\n        return from(this.nodesApi.createNode(parentNodeId, nodeBody, options)).pipe(\n            map(this.getEntryFromEntity),\n            catchError((err) => throwError(err))\n        );\n    }\n\n    /**\n     * Creates a new folder node inside a parent folder.\n     *\n     * @param parentNodeId ID of the parent folder node\n     * @param nodeBody Data for the new folder\n     * @param options Optional parameters supported by JS-API\n     * @returns Details of the new folder\n     */\n    createFolder(parentNodeId: string, nodeBody: any, options: any = {}): Observable<Node> {\n        const body = Object.assign({ nodeType: 'cm:folder' }, nodeBody);\n        return this.createNode(parentNodeId, body, options);\n    }\n\n    /**\n     * Updates the information about a node.\n     *\n     * @param nodeId ID of the target node\n     * @param nodeBody New data for the node\n     * @param options Optional parameters supported by JS-API\n     * @returns Updated node information\n     */\n    updateNode(nodeId: string, nodeBody: any, options: any = {}): Observable<Node> {\n        const defaults = {\n            include: ['path', 'properties', 'allowableOperations', 'permissions', 'definition']\n        };\n        const queryOptions = Object.assign(defaults, options);\n\n        return from(this.nodesApi.updateNode(nodeId, nodeBody, queryOptions)).pipe(\n            map(this.getEntryFromEntity),\n            catchError((err) => throwError(err))\n        );\n    }\n\n    /**\n     * Moves a node to the trashcan.\n     *\n     * @param nodeId ID of the target node\n     * @param options Optional parameters supported by JS-API\n     * @returns Empty result that notifies when the deletion is complete\n     */\n    deleteNode(nodeId: string, options: any = {}): Observable<any> {\n        return from(this.nodesApi.deleteNode(nodeId, options)).pipe(catchError((err) => throwError(err)));\n    }\n\n    /**\n     * Restores a node previously moved to the trashcan.\n     *\n     * @param nodeId ID of the node to restore\n     * @returns Details of the restored node\n     */\n    restoreNode(nodeId: string): Observable<Node> {\n        return from(this.trashcanApi.restoreDeletedNode(nodeId)).pipe(\n            map(this.getEntryFromEntity),\n            catchError((err) => throwError(err))\n        );\n    }\n\n    /**\n     * Get the metadata and the nodeType for a nodeId cleaned by the prefix.\n     *\n     * @param nodeId ID of the target node\n     * @returns Node metadata\n     */\n    getNodeMetadata(nodeId: string): Observable<NodeMetadata> {\n        return from(this.nodesApi.getNode(nodeId)).pipe(map(this.cleanMetadataFromSemicolon));\n    }\n\n    /**\n     * Gets the list of holds assigned to the node.\n     *\n     * @param nodeId ID of the target node\n     * @param options Optional parameters supported by JS-API\n     * @param options.includeSource Also include **source** (in addition to **entries**) with folder information on **nodeId**\n     * @returns List of assigned holds Observable<Hold[]>\n     */\n    getNodeAssignedHolds(\n        nodeId: string,\n        options?: {\n            includeSource?: boolean;\n        } & NodesIncludeQuery &\n            ContentPagingQuery\n    ): Observable<NodeAssignedHold[]> {\n        const queryOptions = Object.assign({ where: `(assocType='rma:frozenContent')` }, options);\n\n        return from(this.nodesApi.listParents(nodeId, queryOptions)).pipe(\n            map(({ list }) =>\n                list.entries?.map(({ entry }) => ({\n                    id: entry.id,\n                    name: entry.name\n                }))\n            )\n        );\n    }\n\n    /**\n     * Gets content for the given node.\n     *\n     * @param nodeId ID of the target node\n     * @returns Content data\n     */\n    getNodeContent(nodeId: string): Observable<any> {\n        return from(this.nodesApi.getNodeContent(nodeId)).pipe(catchError((err) => throwError(err)));\n    }\n\n    /**\n     * Create a new Node inside `-root-` folder\n     *\n     * @param name Node name\n     * @param nodeType Node type\n     * @param properties Node body properties\n     * @param path Path to the node\n     * @returns The created node\n     */\n    createNodeInsideRoot(name: string, nodeType: string, properties: any, path: string): Observable<NodeEntry> {\n        const body = {\n            name,\n            nodeType,\n            properties,\n            relativePath: path\n        };\n        return from(this.nodesApi.createNode('-root-', body, {}));\n    }\n\n    /**\n     * Create a new Node from form metadata.\n     *\n     * @param nodeType Node type\n     * @param nameSpace Namespace for properties\n     * @param data Property data to store in the node under namespace\n     * @param path Path to the node\n     * @param name Node name\n     * @returns The created node\n     */\n    createNodeMetadata(nodeType: string, nameSpace: any, data: any, path: string, name?: string): Observable<NodeEntry> {\n        const properties = {};\n        for (const key in data) {\n            if (data[key]) {\n                properties[nameSpace + ':' + key] = data[key];\n            }\n        }\n\n        return this.createNodeInsideRoot(name || this.randomNodeName(), nodeType, properties, path);\n    }\n\n    /**\n     * Initiate a new request to calculate folder size.\n     *\n     * @param nodeId Node Id\n     * @returns The job id which can be used to track request status\n     */\n    initiateFolderSizeCalculation(nodeId: string): Observable<JobIdBodyEntry> {\n        return from(this.nodesApi.initiateFolderSizeCalculation(nodeId));\n    }\n\n    /**\n     * Gets the size of a folder.\n     *\n     * @param nodeId Node Id\n     * @param jobId Job Id\n     * @returns Folder details\n     */\n    getFolderSizeInfo(nodeId: string, jobId: string): Observable<SizeDetailsEntry> {\n        return from(this.nodesApi.getFolderSizeInfo(nodeId, jobId));\n    }\n\n    private randomNodeName(): string {\n        return `node_${Date.now()}`;\n    }\n\n    private cleanMetadataFromSemicolon(nodeEntry: NodeEntry): NodeMetadata {\n        const metadata = {};\n\n        if (nodeEntry?.entry.properties) {\n            for (const key in nodeEntry.entry.properties) {\n                if (key) {\n                    if (key.indexOf(':') !== -1) {\n                        metadata[key.split(':')[1]] = nodeEntry.entry.properties[key];\n                    } else {\n                        metadata[key] = nodeEntry.entry.properties[key];\n                    }\n                }\n            }\n        }\n\n        return new NodeMetadata(metadata, nodeEntry.entry.nodeType);\n    }\n}\n"]}

package/esm2022/lib/common/services/people-content.service.mjs

@@ -0,0 +1,138 @@
+/*!
+ * @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 { from, of } from 'rxjs';
+import { AuthenticationService } from '@alfresco/adf-core';
+import { map, tap } from 'rxjs/operators';
+import { PeopleApi } from '@alfresco/js-api';
+import { EcmUserModel } from '../models/ecm-user.model';
+import { ContentService } from './content.service';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/alfresco-api.service";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "./content.service";
+export class PeopleContentService {
+    get peopleApi() {
+        this._peopleApi = this._peopleApi ?? new PeopleApi(this.apiService.getInstance());
+        return this._peopleApi;
+    }
+    constructor(apiService, authenticationService, contentService) {
+        this.apiService = apiService;
+        this.contentService = contentService;
+        authenticationService.onLogout.subscribe(() => {
+            this.resetLocalCurrentUser();
+        });
+    }
+    /**
+     * Gets information about a user identified by their username.
+     *
+     * @param personId ID of the target user
+     * @returns User information
+     */
+    getPerson(personId) {
+        return from(this.peopleApi.getPerson(personId)).pipe(map((personEntry) => new EcmUserModel(personEntry.entry)));
+    }
+    getCurrentPerson() {
+        return this.getCurrentUserInfo();
+    }
+    /**
+     * Gets information about the current user alias -me-
+     *
+     * @returns User information
+     */
+    getCurrentUserInfo() {
+        if (this.currentUser) {
+            return of(this.currentUser);
+        }
+        return this.getPerson('-me-').pipe(tap((user) => (this.currentUser = user)));
+    }
+    /**
+     * Used to know if the current user has the admin capability
+     *
+     * @returns true or false
+     */
+    isCurrentUserAdmin() {
+        return this.currentUser?.isAdmin() ?? false;
+    }
+    /**
+     * Reset the local current user object
+     */
+    resetLocalCurrentUser() {
+        this.currentUser = undefined;
+    }
+    /**
+     * Gets a list of people.
+     *
+     * @param requestQuery maxItems and skipCount parameters supported by JS-API
+     * @returns Response containing pagination and list of entries
+     */
+    listPeople(requestQuery) {
+        const requestQueryParams = { skipCount: requestQuery?.skipCount, maxItems: requestQuery?.maxItems };
+        const orderBy = this.buildOrderArray(requestQuery?.sorting);
+        if (orderBy.length) {
+            requestQueryParams['orderBy'] = orderBy;
+        }
+        const promise = this.peopleApi.listPeople(requestQueryParams);
+        return from(promise).pipe(map((response) => ({
+            pagination: response.list.pagination,
+            entries: response.list.entries.map((person) => person.entry)
+        })));
+    }
+    /**
+     * Creates new person.
+     *
+     * @param newPerson Object containing the new person details.
+     * @param opts Optional parameters
+     * @returns Created new person
+     */
+    createPerson(newPerson, opts) {
+        return from(this.peopleApi.createPerson(newPerson, opts)).pipe(map((res) => res?.entry));
+    }
+    /**
+     * Updates the person details
+     *
+     * @param personId The identifier of a person
+     * @param details The person details
+     * @param opts Optional parameters
+     * @returns Updated person model
+     */
+    updatePerson(personId, details, opts) {
+        return from(this.peopleApi.updatePerson(personId, details, opts)).pipe(map((res) => res?.entry));
+    }
+    /**
+     * Returns a profile image as a URL.
+     *
+     * @param avatarId Target avatar
+     * @returns Image URL
+     */
+    getUserProfileImage(avatarId) {
+        return this.contentService.getContentUrl(avatarId);
+    }
+    buildOrderArray(sorting) {
+        return sorting?.orderBy && sorting?.direction ? [`${sorting.orderBy} ${sorting.direction.toUpperCase()}`] : [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PeopleContentService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.AuthenticationService }, { token: i3.ContentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PeopleContentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PeopleContentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.AuthenticationService }, { type: i3.ContentService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"people-content.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/common/services/people-content.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 { from, Observable, of } from 'rxjs';\nimport { AuthenticationService } from '@alfresco/adf-core';\nimport { map, tap } from 'rxjs/operators';\nimport { Pagination, PeopleApi, PersonBodyCreate, PersonBodyUpdate } from '@alfresco/js-api';\nimport { EcmUserModel } from '../models/ecm-user.model';\nimport { ContentService } from './content.service';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\n\nexport interface PeopleContentQueryResponse {\n    pagination: Pagination;\n    entries: EcmUserModel[];\n}\n\nexport interface PeopleContentSortingModel {\n    orderBy: string;\n    direction: string;\n}\n\nexport interface PeopleContentQueryRequestModel {\n    skipCount?: number;\n    maxItems?: number;\n    sorting?: PeopleContentSortingModel;\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class PeopleContentService {\n    private currentUser: EcmUserModel;\n\n    private _peopleApi: PeopleApi;\n    get peopleApi(): PeopleApi {\n        this._peopleApi = this._peopleApi ?? new PeopleApi(this.apiService.getInstance());\n        return this._peopleApi;\n    }\n\n    constructor(private apiService: AlfrescoApiService, authenticationService: AuthenticationService, private contentService: ContentService) {\n        authenticationService.onLogout.subscribe(() => {\n            this.resetLocalCurrentUser();\n        });\n    }\n\n    /**\n     * Gets information about a user identified by their username.\n     *\n     * @param personId ID of the target user\n     * @returns User information\n     */\n    getPerson(personId: string): Observable<EcmUserModel> {\n        return from(this.peopleApi.getPerson(personId)).pipe(map((personEntry) => new EcmUserModel(personEntry.entry)));\n    }\n\n    getCurrentPerson(): Observable<EcmUserModel> {\n        return this.getCurrentUserInfo();\n    }\n\n    /**\n     * Gets information about the current user alias -me-\n     *\n     * @returns User information\n     */\n    getCurrentUserInfo(): Observable<EcmUserModel> {\n        if (this.currentUser) {\n            return of(this.currentUser);\n        }\n        return this.getPerson('-me-').pipe(tap((user) => (this.currentUser = user)));\n    }\n\n    /**\n     * Used to know if the current user has the admin capability\n     *\n     * @returns true or false\n     */\n    isCurrentUserAdmin(): boolean {\n        return this.currentUser?.isAdmin() ?? false;\n    }\n\n    /**\n     * Reset the local current user object\n     */\n    resetLocalCurrentUser() {\n        this.currentUser = undefined;\n    }\n\n    /**\n     * Gets a list of people.\n     *\n     * @param requestQuery maxItems and skipCount parameters supported by JS-API\n     * @returns Response containing pagination and list of entries\n     */\n    listPeople(requestQuery?: PeopleContentQueryRequestModel): Observable<PeopleContentQueryResponse> {\n        const requestQueryParams = { skipCount: requestQuery?.skipCount, maxItems: requestQuery?.maxItems };\n        const orderBy = this.buildOrderArray(requestQuery?.sorting);\n        if (orderBy.length) {\n            requestQueryParams['orderBy'] = orderBy;\n        }\n\n        const promise = this.peopleApi.listPeople(requestQueryParams);\n        return from(promise).pipe(\n            map((response) => ({\n                pagination: response.list.pagination,\n                entries: response.list.entries.map((person) => person.entry as EcmUserModel)\n            }))\n        );\n    }\n\n    /**\n     * Creates new person.\n     *\n     * @param newPerson Object containing the new person details.\n     * @param opts Optional parameters\n     * @returns Created new person\n     */\n    createPerson(newPerson: PersonBodyCreate, opts?: any): Observable<EcmUserModel> {\n        return from(this.peopleApi.createPerson(newPerson, opts)).pipe(map((res) => res?.entry as EcmUserModel));\n    }\n\n    /**\n     * Updates the person details\n     *\n     * @param personId The identifier of a person\n     * @param details The person details\n     * @param opts Optional parameters\n     * @returns Updated person model\n     */\n    updatePerson(personId: string, details: PersonBodyUpdate, opts?: any): Observable<EcmUserModel> {\n        return from(this.peopleApi.updatePerson(personId, details, opts)).pipe(map((res) => res?.entry as EcmUserModel));\n    }\n\n    /**\n     * Returns a profile image as a URL.\n     *\n     * @param avatarId Target avatar\n     * @returns Image URL\n     */\n    getUserProfileImage(avatarId: string): string {\n        return this.contentService.getContentUrl(avatarId);\n    }\n\n    private buildOrderArray(sorting: PeopleContentSortingModel): string[] {\n        return sorting?.orderBy && sorting?.direction ? [`${sorting.orderBy} ${sorting.direction.toUpperCase()}`] : [];\n    }\n}\n"]}