@veloceapps/api 4.0.21-0

package/esm2015/lib/services/price-api.service.js

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+export class PriceApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/price';
+    }
+    calculate(request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/calculate`,
+            body: request,
+            skipErrorHandler: true,
+        });
+    }
+    getPriceLists() {
+        return this.httpService.api({
+            method: 'get',
+            url: '/price-lists',
+        });
+    }
+    getPriceList(id) {
+        return this.httpService.api({
+            method: 'get',
+            url: `/price-lists/${id}`,
+        });
+    }
+    getSellingTermByEndDate(planId, offeringId, startDate, endDate, frequencyUnit, frequencyDuration) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/selling-term-by-end-date`,
+            body: {
+                planId: planId,
+                offeringId: offeringId,
+                startDate: startDate,
+                endDate: endDate,
+                frequencyUnit: frequencyUnit,
+                frequencyDuration: frequencyDuration,
+            },
+        });
+    }
+    getSellingTermByTerm(planId, offeringId, startDate, term, frequencyUnit, frequencyDuration) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/selling-term-by-term`,
+            body: {
+                planId: planId,
+                offeringId: offeringId,
+                startDate: startDate,
+                term: term,
+                frequencyUnit: frequencyUnit,
+                frequencyDuration: frequencyDuration,
+            },
+        });
+    }
+}
+PriceApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PriceApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+PriceApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PriceApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PriceApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/procedures-api.service.js

@@ -0,0 +1,93 @@
+import { HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Expression, } from '@veloceapps/core';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+export class ProceduresApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.ADMIN_SERVICE_URL = '/admin/procedures';
+        this.SERVICE_URL = '/procedures';
+        this.fetchProcedures$ = () => {
+            return this.searchProcedures$(new Expression(), 0, 100);
+        };
+        this.searchProcedures$ = (expression, skip, count) => {
+            let params = new HttpParams();
+            params = params.set('skip', '' + skip);
+            params = params.set('count', '' + count);
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.ADMIN_SERVICE_URL}/search`,
+                params,
+                body: expression,
+            });
+        };
+        this.createProcedure$ = (newProcedure) => {
+            return this.baseHttpService.api({
+                url: `${this.ADMIN_SERVICE_URL}`,
+                method: 'post',
+                body: newProcedure,
+            });
+        };
+        this.updateProcedure$ = (procedure) => {
+            return this.baseHttpService.api({
+                url: `${this.ADMIN_SERVICE_URL}/${procedure.id}`,
+                method: 'put',
+                body: procedure,
+            });
+        };
+        this.duplicateProcedure$ = (body) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.ADMIN_SERVICE_URL}/${body.id}/clone`,
+                method: 'post',
+                body,
+            })
+                .pipe(map(response => response.clonedRecordId));
+        };
+        this.removeProcedure$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.ADMIN_SERVICE_URL}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreProcedure$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.ADMIN_SERVICE_URL}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+    }
+    fetchProcedure$(id) {
+        return this.baseHttpService.api({
+            url: `${this.ADMIN_SERVICE_URL}/${id}`,
+            method: 'get',
+        });
+    }
+    execute$(body) {
+        return this.baseHttpService.api({
+            url: `${this.SERVICE_URL}/execute`,
+            method: 'post',
+            body,
+        });
+    }
+    /**
+     * Run active procedure against QuoteDraft
+     * @param body
+     * @returns
+     */
+    apply$(body) {
+        return this.baseHttpService.api({
+            url: `${this.SERVICE_URL}/apply`,
+            method: 'post',
+            body,
+        });
+    }
+}
+ProceduresApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProceduresApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProceduresApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProceduresApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProceduresApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/product-api.service.js

@@ -0,0 +1,153 @@
+import { HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { noop } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+export class ProductApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/products';
+        this.fetchProducts$ = (payload) => {
+            let params = new HttpParams();
+            params = params.append('count', payload.count);
+            params = params.append('skip', payload.skip);
+            if (payload.name) {
+                params = params.append('name', payload.name);
+            }
+            return this.baseHttpService.api({ url: `${this.serviceUrl}`, params });
+        };
+        this.searchProducts$ = (expression, skip, count) => {
+            let params = new HttpParams();
+            params = params.set('skip', '' + skip);
+            params = params.set('count', '' + count);
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/search`,
+                params: params,
+                body: expression,
+            });
+        };
+        this.fetchProduct$ = (id) => this.baseHttpService.api({ url: `${this.serviceUrl}/${id}` });
+        this.fetchAttributes$ = () => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}/attributes/definition` });
+        };
+        this.searchAttributes$ = (expression, skip, count) => {
+            let params = new HttpParams();
+            params = params.set('skip', '' + skip);
+            params = params.set('count', '' + count);
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/attributes/definition/search`,
+                params: params,
+                body: expression,
+            });
+        };
+        this.fetchAttributesByModel = (modelId) => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}/attributes/definition/forModel/${modelId}` });
+        };
+        this.createNewProduct$ = (productData) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}`,
+                method: 'post',
+                body: productData,
+            });
+        };
+        this.updateProduct$ = (body) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${body.id}`,
+                method: 'put',
+                body,
+            });
+        };
+        this.removeProduct$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreProduct$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+        this.createProductAttribute$ = (attributeData) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes`,
+                method: 'post',
+                body: attributeData,
+            });
+        };
+        this.updateProductAttribute$ = (attributeData) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/${attributeData.id}`,
+                method: 'put',
+                body: attributeData,
+            });
+        };
+        this.removeProductAttribute$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/${id}`,
+                method: 'delete',
+            });
+        };
+        this.createNewAttribute$ = (attributeData) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/definition`,
+                method: 'post',
+                body: attributeData,
+            });
+        };
+        this.updateAttribute$ = (body) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/definition/${body.id}`,
+                method: 'put',
+                body,
+            });
+        };
+        this.removeAttribute$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/definition/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreAttribute$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/definition/${id}/restore`,
+                method: 'patch',
+            });
+        };
+    }
+    attachImage$(productId, file) {
+        const data = new FormData();
+        data.append('image', file);
+        return this.baseHttpService.upload({
+            method: 'post',
+            url: `${this.serviceUrl}/${productId}/image`,
+            body: data,
+        });
+    }
+    removeImage$(productId) {
+        return this.baseHttpService.api({
+            method: 'delete',
+            url: `${this.serviceUrl}/${productId}/image`,
+        });
+    }
+    fetchImage$(productId) {
+        return this.baseHttpService.api({
+            url: this.getImageUrl(productId),
+            method: 'get',
+            responseType: 'blob',
+            errorHandler: noop,
+        });
+    }
+    getImageUrl(productId) {
+        return `${this.serviceUrl}/${productId}/image`;
+    }
+}
+ProductApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"product-api.service.js","sourceRoot":"","sources":["../../../../../../libs/api/src/lib/services/product-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpParams } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport {\n  AttributeDefinition,\n  BaseHttpService,\n  Expression,\n  LazyChunkRequest,\n  NewAttributeDefinition,\n  NewProduct,\n  NewProductAttribute,\n  Product,\n  ProductAttribute,\n} from '@veloceapps/core';\nimport { noop, Observable } from 'rxjs';\n\n@Injectable()\nexport class ProductApiService {\n  private readonly serviceUrl: string = '/products';\n\n  constructor(private baseHttpService: BaseHttpService) {}\n\n  fetchProducts$ = (payload: LazyChunkRequest): Observable<Product[]> => {\n    let params: HttpParams = new HttpParams();\n    params = params.append('count', payload.count);\n    params = params.append('skip', payload.skip);\n    if (payload.name) {\n      params = params.append('name', payload.name);\n    }\n    return this.baseHttpService.api({ url: `${this.serviceUrl}`, params });\n  };\n\n  searchProducts$ = (expression: Expression, skip: number, count: number): Observable<Product[]> => {\n    let params = new HttpParams();\n    params = params.set('skip', '' + skip);\n    params = params.set('count', '' + count);\n    return this.baseHttpService.api({\n      method: 'post',\n      url: `${this.serviceUrl}/search`,\n      params: params,\n      body: expression,\n    });\n  };\n\n  fetchProduct$ = (id: string): Observable<Product> => this.baseHttpService.api({ url: `${this.serviceUrl}/${id}` });\n\n  fetchAttributes$ = (): Observable<AttributeDefinition[]> => {\n    return this.baseHttpService.api({ url: `${this.serviceUrl}/attributes/definition` });\n  };\n\n  searchAttributes$ = (expression: Expression, skip: number, count: number): Observable<AttributeDefinition[]> => {\n    let params = new HttpParams();\n    params = params.set('skip', '' + skip);\n    params = params.set('count', '' + count);\n    return this.baseHttpService.api({\n      method: 'post',\n      url: `${this.serviceUrl}/attributes/definition/search`,\n      params: params,\n      body: expression,\n    });\n  };\n\n  fetchAttributesByModel = (modelId: string): Observable<AttributeDefinition[]> => {\n    return this.baseHttpService.api({ url: `${this.serviceUrl}/attributes/definition/forModel/${modelId}` });\n  };\n\n  createNewProduct$ = (productData: NewProduct): Observable<Product> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}`,\n      method: 'post',\n      body: productData,\n    });\n  };\n\n  updateProduct$ = (body: Product): Observable<Product> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}/${body.id}`,\n      method: 'put',\n      body,\n    });\n  };\n\n  removeProduct$ = (id: string): Observable<string> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}/${id}`,\n      method: 'delete',\n    });\n  };\n\n  restoreProduct$ = (id: string): Observable<void> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}/${id}/restore`,\n      method: 'patch',\n    });\n  };\n\n  createProductAttribute$ = (attributeData: NewProductAttribute): Observable<AttributeDefinition> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}/attributes`,\n      method: 'post',\n      body: attributeData,\n    });\n  };\n\n  updateProductAttribute$ = (attributeData: ProductAttribute): Observable<AttributeDefinition> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}/attributes/${attributeData.id}`,\n      method: 'put',\n      body: attributeData,\n    });\n  };\n\n  removeProductAttribute$ = (id: string): Observable<void> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}/attributes/${id}`,\n      method: 'delete',\n    });\n  };\n\n  createNewAttribute$ = (attributeData: NewAttributeDefinition): Observable<AttributeDefinition> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}/attributes/definition`,\n      method: 'post',\n      body: attributeData,\n    });\n  };\n\n  updateAttribute$ = (body: AttributeDefinition): Observable<AttributeDefinition> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}/attributes/definition/${body.id}`,\n      method: 'put',\n      body,\n    });\n  };\n\n  removeAttribute$ = (id: string): Observable<void> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}/attributes/definition/${id}`,\n      method: 'delete',\n    });\n  };\n\n  restoreAttribute$ = (id: string): Observable<void> => {\n    return this.baseHttpService.api({\n      url: `${this.serviceUrl}/attributes/definition/${id}/restore`,\n      method: 'patch',\n    });\n  };\n\n  attachImage$(productId: string, file: File): Observable<void> {\n    const data = new FormData();\n    data.append('image', file);\n\n    return this.baseHttpService.upload({\n      method: 'post',\n      url: `${this.serviceUrl}/${productId}/image`,\n      body: data,\n    });\n  }\n\n  removeImage$(productId: string): Observable<void> {\n    return this.baseHttpService.api({\n      method: 'delete',\n      url: `${this.serviceUrl}/${productId}/image`,\n    });\n  }\n\n  fetchImage$(productId: string): Observable<File> {\n    return this.baseHttpService.api({\n      url: this.getImageUrl(productId),\n      method: 'get',\n      responseType: 'blob',\n      errorHandler: noop,\n    });\n  }\n\n  getImageUrl(productId: string) {\n    return `${this.serviceUrl}/${productId}/image`;\n  }\n}\n"]}

package/esm2015/lib/services/product-model-api.service.js

@@ -0,0 +1,232 @@
+import { Injectable } from '@angular/core';
+import { EntityUtil, ModelTranslatorUtils, ModelUtils, ProductModelsContainer, } from '@veloceapps/core';
+import { forkJoin } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/core";
+export class ProductModelApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/models';
+    }
+    addModel(model) {
+        return this.httpService
+            .api({
+            method: 'post',
+            url: this.SERVICE_URL,
+            body: model,
+            errorHandler: this.httpService.handleValidationError,
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return result;
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }));
+    }
+    releaseModel(model) {
+        return this.httpService
+            .api({
+            method: 'put',
+            url: `${this.SERVICE_URL}/${model.id}/release`,
+            body: model,
+            errorHandler: this.httpService.handleValidationError,
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return '';
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }));
+    }
+    removeModel(modelId, successFn, failureFn) {
+        const observable = this.httpService
+            .api({
+            method: 'delete',
+            url: `${this.SERVICE_URL}/${modelId}`,
+            errorHandler: this.httpService.handleValidationError,
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return '';
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }));
+        observable.subscribe(() => {
+            successFn && successFn.apply();
+        }, () => {
+            failureFn && failureFn.apply();
+        });
+    }
+    getModelVersions(modelId, count = 100, skip = 0) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/${modelId}/versions`,
+            body: {
+                skipCount: skip,
+                count: count,
+            },
+        });
+    }
+    getModel(id, version) {
+        let url = `${this.SERVICE_URL}/${id}`;
+        if (version) {
+            url += `/versions/${version}`;
+        }
+        return this.httpService.api({ url });
+    }
+    getModels(skipCount, searchText) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/search`,
+            body: {
+                nameRegex: searchText,
+                skipCount: skipCount.toString(),
+                count: ProductModelApiService.MAX_RESULTS,
+            },
+        });
+    }
+    getLinkedModels(id, version) {
+        let url = `${this.SERVICE_URL}/${id}`;
+        if (version) {
+            url += `/versions/${version}`;
+        }
+        url += '/linked';
+        return this.httpService.api({ url }).pipe(map((linkedModels) => {
+            if (linkedModels) {
+                linkedModels.forEach(model => ModelTranslatorUtils.toLocalModel(model));
+            }
+            return linkedModels;
+        }));
+    }
+    load(id, version) {
+        return forkJoin([this.getModel(id, version), this.getLinkedModels(id, version)]).pipe(map(([model, linkedModels]) => {
+            const container = new ProductModelsContainer(model, linkedModels !== null && linkedModels !== void 0 ? linkedModels : []);
+            ModelUtils.override(container.main, container.linked);
+            ModelTranslatorUtils.toLocalModel(container.main, container.linked);
+            return container;
+        }));
+    }
+    getPML(modelId, version) {
+        let url = `${this.SERVICE_URL}/${modelId}/pml/${version}`;
+        if (version) {
+            url += `/versions/${version}`;
+        }
+        return this.httpService.api({
+            url,
+            responseType: 'text',
+        });
+    }
+    savePML(modelId, pml, comment) {
+        return this.httpService
+            .api({
+            method: 'put',
+            url: `${this.SERVICE_URL}/${modelId}/pml`,
+            body: {
+                id: modelId,
+                pml: pml,
+                comment: comment,
+            },
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return '';
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }), catchError(this.httpService.handleValidationError));
+    }
+    generateProducts(modelId) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${modelId}/generate-products`,
+        });
+    }
+    saveModel(productModel, comment) {
+        const model = EntityUtil.clone(productModel);
+        model.comment = comment;
+        ModelTranslatorUtils.toServerModel(model);
+        return this.httpService
+            .api({
+            method: 'put',
+            url: `${this.SERVICE_URL}/${model.id}`,
+            body: model,
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return '';
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }), catchError(this.httpService.handleValidationError));
+    }
+    validateModel(productModel) {
+        return this.httpService
+            .api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/validate`,
+            body: productModel,
+            errorHandler: this.httpService.handleValidationError,
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return '';
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }));
+    }
+    renameModel(productModel, name) {
+        const model = EntityUtil.clone(productModel);
+        model.name = name;
+        ModelTranslatorUtils.toServerModel(model);
+        return this.httpService
+            .api({
+            method: 'patch',
+            url: `${this.SERVICE_URL}/${model.id}`,
+            body: model,
+        })
+            .pipe(catchError(this.httpService.handleValidationError));
+    }
+    uploadPmlFile(file, modelId) {
+        const formData = new FormData();
+        formData.append('file', file, file.name);
+        return this.httpService.upload({
+            url: `${this.SERVICE_URL}/${modelId}/pml/upload`,
+            body: formData,
+        });
+    }
+    runPml(modelId, pml, rootType, configurationMode) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/${modelId}/pml/run`,
+            body: {
+                pml,
+                rootType,
+                configurationMode,
+            },
+            responseType: 'text',
+        });
+    }
+    evictAllCache() {
+        return this.httpService.api({
+            method: 'get',
+            url: '/cache/evict/environment-variables',
+        });
+    }
+}
+ProductModelApiService.MAX_RESULTS = 200;
+ProductModelApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductModelApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductModelApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductModelApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductModelApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"product-model-api.service.js","sourceRoot":"","sources":["../../../../../../libs/api/src/lib/services/product-model-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  BaseHttpService,\n  EntityUtil,\n  ModelReleaseRequest,\n  ModelTranslatorUtils,\n  ModelUtils,\n  PmlConfigurationMode,\n  ProductModel,\n  ProductModelsContainer,\n  ProductModelVersion,\n} from '@veloceapps/core';\nimport { forkJoin, Observable } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\n\n@Injectable()\nexport class ProductModelApiService {\n  public static MAX_RESULTS = 200;\n\n  private readonly SERVICE_URL = '/models';\n\n  constructor(private httpService: BaseHttpService) {}\n\n  addModel(model: ProductModel): Observable<any> {\n    return this.httpService\n      .api({\n        method: 'post',\n        url: this.SERVICE_URL,\n        body: model,\n        errorHandler: this.httpService.handleValidationError,\n      })\n      .pipe(\n        map(result => {\n          if (result.successful) {\n            return result;\n          } else {\n            throw new Error(result.message);\n          }\n        }),\n      );\n  }\n\n  releaseModel(model: ModelReleaseRequest): Observable<any> {\n    return this.httpService\n      .api({\n        method: 'put',\n        url: `${this.SERVICE_URL}/${model.id}/release`,\n        body: model,\n        errorHandler: this.httpService.handleValidationError,\n      })\n      .pipe(\n        map(result => {\n          if (result.successful) {\n            return '';\n          } else {\n            throw new Error(result.message);\n          }\n        }),\n      );\n  }\n\n  removeModel(modelId: string, successFn?: any, failureFn?: any): void {\n    const observable = this.httpService\n      .api({\n        method: 'delete',\n        url: `${this.SERVICE_URL}/${modelId}`,\n        errorHandler: this.httpService.handleValidationError,\n      })\n      .pipe(\n        map(result => {\n          if (result.successful) {\n            return '';\n          } else {\n            throw new Error(result.message);\n          }\n        }),\n      );\n\n    observable.subscribe(\n      () => {\n        successFn && successFn.apply();\n      },\n      () => {\n        failureFn && failureFn.apply();\n      },\n    );\n  }\n\n  getModelVersions(modelId: string, count: number = 100, skip: number = 0): Observable<ProductModelVersion[]> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/${modelId}/versions`,\n      body: {\n        skipCount: skip,\n        count: count,\n      },\n    });\n  }\n\n  getModel(id: string, version?: string): Observable<ProductModel> {\n    let url = `${this.SERVICE_URL}/${id}`;\n\n    if (version) {\n      url += `/versions/${version}`;\n    }\n\n    return this.httpService.api({ url });\n  }\n\n  getModels(skipCount: number, searchText: string): Observable<ProductModel[]> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/search`,\n      body: {\n        nameRegex: searchText,\n        skipCount: skipCount.toString(),\n        count: ProductModelApiService.MAX_RESULTS,\n      },\n    });\n  }\n\n  getLinkedModels(id: string, version?: string): Observable<ProductModel[]> {\n    let url = `${this.SERVICE_URL}/${id}`;\n\n    if (version) {\n      url += `/versions/${version}`;\n    }\n\n    url += '/linked';\n\n    return this.httpService.api({ url }).pipe(\n      map((linkedModels: ProductModel[]) => {\n        if (linkedModels) {\n          linkedModels.forEach(model => ModelTranslatorUtils.toLocalModel(model));\n        }\n        return linkedModels;\n      }),\n    );\n  }\n\n  load(id: string, version?: string): Observable<ProductModelsContainer> {\n    return forkJoin([this.getModel(id, version), this.getLinkedModels(id, version)]).pipe(\n      map(([model, linkedModels]) => {\n        const container = new ProductModelsContainer(model, linkedModels ?? []);\n\n        ModelUtils.override(container.main, container.linked);\n        ModelTranslatorUtils.toLocalModel(container.main, container.linked);\n\n        return container;\n      }),\n    );\n  }\n\n  getPML(modelId: string, version?: string): Observable<any> {\n    let url = `${this.SERVICE_URL}/${modelId}/pml/${version}`;\n\n    if (version) {\n      url += `/versions/${version}`;\n    }\n\n    return this.httpService.api({\n      url,\n      responseType: 'text',\n    });\n  }\n\n  savePML(modelId: string, pml: string, comment: string): Observable<any> {\n    return this.httpService\n      .api({\n        method: 'put',\n        url: `${this.SERVICE_URL}/${modelId}/pml`,\n        body: {\n          id: modelId,\n          pml: pml,\n          comment: comment,\n        },\n      })\n      .pipe(\n        map(result => {\n          if (result.successful) {\n            return '';\n          } else {\n            throw new Error(result.message);\n          }\n        }),\n        catchError(this.httpService.handleValidationError),\n      );\n  }\n\n  generateProducts(modelId: string): Observable<ProductModel> {\n    return this.httpService.api({\n      url: `${this.SERVICE_URL}/${modelId}/generate-products`,\n    });\n  }\n\n  saveModel(productModel: ProductModel, comment: string): Observable<string> {\n    const model = EntityUtil.clone(productModel);\n    model.comment = comment;\n    ModelTranslatorUtils.toServerModel(model);\n\n    return this.httpService\n      .api({\n        method: 'put',\n        url: `${this.SERVICE_URL}/${model.id}`,\n        body: model,\n      })\n      .pipe(\n        map(result => {\n          if (result.successful) {\n            return '';\n          } else {\n            throw new Error(result.message);\n          }\n        }),\n        catchError(this.httpService.handleValidationError),\n      );\n  }\n\n  validateModel(productModel: ProductModel): Observable<string> {\n    return this.httpService\n      .api({\n        method: 'post',\n        url: `${this.SERVICE_URL}/validate`,\n        body: productModel,\n        errorHandler: this.httpService.handleValidationError,\n      })\n      .pipe(\n        map(result => {\n          if (result.successful) {\n            return '';\n          } else {\n            throw new Error(result.message);\n          }\n        }),\n      );\n  }\n\n  renameModel(productModel: ProductModel, name: string): Observable<any> {\n    const model = EntityUtil.clone(productModel);\n    model.name = name;\n    ModelTranslatorUtils.toServerModel(model);\n\n    return this.httpService\n      .api({\n        method: 'patch',\n        url: `${this.SERVICE_URL}/${model.id}`,\n        body: model,\n      })\n      .pipe(catchError(this.httpService.handleValidationError));\n  }\n\n  uploadPmlFile(file: File, modelId: string): Observable<any> {\n    const formData: FormData = new FormData();\n    formData.append('file', file, file.name);\n\n    return this.httpService.upload({\n      url: `${this.SERVICE_URL}/${modelId}/pml/upload`,\n      body: formData,\n    });\n  }\n\n  runPml(modelId: string, pml: string, rootType: string, configurationMode: PmlConfigurationMode): Observable<any> {\n    return this.httpService.api({\n      method: 'post',\n      url: `${this.SERVICE_URL}/${modelId}/pml/run`,\n      body: {\n        pml,\n        rootType,\n        configurationMode,\n      },\n      responseType: 'text',\n    });\n  }\n\n  evictAllCache(): Observable<{ result: string }> {\n    return this.httpService.api({\n      method: 'get',\n      url: '/cache/evict/environment-variables',\n    });\n  }\n}\n"]}