@alfresco/adf-process-services-cloud 8.1.0-16120632321 → 8.1.0-16121703802

package/esm2022/lib/services/web-socket.service.mjs

@@ -0,0 +1,146 @@
+/*!
+ * @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 { createClient } from 'graphql-ws';
+import { inject, Injectable } from '@angular/core';
+import { GraphQLWsLink } from '@apollo/client/link/subscriptions';
+import { from, InMemoryCache, split } from '@apollo/client/core';
+import { Apollo } from 'apollo-angular';
+import { HttpLink } from 'apollo-angular/http';
+import { Kind, OperationTypeNode } from 'graphql';
+import { onError } from '@apollo/client/link/error';
+import { RetryLink } from '@apollo/client/link/retry';
+import { getMainDefinition } from '@apollo/client/utilities';
+import { take } from 'rxjs/operators';
+import { AppConfigService, AuthenticationService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "apollo-angular";
+import * as i2 from "apollo-angular/http";
+import * as i3 from "@alfresco/adf-core";
+export class WebSocketService {
+    constructor(apollo, httpLink, authService) {
+        this.apollo = apollo;
+        this.httpLink = httpLink;
+        this.authService = authService;
+        this.appConfigService = inject(AppConfigService);
+        this.subscriptionProtocol = 'graphql-ws';
+    }
+    getSubscription(options) {
+        const { apolloClientName, subscriptionOptions } = options;
+        this.authService.onLogout.pipe(take(1)).subscribe(() => {
+            if (this.apollo.use(apolloClientName)) {
+                this.apollo.removeClient(apolloClientName);
+            }
+        });
+        if (this.apollo.use(apolloClientName) === undefined) {
+            this.initSubscriptions(options);
+        }
+        return this.apollo.use(apolloClientName).subscribe({ errorPolicy: 'all', ...subscriptionOptions });
+    }
+    get contextRoot() {
+        return this.appConfigService.get('bpmHost', '');
+    }
+    createWsUrl(serviceUrl) {
+        const url = new URL(serviceUrl, this.contextRoot);
+        const protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+        url.protocol = protocol;
+        return url.href;
+    }
+    createHttpUrl(serviceUrl) {
+        const url = new URL(serviceUrl, this.contextRoot);
+        return url.href;
+    }
+    initSubscriptions(options) {
+        this.createGraphQLWsLink(options);
+        this.createHttpLinkHandler(options);
+        const link = split(({ query }) => {
+            const definition = getMainDefinition(query);
+            return definition.kind === Kind.OPERATION_DEFINITION && definition.operation === OperationTypeNode.SUBSCRIPTION;
+        }, this.wsLink, this.httpLinkHandler);
+        const authLink = (operation, forward) => {
+            operation.setContext(({ headers }) => ({
+                headers: {
+                    ...headers,
+                    ...(this.subscriptionProtocol === 'graphql-ws' && { Authorization: `Bearer ${this.authService.getToken()}` }),
+                    ...(this.subscriptionProtocol === 'transport-ws' && { 'X-Authorization': `Bearer ${this.authService.getToken()}` })
+                }
+            }));
+            return forward(operation);
+        };
+        const errorLink = onError(({ graphQLErrors, networkError, operation, forward }) => {
+            if (graphQLErrors) {
+                for (const error of graphQLErrors) {
+                    if (error.extensions && error.extensions['code'] === 'UNAUTHENTICATED') {
+                        authLink(operation, forward);
+                    }
+                }
+            }
+            if (networkError) {
+                console.error(`[Network error]: ${networkError}`);
+            }
+        });
+        const retryLink = new RetryLink({
+            delay: {
+                initial: 300,
+                max: Number.POSITIVE_INFINITY,
+                jitter: true
+            },
+            attempts: {
+                max: 5,
+                retryIf: (error) => !!error
+            }
+        });
+        this.apollo.createNamed(options.apolloClientName, {
+            headers: {
+                ...(this.subscriptionProtocol === 'graphql-ws' && { Authorization: `Bearer ${this.authService.getToken()}` }),
+                ...(this.subscriptionProtocol === 'transport-ws' && { 'X-Authorization': `Bearer ${this.authService.getToken()}` })
+            },
+            link: from([authLink, retryLink, errorLink, link]),
+            cache: new InMemoryCache({ merge: true })
+        });
+    }
+    createGraphQLWsLink(options) {
+        this.wsLink = new GraphQLWsLink(createClient({
+            url: this.createWsUrl(options.wsUrl) + '/v2/ws/graphql',
+            connectionParams: {
+                Authorization: 'Bearer ' + this.authService.getToken()
+            },
+            on: {
+                error: () => {
+                    this.apollo.removeClient(options.apolloClientName);
+                    this.initSubscriptions(options);
+                }
+            },
+            lazy: true
+        }));
+    }
+    createHttpLinkHandler(options) {
+        this.httpLinkHandler = options.httpUrl
+            ? this.httpLink.create({
+                uri: this.createHttpUrl(options.httpUrl)
+            })
+            : undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WebSocketService, deps: [{ token: i1.Apollo }, { token: i2.HttpLink }, { token: i3.AuthenticationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WebSocketService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WebSocketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Apollo }, { type: i2.HttpLink }, { type: i3.AuthenticationService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-socket.service.js","sourceRoot":"","sources":["../../../../../../lib/process-services-cloud/src/lib/services/web-socket.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 { createClient } from 'graphql-ws';\nimport { inject, Injectable } from '@angular/core';\nimport { GraphQLWsLink } from '@apollo/client/link/subscriptions';\nimport { WebSocketLink } from '@apollo/client/link/ws';\nimport {\n    DefaultContext,\n    FetchResult,\n    from,\n    InMemoryCache,\n    InMemoryCacheConfig,\n    NextLink,\n    Operation,\n    split,\n    SubscriptionOptions\n} from '@apollo/client/core';\nimport { Observable } from 'rxjs';\nimport { Apollo } from 'apollo-angular';\nimport { HttpLink, HttpLinkHandler } from 'apollo-angular/http';\nimport { Kind, OperationTypeNode } from 'graphql';\nimport { onError } from '@apollo/client/link/error';\nimport { RetryLink } from '@apollo/client/link/retry';\nimport { getMainDefinition } from '@apollo/client/utilities';\nimport { take } from 'rxjs/operators';\nimport { AppConfigService, AuthenticationService } from '@alfresco/adf-core';\n\ninterface serviceOptions {\n    apolloClientName: string;\n    wsUrl: string;\n    httpUrl?: string;\n    subscriptionOptions: SubscriptionOptions;\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class WebSocketService {\n    private appConfigService = inject(AppConfigService);\n    private subscriptionProtocol = 'graphql-ws';\n    private wsLink: GraphQLWsLink | WebSocketLink;\n    private httpLinkHandler: HttpLinkHandler;\n\n    constructor(private readonly apollo: Apollo, private readonly httpLink: HttpLink, private readonly authService: AuthenticationService) {}\n\n    public getSubscription<T>(options: serviceOptions): Observable<FetchResult<T>> {\n        const { apolloClientName, subscriptionOptions } = options;\n        this.authService.onLogout.pipe(take(1)).subscribe(() => {\n            if (this.apollo.use(apolloClientName)) {\n                this.apollo.removeClient(apolloClientName);\n            }\n        });\n\n        if (this.apollo.use(apolloClientName) === undefined) {\n            this.initSubscriptions(options);\n        }\n        return this.apollo.use(apolloClientName).subscribe<T>({ errorPolicy: 'all', ...subscriptionOptions });\n    }\n\n    private get contextRoot() {\n        return this.appConfigService.get('bpmHost', '');\n    }\n\n    private createWsUrl(serviceUrl: string): string {\n        const url = new URL(serviceUrl, this.contextRoot);\n        const protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';\n        url.protocol = protocol;\n\n        return url.href;\n    }\n\n    private createHttpUrl(serviceUrl: string): string {\n        const url = new URL(serviceUrl, this.contextRoot);\n\n        return url.href;\n    }\n\n    private initSubscriptions(options: serviceOptions): void {\n        this.createGraphQLWsLink(options);\n\n        this.createHttpLinkHandler(options);\n\n        const link = split(\n            ({ query }) => {\n                const definition = getMainDefinition(query);\n                return definition.kind === Kind.OPERATION_DEFINITION && definition.operation === OperationTypeNode.SUBSCRIPTION;\n            },\n            this.wsLink,\n            this.httpLinkHandler\n        );\n\n        const authLink = (operation: Operation, forward: NextLink) => {\n            operation.setContext(({ headers }: DefaultContext) => ({\n                headers: {\n                    ...headers,\n                    ...(this.subscriptionProtocol === 'graphql-ws' && { Authorization: `Bearer ${this.authService.getToken()}` }),\n                    ...(this.subscriptionProtocol === 'transport-ws' && { 'X-Authorization': `Bearer ${this.authService.getToken()}` })\n                }\n            }));\n            return forward(operation);\n        };\n\n        const errorLink = onError(({ graphQLErrors, networkError, operation, forward }) => {\n            if (graphQLErrors) {\n                for (const error of graphQLErrors) {\n                    if (error.extensions && error.extensions['code'] === 'UNAUTHENTICATED') {\n                        authLink(operation, forward);\n                    }\n                }\n            }\n\n            if (networkError) {\n                console.error(`[Network error]: ${networkError}`);\n            }\n        });\n\n        const retryLink = new RetryLink({\n            delay: {\n                initial: 300,\n                max: Number.POSITIVE_INFINITY,\n                jitter: true\n            },\n            attempts: {\n                max: 5,\n                retryIf: (error) => !!error\n            }\n        });\n\n        this.apollo.createNamed(options.apolloClientName, {\n            headers: {\n                ...(this.subscriptionProtocol === 'graphql-ws' && { Authorization: `Bearer ${this.authService.getToken()}` }),\n                ...(this.subscriptionProtocol === 'transport-ws' && { 'X-Authorization': `Bearer ${this.authService.getToken()}` })\n            },\n            link: from([authLink, retryLink, errorLink, link]),\n            cache: new InMemoryCache({ merge: true } as InMemoryCacheConfig)\n        });\n    }\n\n    private createGraphQLWsLink(options: serviceOptions): void {\n        this.wsLink = new GraphQLWsLink(\n            createClient({\n                url: this.createWsUrl(options.wsUrl) + '/v2/ws/graphql',\n                connectionParams: {\n                    Authorization: 'Bearer ' + this.authService.getToken()\n                },\n                on: {\n                    error: () => {\n                        this.apollo.removeClient(options.apolloClientName);\n                        this.initSubscriptions(options);\n                    }\n                },\n                lazy: true\n            })\n        );\n    }\n\n    private createHttpLinkHandler(options: serviceOptions): void {\n        this.httpLinkHandler = options.httpUrl\n            ? this.httpLink.create({\n                  uri: this.createHttpUrl(options.httpUrl)\n              })\n            : undefined;\n    }\n}\n"]}

package/esm2022/lib/task/models/start-task-cloud-request.model.mjs

@@ -0,0 +1,32 @@
+/*!
+ * @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 class StartTaskCloudRequestModel {
+    constructor(obj) {
+        if (obj) {
+            this.name = obj.name || null;
+            this.description = obj.description || null;
+            this.assignee = obj.assignee || null;
+            this.priority = obj.priority || null;
+            this.dueDate = obj.dueDate || null;
+            this.candidateUsers = obj.candidateUsers || null;
+            this.candidateGroups = obj.candidateGroups || null;
+            this.formKey = obj.formKey || null;
+            this.payloadType = 'CreateTaskPayload';
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/task/models/task-details-cloud.model.mjs

@@ -0,0 +1,26 @@
+/*!
+ * @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 const TASK_COMPLETED_STATE = 'COMPLETED';
+export const TASK_CREATED_STATE = 'CREATED';
+export const TASK_ASSIGNED_STATE = 'ASSIGNED';
+export const TASK_SUSPENDED_STATE = 'SUSPENDED';
+export const TASK_CANCELLED_STATE = 'CANCELLED';
+export const TASK_CLAIM_PERMISSION = 'CLAIM';
+export const TASK_RELEASE_PERMISSION = 'RELEASE';
+export const TASK_VIEW_PERMISSION = 'VIEW';
+export const TASK_UPDATE_PERMISSION = 'UPDATE';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/task/models/task.model.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 const DEFAULT_TASK_PRIORITIES = [
+    { label: 'ADF_CLOUD_TASK_LIST.PROPERTIES.PRIORITY_VALUES.NONE', value: '0', key: '0' },
+    { label: 'ADF_CLOUD_TASK_LIST.PROPERTIES.PRIORITY_VALUES.LOW', value: '1', key: '1' },
+    { label: 'ADF_CLOUD_TASK_LIST.PROPERTIES.PRIORITY_VALUES.NORMAL', value: '2', key: '2' },
+    { label: 'ADF_CLOUD_TASK_LIST.PROPERTIES.PRIORITY_VALUES.HIGH', value: '3', key: '3' }
+];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,26 @@
+/*!
+ * @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 './task-list/public-api';
+export * from './task-filters/public-api';
+export * from './models/task-details-cloud.model';
+export * from './models/task.model';
+export * from './models/start-task-cloud-request.model';
+export * from './task-header/public-api';
+export * from './task-form/public-api';
+export * from './services/task-cloud.service';
+export * from './task-cloud.module';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,272 @@
+/*!
+ * @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, Injectable } from '@angular/core';
+import { TranslationService } from '@alfresco/adf-core';
+import { throwError, of, Subject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { TASK_ASSIGNED_STATE, TASK_CLAIM_PERMISSION, TASK_CREATED_STATE, TASK_RELEASE_PERMISSION } from '../models/task-details-cloud.model';
+import { BaseCloudService } from '../../services/base-cloud.service';
+import { StartTaskCloudRequestModel } from '../models/start-task-cloud-request.model';
+import { ProcessDefinitionCloud } from '../../models/process-definition-cloud.model';
+import { DEFAULT_TASK_PRIORITIES } from '../models/task.model';
+import { IdentityUserService } from '../../people/services/identity-user.service';
+import { AdfHttpClient } from '@alfresco/adf-core/api';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core/api";
+export class TaskCloudService extends BaseCloudService {
+    constructor(adfHttpClient) {
+        super(adfHttpClient);
+        this.translateService = inject(TranslationService);
+        this.identityUserService = inject(IdentityUserService);
+        this.dataChangesDetected$ = new Subject();
+    }
+    /**
+     * Complete a task.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the task to complete
+     * @returns Details of the task that was completed
+     */
+    completeTask(appName, taskId) {
+        if ((appName || appName === '') && taskId) {
+            const url = `${this.getBasePath(appName)}/rb/v1/tasks/${taskId}/complete`;
+            const payload = { payloadType: 'CompleteTaskPayload' };
+            return this.post(url, payload);
+        }
+        else {
+            return throwError('AppName/TaskId not configured');
+        }
+    }
+    /**
+     * Validate if a task can be completed.
+     *
+     * @param taskDetails task details object
+     * @returns Boolean value if the task can be completed
+     */
+    canCompleteTask(taskDetails) {
+        return taskDetails && taskDetails.status === TASK_ASSIGNED_STATE && this.isAssignedToMe(taskDetails.assignee);
+    }
+    /**
+     * Validate if a task is editable.
+     *
+     * @param taskDetails task details object
+     * @returns Boolean value if the task is editable
+     */
+    isTaskEditable(taskDetails) {
+        return taskDetails && taskDetails.status === TASK_ASSIGNED_STATE && this.isAssignedToMe(taskDetails.assignee);
+    }
+    isAssigneePropertyClickable(taskDetails, candidateUsers, candidateGroups) {
+        let isClickable = false;
+        const states = [TASK_ASSIGNED_STATE];
+        if (candidateUsers?.length || candidateGroups?.length) {
+            isClickable = states.includes(taskDetails.status);
+        }
+        return isClickable;
+    }
+    /**
+     * Validate if a task can be claimed.
+     *
+     * @param taskDetails task details object
+     * @returns Boolean value if the task can be completed
+     */
+    canClaimTask(taskDetails) {
+        return taskDetails?.status === TASK_CREATED_STATE && taskDetails?.permissions.includes(TASK_CLAIM_PERMISSION) && !taskDetails?.standalone;
+    }
+    /**
+     * Validate if a task can be unclaimed.
+     *
+     * @param taskDetails task details object
+     * @returns Boolean value if the task can be completed
+     */
+    canUnclaimTask(taskDetails) {
+        const currentUser = this.identityUserService.getCurrentUserInfo().username;
+        return (taskDetails?.status === TASK_ASSIGNED_STATE &&
+            taskDetails?.assignee === currentUser &&
+            taskDetails?.permissions.includes(TASK_RELEASE_PERMISSION) &&
+            !taskDetails?.standalone);
+    }
+    /**
+     * Claims a task for an assignee.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the task to claim
+     * @param assignee User to assign the task to
+     * @returns Details of the claimed task
+     */
+    claimTask(appName, taskId, assignee) {
+        if ((appName || appName === '') && taskId) {
+            const queryUrl = `${this.getBasePath(appName)}/rb/v1/tasks/${taskId}/claim?assignee=${assignee}`;
+            return this.post(queryUrl).pipe(map((res) => {
+                this.dataChangesDetected$.next(res);
+                return res.entry;
+            }));
+        }
+        else {
+            return throwError('AppName/TaskId not configured');
+        }
+    }
+    /**
+     * Un-claims a task.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the task to unclaim
+     * @returns Details of the task that was unclaimed
+     */
+    unclaimTask(appName, taskId) {
+        if ((appName || appName === '') && taskId) {
+            const queryUrl = `${this.getBasePath(appName)}/rb/v1/tasks/${taskId}/release`;
+            return this.post(queryUrl).pipe(map((res) => {
+                this.dataChangesDetected$.next(res);
+                return res.entry;
+            }));
+        }
+        else {
+            return throwError('AppName/TaskId not configured');
+        }
+    }
+    /**
+     * Gets details of a task.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the task whose details you want
+     * @returns Task details
+     */
+    getTaskById(appName, taskId) {
+        if ((appName || appName === '') && taskId) {
+            const queryUrl = `${this.getBasePath(appName)}/query/v1/tasks/${taskId}`;
+            return this.get(queryUrl).pipe(map((res) => res.entry));
+        }
+        else {
+            return throwError('AppName/TaskId not configured');
+        }
+    }
+    /**
+     * Creates a new standalone task.
+     *
+     * @param startTaskRequest request model
+     * @param appName application name
+     * @returns Details of the newly created task
+     */
+    createNewTask(startTaskRequest, appName) {
+        const queryUrl = `${this.getBasePath(appName)}/rb/v1/tasks`;
+        const payload = JSON.stringify(new StartTaskCloudRequestModel(startTaskRequest));
+        return this.post(queryUrl, payload).pipe(map((response) => response.entry));
+    }
+    /**
+     * Updates the details (name, description, due date) for a task.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the task to update
+     * @param payload Data to update the task
+     * @returns Updated task details
+     */
+    updateTask(appName, taskId, payload) {
+        if ((appName || appName === '') && taskId) {
+            payload.payloadType = 'UpdateTaskPayload';
+            const queryUrl = `${this.getBasePath(appName)}/rb/v1/tasks/${taskId}`;
+            return this.put(queryUrl, payload).pipe(map((res) => res.entry));
+        }
+        else {
+            return throwError('AppName/TaskId not configured');
+        }
+    }
+    /**
+     * Gets candidate users of the task.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the task
+     * @returns Candidate users
+     */
+    getCandidateUsers(appName, taskId) {
+        if ((appName || appName === '') && taskId) {
+            const queryUrl = `${this.getBasePath(appName)}/query/v1/tasks/${taskId}/candidate-users`;
+            return this.get(queryUrl);
+        }
+        else {
+            return of([]);
+        }
+    }
+    /**
+     * Gets candidate groups of the task.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the task
+     * @returns Candidate groups
+     */
+    getCandidateGroups(appName, taskId) {
+        if ((appName || appName === '') && taskId) {
+            const queryUrl = `${this.getBasePath(appName)}/query/v1/tasks/${taskId}/candidate-groups`;
+            return this.get(queryUrl);
+        }
+        else {
+            return of([]);
+        }
+    }
+    /**
+     * 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');
+        }
+    }
+    /**
+     * Updates the task assignee.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the task to update assignee
+     * @param assignee assignee to update current user task assignee
+     * @returns Updated task details with new assignee
+     */
+    assign(appName, taskId, assignee) {
+        if (appName && taskId) {
+            const payLoad = { assignee, taskId, payloadType: 'AssignTaskPayload' };
+            const url = `${this.getBasePath(appName)}/rb/v1/tasks/${taskId}/assign`;
+            return this.post(url, payLoad).pipe(map((res) => res.entry));
+        }
+        else {
+            return throwError('AppName/TaskId not configured');
+        }
+    }
+    getPriorityLabel(priority) {
+        const priorityItem = this.priorities.find((item) => item.value === priority.toString()) || this.priorities[0];
+        return this.translateService.instant(priorityItem.label);
+    }
+    get priorities() {
+        return this.appConfigService.get('adf-cloud-priority-values') || DEFAULT_TASK_PRIORITIES;
+    }
+    isAssignedToMe(assignee) {
+        const currentUser = this.identityUserService.getCurrentUserInfo().username;
+        return assignee === currentUser;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskCloudService, deps: [{ token: i1.AdfHttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskCloudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskCloudService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AdfHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-cloud.service.js","sourceRoot":"","sources":["../../../../../../../lib/process-services-cloud/src/lib/task/services/task-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 { inject, Injectable } from '@angular/core';\nimport { CardViewArrayItem, TranslationService } from '@alfresco/adf-core';\nimport { throwError, Observable, of, Subject } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport {\n    TaskDetailsCloudModel,\n    StartTaskCloudResponseModel,\n    TASK_ASSIGNED_STATE,\n    TASK_CLAIM_PERMISSION,\n    TASK_CREATED_STATE,\n    TASK_RELEASE_PERMISSION\n} from '../models/task-details-cloud.model';\nimport { BaseCloudService } from '../../services/base-cloud.service';\nimport { StartTaskCloudRequestModel } from '../models/start-task-cloud-request.model';\nimport { ProcessDefinitionCloud } from '../../models/process-definition-cloud.model';\nimport { DEFAULT_TASK_PRIORITIES, TaskPriorityOption } from '../models/task.model';\nimport { IdentityUserService } from '../../people/services/identity-user.service';\nimport { AdfHttpClient } from '@alfresco/adf-core/api';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class TaskCloudService extends BaseCloudService {\n    private translateService = inject(TranslationService);\n    private identityUserService = inject(IdentityUserService);\n\n    dataChangesDetected$ = new Subject();\n\n    constructor(adfHttpClient: AdfHttpClient) {\n        super(adfHttpClient);\n    }\n\n    /**\n     * Complete a task.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the task to complete\n     * @returns Details of the task that was completed\n     */\n    completeTask(appName: string, taskId: string): Observable<TaskDetailsCloudModel> {\n        if ((appName || appName === '') && taskId) {\n            const url = `${this.getBasePath(appName)}/rb/v1/tasks/${taskId}/complete`;\n            const payload = { payloadType: 'CompleteTaskPayload' };\n\n            return this.post<any, TaskDetailsCloudModel>(url, payload);\n        } else {\n            return throwError('AppName/TaskId not configured');\n        }\n    }\n\n    /**\n     * Validate if a task can be completed.\n     *\n     * @param taskDetails task details object\n     * @returns Boolean value if the task can be completed\n     */\n    canCompleteTask(taskDetails: TaskDetailsCloudModel): boolean {\n        return taskDetails && taskDetails.status === TASK_ASSIGNED_STATE && this.isAssignedToMe(taskDetails.assignee);\n    }\n\n    /**\n     * Validate if a task is editable.\n     *\n     * @param taskDetails task details object\n     * @returns Boolean value if the task is editable\n     */\n    isTaskEditable(taskDetails: TaskDetailsCloudModel): boolean {\n        return taskDetails && taskDetails.status === TASK_ASSIGNED_STATE && this.isAssignedToMe(taskDetails.assignee);\n    }\n\n    isAssigneePropertyClickable(\n        taskDetails: TaskDetailsCloudModel,\n        candidateUsers: CardViewArrayItem[],\n        candidateGroups: CardViewArrayItem[]\n    ): boolean {\n        let isClickable = false;\n        const states = [TASK_ASSIGNED_STATE];\n        if (candidateUsers?.length || candidateGroups?.length) {\n            isClickable = states.includes(taskDetails.status);\n        }\n        return isClickable;\n    }\n\n    /**\n     * Validate if a task can be claimed.\n     *\n     * @param taskDetails task details object\n     * @returns Boolean value if the task can be completed\n     */\n    canClaimTask(taskDetails: TaskDetailsCloudModel): boolean {\n        return taskDetails?.status === TASK_CREATED_STATE && taskDetails?.permissions.includes(TASK_CLAIM_PERMISSION) && !taskDetails?.standalone;\n    }\n\n    /**\n     * Validate if a task can be unclaimed.\n     *\n     * @param taskDetails task details object\n     * @returns Boolean value if the task can be completed\n     */\n    canUnclaimTask(taskDetails: TaskDetailsCloudModel): boolean {\n        const currentUser = this.identityUserService.getCurrentUserInfo().username;\n        return (\n            taskDetails?.status === TASK_ASSIGNED_STATE &&\n            taskDetails?.assignee === currentUser &&\n            taskDetails?.permissions.includes(TASK_RELEASE_PERMISSION) &&\n            !taskDetails?.standalone\n        );\n    }\n\n    /**\n     * Claims a task for an assignee.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the task to claim\n     * @param assignee User to assign the task to\n     * @returns Details of the claimed task\n     */\n    claimTask(appName: string, taskId: string, assignee: string): Observable<TaskDetailsCloudModel> {\n        if ((appName || appName === '') && taskId) {\n            const queryUrl = `${this.getBasePath(appName)}/rb/v1/tasks/${taskId}/claim?assignee=${assignee}`;\n\n            return this.post(queryUrl).pipe(\n                map((res: any) => {\n                    this.dataChangesDetected$.next(res);\n                    return res.entry;\n                })\n            );\n        } else {\n            return throwError('AppName/TaskId not configured');\n        }\n    }\n\n    /**\n     * Un-claims a task.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the task to unclaim\n     * @returns Details of the task that was unclaimed\n     */\n    unclaimTask(appName: string, taskId: string): Observable<TaskDetailsCloudModel> {\n        if ((appName || appName === '') && taskId) {\n            const queryUrl = `${this.getBasePath(appName)}/rb/v1/tasks/${taskId}/release`;\n\n            return this.post(queryUrl).pipe(\n                map((res: any) => {\n                    this.dataChangesDetected$.next(res);\n                    return res.entry;\n                })\n            );\n        } else {\n            return throwError('AppName/TaskId not configured');\n        }\n    }\n\n    /**\n     * Gets details of a task.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the task whose details you want\n     * @returns Task details\n     */\n    getTaskById(appName: string, taskId: string): Observable<TaskDetailsCloudModel> {\n        if ((appName || appName === '') && taskId) {\n            const queryUrl = `${this.getBasePath(appName)}/query/v1/tasks/${taskId}`;\n\n            return this.get(queryUrl).pipe(map((res: any) => res.entry));\n        } else {\n            return throwError('AppName/TaskId not configured');\n        }\n    }\n\n    /**\n     * Creates a new standalone task.\n     *\n     * @param startTaskRequest request model\n     * @param appName application name\n     * @returns Details of the newly created task\n     */\n    createNewTask(startTaskRequest: StartTaskCloudRequestModel, appName: string): Observable<TaskDetailsCloudModel> {\n        const queryUrl = `${this.getBasePath(appName)}/rb/v1/tasks`;\n        const payload = JSON.stringify(new StartTaskCloudRequestModel(startTaskRequest));\n\n        return this.post<any, StartTaskCloudResponseModel>(queryUrl, payload).pipe(map((response) => response.entry));\n    }\n\n    /**\n     * Updates the details (name, description, due date) for a task.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the task to update\n     * @param payload Data to update the task\n     * @returns Updated task details\n     */\n    updateTask(appName: string, taskId: string, payload: any): Observable<TaskDetailsCloudModel> {\n        if ((appName || appName === '') && taskId) {\n            payload.payloadType = 'UpdateTaskPayload';\n            const queryUrl = `${this.getBasePath(appName)}/rb/v1/tasks/${taskId}`;\n\n            return this.put(queryUrl, payload).pipe(map((res: any) => res.entry));\n        } else {\n            return throwError('AppName/TaskId not configured');\n        }\n    }\n\n    /**\n     * Gets candidate users of the task.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the task\n     * @returns Candidate users\n     */\n    getCandidateUsers(appName: string, taskId: string): Observable<string[]> {\n        if ((appName || appName === '') && taskId) {\n            const queryUrl = `${this.getBasePath(appName)}/query/v1/tasks/${taskId}/candidate-users`;\n            return this.get<string[]>(queryUrl);\n        } else {\n            return of([]);\n        }\n    }\n\n    /**\n     * Gets candidate groups of the task.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the task\n     * @returns Candidate groups\n     */\n    getCandidateGroups(appName: string, taskId: string): Observable<string[]> {\n        if ((appName || appName === '') && taskId) {\n            const queryUrl = `${this.getBasePath(appName)}/query/v1/tasks/${taskId}/candidate-groups`;\n            return this.get<string[]>(queryUrl);\n        } else {\n            return of([]);\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     * Updates the task assignee.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the task to update assignee\n     * @param assignee assignee to update current user task assignee\n     * @returns Updated task details with new assignee\n     */\n    assign(appName: string, taskId: string, assignee: string): Observable<TaskDetailsCloudModel> {\n        if (appName && taskId) {\n            const payLoad = { assignee, taskId, payloadType: 'AssignTaskPayload' };\n            const url = `${this.getBasePath(appName)}/rb/v1/tasks/${taskId}/assign`;\n\n            return this.post(url, payLoad).pipe(map((res: any) => res.entry));\n        } else {\n            return throwError('AppName/TaskId not configured');\n        }\n    }\n\n    getPriorityLabel(priority: number): string {\n        const priorityItem = this.priorities.find((item) => item.value === priority.toString()) || this.priorities[0];\n        return this.translateService.instant(priorityItem.label);\n    }\n\n    get priorities(): TaskPriorityOption[] {\n        return this.appConfigService.get('adf-cloud-priority-values') || DEFAULT_TASK_PRIORITIES;\n    }\n\n    protected isAssignedToMe(assignee: string): boolean {\n        const currentUser = this.identityUserService.getCurrentUserInfo().username;\n        return assignee === currentUser;\n    }\n}\n"]}