@netgrif/components-core 6.0.1

package/esm2015/lib/resources/engine-endpoint/task-resource.service.js

@@ -0,0 +1,306 @@
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { Injectable } from '@angular/core';
+import { Params, ProviderProgress, ResourceProvider } from '../resource-provider.service';
+import { filter, map } from 'rxjs/operators';
+import { FilterType } from '../../filter/models/filter-type';
+import { HttpEventType } from '@angular/common/http';
+import { FieldConverterService } from '../../task-content/services/field-converter.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { AbstractResourceService } from '../abstract-endpoint/abstract-resource.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../resource-provider.service";
+import * as i2 from "../../configuration/configuration.service";
+import * as i3 from "../../task-content/services/field-converter.service";
+import * as i4 from "../../logger/services/logger.service";
+export class TaskResourceService extends AbstractResourceService {
+    constructor(provider, configService, _fieldConverter, _logger) {
+        super('task', provider, configService);
+        this._fieldConverter = _fieldConverter;
+        this._logger = _logger;
+    }
+    /**
+     *  Count tasks by provided criteria
+     *  POST
+     *  {{baseUrl}}/api/task/count
+     */
+    count(filterParam) {
+        if (filterParam.type !== FilterType.TASK) {
+            throw new Error('Provided filter doesn\'t have type TASK');
+        }
+        return this._resourceProvider.post$('task/count', this.SERVER_URL, filterParam.getRequestBody(), filterParam.getRequestParams())
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Get all tasks
+     * GET
+     * {{baseUrl}}/api/task
+     */
+    getAllTask() {
+        return this._resourceProvider.get$('task', this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, 'tasks')));
+    }
+    /**
+     * Assign task
+     * GET
+     */
+    // {{baseUrl}}/api/task/assign/:id
+    assignTask(taskId) {
+        return this._resourceProvider.get$('task/assign/' + taskId, this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Cancel task
+     * GET
+     */
+    // {{baseUrl}}/api/task/cancel/:id
+    cancelTask(taskId) {
+        return this._resourceProvider.get$('task/cancel/' + taskId, this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Delegate task
+     * POST
+     */
+    // {{baseUrl}}/api/task/delegate/:id
+    delegateTask(taskId, body) {
+        return this._resourceProvider.post$('task/delegate/' + taskId, this.SERVER_URL, body, undefined, { 'Content-Type': 'text/plain' })
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Finish task
+     * GET
+     */
+    // {{baseUrl}}/api/task/finish/:id
+    finishTask(taskId) {
+        return this._resourceProvider.get$('task/finish/' + taskId, this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Searches tasks trough the Elastic endpoint.
+     * POST
+     * @param filterParam filter used to search the tasks. Must be of type `TASK`.
+     * @param params Additional parameters
+     */
+    // {{baseUrl}}/api/task/search_es
+    searchTask(filterParam, params) {
+        if (filterParam.type !== FilterType.TASK) {
+            throw new Error('Provided filter doesn\'t have type TASK');
+        }
+        params = ResourceProvider.combineParams(filterParam.getRequestParams(), params);
+        return this._resourceProvider.post$('task/search_es', this.SERVER_URL, filterParam.getRequestBody(), params)
+            .pipe(map(r => this.getResourcePage(r, 'tasks')));
+    }
+    /**
+     * Searches tasks trough the Mongo endpoint.
+     * POST
+     * @param filterParam filter used to search the tasks. Must be of type `TASK`.
+     * Note that the `query` attribute of the filter cannot be used with this endpoint.
+     * Attempting to use it will display a warning and remove the attribute from the request.
+     * @param params Additional request parameters
+     */
+    // {{baseUrl}}/api/task/search
+    getTasks(filterParam, params) {
+        if (filterParam.type !== FilterType.TASK) {
+            throw new Error('Provided filter doesn\'t have type TASK');
+        }
+        if (filterParam.bodyContainsQuery()) {
+            throw new Error('getTasks endpoint cannot be queried with filters that contain the \'query\' attribute');
+        }
+        params = ResourceProvider.combineParams(filterParam.getRequestParams(), params);
+        return this._resourceProvider.post$('task/search', this.SERVER_URL, filterParam.getRequestBody(), params)
+            .pipe(map(r => this.getResourcePage(r, 'tasks')));
+    }
+    // ----------- CASE ----------
+    /**
+     * Get all tasks by cases
+     * POST
+     */
+    // {{baseUrl}}/api/task/case
+    getAllTasksByCases(body) {
+        return this._resourceProvider.post$('task/case', this.SERVER_URL, body)
+            .pipe(map(r => this.changeType(r, 'tasks')));
+    }
+    /**
+     * Get tasks of the case
+     * GET
+     */
+    // {{baseUrl}}/api/task/case/:id
+    getAllTasksByCase(caseId) {
+        return this._resourceProvider.get$('task/case/' + caseId, this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    // ----------- MY Task ----------
+    /**
+     * Get all tasks assigned to logged user
+     * GET
+     */
+    // {{baseUrl}}/api/task/my
+    getAllMyTasks() {
+        return this._resourceProvider.get$('task/my', this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Get all finished tasks by logged user
+     * GET
+     */
+    // {{baseUrl}}/api/task/my/finished
+    getAllFinishedTask() {
+        return this._resourceProvider.get$('task/my/finished', this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Get all task data
+     *
+     * GET
+     *
+     * If you don't want to parse the response yourself use [getData]{@link TaskResourceService#getData} instead.
+     *
+     * @returns the raw backend response without any additional processing
+     */
+    // {{baseUrl}}/api/task/:id/data
+    rawGetData(taskId) {
+        return this._resourceProvider.get$('task/' + taskId + '/data', this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     *  Get all task data
+     *
+     *  GET
+     *
+     *  If you want to process the raw backend response use [rawGetData]{@link TaskResourceService#rawGetData} instead.
+     *
+     * @param taskId ID of the task who's data should be retrieved from the server
+     * @returns processed data groups of the given task. If the task has no data an empty array will be returned.
+     */
+    getData(taskId) {
+        return this.rawGetData(taskId).pipe(map((responseOutcome) => {
+            const dataGroupsArray = this.changeType(responseOutcome.outcome.data, 'dataGroups');
+            if (!Array.isArray(dataGroupsArray)) {
+                return [];
+            }
+            const result = [];
+            dataGroupsArray.forEach(dataGroupResource => {
+                const dataFields = [];
+                if (!dataGroupResource.fields._embedded) {
+                    return; // continue
+                }
+                const fields = [];
+                Object.keys(dataGroupResource.fields._embedded).forEach(localizedFields => {
+                    fields.push(...dataGroupResource.fields._embedded[localizedFields]);
+                });
+                fields.sort((a, b) => a.order - b.order);
+                dataFields.push(...fields.map(dataFieldResource => this._fieldConverter.toClass(dataFieldResource)));
+                const dataGroupObject = {
+                    fields: dataFields,
+                    stretch: dataGroupResource.stretch,
+                    title: dataGroupResource.title,
+                    layout: dataGroupResource.layout,
+                    alignment: dataGroupResource.alignment,
+                };
+                if (dataGroupResource.parentTaskId !== undefined) {
+                    dataGroupObject.parentTaskId = dataGroupResource.parentTaskId;
+                    dataGroupObject.parentTaskRefId = dataGroupResource.parentTaskRefId;
+                    dataGroupObject.nestingLevel = dataGroupResource.nestingLevel;
+                }
+                if (dataGroupResource.parentCaseId !== undefined) {
+                    dataGroupObject['parentCaseId'] = dataGroupResource.parentCaseId;
+                }
+                result.push(dataGroupObject);
+            });
+            return result;
+        }));
+    }
+    /**
+     * Set task data
+     * POST
+     */
+    // {{baseUrl}}/api/task/:id/data
+    setData(taskId, body) {
+        return this._resourceProvider.post$('task/' + taskId + '/data', this.SERVER_URL, body)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    // ------------- FILE ------------
+    /**
+     * Download task file field value
+     * GET
+     */
+    // {{baseUrl}}/api/task/:id/file/:field         - for file field
+    // {{baseUrl}}/api/task/:id/file/:field/:name   - for file list field
+    downloadFile(taskId, fieldId, name) {
+        const url = !!name ? 'task/' + taskId + '/file/' + fieldId + '/' + name : 'task/' + taskId + '/file/' + fieldId;
+        return this._resourceProvider.getBlob$(url, this.SERVER_URL).pipe(map(event => {
+            switch (event.type) {
+                case HttpEventType.DownloadProgress:
+                    return ResourceProvider.getProgress(event);
+                case HttpEventType.Response:
+                    return event.body;
+                default:
+                    return undefined;
+            }
+        }), filter(value => !!value));
+    }
+    /**
+     * Upload file into the task
+     * POST
+     */
+    // {{baseUrl}}/api/task/:id/file/:field     - for file field
+    // {{baseUrl}}/api/task/:id/files/:field    - for file list field
+    uploadFile(taskId, fieldId, body, multipleFiles) {
+        const url = !multipleFiles ? 'task/' + taskId + '/file/' + fieldId : 'task/' + taskId + '/files/' + fieldId;
+        return this._resourceProvider.postWithEvent$(url, this.SERVER_URL, body).pipe(map(event => {
+            switch (event.type) {
+                case HttpEventType.UploadProgress:
+                    return ResourceProvider.getProgress(event);
+                case HttpEventType.Response:
+                    return event.body;
+                default:
+                    return undefined;
+            }
+        }), filter(value => !!value));
+    }
+    /**
+     * Delete file from the task
+     * DELETE
+     */
+    deleteFile(taskId, fieldId, name) {
+        const url = !!name ? 'task/' + taskId + '/file/' + fieldId + '/' + name : 'task/' + taskId + '/file/' + fieldId;
+        return this._resourceProvider.delete$(url, this.SERVER_URL).pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Download task file preview for field value
+     * GET
+     */
+    // {{baseUrl}}/api/task/:id/file_preview/:field
+    downloadFilePreview(taskId, fieldId) {
+        const url = 'task/' + taskId + '/file_preview/' + fieldId;
+        return this._resourceProvider.getBlob$(url, this.SERVER_URL).pipe(map(event => {
+            switch (event.type) {
+                case HttpEventType.DownloadProgress:
+                    return ResourceProvider.getProgress(event);
+                case HttpEventType.Response:
+                    return event.body;
+                default:
+                    return undefined;
+            }
+        }), filter(value => !!value));
+    }
+}
+TaskResourceService.ctorParameters = () => [
+    { type: ResourceProvider },
+    { type: ConfigurationService },
+    { type: FieldConverterService },
+    { type: LoggerService }
+];
+TaskResourceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TaskResourceService_Factory() { return new TaskResourceService(i0.ɵɵinject(i1.ResourceProvider), i0.ɵɵinject(i2.ConfigurationService), i0.ɵɵinject(i3.FieldConverterService), i0.ɵɵinject(i4.LoggerService)); }, token: TaskResourceService, providedIn: "root" });
+TaskResourceService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+TaskResourceService.ctorParameters = () => [
+    { type: ResourceProvider },
+    { type: ConfigurationService },
+    { type: FieldConverterService },
+    { type: LoggerService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-resource.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/resources/engine-endpoint/task-resource.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {ConfigurationService} from '../../configuration/configuration.service';\nimport {Injectable} from '@angular/core';\nimport {Params, ProviderProgress, ResourceProvider} from '../resource-provider.service';\nimport {Observable} from 'rxjs';\nimport {Count} from '../interface/count';\nimport {EventOutcomeMessageResource, MessageResource} from '../interface/message-resource';\nimport {filter, map} from 'rxjs/operators';\nimport {TaskReference} from '../interface/task-reference';\nimport {Task} from '../interface/task';\nimport {CountService} from '../abstract-endpoint/count-service';\nimport {Filter} from '../../filter/models/filter';\nimport {FilterType} from '../../filter/models/filter-type';\nimport {HttpEventType} from '@angular/common/http';\nimport {Page} from '../interface/page';\nimport {FieldConverterService} from '../../task-content/services/field-converter.service';\nimport {TaskSetDataRequestBody} from '../interface/task-set-data-request-body';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {AbstractResourceService} from '../abstract-endpoint/abstract-resource.service';\nimport {DataGroup} from '../interface/data-groups';\nimport {DataField} from '../../data-fields/models/abstract-data-field';\nimport {GetDataGroupsEventOutcome} from '../../event/model/event-outcomes/data-outcomes/get-data-groups-event-outcome';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class TaskResourceService extends AbstractResourceService implements CountService {\n\n    constructor(provider: ResourceProvider,\n                configService: ConfigurationService,\n                protected _fieldConverter: FieldConverterService,\n                protected _logger: LoggerService) {\n        super('task', provider, configService);\n    }\n\n    /**\n     *  Count tasks by provided criteria\n     *  POST\n     *  {{baseUrl}}/api/task/count\n     */\n    public count(filterParam: Filter): Observable<Count> {\n        if (filterParam.type !== FilterType.TASK) {\n            throw new Error('Provided filter doesn\\'t have type TASK');\n        }\n        return this._resourceProvider.post$('task/count', this.SERVER_URL, filterParam.getRequestBody(), filterParam.getRequestParams())\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get all tasks\n     * GET\n     * {{baseUrl}}/api/task\n     */\n    public getAllTask(): Observable<Array<Task>> {\n        return this._resourceProvider.get$('task', this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, 'tasks')));\n    }\n\n    /**\n     * Assign task\n     * GET\n     */\n    // {{baseUrl}}/api/task/assign/:id\n    public assignTask(taskId: string): Observable<EventOutcomeMessageResource> {\n        return this._resourceProvider.get$('task/assign/' + taskId, this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Cancel task\n     * GET\n     */\n    // {{baseUrl}}/api/task/cancel/:id\n    public cancelTask(taskId: string): Observable<EventOutcomeMessageResource> {\n        return this._resourceProvider.get$('task/cancel/' + taskId, this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Delegate task\n     * POST\n     */\n    // {{baseUrl}}/api/task/delegate/:id\n    public delegateTask(taskId: string, body: object): Observable<EventOutcomeMessageResource> {\n        return this._resourceProvider.post$('task/delegate/' + taskId, this.SERVER_URL, body, undefined, {'Content-Type': 'text/plain'})\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Finish task\n     * GET\n     */\n    // {{baseUrl}}/api/task/finish/:id\n    public finishTask(taskId: string): Observable<EventOutcomeMessageResource> {\n        return this._resourceProvider.get$('task/finish/' + taskId, this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Searches tasks trough the Elastic endpoint.\n     * POST\n     * @param filterParam filter used to search the tasks. Must be of type `TASK`.\n     * @param params Additional parameters\n     */\n    // {{baseUrl}}/api/task/search_es\n    public searchTask(filterParam: Filter, params?: Params): Observable<Page<Task>> {\n        if (filterParam.type !== FilterType.TASK) {\n            throw new Error('Provided filter doesn\\'t have type TASK');\n        }\n        params = ResourceProvider.combineParams(filterParam.getRequestParams(), params);\n        return this._resourceProvider.post$('task/search_es', this.SERVER_URL, filterParam.getRequestBody(), params)\n            .pipe(map(r => this.getResourcePage<Task>(r, 'tasks')));\n    }\n\n    /**\n     * Searches tasks trough the Mongo endpoint.\n     * POST\n     * @param filterParam filter used to search the tasks. Must be of type `TASK`.\n     * Note that the `query` attribute of the filter cannot be used with this endpoint.\n     * Attempting to use it will display a warning and remove the attribute from the request.\n     * @param params Additional request parameters\n     */\n    // {{baseUrl}}/api/task/search\n    public getTasks(filterParam: Filter, params?: Params): Observable<Page<Task>> {\n        if (filterParam.type !== FilterType.TASK) {\n            throw new Error('Provided filter doesn\\'t have type TASK');\n        }\n\n        if (filterParam.bodyContainsQuery()) {\n            throw new Error('getTasks endpoint cannot be queried with filters that contain the \\'query\\' attribute');\n        }\n\n        params = ResourceProvider.combineParams(filterParam.getRequestParams(), params);\n        return this._resourceProvider.post$('task/search', this.SERVER_URL, filterParam.getRequestBody(), params)\n            .pipe(map(r => this.getResourcePage<Task>(r, 'tasks')));\n    }\n\n    // ----------- CASE ----------\n    /**\n     * Get all tasks by cases\n     * POST\n     */\n    // {{baseUrl}}/api/task/case\n    public getAllTasksByCases(body: object): Observable<Array<Task>> { // TODO: ??\n        return this._resourceProvider.post$('task/case', this.SERVER_URL, body)\n            .pipe(map(r => this.changeType(r, 'tasks')));\n    }\n\n    /**\n     * Get tasks of the case\n     * GET\n     */\n    // {{baseUrl}}/api/task/case/:id\n    public getAllTasksByCase(caseId: string): Observable<Array<TaskReference>> {\n        return this._resourceProvider.get$('task/case/' + caseId, this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    // ----------- MY Task ----------\n    /**\n     * Get all tasks assigned to logged user\n     * GET\n     */\n    // {{baseUrl}}/api/task/my\n    public getAllMyTasks(): Observable<Array<Task>> {\n        return this._resourceProvider.get$('task/my', this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get all finished tasks by logged user\n     * GET\n     */\n    // {{baseUrl}}/api/task/my/finished\n    public getAllFinishedTask(): Observable<Array<Task>> {\n        return this._resourceProvider.get$('task/my/finished', this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get all task data\n     *\n     * GET\n     *\n     * If you don't want to parse the response yourself use [getData]{@link TaskResourceService#getData} instead.\n     *\n     * @returns the raw backend response without any additional processing\n     */\n    // {{baseUrl}}/api/task/:id/data\n    public rawGetData(taskId: string): Observable<EventOutcomeMessageResource> {\n        return this._resourceProvider.get$('task/' + taskId + '/data', this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     *  Get all task data\n     *\n     *  GET\n     *\n     *  If you want to process the raw backend response use [rawGetData]{@link TaskResourceService#rawGetData} instead.\n     *\n     * @param taskId ID of the task who's data should be retrieved from the server\n     * @returns processed data groups of the given task. If the task has no data an empty array will be returned.\n     */\n    public getData(taskId: string): Observable<Array<DataGroup>> {\n        return this.rawGetData(taskId).pipe(\n            map((responseOutcome: EventOutcomeMessageResource) => {\n                const dataGroupsArray = this.changeType((responseOutcome.outcome as GetDataGroupsEventOutcome).data, 'dataGroups');\n                if (!Array.isArray(dataGroupsArray)) {\n                    return [];\n                }\n                const result = [];\n                dataGroupsArray.forEach(dataGroupResource => {\n                    const dataFields: Array<DataField<any>> = [];\n                    if (!dataGroupResource.fields._embedded) {\n                        return; // continue\n                    }\n                    const fields = [];\n                    Object.keys(dataGroupResource.fields._embedded).forEach(localizedFields => {\n                        fields.push(...dataGroupResource.fields._embedded[localizedFields]);\n                    });\n                    fields.sort((a, b) => a.order - b.order);\n                    dataFields.push(...fields.map(dataFieldResource => this._fieldConverter.toClass(dataFieldResource)));\n                    const dataGroupObject: DataGroup = {\n                        fields: dataFields,\n                        stretch: dataGroupResource.stretch,\n                        title: dataGroupResource.title,\n                        layout: dataGroupResource.layout,\n                        alignment: dataGroupResource.alignment,\n                    };\n                    if (dataGroupResource.parentTaskId !== undefined) {\n                        dataGroupObject.parentTaskId = dataGroupResource.parentTaskId;\n                        dataGroupObject.parentTaskRefId = dataGroupResource.parentTaskRefId;\n                        dataGroupObject.nestingLevel = dataGroupResource.nestingLevel;\n                    }\n                    if (dataGroupResource.parentCaseId !== undefined) {\n                        dataGroupObject['parentCaseId'] = dataGroupResource.parentCaseId;\n                    }\n                    result.push(dataGroupObject);\n                });\n                return result;\n            })\n        );\n    }\n\n    /**\n     * Set task data\n     * POST\n     */\n    // {{baseUrl}}/api/task/:id/data\n    public setData(taskId: string, body: TaskSetDataRequestBody): Observable<EventOutcomeMessageResource> {\n        return this._resourceProvider.post$('task/' + taskId + '/data', this.SERVER_URL, body)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    // ------------- FILE ------------\n    /**\n     * Download task file field value\n     * GET\n     */\n    // {{baseUrl}}/api/task/:id/file/:field         - for file field\n    // {{baseUrl}}/api/task/:id/file/:field/:name   - for file list field\n    public downloadFile(taskId: string, fieldId: string, name?: string): Observable<ProviderProgress | Blob> {\n        const url = !!name ? 'task/' + taskId + '/file/' + fieldId + '/' + name : 'task/' + taskId + '/file/' + fieldId;\n        return this._resourceProvider.getBlob$(url, this.SERVER_URL).pipe(\n            map(event => {\n                switch (event.type) {\n                    case HttpEventType.DownloadProgress:\n                        return ResourceProvider.getProgress(event);\n                    case HttpEventType.Response:\n                        return event.body;\n                    default:\n                        return undefined;\n                }\n            }),\n            filter(value => !!value)\n        );\n    }\n\n    /**\n     * Upload file into the task\n     * POST\n     */\n    // {{baseUrl}}/api/task/:id/file/:field     - for file field\n    // {{baseUrl}}/api/task/:id/files/:field    - for file list field\n    public uploadFile(taskId: string, fieldId: string, body: object, multipleFiles: boolean):\n        Observable<ProviderProgress | EventOutcomeMessageResource> {\n        const url = !multipleFiles ? 'task/' + taskId + '/file/' + fieldId : 'task/' + taskId + '/files/' + fieldId;\n        return this._resourceProvider.postWithEvent$<EventOutcomeMessageResource>(url, this.SERVER_URL, body).pipe(\n            map(event => {\n                switch (event.type) {\n                    case HttpEventType.UploadProgress:\n                        return ResourceProvider.getProgress(event);\n                    case HttpEventType.Response:\n                        return event.body;\n                    default:\n                        return undefined;\n                }\n            }),\n            filter(value => !!value)\n        );\n    }\n\n    /**\n     * Delete file from the task\n     * DELETE\n     */\n    public deleteFile(taskId: string, fieldId: string, name?: string): Observable<MessageResource> {\n        const url = !!name ? 'task/' + taskId + '/file/' + fieldId + '/' + name : 'task/' + taskId + '/file/' + fieldId;\n        return this._resourceProvider.delete$(url, this.SERVER_URL).pipe(\n            map(r => this.changeType(r, undefined))\n        );\n    }\n\n    /**\n     * Download task file preview for field value\n     * GET\n     */\n    // {{baseUrl}}/api/task/:id/file_preview/:field\n    public downloadFilePreview(taskId: string, fieldId: string): Observable<ProviderProgress | Blob> {\n        const url = 'task/' + taskId + '/file_preview/' + fieldId;\n        return this._resourceProvider.getBlob$(url, this.SERVER_URL).pipe(\n            map(event => {\n                switch (event.type) {\n                    case HttpEventType.DownloadProgress:\n                        return ResourceProvider.getProgress(event);\n                    case HttpEventType.Response:\n                        return event.body;\n                    default:\n                        return undefined;\n                }\n            }),\n            filter(value => !!value)\n        );\n    }\n}\n"]}

package/esm2015/lib/resources/engine-endpoint/user-resource.service.js

@@ -0,0 +1,191 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { Params, ResourceProvider } from '../resource-provider.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { AbstractResourceService } from '../abstract-endpoint/abstract-resource.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../resource-provider.service";
+import * as i2 from "../../configuration/configuration.service";
+export class UserResourceService extends AbstractResourceService {
+    constructor(provider, configService) {
+        super('user', provider, configService);
+    }
+    /**
+     * Assign authority to the user
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/{id}/authority/assign
+     */
+    assignAuthority(userId, body, params) {
+        return this._resourceProvider.post$('user/' + userId + '/authority/assign', this.SERVER_URL, body, params, { 'Content-Type': 'text/plain' })
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Assign role to the user
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/{id}/role/assign
+     */
+    assignRoles(userId, body, params) {
+        return this._resourceProvider.post$('user/' + userId + '/role/assign', this.SERVER_URL, body, params)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Get all authorities of the system
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/authority
+     */
+    getAllAuthorities() {
+        return this._resourceProvider.get$('user/authority', this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, 'authorities')));
+    }
+    /**
+     * Get all users
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user
+     */
+    getAll(params) {
+        return this._resourceProvider.get$('user', this.SERVER_URL, params)
+            .pipe(map(r => this.getResourcePage(r, 'users')));
+    }
+    /**
+     * Get all users with specified roles
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/role
+     */
+    getAllWithRole(body, params) {
+        return this._resourceProvider.post$('user/role', this.SERVER_URL, body, params)
+            .pipe(map(r => this.changeType(r, 'users')));
+    }
+    /**
+     * Get logged user
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/me
+     */
+    getLoggedUser(params) {
+        return this._resourceProvider.get$('user/me', this.SERVER_URL, params).pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Get logged user
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/me
+     */
+    getPublicLoggedUser(params) {
+        return this._resourceProvider.get$('public/user/me', this.SERVER_URL, params).pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Get user by id
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/{id}
+     */
+    getUser(userId, params) {
+        return this._resourceProvider.get$('user/' + userId, this.SERVER_URL, params)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Get user's preferences
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/preferences
+     */
+    getPreferences(params) {
+        return this._resourceProvider.get$('user/preferences', this.SERVER_URL, params)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Set user's preferences
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/preferences
+     */
+    setPreferences(body, params) {
+        return this._resourceProvider.post$('user/preferences', this.SERVER_URL, body, params)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Get user's preferences
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/preferences
+     */
+    getPublicPreferences(params) {
+        return this._resourceProvider.get$('public/user/preferences', this.SERVER_URL, params)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Set user's preferences
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/preferences
+     */
+    setPublicPreferences(body, params) {
+        return this._resourceProvider.post$('public/user/preferences', this.SERVER_URL, body, params)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Generic user search
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/search
+     */
+    search(body, params) {
+        return this._resourceProvider.post$('user/search', this.SERVER_URL, body, params)
+            .pipe(map(r => this.getResourcePage(r, 'users')));
+    }
+    /**
+     * Update user
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/{id}
+     */
+    updateUser(userId, body, params) {
+        return this._resourceProvider.post$('user/' + userId, this.SERVER_URL, body, params)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * get all groups
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/group/all
+     */
+    getAllGroups(params) {
+        return this._resourceProvider.get$('group/all', this.SERVER_URL, params)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+}
+UserResourceService.ctorParameters = () => [
+    { type: ResourceProvider },
+    { type: ConfigurationService }
+];
+UserResourceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserResourceService_Factory() { return new UserResourceService(i0.ɵɵinject(i1.ResourceProvider), i0.ɵɵinject(i2.ConfigurationService)); }, token: UserResourceService, providedIn: "root" });
+UserResourceService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+UserResourceService.ctorParameters = () => [
+    { type: ResourceProvider },
+    { type: ConfigurationService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-resource.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/resources/engine-endpoint/user-resource.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {Observable} from 'rxjs';\nimport {map} from 'rxjs/operators';\nimport {Params, ResourceProvider} from '../resource-provider.service';\nimport {ConfigurationService} from '../../configuration/configuration.service';\nimport {MessageResource} from '../interface/message-resource';\nimport {Authority} from '../interface/authority';\nimport {Preferences} from '../interface/preferences';\nimport {Page} from '../interface/page';\nimport {GroupsInterface} from '../interface/group';\nimport {AbstractResourceService} from '../abstract-endpoint/abstract-resource.service';\nimport {UserResource} from '../interface/user-resource';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UserResourceService extends AbstractResourceService {\n\n    constructor(provider: ResourceProvider, configService: ConfigurationService) {\n        super('user', provider, configService);\n    }\n\n    /**\n     * Assign authority to the user\n     *\n     * **Request Type:** POST\n     *\n     * **Request URL:** {{baseUrl}}/api/user/{id}/authority/assign\n     */\n    public assignAuthority(userId: string, body: object, params?: Params): Observable<MessageResource> {\n        return this._resourceProvider.post$('user/' + userId + '/authority/assign', this.SERVER_URL, body, params,\n            {'Content-Type': 'text/plain'})\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Assign role to the user\n     *\n     * **Request Type:** POST\n     *\n     * **Request URL:** {{baseUrl}}/api/user/{id}/role/assign\n     */\n    public assignRoles(userId: string, body: object, params?: Params): Observable<MessageResource> {\n        return this._resourceProvider.post$('user/' + userId + '/role/assign', this.SERVER_URL, body, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get all authorities of the system\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/user/authority\n     */\n    public getAllAuthorities(): Observable<Array<Authority>> {\n        return this._resourceProvider.get$('user/authority', this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, 'authorities')));\n    }\n\n    /**\n     * Get all users\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/user\n     */\n    public getAll(params?: Params): Observable<Page<UserResource>> {\n        return this._resourceProvider.get$('user', this.SERVER_URL, params)\n            .pipe(map(r => this.getResourcePage<UserResource>(r, 'users')));\n    }\n\n    /**\n     * Get all users with specified roles\n     *\n     * **Request Type:** POST\n     *\n     * **Request URL:** {{baseUrl}}/api/user/role\n     */\n    public getAllWithRole(body: object, params?: Params): Observable<Array<UserResource>> {\n        return this._resourceProvider.post$('user/role', this.SERVER_URL, body, params)\n            .pipe(map(r => this.changeType(r, 'users')));\n    }\n\n    /**\n     * Get logged user\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/user/me\n     */\n    public getLoggedUser(params?: Params): Observable<UserResource> {\n        return this._resourceProvider.get$('user/me', this.SERVER_URL, params).pipe(\n                map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get logged user\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/user/me\n     */\n    public getPublicLoggedUser(params?: Params): Observable<UserResource> {\n        return this._resourceProvider.get$('public/user/me', this.SERVER_URL, params).pipe(\n            map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get user by id\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/user/{id}\n     */\n    public getUser(userId: string, params?: Params): Observable<UserResource> {\n        return this._resourceProvider.get$('user/' + userId, this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get user's preferences\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/user/preferences\n     */\n    public getPreferences(params?: Params): Observable<Preferences> {\n        return this._resourceProvider.get$('user/preferences', this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Set user's preferences\n     *\n     * **Request Type:** POST\n     *\n     * **Request URL:** {{baseUrl}}/api/user/preferences\n     */\n    public setPreferences(body: object, params?: Params): Observable<MessageResource> {\n        return this._resourceProvider.post$('user/preferences', this.SERVER_URL, body, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get user's preferences\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/user/preferences\n     */\n    public getPublicPreferences(params?: Params): Observable<Preferences> {\n        return this._resourceProvider.get$('public/user/preferences', this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Set user's preferences\n     *\n     * **Request Type:** POST\n     *\n     * **Request URL:** {{baseUrl}}/api/user/preferences\n     */\n    public setPublicPreferences(body: object, params?: Params): Observable<MessageResource> {\n        return this._resourceProvider.post$('public/user/preferences', this.SERVER_URL, body, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Generic user search\n     *\n     * **Request Type:** POST\n     *\n     * **Request URL:** {{baseUrl}}/api/user/search\n     */\n    public search(body: object, params?: Params): Observable<Page<UserResource>> {\n        return this._resourceProvider.post$('user/search', this.SERVER_URL, body, params)\n            .pipe(map(r => this.getResourcePage<UserResource>(r, 'users')));\n    }\n\n    /**\n     * Update user\n     *\n     * **Request Type:** POST\n     *\n     * **Request URL:** {{baseUrl}}/api/user/{id}\n     */\n    public updateUser(userId: string, body: object, params?: Params): Observable<UserResource> {\n        return this._resourceProvider.post$('user/' + userId, this.SERVER_URL, body, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * get all groups\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/group/all\n     */\n    public getAllGroups(params?: Params): Observable<GroupsInterface> {\n        return this._resourceProvider.get$('group/all', this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n}\n"]}

package/esm2015/lib/resources/interface/assigned-user-policy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzaWduZWQtdXNlci1wb2xpY3kuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvcmVzb3VyY2VzL2ludGVyZmFjZS9hc3NpZ25lZC11c2VyLXBvbGljeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBBc3NpZ25lZFVzZXJQb2xpY3kge1xuICAgIGNhbmNlbD86IGJvb2xlYW47XG4gICAgcmVhc3NpZ24/OiBib29sZWFuO1xufVxuIl19

package/esm2015/lib/resources/interface/author.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3Jlc291cmNlcy9pbnRlcmZhY2UvYXV0aG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE9iamVjdCBmcm9tIEJhY2tlbmRcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBBdXRob3Ige1xuICAgIC8qKlxuICAgICAqICoqRXhhbXBsZToqKiBleGFtcGxlQG5ldGdyaWYuY29tXG4gICAgICovXG4gICAgZW1haWw6IHN0cmluZztcbiAgICAvKipcbiAgICAgKiBGaXJzdCBuYW1lICsgXCIgXCIgKyBTdXJuYW1lXG4gICAgICpcbiAgICAgKiAqKkV4YW1wbGU6KiogRXhhbXBsZSBOZXRncmlmXG4gICAgICovXG4gICAgZnVsbE5hbWU6IHN0cmluZztcbn1cbiJdfQ==

package/esm2015/lib/resources/interface/authority.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yaXR5LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3Jlc291cmNlcy9pbnRlcmZhY2UvYXV0aG9yaXR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE9iamVjdCBmcm9tIEJhY2tlbmRcbiAqXG4gKiBBdXRob3JpdHk6IFJPTEVfVVNFUiB8IFJPTEVfQURNSU4gfCBST0xFX1NZU1RFTUFETUlOIHwgQ3VzdG9tIFJvbGVcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBBdXRob3JpdHkge1xuICAgIC8qKlxuICAgICAqIFNwcmluZyBCb290IFJvbGVcbiAgICAgKlxuICAgICAqICoqRXhhbXBsZToqKiBST0xFX1NZU1RFTUFETUlOXG4gICAgICovXG4gICAgYXV0aG9yaXR5OiAnUk9MRV9VU0VSJyB8ICdST0xFX0FETUlOJyB8ICdST0xFX1NZU1RFTUFETUlOJyB8IHN0cmluZztcbn1cbiJdfQ==

package/esm2015/lib/resources/interface/case-get-request-body.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/resources/interface/case.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/resources/interface/changed-field-container.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbmdlZC1maWVsZC1jb250YWluZXIuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvcmVzb3VyY2VzL2ludGVyZmFjZS9jaGFuZ2VkLWZpZWxkLWNvbnRhaW5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDaGFuZ2VkRmllbGRzfSBmcm9tICcuLi8uLi9kYXRhLWZpZWxkcy9tb2RlbHMvY2hhbmdlZC1maWVsZHMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIENoYW5nZWRGaWVsZENvbnRhaW5lciB7XG4gICAgY2hhbmdlZEZpZWxkczogQ2hhbmdlZEZpZWxkcztcbn1cbiJdfQ==

package/esm2015/lib/resources/interface/count.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291bnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvcmVzb3VyY2VzL2ludGVyZmFjZS9jb3VudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBPYmplY3QgZnJvbSBCYWNrZW5kXG4gKlxuICogVGhlIG51bWJlciBvZiB0aGVzZSBpbnN0YW5jZXNcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDb3VudCB7XG4gICAgLyoqXG4gICAgICogQ291bnQgaW5zdGFuY2VzXG4gICAgICovXG4gICAgY291bnQ6IG51bWJlcjtcbiAgICAvKipcbiAgICAgKiBOYW1lIGluc3RhbmNlc1xuICAgICAqL1xuICAgIGVudGl0eTogc3RyaW5nO1xufVxuIl19

package/esm2015/lib/resources/interface/create-case-request-body.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWNhc2UtcmVxdWVzdC1ib2R5LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3Jlc291cmNlcy9pbnRlcmZhY2UvY3JlYXRlLWNhc2UtcmVxdWVzdC1ib2R5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENyZWF0ZUNhc2VSZXF1ZXN0Qm9keSB7XG4gICAgLyoqXG4gICAgICogVGl0bGUgb2YgdGhlIG5ldyBjYXNlXG4gICAgICovXG4gICAgdGl0bGU6IHN0cmluZztcbiAgICAvKipcbiAgICAgKiBTdHJpbmdJZCBvZiB0aGUgcHJvY2VzcyBmcm9tIHdoaWNoIHRoZSBuZXcgY2FzZSBzaG91bGQgYmUgY3JlYXRlZFxuICAgICAqL1xuICAgIG5ldElkOiBzdHJpbmc7XG4gICAgY29sb3I/OiBzdHJpbmc7XG59XG4iXX0=