@netgrif/components-core 6.0.1

package/esm5/lib/resources/abstract-endpoint/abstract-resource.service.js

@@ -0,0 +1,85 @@
+/**
+ * The class that contains behavior common to all resource services.
+ *
+ * Mostly endpoint URL resolution and utility functions for response parsing.
+ */
+var AbstractResourceService = /** @class */ (function () {
+    /**
+     * @param resourceName the identifier of the desired endpoint from configuration, found in
+     * {@link SetAuthAndResourcesAddress}.[resources]{@link Resources}.
+     * @param _resourceProvider `ResourceProvider` instance
+     * @param _configService `ConfigurationService` instance
+     */
+    function AbstractResourceService(resourceName, _resourceProvider, _configService) {
+        this._resourceProvider = _resourceProvider;
+        this._configService = _configService;
+        this._SERVER_URL = this.getResourceAddress(resourceName);
+    }
+    Object.defineProperty(AbstractResourceService.prototype, "SERVER_URL", {
+        get: function () {
+            return this._SERVER_URL;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Get URL form nae.json - resources
+     * @param name - ID property
+     */
+    AbstractResourceService.prototype.getResourceAddress = function (name) {
+        var URL = '';
+        var resourcesArray = this._configService.getConfigurationSubtree(['providers', 'resources']);
+        if (resourcesArray instanceof Array) {
+            resourcesArray.forEach(function (resource) {
+                if (resource.name === name) {
+                    URL = resource.address;
+                }
+            });
+        }
+        else {
+            if (resourcesArray.name === name) {
+                URL = resourcesArray.address;
+            }
+        }
+        return URL;
+    };
+    /**
+     * Parses a response `r` into a {@link Page} instance
+     * @param r - response object
+     * @param propertiesParams - plural form of the resource name, that is used to extract the data. Eg. "cases".
+     */
+    AbstractResourceService.prototype.getResourcePage = function (r, propertiesParams) {
+        if (!r) {
+            return r;
+        }
+        var defaultPage = {
+            number: -1,
+            size: 0,
+            totalPages: 0,
+            totalElements: 0
+        };
+        return {
+            content: this.changeType(r, propertiesParams),
+            pagination: r.hasOwnProperty('page') ? r.page : defaultPage
+        };
+    };
+    /**
+     * Extracts data from the response `r` into an object with better usability.
+     * @param r - response object
+     * @param propertiesParams - plural form of the resource name, that is used to extract the data. Eg. "cases".
+     */
+    AbstractResourceService.prototype.changeType = function (r, propertiesParams) {
+        if (!r) {
+            return r;
+        }
+        if (r.hasOwnProperty('_embedded')) {
+            return propertiesParams && r._embedded.hasOwnProperty(propertiesParams) ? r._embedded[propertiesParams] : r._embedded;
+        }
+        else {
+            return r;
+        }
+    };
+    return AbstractResourceService;
+}());
+export { AbstractResourceService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/resources/abstract-endpoint/count-service.js

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

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

@@ -0,0 +1,149 @@
+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 { FilterType } from '../../filter/models/filter-type';
+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 CaseResourceService = /** @class */ (function (_super) {
+    __extends(CaseResourceService, _super);
+    function CaseResourceService(provider, configService) {
+        return _super.call(this, 'case', provider, configService) || this;
+    }
+    /**
+     * Get count of the cases
+     * POST
+     * {{baseUrl}}/api/workflow/case/count
+     */
+    CaseResourceService.prototype.count = function (filter) {
+        var _this = this;
+        if (filter.type !== FilterType.CASE) {
+            throw new Error('Provided filter doesn\'t have type CASE');
+        }
+        return this._resourceProvider.post$('workflow/case/count', this.SERVER_URL, filter.getRequestBody(), filter.getRequestParams())
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get all cases of the system
+     * GET
+     * {{baseUrl}}/api/workflow/all
+     */
+    CaseResourceService.prototype.getAllCase = function () {
+        var _this = this;
+        return this._resourceProvider.get$('workflow/all', this.SERVER_URL).pipe(map(function (r) { return _this.changeType(r, 'cases'); }));
+    };
+    /**
+     * Generic case search
+     * POST
+     * {{baseUrl}}/api/workflow/case/search
+     * @param filter filter used to search cases. Must be of type `CASE`.
+     * @param params request parameters, that can be used for sorting of results.
+     */
+    CaseResourceService.prototype.searchCases = function (filter, params) {
+        var _this = this;
+        if (filter.type !== FilterType.CASE) {
+            throw new Error('Provided filter doesn\'t have type CASE');
+        }
+        params = ResourceProvider.combineParams(filter.getRequestParams(), params);
+        return this._resourceProvider.post$('workflow/case/search', this.SERVER_URL, filter.getRequestBody(), params)
+            .pipe(map(function (r) { return _this.getResourcePage(r, 'cases'); }));
+    };
+    /**
+     * Delete case
+     * DELETE
+     * {{baseUrl}}/api/workflow/case/:id
+     */
+    CaseResourceService.prototype.deleteCase = function (caseID, deleteSubtree) {
+        var _this = this;
+        if (deleteSubtree === void 0) { deleteSubtree = false; }
+        return this._resourceProvider.delete$('workflow/case/' + caseID, this.SERVER_URL, deleteSubtree ? { deleteSubtree: deleteSubtree.toString() } : {})
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Download case file field value
+     * GET
+     * {{baseUrl}}/api/workflow/case/:id/file/:field
+     */
+    CaseResourceService.prototype.getCaseFile = function (caseID, fieldID) {
+        var _this = this;
+        return this._resourceProvider.get$('workflow/case/' + caseID + '/file/' + fieldID, this.SERVER_URL).pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Create new case
+     * POST
+     * {{baseUrl}}/api/workflow/case
+     */
+    CaseResourceService.prototype.createCase = function (body) {
+        var _this = this;
+        return this._resourceProvider.post$('workflow/case/', this.SERVER_URL, body).pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get all cases by user that created them
+     * POST
+     * {{baseUrl}}/api/workflow/case/author/:id
+     */
+    CaseResourceService.prototype.getAllCaseUser = function (userId, body) {
+        var _this = this;
+        return this._resourceProvider.post$('workflow/case/author/' + userId, this.SERVER_URL, body).pipe(map(function (r) { return _this.changeType(r, 'cases'); }));
+    };
+    /**
+     * Generic case search with QueryDSL predicate
+     * POST
+     * {{baseUrl}}/api/workflow/case/search2
+     */
+    CaseResourceService.prototype.getCasesQueryDSL = function (body) {
+        var _this = this;
+        return this._resourceProvider.post$('workflow/case/search2', this.SERVER_URL, body).pipe(map(function (r) { return _this.getResourcePage(r, 'cases'); }));
+    };
+    /**
+     * Generic case search with object encoded search query. Similar to [getCasesQueryDSL]{@link CaseResourceService#getCasesQueryDSL}
+     * POST
+     * {{baseUrl}}/api/workflow/case/search_mongo
+     * @param body object defining the search query
+     * @param params request parameters, that can be used for sorting of results.
+     */
+    CaseResourceService.prototype.getCases = function (body, params) {
+        var _this = this;
+        return this._resourceProvider.post$('workflow/case/search_mongo', this.SERVER_URL, body, params)
+            .pipe(map(function (r) { return _this.getResourcePage(r, 'cases'); }));
+    };
+    /**
+     * Search one case by it's id.
+     * GET
+     * {{baseUrl}}/api/workflow/case/:id
+     */
+    CaseResourceService.prototype.getOneCase = function (caseId) {
+        var _this = this;
+        return this._resourceProvider.get$('workflow/case/' + caseId, this.SERVER_URL).pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get options for enumeration or multiple-choice data field
+     * GET
+     * {{baseUrl}}/api/workflow/case/:caseId/field/:fieldId
+     */
+    CaseResourceService.prototype.getOptionsEnumeration = function (caseId, fieldId) {
+        var _this = this;
+        return this._resourceProvider.get$('workflow/case/' + caseId + '/field/' + fieldId, this.SERVER_URL)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    CaseResourceService.ctorParameters = function () { return [
+        { type: ResourceProvider },
+        { type: ConfigurationService }
+    ]; };
+    CaseResourceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CaseResourceService_Factory() { return new CaseResourceService(i0.ɵɵinject(i1.ResourceProvider), i0.ɵɵinject(i2.ConfigurationService)); }, token: CaseResourceService, providedIn: "root" });
+    CaseResourceService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    CaseResourceService.ctorParameters = function () { return [
+        { type: ResourceProvider },
+        { type: ConfigurationService }
+    ]; };
+    return CaseResourceService;
+}(AbstractResourceService));
+export { CaseResourceService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-resource.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/resources/engine-endpoint/case-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 {Count} from '../interface/count';\nimport {Case} from '../interface/case';\nimport {FileResource} from '../interface/file-resource';\nimport {ConfigurationService} from '../../configuration/configuration.service';\nimport {CountService} from '../abstract-endpoint/count-service';\nimport {Filter} from '../../filter/models/filter';\nimport {FilterType} from '../../filter/models/filter-type';\nimport {Page} from '../interface/page';\nimport {CaseGetRequestBody} from '../interface/case-get-request-body';\nimport {AbstractResourceService} from '../abstract-endpoint/abstract-resource.service';\nimport {EventOutcomeMessageResource} from '../interface/message-resource';\nimport {CreateCaseRequestBody} from '../interface/create-case-request-body';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class CaseResourceService extends AbstractResourceService implements CountService {\n\n    constructor(provider: ResourceProvider, configService: ConfigurationService) {\n        super('case', provider, configService);\n    }\n\n    /**\n     * Get count of the cases\n     * POST\n     * {{baseUrl}}/api/workflow/case/count\n     */\n    public count(filter: Filter): Observable<Count> {\n        if (filter.type !== FilterType.CASE) {\n            throw new Error('Provided filter doesn\\'t have type CASE');\n        }\n        return this._resourceProvider.post$('workflow/case/count', this.SERVER_URL, filter.getRequestBody(), filter.getRequestParams())\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get all cases of the system\n     * GET\n     * {{baseUrl}}/api/workflow/all\n     */\n    public getAllCase(): Observable<Array<Case>> {\n        return this._resourceProvider.get$('workflow/all', this.SERVER_URL).pipe(map(r => this.changeType(r, 'cases')));\n    }\n\n    /**\n     * Generic case search\n     * POST\n     * {{baseUrl}}/api/workflow/case/search\n     * @param filter filter used to search cases. Must be of type `CASE`.\n     * @param params request parameters, that can be used for sorting of results.\n     */\n    public searchCases(filter: Filter, params?: Params): Observable<Page<Case>> {\n        if (filter.type !== FilterType.CASE) {\n            throw new Error('Provided filter doesn\\'t have type CASE');\n        }\n        params = ResourceProvider.combineParams(filter.getRequestParams(), params);\n        return this._resourceProvider.post$('workflow/case/search', this.SERVER_URL, filter.getRequestBody(), params)\n            .pipe(map(r => this.getResourcePage<Case>(r, 'cases')));\n    }\n\n\n    /**\n     * Delete case\n     * DELETE\n     * {{baseUrl}}/api/workflow/case/:id\n     */\n    public deleteCase(caseID: string, deleteSubtree = false): Observable<EventOutcomeMessageResource> {\n        return this._resourceProvider.delete$('workflow/case/' + caseID,\n            this.SERVER_URL,\n            deleteSubtree ? {deleteSubtree: deleteSubtree.toString()} : {})\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n\n    /**\n     * Download case file field value\n     * GET\n     * {{baseUrl}}/api/workflow/case/:id/file/:field\n     */\n    public getCaseFile(caseID: string, fieldID: string): Observable<FileResource> {\n        return this._resourceProvider.get$('workflow/case/' + caseID + '/file/' + fieldID, this.SERVER_URL).pipe(\n            map(r => this.changeType(r, undefined))\n        );\n    }\n\n\n    /**\n     * Create new case\n     * POST\n     * {{baseUrl}}/api/workflow/case\n     */\n    public createCase(body: CreateCaseRequestBody): Observable<EventOutcomeMessageResource> {\n        return this._resourceProvider.post$('workflow/case/', this.SERVER_URL, body).pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * Get all cases by user that created them\n     * POST\n     * {{baseUrl}}/api/workflow/case/author/:id\n     */\n    public getAllCaseUser(userId: string, body: object): Observable<Array<Case>> {\n        return this._resourceProvider.post$('workflow/case/author/' + userId, this.SERVER_URL, body).pipe(\n            map(r => this.changeType(r, 'cases'))\n        );\n    }\n\n\n    /**\n     * Generic case search with QueryDSL predicate\n     * POST\n     * {{baseUrl}}/api/workflow/case/search2\n     */\n    public getCasesQueryDSL(body: object): Observable<Page<Case>> {\n        return this._resourceProvider.post$('workflow/case/search2', this.SERVER_URL, body).pipe(\n            map(r => this.getResourcePage<Case>(r, 'cases'))\n        );\n    }\n\n    /**\n     * Generic case search with object encoded search query. Similar to [getCasesQueryDSL]{@link CaseResourceService#getCasesQueryDSL}\n     * POST\n     * {{baseUrl}}/api/workflow/case/search_mongo\n     * @param body object defining the search query\n     * @param params request parameters, that can be used for sorting of results.\n     */\n    public getCases(body: CaseGetRequestBody, params?: Params): Observable<Page<Case>> {\n        return this._resourceProvider.post$('workflow/case/search_mongo', this.SERVER_URL, body, params)\n            .pipe(map(r => this.getResourcePage<Case>(r, 'cases')));\n    }\n\n    /**\n     * Search one case by it's id.\n     * GET\n     * {{baseUrl}}/api/workflow/case/:id\n     */\n    public getOneCase(caseId: string): Observable<Case> {\n        return this._resourceProvider.get$('workflow/case/' + caseId, this.SERVER_URL).pipe(map(r => this.changeType(r, undefined)));\n    }\n\n\n    /**\n     * Get options for enumeration or multiple-choice data field\n     * GET\n     * {{baseUrl}}/api/workflow/case/:caseId/field/:fieldId\n     */\n    public getOptionsEnumeration(caseId: string, fieldId: string): Observable<Case> {\n        return this._resourceProvider.get$('workflow/case/' + caseId + '/field/' + fieldId, this.SERVER_URL)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n}\n\n"]}

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

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { Injectable } from '@angular/core';
+import { ResourceProvider } from '../resource-provider.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { HttpParams } 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";
+var DashboardResourceService = /** @class */ (function (_super) {
+    __extends(DashboardResourceService, _super);
+    function DashboardResourceService(provider, configService) {
+        return _super.call(this, 'dashboard', provider, configService) || this;
+    }
+    DashboardResourceService.prototype.getDashboardData = function (type, jsonQuery) {
+        var params = new HttpParams();
+        params = params.set('type', type);
+        return this._resourceProvider.post$('/dashboard/search', this.SERVER_URL, jsonQuery, params);
+    };
+    DashboardResourceService.ctorParameters = function () { return [
+        { type: ResourceProvider },
+        { type: ConfigurationService }
+    ]; };
+    DashboardResourceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function DashboardResourceService_Factory() { return new DashboardResourceService(i0.ɵɵinject(i1.ResourceProvider), i0.ɵɵinject(i2.ConfigurationService)); }, token: DashboardResourceService, providedIn: "root" });
+    DashboardResourceService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    DashboardResourceService.ctorParameters = function () { return [
+        { type: ResourceProvider },
+        { type: ConfigurationService }
+    ]; };
+    return DashboardResourceService;
+}(AbstractResourceService));
+export { DashboardResourceService };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,174 @@
+import { __extends } from "tslib";
+import { Injectable } from '@angular/core';
+import { filter, map, switchMap } from 'rxjs/operators';
+import { Params, ProviderProgress, ResourceProvider } from '../resource-provider.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { HttpEventType, HttpParams } from '@angular/common/http';
+import { processMessageResponse } from '../../utility/process-message-response';
+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 PetriNetResourceService = /** @class */ (function (_super) {
+    __extends(PetriNetResourceService, _super);
+    function PetriNetResourceService(provider, configService) {
+        return _super.call(this, 'petrinet', provider, configService) || this;
+    }
+    /**
+     * Get All Using Petri Net
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet
+     */
+    PetriNetResourceService.prototype.getAll = function (params) {
+        var _this = this;
+        return this._resourceProvider.get$('petrinet', this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.changeType(r, 'petriNetReferences'); }));
+    };
+    /**
+     * Get Data Field References Using
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/data
+     */
+    PetriNetResourceService.prototype.getDataPetriNet = function (body) {
+        var _this = this;
+        return this._resourceProvider.post$('petrinet/data', this.SERVER_URL, body)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Get Transition References Using
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/transitions
+     */
+    PetriNetResourceService.prototype.getPetriNetTransitions = function (netId) {
+        var _this = this;
+        return this._resourceProvider.get$('/petrinet/transitions', this.SERVER_URL, new HttpParams().set('ids', netId))
+            .pipe(map(function (r) { return _this.changeType(r, 'transitionReferences'); }));
+    };
+    /**
+     * Get Transaction References Using
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/{id}/transactions
+     */
+    PetriNetResourceService.prototype.getPetriNetTransactions = function (netId, params) {
+        var _this = this;
+        return this._resourceProvider.get$('/petrinet/' + netId + '/transactions', this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.changeType(r, 'transactions'); }));
+    };
+    /**
+     * Get Roles References Using
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/{id}/roles
+     */
+    PetriNetResourceService.prototype.getPetriNetRoles = function (netId, params) {
+        var _this = this;
+        return this._resourceProvider.get$('/petrinet/' + netId + '/roles', this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * get Net File
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/{netId}/file
+     */
+    PetriNetResourceService.prototype.getNetFile = function (netId, params) {
+        var _this = this;
+        return this._resourceProvider.get$('petrinet/' + netId + '/file', this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * get One Net
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/{identifier}/{version}
+     */
+    PetriNetResourceService.prototype.getOne = function (identifier, version, params) {
+        var _this = this;
+        return this._resourceProvider.get$('petrinet/' + identifier + '/' + version, this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.changeType(r, 'petriNetReferences'); }));
+    };
+    /**
+     * get One Net by ID
+     *
+     * **Request Type:** GET
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/{id}
+     */
+    PetriNetResourceService.prototype.getOneById = function (netId, params) {
+        var _this = this;
+        return this._resourceProvider.get$('petrinet/' + netId, this.SERVER_URL, params)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * import PetriNet
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/import
+     */
+    PetriNetResourceService.prototype.importPetriNet = function (body, params) {
+        return this._resourceProvider.postWithEvent$('petrinet/import', this.SERVER_URL, body, params).pipe(map(function (event) {
+            switch (event.type) {
+                case HttpEventType.UploadProgress:
+                    return ResourceProvider.getProgress(event);
+                case HttpEventType.Response:
+                    return ResourceProvider.processMessageResource(event);
+                default:
+                    return undefined;
+            }
+        }), filter(function (value) { return !!value; }));
+    };
+    /**
+     * search PetriNets
+     *
+     * **Request Type:** POST
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/search
+     */
+    PetriNetResourceService.prototype.searchPetriNets = function (body, params) {
+        var _this = this;
+        return this._resourceProvider.post$('petrinet/search', this.SERVER_URL, body, params)
+            .pipe(map(function (r) { return _this.getResourcePage(r, 'petriNetReferences'); }));
+    };
+    /**
+     * delete PetriNet
+     *
+     * **Request Type:** DELETE
+     *
+     * **Request URL:** {{baseUrl}}/api/petrinet/{id}
+     *
+     * @param netId stringId of the deleted Petri Net
+     */
+    PetriNetResourceService.prototype.deletePetriNet = function (netId) {
+        return this._resourceProvider.delete$('petrinet/' + netId, this.SERVER_URL)
+            .pipe(switchMap(processMessageResponse));
+    };
+    PetriNetResourceService.ctorParameters = function () { return [
+        { type: ResourceProvider },
+        { type: ConfigurationService }
+    ]; };
+    PetriNetResourceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PetriNetResourceService_Factory() { return new PetriNetResourceService(i0.ɵɵinject(i1.ResourceProvider), i0.ɵɵinject(i2.ConfigurationService)); }, token: PetriNetResourceService, providedIn: "root" });
+    PetriNetResourceService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    PetriNetResourceService.ctorParameters = function () { return [
+        { type: ResourceProvider },
+        { type: ConfigurationService }
+    ]; };
+    return PetriNetResourceService;
+}(AbstractResourceService));
+export { PetriNetResourceService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"petri-net-resource.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/resources/engine-endpoint/petri-net-resource.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {Observable} from 'rxjs';\nimport {filter, map, switchMap} from 'rxjs/operators';\nimport {PetriNet} from '../interface/petri-net';\nimport {Params, ProviderProgress, ResourceProvider} from '../resource-provider.service';\nimport {ConfigurationService} from '../../configuration/configuration.service';\nimport Transition from '../../process/transition';\nimport {HttpEventType, HttpParams} from '@angular/common/http';\nimport Transaction from '../../process/transaction';\nimport {EventOutcomeMessageResource, MessageResource} from '../interface/message-resource';\nimport {PetriNetReference} from '../interface/petri-net-reference';\nimport {PetriNetRequestBody} from '../interface/petri-net-request-body';\nimport {Page} from '../interface/page';\nimport {processMessageResponse} from '../../utility/process-message-response';\nimport {AbstractResourceService} from '../abstract-endpoint/abstract-resource.service';\nimport RolesAndPermissions from '../../process/rolesAndPermissions';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class PetriNetResourceService extends AbstractResourceService {\n\n    constructor(provider: ResourceProvider, configService: ConfigurationService) {\n        super('petrinet', provider, configService);\n    }\n\n    /**\n     * Get All Using Petri Net\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/petrinet\n     */\n    public getAll(params?: Params): Observable<Array<PetriNetReference>> {\n        return this._resourceProvider.get$('petrinet', this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, 'petriNetReferences')));\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$('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$('/petrinet/transitions', this.SERVER_URL, new HttpParams().set('ids', netId))\n            .pipe(map(r => this.changeType(r, 'transitionReferences')));\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$('/petrinet/' + netId + '/transactions', this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, 'transactions')));\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$('/petrinet/' + netId + '/roles', this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n    /**\n     * get Net File\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/petrinet/{netId}/file\n     */\n    public getNetFile(netId: string, params?: Params): Observable<any> {  // TODO: response\n        return this._resourceProvider.get$('petrinet/' + netId + '/file', 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/petrinet/{identifier}/{version}\n     */\n    public getOne(identifier: string, version: string, params?: Params): Observable<PetriNetReference> {\n        return this._resourceProvider.get$('petrinet/' + identifier + '/' + version, this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, 'petriNetReferences')));\n    }\n\n    /**\n     * get One Net by ID\n     *\n     * **Request Type:** GET\n     *\n     * **Request URL:** {{baseUrl}}/api/petrinet/{id}\n     */\n    public getOneById(netId: string, params?: Params): Observable<PetriNet> {\n        return this._resourceProvider.get$('petrinet/' + netId, this.SERVER_URL, params)\n            .pipe(map(r => this.changeType(r, undefined)));\n    }\n\n\n    /**\n     * import PetriNet\n     *\n     * **Request Type:** POST\n     *\n     * **Request URL:** {{baseUrl}}/api/petrinet/import\n     */\n    public importPetriNet(body: FormData, params?: Params): Observable<ProviderProgress | EventOutcomeMessageResource> {\n        return this._resourceProvider.postWithEvent$<MessageResource>('petrinet/import', this.SERVER_URL, body, params).pipe(\n            map(event => {\n                switch (event.type) {\n                    case HttpEventType.UploadProgress:\n                        return ResourceProvider.getProgress(event);\n                    case HttpEventType.Response:\n                        return ResourceProvider.processMessageResource(event);\n                    default:\n                        return undefined;\n                }\n            }),\n            filter(value => !!value)\n        );\n    }\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$('petrinet/search', this.SERVER_URL, body, params)\n            .pipe(map(r => this.getResourcePage<PetriNetReference>(r, 'petriNetReferences')));\n    }\n\n    /**\n     * delete PetriNet\n     *\n     * **Request Type:** DELETE\n     *\n     * **Request URL:** {{baseUrl}}/api/petrinet/{id}\n     *\n     * @param netId stringId of the deleted Petri Net\n     */\n    public deletePetriNet(netId: string): Observable<MessageResource> {\n        return this._resourceProvider.delete$<MessageResource>('petrinet/' + netId, this.SERVER_URL)\n            .pipe(switchMap(processMessageResponse));\n    }\n}\n"]}

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

@@ -0,0 +1,52 @@
+import { __extends } from "tslib";
+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";
+var PublicCaseResourceService = /** @class */ (function (_super) {
+    __extends(PublicCaseResourceService, _super);
+    function PublicCaseResourceService(provider, configService) {
+        return _super.call(this, provider, configService) || this;
+    }
+    /**
+     * Get all case data
+     * GET
+     * {{baseUrl}}/api/public/case/:id/data
+     */
+    PublicCaseResourceService.prototype.getCaseData = function (caseID) {
+        var _this = this;
+        return this._resourceProvider.get$('public/case/' + caseID + '/data', this.SERVER_URL)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    /**
+     * Create new case
+     * POST
+     * {{baseUrl}}/api/workflow/case
+     */
+    PublicCaseResourceService.prototype.createCase = function (body) {
+        var _this = this;
+        return this._resourceProvider.post$('public/case/', this.SERVER_URL, body)
+            .pipe(map(function (r) { return _this.changeType(r, undefined); }));
+    };
+    PublicCaseResourceService.ctorParameters = function () { return [
+        { 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 = function () { return [
+        { type: ResourceProvider },
+        { type: ConfigurationService }
+    ]; };
+    return PublicCaseResourceService;
+}(CaseResourceService));
+export { PublicCaseResourceService };
+//# sourceMappingURL=data:application/json;base64,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