@netgrif/components-core
Version:
Netgrif Application engine frontend core Angular library
299 lines • 43.1 kB
JavaScript
import { Injectable } from '@angular/core';
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 { AbstractResourceService } from '../abstract-endpoint/abstract-resource.service';
import * as i0 from "@angular/core";
import * as i1 from "../resource-provider.service";
import * as i2 from "../../configuration/configuration.service";
import * as i3 from "../../task-content/services/field-converter.service";
import * as i4 from "../../logger/services/logger.service";
export class TaskResourceService extends AbstractResourceService {
_fieldConverter;
_logger;
constructor(provider, configService, _fieldConverter, _logger) {
super('task', provider, configService);
this._fieldConverter = _fieldConverter;
this._logger = _logger;
}
/**
* Count tasks by provided criteria
* POST
* {{baseUrl}}/api/task/count
*/
count(filterParam) {
if (filterParam.type !== FilterType.TASK) {
throw new Error('Provided filter doesn\'t have type TASK');
}
return this._resourceProvider.post$('task/count', this.SERVER_URL, filterParam.getRequestBody(), filterParam.getRequestParams())
.pipe(map(r => this.changeType(r, undefined)));
}
/**
* Get all tasks
* GET
* {{baseUrl}}/api/task
*/
getAllTask() {
return this._resourceProvider.get$('task', this.SERVER_URL)
.pipe(map(r => this.changeType(r, 'tasks')));
}
/**
* Assign task
* GET
*/
// {{baseUrl}}/api/task/assign/:id
assignTask(taskId) {
return this._resourceProvider.get$('task/assign/' + taskId, this.SERVER_URL)
.pipe(map(r => this.changeType(r, undefined)));
}
/**
* Cancel task
* GET
*/
// {{baseUrl}}/api/task/cancel/:id
cancelTask(taskId) {
return this._resourceProvider.get$('task/cancel/' + taskId, this.SERVER_URL)
.pipe(map(r => this.changeType(r, undefined)));
}
/**
* Delegate task
* POST
*/
// {{baseUrl}}/api/task/delegate/:id
delegateTask(taskId, body) {
return this._resourceProvider.post$('task/delegate/' + taskId, this.SERVER_URL, body, undefined, { 'Content-Type': 'text/plain' })
.pipe(map(r => this.changeType(r, undefined)));
}
/**
* Finish task
* GET
*/
// {{baseUrl}}/api/task/finish/:id
finishTask(taskId) {
return this._resourceProvider.get$('task/finish/' + taskId, this.SERVER_URL)
.pipe(map(r => this.changeType(r, undefined)));
}
/**
* Searches tasks trough the Elastic endpoint.
* POST
* @param filterParam filter used to search the tasks. Must be of type `TASK`.
* @param params Additional parameters
*/
// {{baseUrl}}/api/task/search_es
searchTask(filterParam, params) {
if (filterParam.type !== FilterType.TASK) {
throw new Error('Provided filter doesn\'t have type TASK');
}
params = ResourceProvider.combineParams(filterParam.getRequestParams(), params);
return this._resourceProvider.post$('task/search_es', this.SERVER_URL, filterParam.getRequestBody(), params)
.pipe(map(r => this.getResourcePage(r, 'tasks')));
}
/**
* Searches tasks trough the Mongo endpoint.
* POST
* @param filterParam filter used to search the tasks. Must be of type `TASK`.
* Note that the `query` attribute of the filter cannot be used with this endpoint.
* Attempting to use it will display a warning and remove the attribute from the request.
* @param params Additional request parameters
*/
// {{baseUrl}}/api/task/search
getTasks(filterParam, params) {
if (filterParam.type !== FilterType.TASK) {
throw new Error('Provided filter doesn\'t have type TASK');
}
if (filterParam.bodyContainsQuery()) {
throw new Error('getTasks endpoint cannot be queried with filters that contain the \'query\' attribute');
}
params = ResourceProvider.combineParams(filterParam.getRequestParams(), params);
return this._resourceProvider.post$('task/search', this.SERVER_URL, filterParam.getRequestBody(), params)
.pipe(map(r => this.getResourcePage(r, 'tasks')));
}
// ----------- CASE ----------
/**
* Get all tasks by cases
* POST
*/
// {{baseUrl}}/api/task/case
getAllTasksByCases(body) {
return this._resourceProvider.post$('task/case', this.SERVER_URL, body)
.pipe(map(r => this.changeType(r, 'tasks')));
}
/**
* Get tasks of the case
* GET
*/
// {{baseUrl}}/api/task/case/:id
getAllTasksByCase(caseId) {
return this._resourceProvider.get$('task/case/' + caseId, this.SERVER_URL)
.pipe(map(r => this.changeType(r, undefined)));
}
// ----------- MY Task ----------
/**
* Get all tasks assigned to logged user
* GET
*/
// {{baseUrl}}/api/task/my
getAllMyTasks() {
return this._resourceProvider.get$('task/my', this.SERVER_URL)
.pipe(map(r => this.changeType(r, undefined)));
}
/**
* Get all finished tasks by logged user
* GET
*/
// {{baseUrl}}/api/task/my/finished
getAllFinishedTask() {
return this._resourceProvider.get$('task/my/finished', this.SERVER_URL)
.pipe(map(r => this.changeType(r, undefined)));
}
/**
* Get all task data
*
* GET
*
* If you don't want to parse the response yourself use [getData]{@link TaskResourceService#getData} instead.
*
* @returns the raw backend response without any additional processing
*/
// {{baseUrl}}/api/task/:id/data
rawGetData(taskId) {
return this._resourceProvider.get$('task/' + taskId + '/data', this.SERVER_URL)
.pipe(map(r => this.changeType(r, undefined)));
}
/**
* Get all task data
*
* GET
*
* If you want to process the raw backend response use [rawGetData]{@link TaskResourceService#rawGetData} instead.
*
* @param taskId ID of the task who's data should be retrieved from the server
* @returns processed data groups of the given task. If the task has no data an empty array will be returned.
*/
getData(taskId) {
return this.rawGetData(taskId).pipe(map((responseOutcome) => {
if (responseOutcome.error) {
throw new Error(responseOutcome.error);
}
const dataGroupsArray = this.changeType(responseOutcome.outcome.data, 'dataGroups');
if (!Array.isArray(dataGroupsArray)) {
return [];
}
const result = [];
dataGroupsArray.forEach(dataGroupResource => {
const dataFields = [];
if (!dataGroupResource.fields._embedded) {
return; // continue
}
const fields = [];
Object.keys(dataGroupResource.fields._embedded).forEach(localizedFields => {
fields.push(...dataGroupResource.fields._embedded[localizedFields]);
});
fields.sort((a, b) => a.order - b.order);
dataFields.push(...fields.map(dataFieldResource => this._fieldConverter.toClass(dataFieldResource)));
const dataGroupObject = {
fields: dataFields,
stretch: dataGroupResource.stretch,
title: dataGroupResource.title,
layout: dataGroupResource.layout,
alignment: dataGroupResource.alignment,
};
if (dataGroupResource.parentTaskId !== undefined) {
dataGroupObject.parentTaskId = dataGroupResource.parentTaskId;
dataGroupObject.parentTransitionId = dataGroupResource.parentTransitionId;
dataGroupObject.parentTaskRefId = dataGroupResource.parentTaskRefId;
dataGroupObject.nestingLevel = dataGroupResource.nestingLevel;
}
if (dataGroupResource.parentCaseId !== undefined) {
dataGroupObject['parentCaseId'] = dataGroupResource.parentCaseId;
}
result.push(dataGroupObject);
});
return result;
}));
}
/**
* Set task data
* POST
*/
// {{baseUrl}}/api/task/:id/data
setData(taskId, body) {
return this._resourceProvider.post$('task/' + taskId + '/data', this.SERVER_URL, body)
.pipe(map(r => this.changeType(r, undefined)));
}
// ------------- FILE ------------
/**
* Download task file field value
* GET
*/
// {{baseUrl}}/api/task/:id/file/:field - for file field
// {{baseUrl}}/api/task/:id/file/:field/:name - for file list field
downloadFile(taskId, params) {
const url = `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
*/
// {{baseUrl}}/api/task/:id/file/:field - for file field
// {{baseUrl}}/api/task/:id/files/:field - for file list field
uploadFile(taskId, body, multipleFiles) {
const url = `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 = `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
*/
// {{baseUrl}}/api/task/:id/file_preview/:field
downloadFilePreview(taskId, params) {
const url = `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: TaskResourceService, 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: TaskResourceService, providedIn: 'root' });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TaskResourceService, 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":"task-resource.service.js","sourceRoot":"","sources":["../../../../../../projects/netgrif-components-core/src/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, HttpParams } 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';\nimport {FileFieldRequest} from \"../interface/file-field-request-body\";\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                if (responseOutcome.error) {\n                    throw new Error(responseOutcome.error);\n                }\n\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.parentTransitionId = dataGroupResource.parentTransitionId;\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, params: HttpParams): Observable<ProviderProgress | Blob> {\n        const url = `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    // {{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, body: object, multipleFiles: boolean):\n        Observable<ProviderProgress | EventOutcomeMessageResource> {\n        const url = `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 = `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    // {{baseUrl}}/api/task/:id/file_preview/:field\n    public downloadFilePreview(taskId: string, params: HttpParams): Observable<ProviderProgress | Blob> {\n        const url = `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"]}