@netgrif/components-core
Version:
Netgrif Application engine frontend core Angular library
171 lines • 24.2 kB
JavaScript
import { Injectable } from '@angular/core';
import { TaskResourceService } from '../task-resource.service';
import { 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 * 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 {
_provider;
_configService;
_fieldConverter;
_logger;
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')));
}
/**
* 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
*/
downloadFile(taskId, params) {
const url = `public/task/${taskId}/file${params?.has("fileName") ? '/named' : ''}`;
return this._resourceProvider.getBlob$(url, this.SERVER_URL, params).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
*/
uploadFile(taskId, body, multipleFiles) {
const url = `public/task/${taskId}/${multipleFiles ? 'files' : 'file'}`;
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, body) {
const url = `public/task/${taskId}/file${body.fileName ? '/named' : ''}`;
return this._resourceProvider.delete$(url, this.SERVER_URL, {}, {}, 'json', body).pipe(map(r => this.changeType(r, undefined)));
}
/**
* Download task file preview for field value
* GET
*/
downloadFilePreview(taskId, params) {
const url = `public/task/${taskId}/file_preview`;
return this._resourceProvider.getBlob$(url, this.SERVER_URL, params).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));
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PublicTaskResourceService, deps: [{ token: i1.ResourceProvider }, { token: i2.ConfigurationService }, { token: i3.FieldConverterService }, { token: i4.LoggerService }], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PublicTaskResourceService, providedIn: 'root' });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PublicTaskResourceService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.ResourceProvider }, { type: i2.ConfigurationService }, { type: i3.FieldConverterService }, { type: i4.LoggerService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-task-resource.service.js","sourceRoot":"","sources":["../../../../../../../projects/netgrif-components-core/src/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 {TaskSetDataRequestBody} from '../../interface/task-set-data-request-body';\nimport {TaskReference} from '../../interface/task-reference';\nimport {Task} from '../../interface/task';\nimport {HttpEventType, HttpParams} from '@angular/common/http';\nimport {EventOutcomeMessageResource, MessageResource} from '../../interface/message-resource';\nimport {FileFieldRequest} from \"../../interface/file-field-request-body\";\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     * 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    public downloadFile(taskId: string, params: HttpParams): Observable<ProviderProgress | Blob> {\n        const url = `public/task/${taskId}/file${params?.has(\"fileName\") ? '/named' : ''}`;\n        return this._resourceProvider.getBlob$(url, this.SERVER_URL, params).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    public uploadFile(taskId: string, body: object, multipleFiles: boolean):\n        Observable<ProviderProgress | EventOutcomeMessageResource> {\n        const url = `public/task/${taskId}/${multipleFiles ? 'files' : 'file'}`;\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, body: FileFieldRequest): Observable<MessageResource> {\n        const url = `public/task/${taskId}/file${body.fileName ? '/named' : ''}`;\n        return this._resourceProvider.delete$(url, this.SERVER_URL, {}, {}, 'json', body).pipe(\n            map(r => this.changeType(r, undefined))\n        );\n    }\n\n    /**\n     * Download task file preview for field value\n     * GET\n     */\n    public downloadFilePreview(taskId: string, params: HttpParams): Observable<ProviderProgress | Blob> {\n        const url = `public/task/${taskId}/file_preview`;\n        return this._resourceProvider.getBlob$(url, this.SERVER_URL, params).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"]}