@netgrif/components-core 6.0.1

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

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { CaseResourceService } from '../case-resource.service';
+import { ResourceProvider } from '../../resource-provider.service';
+import { ConfigurationService } from '../../../configuration/configuration.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../resource-provider.service";
+import * as i2 from "../../../configuration/configuration.service";
+export class PublicCaseResourceService extends CaseResourceService {
+    constructor(provider, configService) {
+        super(provider, configService);
+    }
+    /**
+     * Get all case data
+     * GET
+     * {{baseUrl}}/api/public/case/:id/data
+     */
+    getCaseData(caseID) {
+        return this._resourceProvider.get$('public/case/' + caseID + '/data', this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Create new case
+     * POST
+     * {{baseUrl}}/api/workflow/case
+     */
+    createCase(body) {
+        return this._resourceProvider.post$('public/case/', this.SERVER_URL, body)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+}
+PublicCaseResourceService.ctorParameters = () => [
+    { type: ResourceProvider },
+    { type: ConfigurationService }
+];
+PublicCaseResourceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PublicCaseResourceService_Factory() { return new PublicCaseResourceService(i0.ɵɵinject(i1.ResourceProvider), i0.ɵɵinject(i2.ConfigurationService)); }, token: PublicCaseResourceService, providedIn: "root" });
+PublicCaseResourceService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+PublicCaseResourceService.ctorParameters = () => [
+    { type: ResourceProvider },
+    { type: ConfigurationService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/resources/engine-endpoint/public/public-petri-net-resource.service.js

@@ -0,0 +1,108 @@
+import { Injectable } from '@angular/core';
+import { PetriNetResourceService } from '../petri-net-resource.service';
+import { Params, ResourceProvider } from '../../resource-provider.service';
+import { ConfigurationService } from '../../../configuration/configuration.service';
+import { map } from 'rxjs/operators';
+import { HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "../../resource-provider.service";
+import * as i2 from "../../../configuration/configuration.service";
+export class PublicPetriNetResourceService extends PetriNetResourceService {
+    constructor(provider, _configService) {
+        super(provider, _configService);
+        this.provider = provider;
+        this._configService = _configService;
+    }
+    /**
+     * get One Net by ID
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/public/petrinet/{id}
+     */
+    getOneById(netId, params) {
+        return this.provider.get$('public/petrinet/' + netId, this.SERVER_URL, params)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * get One Net
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/public/petrinet/{identifier}/{version}
+     */
+    getOne(identifier, version, params) {
+        return this.provider.get$('public/petrinet/' + identifier + '/' + version, this.SERVER_URL, params)
+            .pipe(map(r => this.changeType(r, 'petriNetReferences')));
+    }
+    /**
+     * search PetriNets
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/search
+     */
+    searchPetriNets(body, params) {
+        return this._resourceProvider.post$('public/petrinet/search', this.SERVER_URL, body, params)
+            .pipe(map(r => this.getResourcePage(r, 'petriNetReferences')));
+    }
+    /**
+     * Get Roles References Using
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/{id}/roles
+     */
+    getPetriNetRoles(netId, params) {
+        return this._resourceProvider.get$('public/petrinet/' + netId + '/roles', this.SERVER_URL, params)
+            .pipe(map(r => this.changeType(r, 'processRoles')));
+    }
+    /**
+     * Get Transaction References Using
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/{id}/transactions
+     */
+    getPetriNetTransactions(netId, params) {
+        return this._resourceProvider.get$('public/petrinet/' + netId + '/transactions', this.SERVER_URL, params)
+            .pipe(map(r => this.changeType(r, 'transactions')));
+    }
+    /**
+     * Get Data Field References Using
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/data
+     */
+    getDataPetriNet(body) {
+        return this._resourceProvider.post$('public/petrinet/data', this.SERVER_URL, body)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Get Transition References Using
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/transitions
+     */
+    getPetriNetTransitions(netId) {
+        return this._resourceProvider.get$('public/petrinet/transitions', this.SERVER_URL, new HttpParams().set('ids', netId))
+            .pipe(map(r => this.changeType(r, 'transitionReferences')));
+    }
+}
+PublicPetriNetResourceService.ctorParameters = () => [
+    { type: ResourceProvider },
+    { type: ConfigurationService }
+];
+PublicPetriNetResourceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PublicPetriNetResourceService_Factory() { return new PublicPetriNetResourceService(i0.ɵɵinject(i1.ResourceProvider), i0.ɵɵinject(i2.ConfigurationService)); }, token: PublicPetriNetResourceService, providedIn: "root" });
+PublicPetriNetResourceService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+PublicPetriNetResourceService.ctorParameters = () => [
+    { type: ResourceProvider },
+    { type: ConfigurationService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-petri-net-resource.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/resources/engine-endpoint/public/public-petri-net-resource.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {PetriNetResourceService} from '../petri-net-resource.service';\nimport {Params, ResourceProvider} from '../../resource-provider.service';\nimport {ConfigurationService} from '../../../configuration/configuration.service';\nimport {Observable} from 'rxjs';\nimport {PetriNet} from '../../interface/petri-net';\nimport {PetriNetReference} from '../../interface/petri-net-reference';\nimport {map} from 'rxjs/operators';\nimport {PetriNetRequestBody} from '../../interface/petri-net-request-body';\nimport {Page} from '../../interface/page';\nimport Transaction from '../../../process/transaction';\nimport Transition from '../../../process/transition';\nimport {HttpParams} from '@angular/common/http';\nimport RolesAndPermissions from '../../../process/rolesAndPermissions';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PublicPetriNetResourceService extends PetriNetResourceService {\n\n    constructor(protected provider: ResourceProvider, protected _configService: ConfigurationService) {\n        super(provider, _configService);\n    }\n\n    /**\n     * get One Net by ID\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/public/petrinet/{id}\n     */\n    public getOneById(netId: string, params?: Params): Observable<PetriNet> {\n        return this.provider.get$('public/petrinet/' + netId, this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * get One Net\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/public/petrinet/{identifier}/{version}\n     */\n    public getOne(identifier: string, version: string, params?: Params): Observable<PetriNetReference> {\n        return this.provider.get$('public/petrinet/' + identifier + '/' + version, this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, 'petriNetReferences')));\n    }\n\n    /**\n     * search PetriNets\n     *\n     * **Request Type:** POST\n     *\n     * **Request URL:** {{baseUrl}}/api/petrinet/search\n     */\n    public searchPetriNets(body: PetriNetRequestBody, params?: Params): Observable<Page<PetriNetReference>> {\n        return this._resourceProvider.post$('public/petrinet/search', this.SERVER_URL, body, params)\n            .pipe(map(r => this.getResourcePage<PetriNetReference>(r, 'petriNetReferences')));\n    }\n\n    /**\n     * Get Roles References Using\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/petrinet/{id}/roles\n     */\n    public getPetriNetRoles(netId: string, params?: Params): Observable<RolesAndPermissions> {\n        return this._resourceProvider.get$('public/petrinet/' + netId + '/roles', this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, 'processRoles')));\n    }\n\n    /**\n     * Get Transaction References Using\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/petrinet/{id}/transactions\n     */\n    public getPetriNetTransactions(netId: string, params?: Params): Observable<Array<Transaction>> {\n        return this._resourceProvider.get$('public/petrinet/' + netId + '/transactions', this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, 'transactions')));\n    }\n\n    /**\n     * Get Data Field References Using\n     *\n     * **Request Type:** POST\n     *\n     * **Request URL:** {{baseUrl}}/api/petrinet/data\n     */\n    public getDataPetriNet(body: object): Observable<any> {  // TODO: response\n        return this._resourceProvider.post$('public/petrinet/data', this.SERVER_URL, body)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get Transition References Using\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/petrinet/transitions\n     */\n    public getPetriNetTransitions(netId: string): Observable<Array<Transition>> {\n        return this._resourceProvider.get$('public/petrinet/transitions', this.SERVER_URL, new HttpParams().set('ids', netId))\n            .pipe(map(r => this.changeType(r, 'transitionReferences')));\n    }\n}\n"]}

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

@@ -0,0 +1,224 @@
+import { Injectable } from '@angular/core';
+import { TaskResourceService } from '../task-resource.service';
+import { FieldConverterService } from '../../../task-content/services/field-converter.service';
+import { ConfigurationService } from '../../../configuration/configuration.service';
+import { Params, ProviderProgress, ResourceProvider } from '../../resource-provider.service';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { filter, map } from 'rxjs/operators';
+import { FilterType } from '../../../filter/models/filter-type';
+import { HttpEventType } from '@angular/common/http';
+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 PublicTaskResourceService extends TaskResourceService {
+    constructor(_provider, _configService, _fieldConverter, _logger) {
+        super(_provider, _configService, _fieldConverter, _logger);
+        this._provider = _provider;
+        this._configService = _configService;
+        this._fieldConverter = _fieldConverter;
+        this._logger = _logger;
+    }
+    /**
+     * Assign task
+     * GET
+     */
+    // {{baseUrl}}/api/public/task/assign/:id
+    assignTask(taskId) {
+        return this._provider.get$('public/task/assign/' + taskId, this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Cancel task
+     * GET
+     */
+    // {{baseUrl}}/api/public/task/cancel/:id
+    cancelTask(taskId) {
+        return this._provider.get$('public/task/cancel/' + taskId, this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Finish task
+     * GET
+     */
+    // {{baseUrl}}/api/public/task/finish/:id
+    finishTask(taskId) {
+        return this._provider.get$('public/task/finish/' + taskId, this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * Get tasks of the case
+     * GET
+     */
+    // {{baseUrl}}/api/public/task/case/:id
+    getAllTasksByCase(caseId) {
+        return this._provider.get$('public/task/case/' + caseId, 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/public/task/:id/data
+    rawGetData(taskId) {
+        return this._provider.get$('public/task/' + taskId + '/data', this.SERVER_URL)
+            .pipe(map(r => this.changeType(r, 'dataGroups')));
+    }
+    /**
+     *  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)));
+                result.push({
+                    fields: dataFields,
+                    stretch: dataGroupResource.stretch,
+                    title: dataGroupResource.title,
+                    layout: dataGroupResource.layout,
+                    alignment: dataGroupResource.alignment
+                });
+            });
+            return result;
+        }));
+    }
+    /**
+     * Set task data
+     * POST
+     */
+    // {{baseUrl}}/api/public/task/:id/data
+    setData(taskId, body) {
+        return this._provider.post$('public/task/' + taskId + '/data', this.SERVER_URL, body)
+            .pipe(map(r => this.changeType(r, undefined)));
+    }
+    /**
+     * 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/public/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._provider.post$('public/task/search', this.SERVER_URL, filterParam.getRequestBody(), params)
+            .pipe(map(r => this.getResourcePage(r, 'tasks')));
+    }
+    /**
+     * 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 ? `public/task/${taskId}/file/${fieldId}/${name}` : `public/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 ? `public/task/${taskId}/file/${fieldId}` : `public/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 ? `public/task/${taskId}/file/${fieldId}/${name}` : `public/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 = 'public/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));
+    }
+}
+PublicTaskResourceService.ctorParameters = () => [
+    { type: ResourceProvider },
+    { type: ConfigurationService },
+    { type: FieldConverterService },
+    { type: LoggerService }
+];
+PublicTaskResourceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PublicTaskResourceService_Factory() { return new PublicTaskResourceService(i0.ɵɵinject(i1.ResourceProvider), i0.ɵɵinject(i2.ConfigurationService), i0.ɵɵinject(i3.FieldConverterService), i0.ɵɵinject(i4.LoggerService)); }, token: PublicTaskResourceService, providedIn: "root" });
+PublicTaskResourceService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+PublicTaskResourceService.ctorParameters = () => [
+    { type: ResourceProvider },
+    { type: ConfigurationService },
+    { type: FieldConverterService },
+    { type: LoggerService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-task-resource.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/resources/engine-endpoint/public/public-task-resource.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {TaskResourceService} from '../task-resource.service';\nimport {FieldConverterService} from '../../../task-content/services/field-converter.service';\nimport {ConfigurationService} from '../../../configuration/configuration.service';\nimport {Params, ProviderProgress, ResourceProvider} from '../../resource-provider.service';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {Observable} from 'rxjs';\nimport {filter, map} from 'rxjs/operators';\nimport {FilterType} from '../../../filter/models/filter-type';\nimport {Filter} from '../../../filter/models/filter';\nimport {Page} from '../../interface/page';\nimport {ChangedFieldContainer} from '../../interface/changed-field-container';\nimport {TaskSetDataRequestBody} from '../../interface/task-set-data-request-body';\nimport {TaskReference} from '../../interface/task-reference';\nimport {DataGroup} from '../../interface/data-groups';\nimport {DataField} from '../../../data-fields/models/abstract-data-field';\nimport {Task} from '../../interface/task';\nimport {HttpEventType} from '@angular/common/http';\nimport {EventOutcomeMessageResource, MessageResource} from '../../interface/message-resource';\nimport {GetDataGroupsEventOutcome} from '../../../event/model/event-outcomes/data-outcomes/get-data-groups-event-outcome';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PublicTaskResourceService extends TaskResourceService {\n\n    constructor(protected _provider: ResourceProvider,\n                protected _configService: ConfigurationService,\n                protected _fieldConverter: FieldConverterService,\n                protected _logger: LoggerService) {\n        super(_provider, _configService, _fieldConverter, _logger);\n    }\n\n    /**\n     * Assign task\n     * GET\n     */\n    // {{baseUrl}}/api/public/task/assign/:id\n    public assignTask(taskId: string): Observable<EventOutcomeMessageResource> {\n        return this._provider.get$('public/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/public/task/cancel/:id\n    public cancelTask(taskId: string): Observable<EventOutcomeMessageResource> {\n        return this._provider.get$('public/task/cancel/' + taskId, this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Finish task\n     * GET\n     */\n    // {{baseUrl}}/api/public/task/finish/:id\n    public finishTask(taskId: string): Observable<EventOutcomeMessageResource> {\n        return this._provider.get$('public/task/finish/' + taskId, this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get tasks of the case\n     * GET\n     */\n    // {{baseUrl}}/api/public/task/case/:id\n    public getAllTasksByCase(caseId: string): Observable<Array<TaskReference>> {\n        return this._provider.get$('public/task/case/' + caseId, 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/public/task/:id/data\n    public rawGetData(taskId: string): Observable<EventOutcomeMessageResource> {\n        return this._provider.get$('public/task/' + taskId + '/data', this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, 'dataGroups')));\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                    result.push({\n                        fields: dataFields,\n                        stretch: dataGroupResource.stretch,\n                        title: dataGroupResource.title,\n                        layout: dataGroupResource.layout,\n                        alignment: dataGroupResource.alignment\n                    });\n                });\n                return result;\n            })\n        );\n    }\n\n    /**\n     * Set task data\n     * POST\n     */\n    // {{baseUrl}}/api/public/task/:id/data\n    public setData(taskId: string, body: TaskSetDataRequestBody): Observable<EventOutcomeMessageResource> {\n        return this._provider.post$('public/task/' + taskId + '/data', this.SERVER_URL, body)\n            .pipe(map(r => this.changeType(r, undefined)));\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/public/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._provider.post$('public/task/search', this.SERVER_URL, filterParam.getRequestBody(), params)\n            .pipe(map(r => this.getResourcePage<Task>(r, 'tasks')));\n    }\n\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 ? `public/task/${taskId}/file/${fieldId}/${name}` : `public/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 ? `public/task/${taskId}/file/${fieldId}` : `public/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 ? `public/task/${taskId}/file/${fieldId}/${name}` : `public/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 = 'public/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"]}