@netgrif/components-core
Version:
Netgrif Application engine frontend core Angular library
138 lines • 23.1 kB
JavaScript
import { Injectable } from '@angular/core';
import { AllowedNetsService } from '../allowed-nets.service';
import { switchMap } from 'rxjs/operators';
import { BehaviorSubject, of } from 'rxjs';
import { getImmediateData } from '../../../utility/get-immediate-data';
import { UserFilterConstants } from '../../../filter/models/user-filter-constants';
import { getFieldFromDataGroups } from '../../../utility/get-field';
import { HttpParams } from '@angular/common/http';
import { PaginationParams } from '../../../utility/pagination/pagination-params';
import * as i0 from "@angular/core";
import * as i1 from "../../../process/process.service";
import * as i2 from "../../../resources/engine-endpoint/petri-net-resource.service";
import * as i3 from "../../../configuration/configuration.service";
import * as i4 from "../../../logger/services/logger.service";
function addAllowedNets(allowedNets, existingAllowedNets) {
if (!!allowedNets && allowedNets.length > 0) {
existingAllowedNets.next([...allowedNets]);
}
}
/**
* Convenience method that can be used as an allowed nets factory for tabbed task views.
* If no allowed nets are provided in the injected data then an {@link AllowedNetsService} with no allowed nets is created.
* It has a dependency on this class and {@link NAE_TAB_DATA} injection token.
*/
export function tabbedAllowedNetsServiceFactory(factory, tabData) {
return factory.createFromArray(tabData?.allowedNets ?? []);
}
/**
* Convenience method that can be used as an allowed nets factory for views that are loaded from filter process instances.
* It has a dependency on this class and {@link NAE_NAVIGATION_ITEM_TASK_DATA} injection token.
*/
export function navigationItemTaskAllowedNetsServiceFactory(factory, baseAllowedNets, navigationItemTaskData) {
if (!navigationItemTaskData) {
return factory.createWithAllNets();
}
const filterField = getFieldFromDataGroups(navigationItemTaskData, UserFilterConstants.FILTER_FIELD_ID);
const allowedNetsField = getFieldFromDataGroups(navigationItemTaskData, UserFilterConstants.ALLOWED_NETS_FIELD_ID);
if (filterField === undefined) {
throw new Error(`Provided navigation item task data does not contain a filter field with ID '${UserFilterConstants.FILTER_FIELD_ID}'! Allowed nets cannot be generated from it!`);
}
const nets = new BehaviorSubject(Array.from(new Set([...filterField.allowedNets])));
if (filterField.filterMetadata.inheritAllowedNets) {
baseAllowedNets.allowedNets$.subscribe(allowedNets => {
const netSet = new Set(allowedNets);
nets.next(Array.from(netSet));
});
}
if (!!allowedNetsField) {
addAllowedNets(allowedNetsField.value, nets);
allowedNetsField.valueChanges().subscribe(allowedNets => {
addAllowedNets(allowedNetsField.value, nets);
});
}
return factory.createFromObservable(nets.asObservable());
}
/**
* Simplifies the creation of {@link AllowedNetsService} instances
*/
export class AllowedNetsServiceFactory {
_processService;
_petriNetResource;
_configService;
_log;
constructor(_processService, _petriNetResource, _configService, _log) {
this._processService = _processService;
this._petriNetResource = _petriNetResource;
this._configService = _configService;
this._log = _log;
}
/**
* Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.
* @returns an instance of {@link AllowedNetsService} with all nets set as the `allowedNets`
*/
createWithAllNets() {
let httpParams = new HttpParams()
.set(PaginationParams.PAGE_SIZE, 10000);
return new AllowedNetsService(this._petriNetResource.getAll(httpParams).pipe(switchMap(nets => {
if (nets && Array.isArray(nets)) {
return of(nets.map(n => n.identifier));
}
else {
return of([]);
}
})), this._processService);
}
/**
* Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.
* @param allowedNetsIdentifiers identifiers of the allowed nets
*/
createFromArray(allowedNetsIdentifiers) {
return new AllowedNetsService(of(allowedNetsIdentifiers), this._processService);
}
/**
* Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.
* @param webViewPath path to the view as specified in its configuration. No leading backslash.
* Allowed nets are loaded from the configuration of the view.
*/
createFromConfig(webViewPath) {
const view = this._configService.getViewByPath(webViewPath);
if (view?.layout?.params === undefined) {
throw new Error(`Can't load configuration for view with webPath: '${webViewPath}'`);
}
const viewParams = view.layout.params;
if (viewParams.allowedNets === undefined) {
this._log.warn(`No 'allowedNets' provided for view with webPath '${webViewPath}'`);
}
return new AllowedNetsService(of(viewParams.allowedNets ?? []), this._processService);
}
/**
* Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.
* @param netIdentifiers$ observable containing the identifiers of the allowed nets.
* When a new value is emitted the allowed nets will be updated.
*/
createFromObservable(netIdentifiers$) {
return new AllowedNetsService(netIdentifiers$, this._processService);
}
/**
* Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.
* @param filterCase a filter process instance
* Allowed nets are set from filter process immediate data
*/
createFromFilterCase(filterCase) {
const filterData = getImmediateData(filterCase, UserFilterConstants.FILTER_FIELD_ID);
if (filterData === undefined) {
throw new Error(`Cannot get filter from case '${filterCase.title}' with id '${filterCase.stringId}'`);
}
return new AllowedNetsService(of(filterData.allowedNets), this._processService);
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AllowedNetsServiceFactory, deps: [{ token: i1.ProcessService }, { token: i2.PetriNetResourceService }, { token: i3.ConfigurationService }, { token: i4.LoggerService }], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AllowedNetsServiceFactory, providedIn: 'root' });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AllowedNetsServiceFactory, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.ProcessService }, { type: i2.PetriNetResourceService }, { type: i3.ConfigurationService }, { type: i4.LoggerService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"allowed-nets-service-factory.js","sourceRoot":"","sources":["../../../../../../../projects/netgrif-components-core/src/lib/allowed-nets/services/factory/allowed-nets-service-factory.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {ProcessService} from '../../../process/process.service';\nimport {AllowedNetsService} from '../allowed-nets.service';\nimport {switchMap} from 'rxjs/operators';\nimport { BehaviorSubject, Observable, of } from 'rxjs';\nimport {PetriNetResourceService} from '../../../resources/engine-endpoint/petri-net-resource.service';\nimport {ConfigurationService} from '../../../configuration/configuration.service';\nimport {CaseViewParams} from '../../../view/case-view/models/case-view-params';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {TaskViewParams} from '../../../view/task-view/models/task-view-params';\nimport {InjectedTabbedTaskViewData} from '../../../view/task-view/models/injected-tabbed-task-view-data';\nimport {Case} from '../../../resources/interface/case';\nimport {getImmediateData} from '../../../utility/get-immediate-data';\nimport {UserFilterConstants} from '../../../filter/models/user-filter-constants';\nimport {DataGroup} from '../../../resources/public-api';\nimport {getFieldFromDataGroups} from '../../../utility/get-field';\nimport {FilterField} from '../../../data-fields/filter-field/models/filter-field';\nimport {BaseAllowedNetsService} from '../base-allowed-nets.service';\nimport {MultichoiceField} from '../../../data-fields/multichoice-field/models/multichoice-field';\nimport {HttpParams} from '@angular/common/http';\nimport {PaginationParams} from '../../../utility/pagination/pagination-params';\n\nfunction addAllowedNets(allowedNets, existingAllowedNets) {\n    if (!!allowedNets && allowedNets.length > 0) {\n        existingAllowedNets.next([...allowedNets]);\n    }\n}\n\n/**\n * Convenience method that can be used as an allowed nets factory for tabbed task views.\n * If no allowed nets are provided in the injected data then an {@link AllowedNetsService} with no allowed nets is created.\n * It has a dependency on this class and {@link NAE_TAB_DATA} injection token.\n */\nexport function tabbedAllowedNetsServiceFactory(factory: AllowedNetsServiceFactory,\n                                                tabData: InjectedTabbedTaskViewData): AllowedNetsService {\n    return factory.createFromArray(tabData?.allowedNets ?? []);\n}\n\n/**\n * Convenience method that can be used as an allowed nets factory for views that are loaded from filter process instances.\n * It has a dependency on this class and {@link NAE_NAVIGATION_ITEM_TASK_DATA} injection token.\n */\nexport function navigationItemTaskAllowedNetsServiceFactory(factory: AllowedNetsServiceFactory,\n                                                            baseAllowedNets: BaseAllowedNetsService,\n                                                            navigationItemTaskData?: Array<DataGroup>): AllowedNetsService {\n    if (!navigationItemTaskData) {\n        return factory.createWithAllNets();\n    }\n    const filterField = getFieldFromDataGroups(navigationItemTaskData, UserFilterConstants.FILTER_FIELD_ID) as FilterField;\n    const allowedNetsField = getFieldFromDataGroups(navigationItemTaskData, UserFilterConstants.ALLOWED_NETS_FIELD_ID) as MultichoiceField;\n\n    if (filterField === undefined) {\n        throw new Error(`Provided navigation item task data does not contain a filter field with ID '${UserFilterConstants.FILTER_FIELD_ID\n        }'! Allowed nets cannot be generated from it!`);\n    }\n    const nets = new BehaviorSubject<Array<string>>(Array.from(new Set<string>([...filterField.allowedNets])));\n    if (filterField.filterMetadata.inheritAllowedNets) {\n        baseAllowedNets.allowedNets$.subscribe(allowedNets => {\n            const netSet = new Set<string>(allowedNets);\n            nets.next(Array.from(netSet));\n        });\n    }\n    if (!!allowedNetsField) {\n        addAllowedNets(allowedNetsField.value, nets);\n        allowedNetsField.valueChanges().subscribe(allowedNets => {\n            addAllowedNets(allowedNetsField.value, nets);\n        });\n    }\n    return factory.createFromObservable(nets.asObservable());\n}\n\n/**\n * Simplifies the creation of {@link AllowedNetsService} instances\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class AllowedNetsServiceFactory {\n\n    constructor(protected _processService: ProcessService,\n                protected _petriNetResource: PetriNetResourceService,\n                protected _configService: ConfigurationService,\n                protected _log: LoggerService) {\n    }\n\n    /**\n     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.\n     * @returns an instance of {@link AllowedNetsService} with all nets set as the `allowedNets`\n     */\n    public createWithAllNets(): AllowedNetsService {\n        let httpParams = new HttpParams()\n            .set(PaginationParams.PAGE_SIZE, 10000)\n        return new AllowedNetsService(\n            this._petriNetResource.getAll(httpParams).pipe(\n                switchMap(nets => {\n                    if (nets && Array.isArray(nets)) {\n                        return of(nets.map(n => n.identifier));\n                    } else {\n                        return of([]);\n                    }\n                })\n            ),\n            this._processService\n        );\n    }\n\n    /**\n     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.\n     * @param allowedNetsIdentifiers identifiers of the allowed nets\n     */\n    public createFromArray(allowedNetsIdentifiers: Array<string>): AllowedNetsService {\n        return new AllowedNetsService(\n            of(allowedNetsIdentifiers),\n            this._processService\n        );\n    }\n\n    /**\n     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.\n     * @param webViewPath path to the view as specified in its configuration. No leading backslash.\n     * Allowed nets are loaded from the configuration of the view.\n     */\n    public createFromConfig(webViewPath: string): AllowedNetsService {\n        const view = this._configService.getViewByPath(webViewPath);\n        if (view?.layout?.params === undefined) {\n            throw new Error(`Can't load configuration for view with webPath: '${webViewPath}'`);\n        }\n        const viewParams = view.layout.params as CaseViewParams | TaskViewParams;\n        if (viewParams.allowedNets === undefined) {\n            this._log.warn(`No 'allowedNets' provided for view with webPath '${webViewPath}'`);\n        }\n        return new AllowedNetsService(\n            of(viewParams.allowedNets ?? []),\n            this._processService\n        );\n    }\n\n    /**\n     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.\n     * @param netIdentifiers$ observable containing the identifiers of the allowed nets.\n     * When a new value is emitted the allowed nets will be updated.\n     */\n    public createFromObservable(netIdentifiers$: Observable<Array<string>>): AllowedNetsService {\n        return new AllowedNetsService(\n            netIdentifiers$,\n            this._processService\n        );\n    }\n\n    /**\n     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.\n     * @param filterCase a filter process instance\n     * Allowed nets are set from filter process immediate data\n     */\n    public createFromFilterCase(filterCase: Case): AllowedNetsService {\n        const filterData = getImmediateData(filterCase, UserFilterConstants.FILTER_FIELD_ID);\n        if (filterData === undefined) {\n            throw new Error(`Cannot get filter from case '${filterCase.title}' with id '${filterCase.stringId}'`);\n        }\n        return new AllowedNetsService(\n            of(filterData.allowedNets),\n            this._processService\n        );\n    }\n}\n"]}