@alfresco/adf-process-services-cloud 8.1.0-15469386840 → 8.1.0-15484232623

package/esm2022/lib/process/process-list/services/process-list-cloud.service.mjs

@@ -0,0 +1,253 @@
+/*!
+ * @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 { throwError } from 'rxjs';
+import { BaseCloudService } from '../../../services/base-cloud.service';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class ProcessListCloudService extends BaseCloudService {
+    getProcess(callback, defaultQueryUrl, requestNode, queryUrl) {
+        if (requestNode.appName || requestNode.appName === '') {
+            queryUrl = queryUrl || `${this.getBasePath(requestNode.appName)}/${defaultQueryUrl}`;
+            const queryParams = this.buildQueryParams(requestNode);
+            const sortingParams = this.buildSortingParam(requestNode.sorting);
+            if (sortingParams) {
+                queryParams['sort'] = sortingParams;
+            }
+            return callback(queryUrl, queryParams).pipe(map((response) => {
+                const entries = response.list?.entries;
+                if (entries) {
+                    // TODO: this is a hack of the model and needs to be revisited
+                    response.list.entries = entries.map((entryData) => entryData.entry);
+                }
+                return response;
+            }));
+        }
+        else {
+            return throwError('Appname not configured');
+        }
+    }
+    /**
+     * Finds a process using an object with optional query properties.
+     *
+     * @deprecated From Activiti 8.7.0 forward, use ProcessListCloudService.fetchProcessList instead.
+     * @param requestNode Query object
+     * @param queryUrl Query url
+     * @returns Process information
+     */
+    getProcessByRequest(requestNode, queryUrl) {
+        const callback = (url, queryParams) => this.get(url, queryParams);
+        const defaultQueryUrl = 'query/v1/process-instances';
+        return this.getProcess(callback, defaultQueryUrl, requestNode, queryUrl);
+    }
+    /**
+     * Available from Activiti version 8.7.0 onwards.
+     * Retrieves a list of processes using an object with optional query properties.
+     *
+     * @param requestNode Query object
+     * @param queryUrl Query url
+     * @returns List of processes
+     */
+    fetchProcessList(requestNode, queryUrl) {
+        if (!requestNode?.appName) {
+            return throwError(() => new Error('Appname not configured'));
+        }
+        queryUrl = queryUrl || `${this.getBasePath(requestNode.appName)}/query/v1/process-instances/search`;
+        const queryParams = {
+            maxItems: requestNode.pagination?.maxItems || 25,
+            skipCount: requestNode.pagination?.skipCount || 0
+        };
+        const queryData = this.buildQueryData(requestNode);
+        return this.post(queryUrl, queryData, queryParams).pipe(map((response) => {
+            const entries = response.list?.entries;
+            if (entries) {
+                response.list.entries = entries.map((entryData) => entryData.entry);
+            }
+            return response;
+        }));
+    }
+    buildQueryData(requestNode) {
+        const queryData = {
+            name: requestNode.name,
+            id: requestNode.id,
+            parentId: requestNode.parentId,
+            processDefinitionName: requestNode.processDefinitionName,
+            initiator: requestNode.initiator,
+            appVersion: requestNode.appVersion,
+            status: requestNode.status,
+            lastModifiedFrom: requestNode.lastModifiedFrom,
+            lasModifiedTo: requestNode.lasModifiedTo,
+            startFrom: requestNode.startFrom,
+            startTo: requestNode.startTo,
+            completedFrom: requestNode.completedFrom,
+            completedTo: requestNode.completedTo,
+            suspendedFrom: requestNode.suspendedFrom,
+            suspendedTo: requestNode.suspendedTo,
+            processVariableKeys: requestNode.processVariableKeys,
+            processVariableFilters: requestNode.processVariableFilters
+        };
+        if (requestNode.sorting) {
+            queryData['sort'] = {
+                field: requestNode.sorting.orderBy,
+                direction: requestNode.sorting.direction.toLowerCase(),
+                isProcessVariable: requestNode.sorting.isFieldProcessVariable
+            };
+            if (queryData['sort'].isProcessVariable) {
+                queryData['sort'].processDefinitionKey = requestNode.sorting.processVariableData?.processDefinitionKey;
+                queryData['sort'].type = requestNode.sorting.processVariableData?.type;
+            }
+        }
+        /*
+         * Remove process variable filter keys with empty values from the query data.
+         */
+        if (queryData['processVariableFilters']) {
+            queryData['processVariableFilters'] = queryData['processVariableFilters'].filter((filter) => filter.value !== '' && filter.value !== null && filter.value !== undefined);
+        }
+        /*
+         * Remove keys with empty values from the query data.
+         */
+        Object.keys(queryData).forEach((key) => {
+            const value = queryData[key];
+            const isValueEmpty = !value;
+            const isValueArrayWithEmptyValue = Array.isArray(value) && (value.length === 0 || value[0] === null);
+            if (isValueEmpty || isValueArrayWithEmptyValue) {
+                delete queryData[key];
+            }
+        });
+        return queryData;
+    }
+    getProcessListCounter(requestNode) {
+        if (!requestNode.appName) {
+            return throwError(() => new Error('Appname not configured'));
+        }
+        return this.fetchProcessList(requestNode).pipe(map((processes) => processes.list.pagination.totalItems));
+    }
+    /**
+     * Finds a process using an object with optional query properties.
+     *
+     * @param appName app name
+     * @param status filter status
+     * @returns Total items
+     */
+    getProcessCounter(appName, status) {
+        const callback = (url, queryParams) => this.get(url, queryParams);
+        let queryUrl;
+        const defaultQueryUrl = 'query/v1/process-instances';
+        const requestNode = {
+            appName,
+            appVersion: '',
+            initiator: null,
+            id: '',
+            name: null,
+            processDefinitionId: '',
+            processDefinitionName: null,
+            processDefinitionKey: '',
+            status,
+            businessKey: '',
+            startFrom: null,
+            startTo: null,
+            completedFrom: null,
+            completedTo: null,
+            suspendedFrom: null,
+            suspendedTo: null,
+            completedDate: '',
+            maxItems: 1,
+            skipCount: 0,
+            sorting: [
+                {
+                    orderBy: 'startDate',
+                    direction: 'DESC'
+                }
+            ]
+        };
+        return this.getProcess(callback, defaultQueryUrl, requestNode, queryUrl).pipe(map((tasks) => tasks?.list?.pagination?.totalItems));
+    }
+    /**
+     * Finds a process using an object with optional query properties in admin app.
+     *
+     * @param requestNode Query object
+     * @param queryUrl Query url
+     * @returns Process information
+     */
+    getAdminProcessByRequest(requestNode, queryUrl) {
+        const callback = (url, params) => {
+            const postBody = {
+                variableKeys: this.getVariableKeysFromQueryParams(params)
+            };
+            delete params['variableKeys'];
+            return this.post(url, postBody, params);
+        };
+        const defaultQueryUrl = 'query/admin/v1/process-instances';
+        return this.getProcess(callback, defaultQueryUrl, requestNode, queryUrl);
+    }
+    getVariableKeysFromQueryParams(queryParams) {
+        if (!queryParams['variableKeys'] || queryParams['variableKeys'].length <= 0) {
+            return [];
+        }
+        return queryParams['variableKeys'].split(',');
+    }
+    isPropertyValueValid(requestNode, property) {
+        return requestNode[property] !== '' && requestNode[property] !== null && requestNode[property] !== undefined;
+    }
+    buildQueryParams(requestNode) {
+        const queryParam = {};
+        for (const property in requestNode) {
+            if (Object.prototype.hasOwnProperty.call(requestNode, property) &&
+                !this.isExcludedField(property) &&
+                this.isPropertyValueValid(requestNode, property)) {
+                queryParam[property] = this.getQueryParamValueFromRequestNode(requestNode, property);
+            }
+        }
+        if (!queryParam['status']) {
+            queryParam['status'] = this.buildFilterForAllStatus();
+        }
+        return queryParam;
+    }
+    getQueryParamValueFromRequestNode(requestNode, property) {
+        if (property === 'variableKeys' && requestNode[property]?.length > 0) {
+            return `${requestNode[property].map((variableId) => variableId).join(',')}`;
+        }
+        return requestNode[property];
+    }
+    buildFilterForAllStatus() {
+        return ['RUNNING', 'SUSPENDED', 'CANCELLED', 'COMPLETED'];
+    }
+    isExcludedField(property) {
+        return property === 'appName' || property === 'sorting';
+    }
+    buildSortingParam(models) {
+        let finalSorting = '';
+        if (models) {
+            for (const sort of models) {
+                if (!finalSorting) {
+                    finalSorting = `${sort.orderBy},${sort.direction}`;
+                }
+                else {
+                    finalSorting = `${finalSorting}&${sort.orderBy},${sort.direction}`;
+                }
+            }
+        }
+        return encodeURI(finalSorting);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessListCloudService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessListCloudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessListCloudService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-list-cloud.service.js","sourceRoot":"","sources":["../../../../../../../../lib/process-services-cloud/src/lib/process/process-list/services/process-list-cloud.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 { ProcessListRequestModel, ProcessQueryCloudRequestModel } from '../models/process-cloud-query-request.model';\nimport { Observable, throwError } from 'rxjs';\nimport { ProcessListCloudSortingModel } from '../models/process-list-sorting.model';\nimport { BaseCloudService } from '../../../services/base-cloud.service';\nimport { map } from 'rxjs/operators';\n\n@Injectable({ providedIn: 'root' })\nexport class ProcessListCloudService extends BaseCloudService {\n    private getProcess(\n        callback: (queryUrl: string, queryParams: any) => Observable<any>,\n        defaultQueryUrl: string,\n        requestNode: ProcessQueryCloudRequestModel,\n        queryUrl?: string\n    ): Observable<any> {\n        if (requestNode.appName || requestNode.appName === '') {\n            queryUrl = queryUrl || `${this.getBasePath(requestNode.appName)}/${defaultQueryUrl}`;\n            const queryParams = this.buildQueryParams(requestNode);\n            const sortingParams = this.buildSortingParam(requestNode.sorting);\n            if (sortingParams) {\n                queryParams['sort'] = sortingParams;\n            }\n\n            return callback(queryUrl, queryParams).pipe(\n                map((response: any) => {\n                    const entries = response.list?.entries;\n                    if (entries) {\n                        // TODO: this is a hack of the model and needs to be revisited\n                        response.list.entries = entries.map((entryData) => entryData.entry);\n                    }\n                    return response;\n                })\n            );\n        } else {\n            return throwError('Appname not configured');\n        }\n    }\n\n    /**\n     * Finds a process using an object with optional query properties.\n     *\n     * @deprecated From Activiti 8.7.0 forward, use ProcessListCloudService.fetchProcessList instead.\n     * @param requestNode Query object\n     * @param queryUrl Query url\n     * @returns Process information\n     */\n    getProcessByRequest(requestNode: ProcessQueryCloudRequestModel, queryUrl?: string): Observable<any> {\n        const callback = (url: string, queryParams: any) => this.get(url, queryParams);\n        const defaultQueryUrl = 'query/v1/process-instances';\n\n        return this.getProcess(callback, defaultQueryUrl, requestNode, queryUrl);\n    }\n\n    /**\n     * Available from Activiti version 8.7.0 onwards.\n     * Retrieves a list of processes using an object with optional query properties.\n     *\n     * @param requestNode Query object\n     * @param queryUrl Query url\n     * @returns List of processes\n     */\n    fetchProcessList(requestNode: ProcessListRequestModel, queryUrl?: string): Observable<any> {\n        if (!requestNode?.appName) {\n            return throwError(() => new Error('Appname not configured'));\n        }\n\n        queryUrl = queryUrl || `${this.getBasePath(requestNode.appName)}/query/v1/process-instances/search`;\n\n        const queryParams = {\n            maxItems: requestNode.pagination?.maxItems || 25,\n            skipCount: requestNode.pagination?.skipCount || 0\n        };\n\n        const queryData = this.buildQueryData(requestNode);\n        return this.post<any, any>(queryUrl, queryData, queryParams).pipe(\n            map((response: any) => {\n                const entries = response.list?.entries;\n                if (entries) {\n                    response.list.entries = entries.map((entryData) => entryData.entry);\n                }\n                return response;\n            })\n        );\n    }\n\n    protected buildQueryData(requestNode: ProcessListRequestModel) {\n        const queryData: any = {\n            name: requestNode.name,\n            id: requestNode.id,\n            parentId: requestNode.parentId,\n            processDefinitionName: requestNode.processDefinitionName,\n            initiator: requestNode.initiator,\n            appVersion: requestNode.appVersion,\n            status: requestNode.status,\n            lastModifiedFrom: requestNode.lastModifiedFrom,\n            lasModifiedTo: requestNode.lasModifiedTo,\n            startFrom: requestNode.startFrom,\n            startTo: requestNode.startTo,\n            completedFrom: requestNode.completedFrom,\n            completedTo: requestNode.completedTo,\n            suspendedFrom: requestNode.suspendedFrom,\n            suspendedTo: requestNode.suspendedTo,\n            processVariableKeys: requestNode.processVariableKeys,\n            processVariableFilters: requestNode.processVariableFilters\n        };\n\n        if (requestNode.sorting) {\n            queryData['sort'] = {\n                field: requestNode.sorting.orderBy,\n                direction: requestNode.sorting.direction.toLowerCase(),\n                isProcessVariable: requestNode.sorting.isFieldProcessVariable\n            };\n            if (queryData['sort'].isProcessVariable) {\n                queryData['sort'].processDefinitionKey = requestNode.sorting.processVariableData?.processDefinitionKey;\n                queryData['sort'].type = requestNode.sorting.processVariableData?.type;\n            }\n        }\n\n        /*\n         * Remove process variable filter keys with empty values from the query data.\n         */\n        if (queryData['processVariableFilters']) {\n            queryData['processVariableFilters'] = queryData['processVariableFilters'].filter(\n                (filter) => filter.value !== '' && filter.value !== null && filter.value !== undefined\n            );\n        }\n\n        /*\n         * Remove keys with empty values from the query data.\n         */\n        Object.keys(queryData).forEach((key) => {\n            const value = queryData[key];\n            const isValueEmpty = !value;\n            const isValueArrayWithEmptyValue = Array.isArray(value) && (value.length === 0 || value[0] === null);\n            if (isValueEmpty || isValueArrayWithEmptyValue) {\n                delete queryData[key];\n            }\n        });\n\n        return queryData;\n    }\n\n    getProcessListCounter(requestNode: ProcessListRequestModel): Observable<number> {\n        if (!requestNode.appName) {\n            return throwError(() => new Error('Appname not configured'));\n        }\n        return this.fetchProcessList(requestNode).pipe(map((processes) => processes.list.pagination.totalItems));\n    }\n\n    /**\n     * Finds a process using an object with optional query properties.\n     *\n     * @param appName app name\n     * @param status filter status\n     * @returns Total items\n     */\n    getProcessCounter(appName: string, status: string): Observable<any> {\n        const callback = (url: string, queryParams: any) => this.get(url, queryParams);\n        let queryUrl: string;\n        const defaultQueryUrl = 'query/v1/process-instances';\n        const requestNode: ProcessQueryCloudRequestModel = {\n            appName,\n            appVersion: '',\n            initiator: null,\n            id: '',\n            name: null,\n            processDefinitionId: '',\n            processDefinitionName: null,\n            processDefinitionKey: '',\n            status,\n            businessKey: '',\n            startFrom: null,\n            startTo: null,\n            completedFrom: null,\n            completedTo: null,\n            suspendedFrom: null,\n            suspendedTo: null,\n            completedDate: '',\n            maxItems: 1,\n            skipCount: 0,\n            sorting: [\n                {\n                    orderBy: 'startDate',\n                    direction: 'DESC'\n                }\n            ]\n        };\n\n        return this.getProcess(callback, defaultQueryUrl, requestNode, queryUrl).pipe(map((tasks) => tasks?.list?.pagination?.totalItems));\n    }\n\n    /**\n     * Finds a process using an object with optional query properties in admin app.\n     *\n     * @param requestNode Query object\n     * @param queryUrl Query url\n     * @returns Process information\n     */\n    getAdminProcessByRequest(requestNode: ProcessQueryCloudRequestModel, queryUrl?: string): Observable<any> {\n        const callback = (url: string, params: any) => {\n            const postBody = {\n                variableKeys: this.getVariableKeysFromQueryParams(params)\n            };\n\n            delete params['variableKeys'];\n\n            return this.post(url, postBody, params);\n        };\n\n        const defaultQueryUrl = 'query/admin/v1/process-instances';\n\n        return this.getProcess(callback, defaultQueryUrl, requestNode, queryUrl);\n    }\n\n    private getVariableKeysFromQueryParams(queryParams: any): string[] {\n        if (!queryParams['variableKeys'] || queryParams['variableKeys'].length <= 0) {\n            return [];\n        }\n\n        return queryParams['variableKeys'].split(',');\n    }\n\n    protected isPropertyValueValid(requestNode: ProcessQueryCloudRequestModel, property: string): boolean {\n        return requestNode[property] !== '' && requestNode[property] !== null && requestNode[property] !== undefined;\n    }\n\n    protected buildQueryParams(requestNode: ProcessQueryCloudRequestModel): any {\n        const queryParam = {};\n\n        for (const property in requestNode) {\n            if (\n                Object.prototype.hasOwnProperty.call(requestNode, property) &&\n                !this.isExcludedField(property) &&\n                this.isPropertyValueValid(requestNode, property)\n            ) {\n                queryParam[property] = this.getQueryParamValueFromRequestNode(requestNode, property as keyof ProcessQueryCloudRequestModel);\n            }\n        }\n\n        if (!queryParam['status']) {\n            queryParam['status'] = this.buildFilterForAllStatus();\n        }\n\n        return queryParam;\n    }\n\n    private getQueryParamValueFromRequestNode(requestNode: ProcessQueryCloudRequestModel, property: keyof ProcessQueryCloudRequestModel) {\n        if (property === 'variableKeys' && requestNode[property]?.length > 0) {\n            return `${requestNode[property].map((variableId) => variableId).join(',')}`;\n        }\n\n        return requestNode[property];\n    }\n\n    protected buildFilterForAllStatus(): string[] {\n        return ['RUNNING', 'SUSPENDED', 'CANCELLED', 'COMPLETED'];\n    }\n\n    protected isExcludedField(property: string): boolean {\n        return property === 'appName' || property === 'sorting';\n    }\n\n    protected buildSortingParam(models: ProcessListCloudSortingModel[]): string {\n        let finalSorting: string = '';\n        if (models) {\n            for (const sort of models) {\n                if (!finalSorting) {\n                    finalSorting = `${sort.orderBy},${sort.direction}`;\n                } else {\n                    finalSorting = `${finalSorting}&${sort.orderBy},${sort.direction}`;\n                }\n            }\n        }\n        return encodeURI(finalSorting);\n    }\n}\n"]}

package/esm2022/lib/process/process-list/services/process-task-list-cloud.service.mjs

@@ -0,0 +1,109 @@
+/*!
+ * @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 { throwError } from 'rxjs';
+import { BaseCloudService } from '../../../services/base-cloud.service';
+import { map } from 'rxjs/operators';
+import { TaskQueryCloudRequestModel } from '../../../models/filter-cloud-model';
+import * as i0 from "@angular/core";
+export class ProcessTaskListCloudService extends BaseCloudService {
+    /**
+     * Finds a task using an object with optional query properties.
+     *
+     * @param requestNode Query object
+     * @param queryUrl Query url
+     * @returns Task information
+     */
+    getTaskByRequest(requestNode, queryUrl) {
+        if (requestNode.appName || requestNode.appName === '') {
+            queryUrl = queryUrl || `${this.getBasePath(requestNode.appName)}/query/v1/process-instances/${requestNode.processInstanceId}/tasks`;
+            const queryParams = this.buildQueryParams(requestNode);
+            const sortingParams = this.buildSortingParam(requestNode.sorting);
+            if (sortingParams) {
+                queryParams['sort'] = sortingParams;
+            }
+            return this.get(queryUrl, queryParams).pipe(map((response) => {
+                const entries = response.list?.entries;
+                if (entries) {
+                    // TODO: this is a hack of the model and should be revisited
+                    response.list.entries = entries.map((entryData) => entryData.entry);
+                }
+                return response;
+            }));
+        }
+        else {
+            return throwError('Appname not configured');
+        }
+    }
+    /**
+     * Retrieves a list of tasks using an object with optional query properties.
+     *
+     * @param requestNode Query object
+     * @param queryUrl Query url
+     * @returns List of tasks
+     */
+    fetchTaskList(requestNode, queryUrl) {
+        return this.getTaskByRequest(new TaskQueryCloudRequestModel({
+            appName: requestNode.appName,
+            processInstanceId: requestNode.processInstanceId
+        }), queryUrl);
+    }
+    getTaskListCounter(requestNode) {
+        if (!requestNode.appName) {
+            return throwError(() => new Error('Appname not configured'));
+        }
+        return this.fetchTaskList(requestNode).pipe(map((tasks) => tasks.list.pagination.totalItems));
+    }
+    buildQueryParams(requestNode) {
+        const queryParam = {};
+        for (const property in requestNode) {
+            if (Object.prototype.hasOwnProperty.call(requestNode, property) &&
+                !this.isExcludedField(property) &&
+                this.isPropertyValueValid(requestNode, property)) {
+                queryParam[property] = requestNode[property];
+            }
+        }
+        return queryParam;
+    }
+    isExcludedField(property) {
+        return property === 'appName' || property === 'sorting';
+    }
+    isPropertyValueValid(requestNode, property) {
+        return requestNode[property] !== '' && requestNode[property] !== null && requestNode[property] !== undefined;
+    }
+    buildSortingParam(models) {
+        let finalSorting = '';
+        if (models) {
+            for (const sort of models) {
+                if (!finalSorting) {
+                    finalSorting = `${sort.orderBy},${sort.direction}`;
+                }
+                else {
+                    finalSorting = `${finalSorting}&${sort.orderBy},${sort.direction}`;
+                }
+            }
+        }
+        return encodeURI(finalSorting);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessTaskListCloudService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessTaskListCloudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessTaskListCloudService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-task-list-cloud.service.js","sourceRoot":"","sources":["../../../../../../../../lib/process-services-cloud/src/lib/process/process-list/services/process-task-list-cloud.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, throwError } from 'rxjs';\nimport { BaseCloudService } from '../../../services/base-cloud.service';\nimport { map } from 'rxjs/operators';\nimport { TaskListRequestModel, TaskQueryCloudRequestModel } from '../../../models/filter-cloud-model';\nimport { TaskCloudNodePaging } from '../../../models/task-cloud.model';\nimport { TaskListCloudSortingModel } from '../../../models/task-list-sorting.model';\n\n@Injectable({ providedIn: 'root' })\nexport class ProcessTaskListCloudService extends BaseCloudService {\n    /**\n     * Finds a task using an object with optional query properties.\n     *\n     * @param requestNode Query object\n     * @param queryUrl Query url\n     * @returns Task information\n     */\n    getTaskByRequest(requestNode: TaskQueryCloudRequestModel, queryUrl?: string): Observable<any> {\n        if (requestNode.appName || requestNode.appName === '') {\n            queryUrl = queryUrl || `${this.getBasePath(requestNode.appName)}/query/v1/process-instances/${requestNode.processInstanceId}/tasks`;\n            const queryParams = this.buildQueryParams(requestNode);\n            const sortingParams = this.buildSortingParam(requestNode.sorting);\n            if (sortingParams) {\n                queryParams['sort'] = sortingParams;\n            }\n            return this.get<TaskCloudNodePaging>(queryUrl, queryParams).pipe(\n                map((response) => {\n                    const entries = response.list?.entries;\n                    if (entries) {\n                        // TODO: this is a hack of the model and should be revisited\n                        response.list.entries = entries.map((entryData: any) => entryData.entry);\n                    }\n                    return response;\n                })\n            );\n        } else {\n            return throwError('Appname not configured');\n        }\n    }\n\n    /**\n     * Retrieves a list of tasks using an object with optional query properties.\n     *\n     * @param requestNode Query object\n     * @param queryUrl Query url\n     * @returns List of tasks\n     */\n    fetchTaskList(requestNode: TaskListRequestModel, queryUrl?: string): Observable<any> {\n        return this.getTaskByRequest(\n            new TaskQueryCloudRequestModel({\n                appName: requestNode.appName,\n                processInstanceId: requestNode.processInstanceId\n            }),\n            queryUrl\n        );\n    }\n\n    getTaskListCounter(requestNode: TaskListRequestModel): Observable<number> {\n        if (!requestNode.appName) {\n            return throwError(() => new Error('Appname not configured'));\n        }\n        return this.fetchTaskList(requestNode).pipe(map((tasks) => tasks.list.pagination.totalItems));\n    }\n\n    protected buildQueryParams(requestNode: TaskQueryCloudRequestModel): any {\n        const queryParam: any = {};\n        for (const property in requestNode) {\n            if (\n                Object.prototype.hasOwnProperty.call(requestNode, property) &&\n                !this.isExcludedField(property) &&\n                this.isPropertyValueValid(requestNode, property)\n            ) {\n                queryParam[property] = requestNode[property];\n            }\n        }\n        return queryParam;\n    }\n\n    protected isExcludedField(property: string): boolean {\n        return property === 'appName' || property === 'sorting';\n    }\n\n    protected isPropertyValueValid(requestNode: TaskQueryCloudRequestModel, property: string): boolean {\n        return requestNode[property] !== '' && requestNode[property] !== null && requestNode[property] !== undefined;\n    }\n\n    protected buildSortingParam(models: TaskListCloudSortingModel[]): string {\n        let finalSorting: string = '';\n        if (models) {\n            for (const sort of models) {\n                if (!finalSorting) {\n                    finalSorting = `${sort.orderBy},${sort.direction}`;\n                } else {\n                    finalSorting = `${finalSorting}&${sort.orderBy},${sort.direction}`;\n                }\n            }\n        }\n        return encodeURI(finalSorting);\n    }\n}\n"]}

package/esm2022/lib/process/public-api.mjs

@@ -0,0 +1,23 @@
+/*!
+ * @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.
+ */
+export * from './process-list/public-api';
+export * from './process-filters/public-api';
+export * from './start-process/public-api';
+export * from './process-header/public-api';
+export * from './services/process-cloud.service';
+export * from './process-cloud.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9wcm9jZXNzLXNlcnZpY2VzLWNsb3VkL3NyYy9saWIvcHJvY2Vzcy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxrQ0FBa0MsQ0FBQztBQUVqRCxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3Byb2Nlc3MtbGlzdC9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvY2Vzcy1maWx0ZXJzL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFydC1wcm9jZXNzL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9wcm9jZXNzLWhlYWRlci9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvcHJvY2Vzcy1jbG91ZC5zZXJ2aWNlJztcblxuZXhwb3J0ICogZnJvbSAnLi9wcm9jZXNzLWNsb3VkLm1vZHVsZSc7XG4iXX0=

package/esm2022/lib/process/services/process-cloud.service.mjs

@@ -0,0 +1,105 @@
+/*!
+ * @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 { Subject, throwError } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { BaseCloudService } from '../../services/base-cloud.service';
+import { ProcessDefinitionCloud } from '../../models/process-definition-cloud.model';
+import * as i0 from "@angular/core";
+export class ProcessCloudService extends BaseCloudService {
+    constructor() {
+        super(...arguments);
+        this.dataChangesDetected = new Subject();
+    }
+    /**
+     * Gets details of a process instance.
+     *
+     * @param appName Name of the app
+     * @param processInstanceId ID of the process instance whose details you want
+     * @returns Process instance details
+     */
+    getProcessInstanceById(appName, processInstanceId) {
+        if (appName && processInstanceId) {
+            const url = `${this.getBasePath(appName)}/query/v1/process-instances/${processInstanceId}`;
+            return this.get(url).pipe(map((res) => {
+                this.dataChangesDetected.next(res.entry);
+                return res.entry;
+            }));
+        }
+        else {
+            return throwError('AppName/ProcessInstanceId not configured');
+        }
+    }
+    /**
+     * Gets the process definitions associated with an app.
+     *
+     * @param appName Name of the target app
+     * @returns Array of process definitions
+     */
+    getProcessDefinitions(appName) {
+        if (appName || appName === '') {
+            const url = `${this.getBasePath(appName)}/rb/v1/process-definitions`;
+            return this.get(url).pipe(map((res) => res.list.entries.map((processDefs) => new ProcessDefinitionCloud(processDefs.entry))));
+        }
+        else {
+            return throwError('AppName not configured');
+        }
+    }
+    /**
+     * Gets the application versions associated with an app.
+     *
+     * @param appName Name of the target app
+     * @returns Array of Application Version Models
+     */
+    getApplicationVersions(appName) {
+        if (appName) {
+            const url = `${this.getBasePath(appName)}/query/v1/applications`;
+            return this.get(url).pipe(map((appEntities) => appEntities.list.entries));
+        }
+        else {
+            return throwError('AppName not configured');
+        }
+    }
+    /**
+     * Cancels a process.
+     *
+     * @param appName Name of the app
+     * @param processInstanceId Id of the process to cancel
+     * @returns Operation Information
+     */
+    cancelProcess(appName, processInstanceId) {
+        if (appName && processInstanceId) {
+            const queryUrl = `${this.getBasePath(appName)}/rb/v1/process-instances/${processInstanceId}`;
+            return this.delete(queryUrl).pipe(map((res) => {
+                this.dataChangesDetected.next(res.entry);
+                return res.entry;
+            }));
+        }
+        else {
+            return throwError('App name and process id not configured');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessCloudService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessCloudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessCloudService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-cloud.service.js","sourceRoot":"","sources":["../../../../../../../lib/process-services-cloud/src/lib/process/services/process-cloud.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, Subject, throwError } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { ProcessInstanceCloud } from '../start-process/models/process-instance-cloud.model';\nimport { BaseCloudService } from '../../services/base-cloud.service';\nimport { ProcessDefinitionCloud } from '../../models/process-definition-cloud.model';\nimport { ApplicationVersionModel, ApplicationVersionResponseModel } from '../../models/application-version.model';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ProcessCloudService extends BaseCloudService {\n    dataChangesDetected = new Subject<ProcessInstanceCloud>();\n\n    /**\n     * Gets details of a process instance.\n     *\n     * @param appName Name of the app\n     * @param processInstanceId ID of the process instance whose details you want\n     * @returns Process instance details\n     */\n    getProcessInstanceById(appName: string, processInstanceId: string): Observable<ProcessInstanceCloud> {\n        if (appName && processInstanceId) {\n            const url = `${this.getBasePath(appName)}/query/v1/process-instances/${processInstanceId}`;\n\n            return this.get<{ entry: ProcessInstanceCloud }>(url).pipe(\n                map((res) => {\n                    this.dataChangesDetected.next(res.entry);\n                    return res.entry;\n                })\n            );\n        } else {\n            return throwError('AppName/ProcessInstanceId not configured');\n        }\n    }\n\n    /**\n     * Gets the process definitions associated with an app.\n     *\n     * @param appName Name of the target app\n     * @returns Array of process definitions\n     */\n    getProcessDefinitions(appName: string): Observable<ProcessDefinitionCloud[]> {\n        if (appName || appName === '') {\n            const url = `${this.getBasePath(appName)}/rb/v1/process-definitions`;\n\n            return this.get(url).pipe(map((res: any) => res.list.entries.map((processDefs) => new ProcessDefinitionCloud(processDefs.entry))));\n        } else {\n            return throwError('AppName not configured');\n        }\n    }\n\n    /**\n     * Gets the application versions associated with an app.\n     *\n     * @param appName Name of the target app\n     * @returns Array of Application Version Models\n     */\n    getApplicationVersions(appName: string): Observable<ApplicationVersionModel[]> {\n        if (appName) {\n            const url = `${this.getBasePath(appName)}/query/v1/applications`;\n\n            return this.get(url).pipe(map((appEntities: ApplicationVersionResponseModel) => appEntities.list.entries));\n        } else {\n            return throwError('AppName not configured');\n        }\n    }\n\n    /**\n     * Cancels a process.\n     *\n     * @param appName Name of the app\n     * @param processInstanceId Id of the process to cancel\n     * @returns Operation Information\n     */\n    cancelProcess(appName: string, processInstanceId: string): Observable<ProcessInstanceCloud> {\n        if (appName && processInstanceId) {\n            const queryUrl = `${this.getBasePath(appName)}/rb/v1/process-instances/${processInstanceId}`;\n            return this.delete(queryUrl).pipe(\n                map((res: any) => {\n                    this.dataChangesDetected.next(res.entry);\n                    return res.entry;\n                })\n            );\n        } else {\n            return throwError('App name and process id not configured');\n        }\n    }\n}\n"]}