@netgrif/components-core 6.0.1

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

@@ -0,0 +1,327 @@
+import { __extends, __read, __spread } from "tslib";
+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";
+var TaskResourceService = /** @class */ (function (_super) {
+    __extends(TaskResourceService, _super);
+    function TaskResourceService(provider, configService, _fieldConverter, _logger) {
+        var _this = _super.call(this, 'task', provider, configService) || this;
+        _this._fieldConverter = _fieldConverter;
+        _this._logger = _logger;
+        return _this;
+    }
+    /**
+     *  Count tasks by provided criteria
+     *  POST
+     *  {{baseUrl}}/api/task/count
+     */
+    TaskResourceService.prototype.count = function (filterParam) {
+        var _this = this;
+        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(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get all tasks
+     * GET
+     * {{baseUrl}}/api/task
+     */
+    TaskResourceService.prototype.getAllTask = function () {
+        var _this = this;
+        return this._resourceProvider.get$('task', this.SERVER_URL)
+            .pipe(map(function (r) { return _this.changeType(r, 'tasks'); }));
+    };
+    /**
+     * Assign task
+     * GET
+     */
+    // {{baseUrl}}/api/task/assign/:id
+    TaskResourceService.prototype.assignTask = function (taskId) {
+        var _this = this;
+        return this._resourceProvider.get$('task/assign/' + taskId, this.SERVER_URL)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Cancel task
+     * GET
+     */
+    // {{baseUrl}}/api/task/cancel/:id
+    TaskResourceService.prototype.cancelTask = function (taskId) {
+        var _this = this;
+        return this._resourceProvider.get$('task/cancel/' + taskId, this.SERVER_URL)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Delegate task
+     * POST
+     */
+    // {{baseUrl}}/api/task/delegate/:id
+    TaskResourceService.prototype.delegateTask = function (taskId, body) {
+        var _this = this;
+        return this._resourceProvider.post$('task/delegate/' + taskId, this.SERVER_URL, body, undefined, { 'Content-Type': 'text/plain' })
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Finish task
+     * GET
+     */
+    // {{baseUrl}}/api/task/finish/:id
+    TaskResourceService.prototype.finishTask = function (taskId) {
+        var _this = this;
+        return this._resourceProvider.get$('task/finish/' + taskId, this.SERVER_URL)
+            .pipe(map(function (r) { return _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
+    TaskResourceService.prototype.searchTask = function (filterParam, params) {
+        var _this = this;
+        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(function (r) { return _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
+    TaskResourceService.prototype.getTasks = function (filterParam, params) {
+        var _this = this;
+        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(function (r) { return _this.getResourcePage(r, 'tasks'); }));
+    };
+    // ----------- CASE ----------
+    /**
+     * Get all tasks by cases
+     * POST
+     */
+    // {{baseUrl}}/api/task/case
+    TaskResourceService.prototype.getAllTasksByCases = function (body) {
+        var _this = this;
+        return this._resourceProvider.post$('task/case', this.SERVER_URL, body)
+            .pipe(map(function (r) { return _this.changeType(r, 'tasks'); }));
+    };
+    /**
+     * Get tasks of the case
+     * GET
+     */
+    // {{baseUrl}}/api/task/case/:id
+    TaskResourceService.prototype.getAllTasksByCase = function (caseId) {
+        var _this = this;
+        return this._resourceProvider.get$('task/case/' + caseId, this.SERVER_URL)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    // ----------- MY Task ----------
+    /**
+     * Get all tasks assigned to logged user
+     * GET
+     */
+    // {{baseUrl}}/api/task/my
+    TaskResourceService.prototype.getAllMyTasks = function () {
+        var _this = this;
+        return this._resourceProvider.get$('task/my', this.SERVER_URL)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get all finished tasks by logged user
+     * GET
+     */
+    // {{baseUrl}}/api/task/my/finished
+    TaskResourceService.prototype.getAllFinishedTask = function () {
+        var _this = this;
+        return this._resourceProvider.get$('task/my/finished', this.SERVER_URL)
+            .pipe(map(function (r) { return _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
+    TaskResourceService.prototype.rawGetData = function (taskId) {
+        var _this = this;
+        return this._resourceProvider.get$('task/' + taskId + '/data', this.SERVER_URL)
+            .pipe(map(function (r) { return _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.
+     */
+    TaskResourceService.prototype.getData = function (taskId) {
+        var _this = this;
+        return this.rawGetData(taskId).pipe(map(function (responseOutcome) {
+            var dataGroupsArray = _this.changeType(responseOutcome.outcome.data, 'dataGroups');
+            if (!Array.isArray(dataGroupsArray)) {
+                return [];
+            }
+            var result = [];
+            dataGroupsArray.forEach(function (dataGroupResource) {
+                var dataFields = [];
+                if (!dataGroupResource.fields._embedded) {
+                    return; // continue
+                }
+                var fields = [];
+                Object.keys(dataGroupResource.fields._embedded).forEach(function (localizedFields) {
+                    fields.push.apply(fields, __spread(dataGroupResource.fields._embedded[localizedFields]));
+                });
+                fields.sort(function (a, b) { return a.order - b.order; });
+                dataFields.push.apply(dataFields, __spread(fields.map(function (dataFieldResource) { return _this._fieldConverter.toClass(dataFieldResource); })));
+                var 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
+    TaskResourceService.prototype.setData = function (taskId, body) {
+        var _this = this;
+        return this._resourceProvider.post$('task/' + taskId + '/data', this.SERVER_URL, body)
+            .pipe(map(function (r) { return _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
+    TaskResourceService.prototype.downloadFile = function (taskId, fieldId, name) {
+        var url = !!name ? 'task/' + taskId + '/file/' + fieldId + '/' + name : 'task/' + taskId + '/file/' + fieldId;
+        return this._resourceProvider.getBlob$(url, this.SERVER_URL).pipe(map(function (event) {
+            switch (event.type) {
+                case HttpEventType.DownloadProgress:
+                    return ResourceProvider.getProgress(event);
+                case HttpEventType.Response:
+                    return event.body;
+                default:
+                    return undefined;
+            }
+        }), filter(function (value) { return !!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
+    TaskResourceService.prototype.uploadFile = function (taskId, fieldId, body, multipleFiles) {
+        var url = !multipleFiles ? 'task/' + taskId + '/file/' + fieldId : 'task/' + taskId + '/files/' + fieldId;
+        return this._resourceProvider.postWithEvent$(url, this.SERVER_URL, body).pipe(map(function (event) {
+            switch (event.type) {
+                case HttpEventType.UploadProgress:
+                    return ResourceProvider.getProgress(event);
+                case HttpEventType.Response:
+                    return event.body;
+                default:
+                    return undefined;
+            }
+        }), filter(function (value) { return !!value; }));
+    };
+    /**
+     * Delete file from the task
+     * DELETE
+     */
+    TaskResourceService.prototype.deleteFile = function (taskId, fieldId, name) {
+        var _this = this;
+        var url = !!name ? 'task/' + taskId + '/file/' + fieldId + '/' + name : 'task/' + taskId + '/file/' + fieldId;
+        return this._resourceProvider.delete$(url, this.SERVER_URL).pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Download task file preview for field value
+     * GET
+     */
+    // {{baseUrl}}/api/task/:id/file_preview/:field
+    TaskResourceService.prototype.downloadFilePreview = function (taskId, fieldId) {
+        var url = 'task/' + taskId + '/file_preview/' + fieldId;
+        return this._resourceProvider.getBlob$(url, this.SERVER_URL).pipe(map(function (event) {
+            switch (event.type) {
+                case HttpEventType.DownloadProgress:
+                    return ResourceProvider.getProgress(event);
+                case HttpEventType.Response:
+                    return event.body;
+                default:
+                    return undefined;
+            }
+        }), filter(function (value) { return !!value; }));
+    };
+    TaskResourceService.ctorParameters = function () { return [
+        { 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 = function () { return [
+        { type: ResourceProvider },
+        { type: ConfigurationService },
+        { type: FieldConverterService },
+        { type: LoggerService }
+    ]; };
+    return TaskResourceService;
+}(AbstractResourceService));
+export { TaskResourceService };
+//# 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/esm5/lib/resources/engine-endpoint/user-resource.service.js

@@ -0,0 +1,210 @@
+import { __extends } from "tslib";
+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";
+var UserResourceService = /** @class */ (function (_super) {
+    __extends(UserResourceService, _super);
+    function UserResourceService(provider, configService) {
+        return _super.call(this, 'user', provider, configService) || this;
+    }
+    /**
+     * Assign authority to the user
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/{id}/authority/assign
+     */
+    UserResourceService.prototype.assignAuthority = function (userId, body, params) {
+        var _this = this;
+        return this._resourceProvider.post$('user/' + userId + '/authority/assign', this.SERVER_URL, body, params, { 'Content-Type': 'text/plain' })
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Assign role to the user
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/{id}/role/assign
+     */
+    UserResourceService.prototype.assignRoles = function (userId, body, params) {
+        var _this = this;
+        return this._resourceProvider.post$('user/' + userId + '/role/assign', this.SERVER_URL, body, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get all authorities of the system
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/authority
+     */
+    UserResourceService.prototype.getAllAuthorities = function () {
+        var _this = this;
+        return this._resourceProvider.get$('user/authority', this.SERVER_URL)
+            .pipe(map(function (r) { return _this.changeType(r, 'authorities'); }));
+    };
+    /**
+     * Get all users
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user
+     */
+    UserResourceService.prototype.getAll = function (params) {
+        var _this = this;
+        return this._resourceProvider.get$('user', this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.getResourcePage(r, 'users'); }));
+    };
+    /**
+     * Get all users with specified roles
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/role
+     */
+    UserResourceService.prototype.getAllWithRole = function (body, params) {
+        var _this = this;
+        return this._resourceProvider.post$('user/role', this.SERVER_URL, body, params)
+            .pipe(map(function (r) { return _this.changeType(r, 'users'); }));
+    };
+    /**
+     * Get logged user
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/me
+     */
+    UserResourceService.prototype.getLoggedUser = function (params) {
+        var _this = this;
+        return this._resourceProvider.get$('user/me', this.SERVER_URL, params).pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get logged user
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/me
+     */
+    UserResourceService.prototype.getPublicLoggedUser = function (params) {
+        var _this = this;
+        return this._resourceProvider.get$('public/user/me', this.SERVER_URL, params).pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get user by id
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/{id}
+     */
+    UserResourceService.prototype.getUser = function (userId, params) {
+        var _this = this;
+        return this._resourceProvider.get$('user/' + userId, this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get user's preferences
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/preferences
+     */
+    UserResourceService.prototype.getPreferences = function (params) {
+        var _this = this;
+        return this._resourceProvider.get$('user/preferences', this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Set user's preferences
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/preferences
+     */
+    UserResourceService.prototype.setPreferences = function (body, params) {
+        var _this = this;
+        return this._resourceProvider.post$('user/preferences', this.SERVER_URL, body, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get user's preferences
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/user/preferences
+     */
+    UserResourceService.prototype.getPublicPreferences = function (params) {
+        var _this = this;
+        return this._resourceProvider.get$('public/user/preferences', this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Set user's preferences
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/preferences
+     */
+    UserResourceService.prototype.setPublicPreferences = function (body, params) {
+        var _this = this;
+        return this._resourceProvider.post$('public/user/preferences', this.SERVER_URL, body, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Generic user search
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/search
+     */
+    UserResourceService.prototype.search = function (body, params) {
+        var _this = this;
+        return this._resourceProvider.post$('user/search', this.SERVER_URL, body, params)
+            .pipe(map(function (r) { return _this.getResourcePage(r, 'users'); }));
+    };
+    /**
+     * Update user
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/user/{id}
+     */
+    UserResourceService.prototype.updateUser = function (userId, body, params) {
+        var _this = this;
+        return this._resourceProvider.post$('user/' + userId, this.SERVER_URL, body, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * get all groups
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/group/all
+     */
+    UserResourceService.prototype.getAllGroups = function (params) {
+        var _this = this;
+        return this._resourceProvider.get$('group/all', this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    UserResourceService.ctorParameters = function () { return [
+        { 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 = function () { return [
+        { type: ResourceProvider },
+        { type: ConfigurationService }
+    ]; };
+    return UserResourceService;
+}(AbstractResourceService));
+export { UserResourceService };
+//# 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/esm5/lib/resources/interface/assigned-user-policy.js

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

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

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

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

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