@veloceapps/sdk 7.0.0-8 → 7.0.1-0

package/esm2020/core/modules/flow-configuration/services/flow-update.service.mjs

@@ -0,0 +1,129 @@
+import { Injectable } from '@angular/core';
+import { ChargeGroupUtils } from '@veloceapps/core';
+import { flatten } from 'lodash';
+import moment from 'moment';
+import { LineItemWorker } from '../../../utils';
+import * as i0 from "@angular/core";
+export class FlowUpdateService {
+    update(rootLineItems, updates, charges) {
+        let remainingUpdates = [...updates];
+        let currentLevel = rootLineItems;
+        while (currentLevel.length && remainingUpdates.length) {
+            currentLevel.forEach(li => {
+                const unhandledUpdates = [];
+                remainingUpdates.forEach(update => {
+                    let updated = false;
+                    switch (update.dataType) {
+                        case 'LINEITEM':
+                            updated = this.applyLineItemUpdate(li, update, charges);
+                            break;
+                        case 'CHARGE':
+                            updated = this.applyChargeUpdate(li, update);
+                            break;
+                        case 'GROUP_CHARGE':
+                            updated = this.applyChargeGroupUpdate(li, update);
+                            break;
+                        default:
+                            // Unknown dataType. Do not try to handle it anymore
+                            updated = true;
+                    }
+                    if (!updated) {
+                        unhandledUpdates.push(update);
+                    }
+                });
+                remainingUpdates = unhandledUpdates;
+            });
+            currentLevel = flatten(currentLevel.map(parent => parent.lineItems));
+        }
+    }
+    delete(lineItems, id) {
+        const idsToRemove = [id];
+        const topLevelLineItem = lineItems.find(li => li.id === id);
+        if (topLevelLineItem) {
+            // find term-related line items (which are only top level)
+            // expired term line items won't be deleted
+            let foundTermLineItem = topLevelLineItem;
+            while (foundTermLineItem) {
+                foundTermLineItem = lineItems.find(li => foundTermLineItem && li.rampInstanceId === foundTermLineItem.id);
+                if (foundTermLineItem) {
+                    idsToRemove.push(foundTermLineItem.id);
+                }
+            }
+        }
+        const filtered = lineItems.filter(lineItem => !idsToRemove.includes(lineItem.id));
+        return filtered.map(lineItem => new LineItemWorker(lineItem).remove(id).li);
+    }
+    applyLineItemUpdate(lineItem, update, charges) {
+        if (lineItem.id !== update.id) {
+            return false;
+        }
+        switch (update.attributeType) {
+            case 'QTY':
+                lineItem.qty = update.newValue;
+                break;
+            case 'EFFECTIVE_START_DATE':
+                lineItem.properties['StartDate'] = moment(update.newValue).format('YYYY-MM-DD');
+                break;
+            case 'END_DATE':
+                lineItem.properties['EndDate'] = moment(update.newValue).format('YYYY-MM-DD');
+                break;
+            case 'PRICE_ADJUSTMENT':
+                {
+                    const charge = lineItem.chargeItems.find(charge => (charges || {})[charge.chargeId]?.main);
+                    if (charge) {
+                        charge.priceAdjustment = update.newValue;
+                    }
+                }
+                break;
+            case 'LIST_PRICE_ADJUSTMENT':
+                {
+                    const charge = lineItem.chargeItems.find(charge => (charges || {})[charge.chargeId]?.main);
+                    if (charge) {
+                        charge.listPriceAdjustment = update.newValue;
+                    }
+                }
+                break;
+            default:
+                throw new Error(`Not suppored AttributeType for LineItem update: ${update.attributeType}`);
+        }
+        return true;
+    }
+    applyChargeUpdate(lineItem, update) {
+        const foundCharge = lineItem.chargeItems.find(({ id }) => id === update.id);
+        if (!foundCharge) {
+            return false;
+        }
+        if (update.attributeType === 'PRICE_ADJUSTMENT') {
+            foundCharge.priceAdjustment = update.newValue;
+        }
+        else if (update.attributeType === 'LIST_PRICE_ADJUSTMENT') {
+            foundCharge.listPriceAdjustment = update.newValue;
+        }
+        else {
+            throw new Error(`Not suppored AttributeType for Charge Item update: ${update.attributeType}`);
+        }
+        return true;
+    }
+    applyChargeGroupUpdate(lineItem, update) {
+        const foundChargeGroup = ChargeGroupUtils.findChargeGroupById(update.id, lineItem);
+        if (!foundChargeGroup) {
+            return false;
+        }
+        if (update.attributeType === 'PRICE_ADJUSTMENT') {
+            foundChargeGroup.priceAdjustment = update.newValue;
+        }
+        else if (update.attributeType === 'LIST_PRICE_ADJUSTMENT') {
+            foundChargeGroup.listPriceAdjustment = update.newValue;
+        }
+        else {
+            throw new Error(`Not suppored AttributeType for Charge Group Item update: ${update.attributeType}`);
+        }
+        return true;
+    }
+}
+FlowUpdateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowUpdateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FlowUpdateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowUpdateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowUpdateService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-update.service.js","sourceRoot":"","sources":["../../../../../../../../libs/sdk/core/modules/flow-configuration/services/flow-update.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAU,gBAAgB,EAAY,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAc,OAAO,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;;AAIhD,MAAM,OAAO,iBAAiB;IACrB,MAAM,CAAC,aAAyB,EAAE,OAA2B,EAAE,OAA4B;QAChG,IAAI,gBAAgB,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC;QACpC,IAAI,YAAY,GAAG,aAAa,CAAC;QAEjC,OAAO,YAAY,CAAC,MAAM,IAAI,gBAAgB,CAAC,MAAM,EAAE;YACrD,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;gBACxB,MAAM,gBAAgB,GAAuB,EAAE,CAAC;gBAEhD,gBAAgB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;oBAChC,IAAI,OAAO,GAAG,KAAK,CAAC;oBAEpB,QAAQ,MAAM,CAAC,QAAQ,EAAE;wBACvB,KAAK,UAAU;4BACb,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;4BACxD,MAAM;wBACR,KAAK,QAAQ;4BACX,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;4BAC7C,MAAM;wBACR,KAAK,cAAc;4BACjB,OAAO,GAAG,IAAI,CAAC,sBAAsB,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;4BAClD,MAAM;wBACR;4BACE,oDAAoD;4BACpD,OAAO,GAAG,IAAI,CAAC;qBAClB;oBAED,IAAI,CAAC,OAAO,EAAE;wBACZ,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;qBAC/B;gBACH,CAAC,CAAC,CAAC;gBAEH,gBAAgB,GAAG,gBAAgB,CAAC;YACtC,CAAC,CAAC,CAAC;YAEH,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;SACtE;IACH,CAAC;IAEM,MAAM,CAAC,SAAqB,EAAE,EAAU;QAC7C,MAAM,WAAW,GAAa,CAAC,EAAE,CAAC,CAAC;QACnC,MAAM,gBAAgB,GAAG,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAE5D,IAAI,gBAAgB,EAAE;YACpB,0DAA0D;YAC1D,2CAA2C;YAC3C,IAAI,iBAAiB,GAAyB,gBAAgB,CAAC;YAE/D,OAAO,iBAAiB,EAAE;gBACxB,iBAAiB,GAAG,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,iBAAiB,IAAI,EAAE,CAAC,cAAc,KAAK,iBAAiB,CAAC,EAAE,CAAC,CAAC;gBAC1G,IAAI,iBAAiB,EAAE;oBACrB,WAAW,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;iBACxC;aACF;SACF;QAED,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;QAClF,OAAO,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,cAAc,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IAC9E,CAAC;IAEO,mBAAmB,CAAC,QAAkB,EAAE,MAAwB,EAAE,OAA4B;QACpG,IAAI,QAAQ,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,EAAE;YAC7B,OAAO,KAAK,CAAC;SACd;QAED,QAAQ,MAAM,CAAC,aAAa,EAAE;YAC5B,KAAK,KAAK;gBACR,QAAQ,CAAC,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC;gBAC/B,MAAM;YACR,KAAK,sBAAsB;gBACzB,QAAQ,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;gBAChF,MAAM;YACR,KAAK,UAAU;gBACb,QAAQ,CAAC,UAAU,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;gBAC9E,MAAM;YACR,KAAK,kBAAkB;gBACrB;oBACE,MAAM,MAAM,GAAG,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC;oBAC3F,IAAI,MAAM,EAAE;wBACV,MAAM,CAAC,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC;qBAC1C;iBACF;gBACD,MAAM;YACR,KAAK,uBAAuB;gBAC1B;oBACE,MAAM,MAAM,GAAG,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC;oBAC3F,IAAI,MAAM,EAAE;wBACV,MAAM,CAAC,mBAAmB,GAAG,MAAM,CAAC,QAAQ,CAAC;qBAC9C;iBACF;gBACD,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,mDAAmD,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC;SAC9F;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,iBAAiB,CAAC,QAAkB,EAAE,MAAwB;QACpE,MAAM,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,CAAC,CAAC;QAC5E,IAAI,CAAC,WAAW,EAAE;YAChB,OAAO,KAAK,CAAC;SACd;QAED,IAAI,MAAM,CAAC,aAAa,KAAK,kBAAkB,EAAE;YAC/C,WAAW,CAAC,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC;SAC/C;aAAM,IAAI,MAAM,CAAC,aAAa,KAAK,uBAAuB,EAAE;YAC3D,WAAW,CAAC,mBAAmB,GAAG,MAAM,CAAC,QAAQ,CAAC;SACnD;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,sDAAsD,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC;SAC/F;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,sBAAsB,CAAC,QAAkB,EAAE,MAAwB;QACzE,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;QACnF,IAAI,CAAC,gBAAgB,EAAE;YACrB,OAAO,KAAK,CAAC;SACd;QAED,IAAI,MAAM,CAAC,aAAa,KAAK,kBAAkB,EAAE;YAC/C,gBAAgB,CAAC,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC;SACpD;aAAM,IAAI,MAAM,CAAC,aAAa,KAAK,uBAAuB,EAAE;YAC3D,gBAAgB,CAAC,mBAAmB,GAAG,MAAM,CAAC,QAAQ,CAAC;SACxD;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,4DAA4D,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC;SACrG;QAED,OAAO,IAAI,CAAC;IACd,CAAC;;8GAlIU,iBAAiB;kHAAjB,iBAAiB;2FAAjB,iBAAiB;kBAD7B,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Charge, ChargeGroupUtils, LineItem } from '@veloceapps/core';\nimport { Dictionary, flatten } from 'lodash';\nimport moment from 'moment';\nimport { LineItemWorker } from '../../../utils';\nimport { FlowUpdateParams } from '../types/update.types';\n\n@Injectable()\nexport class FlowUpdateService {\n  public update(rootLineItems: LineItem[], updates: FlowUpdateParams[], charges?: Dictionary<Charge>): void {\n    let remainingUpdates = [...updates];\n    let currentLevel = rootLineItems;\n\n    while (currentLevel.length && remainingUpdates.length) {\n      currentLevel.forEach(li => {\n        const unhandledUpdates: FlowUpdateParams[] = [];\n\n        remainingUpdates.forEach(update => {\n          let updated = false;\n\n          switch (update.dataType) {\n            case 'LINEITEM':\n              updated = this.applyLineItemUpdate(li, update, charges);\n              break;\n            case 'CHARGE':\n              updated = this.applyChargeUpdate(li, update);\n              break;\n            case 'GROUP_CHARGE':\n              updated = this.applyChargeGroupUpdate(li, update);\n              break;\n            default:\n              // Unknown dataType. Do not try to handle it anymore\n              updated = true;\n          }\n\n          if (!updated) {\n            unhandledUpdates.push(update);\n          }\n        });\n\n        remainingUpdates = unhandledUpdates;\n      });\n\n      currentLevel = flatten(currentLevel.map(parent => parent.lineItems));\n    }\n  }\n\n  public delete(lineItems: LineItem[], id: string): LineItem[] {\n    const idsToRemove: string[] = [id];\n    const topLevelLineItem = lineItems.find(li => li.id === id);\n\n    if (topLevelLineItem) {\n      // find term-related line items (which are only top level)\n      // expired term line items won't be deleted\n      let foundTermLineItem: LineItem | undefined = topLevelLineItem;\n\n      while (foundTermLineItem) {\n        foundTermLineItem = lineItems.find(li => foundTermLineItem && li.rampInstanceId === foundTermLineItem.id);\n        if (foundTermLineItem) {\n          idsToRemove.push(foundTermLineItem.id);\n        }\n      }\n    }\n\n    const filtered = lineItems.filter(lineItem => !idsToRemove.includes(lineItem.id));\n    return filtered.map(lineItem => new LineItemWorker(lineItem).remove(id).li);\n  }\n\n  private applyLineItemUpdate(lineItem: LineItem, update: FlowUpdateParams, charges?: Dictionary<Charge>): boolean {\n    if (lineItem.id !== update.id) {\n      return false;\n    }\n\n    switch (update.attributeType) {\n      case 'QTY':\n        lineItem.qty = update.newValue;\n        break;\n      case 'EFFECTIVE_START_DATE':\n        lineItem.properties['StartDate'] = moment(update.newValue).format('YYYY-MM-DD');\n        break;\n      case 'END_DATE':\n        lineItem.properties['EndDate'] = moment(update.newValue).format('YYYY-MM-DD');\n        break;\n      case 'PRICE_ADJUSTMENT':\n        {\n          const charge = lineItem.chargeItems.find(charge => (charges || {})[charge.chargeId]?.main);\n          if (charge) {\n            charge.priceAdjustment = update.newValue;\n          }\n        }\n        break;\n      case 'LIST_PRICE_ADJUSTMENT':\n        {\n          const charge = lineItem.chargeItems.find(charge => (charges || {})[charge.chargeId]?.main);\n          if (charge) {\n            charge.listPriceAdjustment = update.newValue;\n          }\n        }\n        break;\n      default:\n        throw new Error(`Not suppored AttributeType for LineItem update: ${update.attributeType}`);\n    }\n\n    return true;\n  }\n\n  private applyChargeUpdate(lineItem: LineItem, update: FlowUpdateParams): boolean {\n    const foundCharge = lineItem.chargeItems.find(({ id }) => id === update.id);\n    if (!foundCharge) {\n      return false;\n    }\n\n    if (update.attributeType === 'PRICE_ADJUSTMENT') {\n      foundCharge.priceAdjustment = update.newValue;\n    } else if (update.attributeType === 'LIST_PRICE_ADJUSTMENT') {\n      foundCharge.listPriceAdjustment = update.newValue;\n    } else {\n      throw new Error(`Not suppored AttributeType for Charge Item update: ${update.attributeType}`);\n    }\n\n    return true;\n  }\n\n  private applyChargeGroupUpdate(lineItem: LineItem, update: FlowUpdateParams): boolean {\n    const foundChargeGroup = ChargeGroupUtils.findChargeGroupById(update.id, lineItem);\n    if (!foundChargeGroup) {\n      return false;\n    }\n\n    if (update.attributeType === 'PRICE_ADJUSTMENT') {\n      foundChargeGroup.priceAdjustment = update.newValue;\n    } else if (update.attributeType === 'LIST_PRICE_ADJUSTMENT') {\n      foundChargeGroup.listPriceAdjustment = update.newValue;\n    } else {\n      throw new Error(`Not suppored AttributeType for Charge Group Item update: ${update.attributeType}`);\n    }\n\n    return true;\n  }\n}\n"]}

package/esm2020/core/services/context.service.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import { ContextApiService } from '@veloceapps/api';
+import { ConfigurationContext } from '@veloceapps/core';
+import { merge } from 'lodash';
+import { BehaviorSubject } from 'rxjs';
+import { filter, map, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/api";
+export class ContextService {
+    constructor(contextApiService) {
+        this.contextApiService = contextApiService;
+        this.context = new BehaviorSubject(null);
+    }
+    get isInitialized() {
+        return Boolean(this.context.value);
+    }
+    get mode() {
+        return this.resolve().properties.mode;
+    }
+    resolve() {
+        if (!this.context.value) {
+            throw new Error('Context is not initialized yet!');
+        }
+        return { ...this.context.value };
+    }
+    resolve$() {
+        return this.context.pipe(filter((ctx) => Boolean(ctx)));
+    }
+    create(headerId, mode) {
+        return this.contextApiService.getContext(headerId, mode).pipe(tap(context => this.context.next(merge(new ConfigurationContext(headerId, mode), context))), map(() => this.resolve()));
+    }
+    update(partialContext) {
+        const originalContext = this.resolve();
+        const updatedContext = {
+            ...originalContext,
+            ...partialContext,
+            properties: {
+                ...originalContext.properties,
+                ...partialContext.properties,
+            },
+        };
+        this.context.next(updatedContext);
+        return updatedContext;
+    }
+    set(context) {
+        const originalContext = this.resolve();
+        const updatedContext = {
+            ...originalContext,
+            ...context,
+        };
+        this.context.next(updatedContext);
+        return updatedContext;
+    }
+    delete() {
+        this.context.next(null);
+    }
+}
+ContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ContextService, deps: [{ token: i1.ContextApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ContextService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ContextService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.ContextApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/services/metric-calculation/metric-calculation.service.mjs

@@ -0,0 +1,85 @@
+import { Injectable } from '@angular/core';
+import { ConfigurationSettingsApiService } from '@veloceapps/api';
+import { uniq } from 'lodash';
+import { combineLatest, Subject, take } from 'rxjs';
+import { FlowConfigurationService } from '../../modules/flow-configuration/services/flow-configuration.service';
+import { QuoteDraftService } from '../quote-draft.service';
+import { calculateMetricByMethod } from './metric-calculation.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../quote-draft.service";
+import * as i2 from "../../modules/flow-configuration/services/flow-configuration.service";
+import * as i3 from "@veloceapps/api";
+export class MetricsCalculationService {
+    get onMetricsUpdate$() {
+        return this.metricsUpdated$.asObservable();
+    }
+    constructor(quoteDraftService, flowConfiguration, settingsService) {
+        this.quoteDraftService = quoteDraftService;
+        this.flowConfiguration = flowConfiguration;
+        this.settingsService = settingsService;
+        this.metricsUpdated$ = new Subject();
+        this.quoteMetricsSettings = {};
+        this.metricsCalculationMethodMap = {};
+        this.metricsData = {};
+        this.activeMetricRules = [];
+        this.activeMetricRules = this.flowConfiguration.activeMetricsSnapshot.filter(metricRule => metricRule.metrics.some(metric => !!metric.totalName));
+        combineLatest([
+            this.quoteDraftService.currentState$,
+            this.settingsService.fetchSetting('QUOTE_LEVEL_METRIC_CALCULATION_METHOD').pipe(take(1)),
+        ]).subscribe(([lineItems, setting]) => {
+            let settingsData = {};
+            try {
+                settingsData = JSON.parse(setting?.value || '{}');
+            }
+            catch (error) {
+                settingsData = {};
+            }
+            this.quoteMetricsSettings = settingsData;
+            this.updateMetrics(lineItems);
+        });
+    }
+    getMetricValue(metric) {
+        return this.metricsData[metric] || 0;
+    }
+    updateMetrics(lineItems) {
+        const metricKeys = this.collectMetricKeys(lineItems).filter(key => !key.includes('Effective_'));
+        this.metricsCalculationMethodMap = this.buildMetricsCalculationMethods(metricKeys, this.metricsCalculationMethodMap);
+        this.metricsData = metricKeys.reduce((acc, key) => ({ ...acc, [key]: this.calculateMetric(lineItems, key) }), {});
+        this.metricsUpdated$.next();
+    }
+    calculateMetric(lineItems, metric) {
+        return calculateMetricByMethod(lineItems, metric, this.metricsCalculationMethodMap[metric] || 'sum');
+    }
+    buildMetricsCalculationMethods(metricKeys, initial) {
+        return metricKeys.reduce((acc, name) => {
+            if (acc[name]) {
+                return acc;
+            }
+            acc = { ...acc, [name]: 'sum' };
+            const metricRule = this.getMetricRuleByTotalMetricName(name);
+            const settingKey = metricRule?.metrics?.find(metric => metric.totalName === name)?.name || name;
+            if (this.quoteMetricsSettings[settingKey]) {
+                acc = { ...acc, [name]: this.quoteMetricsSettings[settingKey] };
+            }
+            return acc;
+        }, initial);
+    }
+    collectMetricKeys(lineItems) {
+        const keys = [];
+        lineItems.forEach(lineItem => {
+            keys.push(...Object.keys(lineItem.totalMetrics || {}));
+            keys.push(...this.collectMetricKeys(lineItem.lineItems));
+        });
+        return uniq(keys);
+    }
+    getMetricRuleByTotalMetricName(name) {
+        return this.activeMetricRules.find(metricRule => metricRule.metrics.find(metric => metric.totalName === name));
+    }
+}
+MetricsCalculationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: MetricsCalculationService, deps: [{ token: i1.QuoteDraftService }, { token: i2.FlowConfigurationService }, { token: i3.ConfigurationSettingsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+MetricsCalculationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: MetricsCalculationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: MetricsCalculationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.QuoteDraftService }, { type: i2.FlowConfigurationService }, { type: i3.ConfigurationSettingsApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metric-calculation.service.js","sourceRoot":"","sources":["../../../../../../../libs/sdk/core/services/metric-calculation/metric-calculation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ConfigurationSettingsApiService } from '@veloceapps/api';\nimport { LineItem, MetricRule } from '@veloceapps/core';\nimport { Dictionary, uniq } from 'lodash';\nimport { combineLatest, Observable, Subject, take } from 'rxjs';\nimport { FlowConfigurationService } from '../../modules/flow-configuration/services/flow-configuration.service';\nimport { QuoteDraftService } from '../quote-draft.service';\nimport { MetricCalculationMethod } from './metric-calculation.types';\nimport { calculateMetricByMethod } from './metric-calculation.utils';\n\n@Injectable({ providedIn: 'root' })\nexport class MetricsCalculationService {\n  public get onMetricsUpdate$(): Observable<void> {\n    return this.metricsUpdated$.asObservable();\n  }\n\n  private metricsUpdated$ = new Subject<void>();\n  private quoteMetricsSettings: Dictionary<MetricCalculationMethod> = {};\n  private metricsCalculationMethodMap: Dictionary<MetricCalculationMethod> = {};\n  private metricsData: Dictionary<number> = {};\n  private activeMetricRules: MetricRule[] = [];\n\n  constructor(\n    private quoteDraftService: QuoteDraftService,\n    private flowConfiguration: FlowConfigurationService,\n    private settingsService: ConfigurationSettingsApiService,\n  ) {\n    this.activeMetricRules = this.flowConfiguration.activeMetricsSnapshot.filter(metricRule =>\n      metricRule.metrics.some(metric => !!metric.totalName),\n    );\n\n    combineLatest([\n      this.quoteDraftService.currentState$,\n      this.settingsService.fetchSetting('QUOTE_LEVEL_METRIC_CALCULATION_METHOD').pipe(take(1)),\n    ]).subscribe(([lineItems, setting]) => {\n      let settingsData: Dictionary<MetricCalculationMethod> = {};\n      try {\n        settingsData = JSON.parse(setting?.value || '{}');\n      } catch (error) {\n        settingsData = {};\n      }\n\n      this.quoteMetricsSettings = settingsData;\n\n      this.updateMetrics(lineItems);\n    });\n  }\n\n  public getMetricValue(metric: string): number {\n    return this.metricsData[metric] || 0;\n  }\n\n  private updateMetrics(lineItems: LineItem[]): void {\n    const metricKeys = this.collectMetricKeys(lineItems).filter(key => !key.includes('Effective_'));\n    this.metricsCalculationMethodMap = this.buildMetricsCalculationMethods(\n      metricKeys,\n      this.metricsCalculationMethodMap,\n    );\n\n    this.metricsData = metricKeys.reduce(\n      (acc: Dictionary<number>, key: string) => ({ ...acc, [key]: this.calculateMetric(lineItems, key) }),\n      {},\n    );\n\n    this.metricsUpdated$.next();\n  }\n\n  private calculateMetric(lineItems: LineItem[], metric: string): number {\n    return calculateMetricByMethod(lineItems, metric, this.metricsCalculationMethodMap[metric] || 'sum');\n  }\n\n  private buildMetricsCalculationMethods(\n    metricKeys: string[],\n    initial: Dictionary<MetricCalculationMethod>,\n  ): Dictionary<MetricCalculationMethod> {\n    return metricKeys.reduce((acc: Dictionary<MetricCalculationMethod>, name: string) => {\n      if (acc[name]) {\n        return acc;\n      }\n\n      acc = { ...acc, [name]: 'sum' };\n\n      const metricRule = this.getMetricRuleByTotalMetricName(name);\n      const settingKey = metricRule?.metrics?.find(metric => metric.totalName === name)?.name || name;\n\n      if (this.quoteMetricsSettings[settingKey]) {\n        acc = { ...acc, [name]: this.quoteMetricsSettings[settingKey] };\n      }\n\n      return acc;\n    }, initial);\n  }\n\n  private collectMetricKeys(lineItems: LineItem[]): string[] {\n    const keys: string[] = [];\n    lineItems.forEach(lineItem => {\n      keys.push(...Object.keys(lineItem.totalMetrics || {}));\n      keys.push(...this.collectMetricKeys(lineItem.lineItems));\n    });\n    return uniq(keys);\n  }\n\n  private getMetricRuleByTotalMetricName(name: string): MetricRule | undefined {\n    return this.activeMetricRules.find(metricRule => metricRule.metrics.find(metric => metric.totalName === name));\n  }\n}\n"]}

package/esm2020/core/services/product-images.service.mjs

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { ProductApiService } from '@veloceapps/api';
+import { BehaviorSubject, catchError, distinctUntilChanged, map, of, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/api";
+export class ProductImagesService {
+    constructor(productApiService) {
+        this.productApiService = productApiService;
+        this.imagesMap$ = new BehaviorSubject({});
+    }
+    getImageUrl$(productId) {
+        if (this.imagesMap$.value[productId] == null) {
+            this.imagesMap$.next({ ...this.imagesMap$.value, [productId]: '' });
+            this.fetchProductImage(productId);
+        }
+        return this.imagesMap$.pipe(map(imagesMap => imagesMap[productId]), distinctUntilChanged());
+    }
+    fetchProductImage(productId) {
+        this.productApiService
+            .fetchImage$(productId)
+            .pipe(map(file => URL.createObjectURL(file)), catchError(() => of('')), tap(url => this.imagesMap$.next({ ...this.imagesMap$.value, [productId]: url })))
+            .subscribe();
+    }
+}
+ProductImagesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ProductImagesService, deps: [{ token: i1.ProductApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductImagesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ProductImagesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ProductImagesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.ProductApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/services/quote-draft.service.mjs

@@ -0,0 +1,232 @@
+import { Injectable } from '@angular/core';
+import { PriceApiService, QuoteApiService } from '@veloceapps/api';
+import { ConfigurationContextMode } from '@veloceapps/core';
+import { isEqual } from 'lodash';
+import { BehaviorSubject, combineLatest, noop, zip } from 'rxjs';
+import { filter, map, shareReplay, skip, switchMap, take, tap } from 'rxjs/operators';
+import { ContextService } from './context.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./context.service";
+import * as i2 from "@veloceapps/api";
+export class QuoteDraftService {
+    get isInitialized() {
+        return this.isInitializedSubj$.getValue();
+    }
+    set isInitialized(value) {
+        if (this.isInitialized !== value) {
+            this.isInitializedSubj$.next(value);
+        }
+    }
+    get hasUnsavedChanges() {
+        return this._hasUnsavedChanges;
+    }
+    set hasUnsavedChanges(value) {
+        this._hasUnsavedChanges = value;
+        if (!this._hasUnsavedChanges) {
+            this.initialCurrentState = this.quoteDraft?.currentState ?? [];
+        }
+    }
+    get hasProducts$() {
+        return this.quoteSubj$.pipe(map(() => this.hasProducts));
+    }
+    get hasProducts() {
+        const quoteDraft = this.quoteSubj$.value;
+        return Boolean(quoteDraft && quoteDraft.currentState.length > 0);
+    }
+    constructor(context, quoteApiService, priceApiService) {
+        this.context = context;
+        this.quoteApiService = quoteApiService;
+        this.priceApiService = priceApiService;
+        this.quoteSubj$ = new BehaviorSubject(null);
+        this.resetSubj$ = new BehaviorSubject(true);
+        this.isInitializedSubj$ = new BehaviorSubject(false);
+        this.initialCurrentState = [];
+        this._hasUnsavedChanges = false;
+        this.allPriceLists = [];
+        this.assetPriceLists = [];
+        this.reset$ = this.resetSubj$.asObservable();
+        this.activePriceList$ = this.context.resolve$().pipe(map(ctx => this.allPriceLists.find(priceList => priceList.id === ctx.properties.PriceListId)), map(priceList => priceList ?? null));
+        this.isInitializedSubj$
+            .pipe(filter(isInitialized => isInitialized), switchMap(() => this.quoteSubj$.asObservable()), skip(1), tap(quote => this.markAsUpdated(quote)))
+            .subscribe();
+    }
+    reset() {
+        this.resetSubj$.next(true);
+        this.quoteSubj$.next(null);
+        this.hasUnsavedChanges = false;
+    }
+    init(quoteId, params) {
+        return zip(this.quoteApiService.getQuoteDraft(quoteId, params), this.priceApiService.getPriceLists()).pipe(tap(([quote, allPriceLists]) => {
+            this.allPriceLists = allPriceLists;
+            this.quoteSubj$.next(quote);
+            this.context.update(quote.context);
+            this.populateActivePriceLists$();
+        }), map(() => noop()), take(1));
+    }
+    setCurrentLineItemState(lineItems) {
+        const quoteDraft = this.quoteSubj$.value;
+        if (!quoteDraft) {
+            return;
+        }
+        this.quoteSubj$.next({
+            ...quoteDraft,
+            currentState: lineItems,
+        });
+    }
+    updateQuoteDraft(update) {
+        const quoteDraft = this.quoteSubj$.value;
+        if (!quoteDraft) {
+            return;
+        }
+        if (update.context) {
+            this.context.set(update.context);
+        }
+        this.quoteSubj$.next({
+            ...quoteDraft,
+            ...update,
+        });
+    }
+    updateByPriceSummary(priceSummary) {
+        const quoteDraft = this.quoteSubj$.value;
+        if (!quoteDraft) {
+            return;
+        }
+        const updatedCurrentState = this.currentState.map(lineItem => {
+            const updated = priceSummary.lineItems.find(li => li.id === lineItem.id);
+            return updated ?? lineItem;
+        });
+        this.quoteSubj$.next({
+            ...quoteDraft,
+            currentState: updatedCurrentState,
+            totalPrices: priceSummary.totalPrices,
+            approvalItems: priceSummary.approvalItems,
+        });
+    }
+    get quoteDraft$() {
+        return combineLatest([this.quoteSubj$, this.context.resolve$()]).pipe(map(() => this.quoteDraft), filter((quote) => Boolean(quote)), shareReplay());
+    }
+    get quoteDraft() {
+        const quote = this.quoteSubj$.value;
+        if (!quote) {
+            return null;
+        }
+        return {
+            ...quote,
+            context: this.context.resolve(),
+        };
+    }
+    get quoteDraftForActivePriceList() {
+        const quoteDraft = this.quoteDraft;
+        if (!quoteDraft) {
+            return null;
+        }
+        return {
+            ...quoteDraft,
+            initialState: this.filterByActivePriceList(quoteDraft.initialState),
+            currentState: this.filterByActivePriceList(quoteDraft.currentState),
+        };
+    }
+    get currentState$() {
+        return this.quoteDraft$.pipe(map(quote => quote.currentState));
+    }
+    get currentState() {
+        return this.quoteDraft?.currentState ?? [];
+    }
+    /**
+     * Stream of activeCurrentState
+     */
+    get activeCurrentState$() {
+        return this.quoteDraft$.pipe(map(() => this.activeCurrentState));
+    }
+    /**
+     * activeCurrentState is currentState passed through additional filters
+     */
+    get activeCurrentState() {
+        let currentState = this.quoteDraft?.currentState ?? [];
+        currentState = this.filterByActivePriceList(currentState);
+        return currentState;
+    }
+    /**
+     * Stream of activeInitialState
+     */
+    get activeInitialState$() {
+        return this.quoteDraft$.pipe(map(() => this.activeInitialState));
+    }
+    /**
+     * activeInitialState is initialState passed through additional filters
+     */
+    get activeInitialState() {
+        const ctx = this.context.resolve();
+        let initialState = this.quoteDraft?.initialState ?? [];
+        if (ctx.mode === ConfigurationContextMode.ACCOUNT) {
+            initialState = this.filterByActivePriceList(initialState);
+        }
+        return initialState;
+    }
+    get isStandalone() {
+        return this.context.resolve().properties.standalone === 'true';
+    }
+    get isStandalone$() {
+        return this.context.resolve$().pipe(map(() => this.isStandalone));
+    }
+    getInitialCurrentState() {
+        return this.initialCurrentState;
+    }
+    isEditMode$() {
+        return this.context.resolve$().pipe(map(() => this.isEditMode()));
+    }
+    isEditMode() {
+        const context = this.context.resolve();
+        if (context.mode === ConfigurationContextMode.ACCOUNT) {
+            return true;
+        }
+        if (context.mode === ConfigurationContextMode.QUOTE) {
+            return context.properties.Status === 'Draft';
+        }
+        return false;
+    }
+    updateActivePriceList(priceListId) {
+        this.context.update({ properties: { PriceListId: priceListId } });
+    }
+    populateActivePriceLists$() {
+        const ctx = this.context.resolve();
+        const quoteDraft = this.quoteDraft;
+        if (!quoteDraft) {
+            return;
+        }
+        // In ACCOUNT mode populate price lists from related assets
+        if (ctx.mode === ConfigurationContextMode.ACCOUNT) {
+            // Populate list of price lists
+            this.assetPriceLists = quoteDraft.currentState
+                .map(({ priceListId }) => priceListId)
+                .reduce((trunk, priceListId) => {
+                if (!priceListId || trunk.some(item => item.id === priceListId)) {
+                    return trunk;
+                }
+                return [
+                    ...trunk,
+                    { id: priceListId, name: this.allPriceLists.find(item => item.id === priceListId)?.name ?? '' },
+                ];
+            }, []);
+        }
+    }
+    filterByActivePriceList(lineItems) {
+        const ctx = this.context.resolve();
+        return lineItems.filter(li => !li.priceListId || li.priceListId === ctx.properties.PriceListId);
+    }
+    markAsUpdated(quote) {
+        if (quote?.context.properties.mode === ConfigurationContextMode.ACCOUNT) {
+            this.hasUnsavedChanges = !!quote && !quote.currentState.every(li => li.actionCode === 'EXIST');
+        }
+        else {
+            this.hasUnsavedChanges = !isEqual(this.initialCurrentState, quote?.currentState);
+        }
+    }
+}
+QuoteDraftService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: QuoteDraftService, deps: [{ token: i1.ContextService }, { token: i2.QuoteApiService }, { token: i2.PriceApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+QuoteDraftService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: QuoteDraftService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: QuoteDraftService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.ContextService }, { type: i2.QuoteApiService }, { type: i2.PriceApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quote-draft.service.js","sourceRoot":"","sources":["../../../../../../libs/sdk/core/services/quote-draft.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { PriceApiService, QuoteApiService } from '@veloceapps/api';\nimport { ConfigurationContextMode, LineItem, PriceList, PriceSummary, QuoteDraft } from '@veloceapps/core';\nimport { Dictionary, isEqual } from 'lodash';\nimport { BehaviorSubject, combineLatest, noop, Observable, zip } from 'rxjs';\nimport { filter, map, shareReplay, skip, switchMap, take, tap } from 'rxjs/operators';\nimport { ContextService } from './context.service';\n\n@Injectable({ providedIn: 'root' })\nexport class QuoteDraftService {\n  private quoteSubj$ = new BehaviorSubject<QuoteDraft | null>(null);\n  private resetSubj$ = new BehaviorSubject<boolean>(true);\n  private isInitializedSubj$ = new BehaviorSubject<boolean>(false);\n  private initialCurrentState: LineItem[] = [];\n  private _hasUnsavedChanges = false;\n\n  public get isInitialized(): boolean {\n    return this.isInitializedSubj$.getValue();\n  }\n  public set isInitialized(value: boolean) {\n    if (this.isInitialized !== value) {\n      this.isInitializedSubj$.next(value);\n    }\n  }\n\n  public get hasUnsavedChanges(): boolean {\n    return this._hasUnsavedChanges;\n  }\n  public set hasUnsavedChanges(value: boolean) {\n    this._hasUnsavedChanges = value;\n\n    if (!this._hasUnsavedChanges) {\n      this.initialCurrentState = this.quoteDraft?.currentState ?? [];\n    }\n  }\n\n  public get hasProducts$(): Observable<boolean> {\n    return this.quoteSubj$.pipe(map(() => this.hasProducts));\n  }\n  public get hasProducts(): boolean {\n    const quoteDraft = this.quoteSubj$.value;\n    return Boolean(quoteDraft && quoteDraft.currentState.length > 0);\n  }\n\n  public allPriceLists: PriceList[] = [];\n  public assetPriceLists: PriceList[] = [];\n  public reset$ = this.resetSubj$.asObservable();\n  public activePriceList$: Observable<PriceList | null>;\n\n  constructor(\n    private context: ContextService,\n    private quoteApiService: QuoteApiService,\n    private priceApiService: PriceApiService,\n  ) {\n    this.activePriceList$ = this.context.resolve$().pipe(\n      map(ctx => this.allPriceLists.find(priceList => priceList.id === ctx.properties.PriceListId)),\n      map(priceList => priceList ?? null),\n    );\n\n    this.isInitializedSubj$\n      .pipe(\n        filter(isInitialized => isInitialized),\n        switchMap(() => this.quoteSubj$.asObservable()),\n        skip(1),\n        tap(quote => this.markAsUpdated(quote)),\n      )\n      .subscribe();\n  }\n\n  public reset(): void {\n    this.resetSubj$.next(true);\n    this.quoteSubj$.next(null);\n    this.hasUnsavedChanges = false;\n  }\n\n  public init(quoteId: string, params: Dictionary<string>): Observable<void> {\n    return zip(this.quoteApiService.getQuoteDraft(quoteId, params), this.priceApiService.getPriceLists()).pipe(\n      tap(([quote, allPriceLists]) => {\n        this.allPriceLists = allPriceLists;\n        this.quoteSubj$.next(quote);\n\n        this.context.update(quote.context);\n\n        this.populateActivePriceLists$();\n      }),\n      map(() => noop()),\n      take(1),\n    );\n  }\n\n  public setCurrentLineItemState(lineItems: LineItem[]): void {\n    const quoteDraft = this.quoteSubj$.value;\n\n    if (!quoteDraft) {\n      return;\n    }\n\n    this.quoteSubj$.next({\n      ...quoteDraft,\n      currentState: lineItems,\n    });\n  }\n\n  public updateQuoteDraft(update: Partial<QuoteDraft>): void {\n    const quoteDraft = this.quoteSubj$.value;\n\n    if (!quoteDraft) {\n      return;\n    }\n\n    if (update.context) {\n      this.context.set(update.context);\n    }\n\n    this.quoteSubj$.next({\n      ...quoteDraft,\n      ...update,\n    });\n  }\n\n  public updateByPriceSummary(priceSummary: PriceSummary): void {\n    const quoteDraft = this.quoteSubj$.value;\n\n    if (!quoteDraft) {\n      return;\n    }\n\n    const updatedCurrentState = this.currentState.map(lineItem => {\n      const updated = priceSummary.lineItems.find(li => li.id === lineItem.id);\n      return updated ?? lineItem;\n    });\n\n    this.quoteSubj$.next({\n      ...quoteDraft,\n      currentState: updatedCurrentState,\n      totalPrices: priceSummary.totalPrices,\n      approvalItems: priceSummary.approvalItems,\n    });\n  }\n\n  public get quoteDraft$(): Observable<QuoteDraft> {\n    return combineLatest([this.quoteSubj$, this.context.resolve$()]).pipe(\n      map(() => this.quoteDraft),\n      filter((quote): quote is QuoteDraft => Boolean(quote)),\n      shareReplay(),\n    );\n  }\n\n  public get quoteDraft(): QuoteDraft | null {\n    const quote = this.quoteSubj$.value;\n\n    if (!quote) {\n      return null;\n    }\n\n    return {\n      ...quote,\n      context: this.context.resolve(),\n    };\n  }\n\n  public get quoteDraftForActivePriceList(): QuoteDraft | null {\n    const quoteDraft = this.quoteDraft;\n\n    if (!quoteDraft) {\n      return null;\n    }\n\n    return {\n      ...quoteDraft,\n      initialState: this.filterByActivePriceList(quoteDraft.initialState),\n      currentState: this.filterByActivePriceList(quoteDraft.currentState),\n    };\n  }\n\n  public get currentState$(): Observable<LineItem[]> {\n    return this.quoteDraft$.pipe(map(quote => quote.currentState));\n  }\n\n  public get currentState(): LineItem[] {\n    return this.quoteDraft?.currentState ?? [];\n  }\n\n  /**\n   * Stream of activeCurrentState\n   */\n  public get activeCurrentState$(): Observable<LineItem[]> {\n    return this.quoteDraft$.pipe(map(() => this.activeCurrentState));\n  }\n\n  /**\n   * activeCurrentState is currentState passed through additional filters\n   */\n  public get activeCurrentState(): LineItem[] {\n    let currentState = this.quoteDraft?.currentState ?? [];\n\n    currentState = this.filterByActivePriceList(currentState);\n\n    return currentState;\n  }\n\n  /**\n   * Stream of activeInitialState\n   */\n  public get activeInitialState$(): Observable<LineItem[]> {\n    return this.quoteDraft$.pipe(map(() => this.activeInitialState));\n  }\n\n  /**\n   * activeInitialState is initialState passed through additional filters\n   */\n  public get activeInitialState(): LineItem[] {\n    const ctx = this.context.resolve();\n    let initialState = this.quoteDraft?.initialState ?? [];\n\n    if (ctx.mode === ConfigurationContextMode.ACCOUNT) {\n      initialState = this.filterByActivePriceList(initialState);\n    }\n\n    return initialState;\n  }\n\n  public get isStandalone(): boolean {\n    return this.context.resolve().properties.standalone === 'true';\n  }\n\n  public get isStandalone$(): Observable<boolean> {\n    return this.context.resolve$().pipe(map(() => this.isStandalone));\n  }\n\n  public getInitialCurrentState(): LineItem[] {\n    return this.initialCurrentState;\n  }\n\n  public isEditMode$(): Observable<boolean> {\n    return this.context.resolve$().pipe(map(() => this.isEditMode()));\n  }\n\n  public isEditMode(): boolean {\n    const context = this.context.resolve();\n\n    if (context.mode === ConfigurationContextMode.ACCOUNT) {\n      return true;\n    }\n\n    if (context.mode === ConfigurationContextMode.QUOTE) {\n      return context.properties.Status === 'Draft';\n    }\n\n    return false;\n  }\n\n  public updateActivePriceList(priceListId: string): void {\n    this.context.update({ properties: { PriceListId: priceListId } });\n  }\n\n  private populateActivePriceLists$(): void {\n    const ctx = this.context.resolve();\n    const quoteDraft = this.quoteDraft;\n\n    if (!quoteDraft) {\n      return;\n    }\n\n    // In ACCOUNT mode populate price lists from related assets\n    if (ctx.mode === ConfigurationContextMode.ACCOUNT) {\n      // Populate list of price lists\n      this.assetPriceLists = quoteDraft.currentState\n        .map(({ priceListId }) => priceListId)\n        .reduce<PriceList[]>((trunk, priceListId) => {\n          if (!priceListId || trunk.some(item => item.id === priceListId)) {\n            return trunk;\n          }\n\n          return [\n            ...trunk,\n            { id: priceListId, name: this.allPriceLists.find(item => item.id === priceListId)?.name ?? '' },\n          ];\n        }, []);\n    }\n  }\n\n  private filterByActivePriceList(lineItems: LineItem[]): LineItem[] {\n    const ctx = this.context.resolve();\n\n    return lineItems.filter(li => !li.priceListId || li.priceListId === ctx.properties.PriceListId);\n  }\n\n  private markAsUpdated(quote: QuoteDraft | null): void {\n    if (quote?.context.properties.mode === ConfigurationContextMode.ACCOUNT) {\n      this.hasUnsavedChanges = !!quote && !quote.currentState.every(li => li.actionCode === 'EXIST');\n    } else {\n      this.hasUnsavedChanges = !isEqual(this.initialCurrentState, quote?.currentState);\n    }\n  }\n}\n"]}