@aptos-scp/scp-component-store-selling-features-domain-model 1.0.0

package/lib/domain/model/StoreItem.js

@@ -0,0 +1,750 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = require("lodash");
+const scp_component_business_core_1 = require("@aptos-scp/scp-component-business-core");
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const scp_component_store_items_1 = require("@aptos-scp/scp-component-store-items");
+const scp_component_store_selling_core_1 = require("@aptos-scp/scp-component-store-selling-core");
+const scp_types_commerce_transaction_1 = require("@aptos-scp/scp-types-commerce-transaction");
+const ErrorCodes_1 = require("../../config/ErrorCodes");
+const utils_1 = require("../utility/utils");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.domain.model.StoreItem");
+var SourceType;
+(function (SourceType) {
+    SourceType["local"] = "Local";
+    SourceType["remote"] = "Remote";
+    SourceType["notOnFile"] = "NotOnFile";
+})(SourceType = exports.SourceType || (exports.SourceType = {}));
+var SelectedUnitPrice;
+(function (SelectedUnitPrice) {
+    SelectedUnitPrice["PermanentPrice"] = "PermanentPrice";
+    SelectedUnitPrice["TemporaryPrice"] = "TemporaryPrice";
+    SelectedUnitPrice["FullPrice"] = "FullPrice";
+})(SelectedUnitPrice = exports.SelectedUnitPrice || (exports.SelectedUnitPrice = {}));
+function findSourceType(type) {
+    switch (type) {
+        case "Local":
+            return SourceType.local;
+        case "Remote":
+            return SourceType.remote;
+        case "NotOnFile":
+            return SourceType.notOnFile;
+        default:
+            throw new scp_component_store_selling_core_1.PosError(`Cannot find SourceType for type: ${type}`, ErrorCodes_1.SSF_DATA_ERROR_CODE);
+    }
+}
+exports.findSourceType = findSourceType;
+function findItemType(type) {
+    switch (type) {
+        case "Merchandise":
+            return scp_types_commerce_transaction_1.ItemType.Merchandise;
+        case "NonMerch":
+            return scp_types_commerce_transaction_1.ItemType.NonMerch;
+        case "Service":
+            return scp_types_commerce_transaction_1.ItemType.Service;
+        case "ValueCard":
+            return scp_types_commerce_transaction_1.ItemType.ValueCard;
+        case "ValueCertificate":
+            return scp_types_commerce_transaction_1.ItemType.ValueCertificate;
+        default:
+            throw new scp_component_store_selling_core_1.PosError(`Cannot find ItemType for type: ${type}`, ErrorCodes_1.SSF_DATA_ERROR_CODE);
+    }
+}
+exports.findItemType = findItemType;
+class ItemLookupKey {
+    constructor(type, value) {
+        this.type = type;
+        this.value = value;
+    }
+    static createFromJsonObj(itemLookupKeyFromJson) {
+        return (itemLookupKeyFromJson && new ItemLookupKey(itemLookupKeyFromJson.type, itemLookupKeyFromJson.value));
+    }
+}
+exports.ItemLookupKey = ItemLookupKey;
+class HierarchyNodeId {
+    constructor(levelId, nodeIdInLevel, groupId) {
+        this.levelId = levelId;
+        this.nodeIdInLevel = nodeIdInLevel;
+        this.groupId = groupId;
+    }
+    static createFromJsonObj(hierarchyNodeIdFromJson) {
+        if (hierarchyNodeIdFromJson) {
+            return new HierarchyNodeId(hierarchyNodeIdFromJson.levelId, hierarchyNodeIdFromJson.nodeIdInLevel, hierarchyNodeIdFromJson.groupId);
+        }
+        return undefined;
+    }
+}
+exports.HierarchyNodeId = HierarchyNodeId;
+class HierarchyNode {
+    constructor(nodeId, parentId) {
+        this.nodeId = nodeId;
+        this.parentId = parentId;
+    }
+    static createFromJsonObj(hierarchyNodeFromJson) {
+        return new HierarchyNode(HierarchyNodeId.createFromJsonObj(hierarchyNodeFromJson.nodeId), HierarchyNodeId.createFromJsonObj(hierarchyNodeFromJson.parentId));
+    }
+}
+exports.HierarchyNode = HierarchyNode;
+class SalePrice {
+    static createFromJsonObject(salePriceFromJson) {
+        let salePrice = undefined;
+        if (salePriceFromJson) {
+            salePrice = new SalePrice();
+            salePrice.price = scp_component_business_core_1.Price.fromJSON(salePriceFromJson.price);
+            salePrice.shortDescription = salePriceFromJson.shortDescription;
+            salePrice.startDateTime = new Date(Date.parse(salePriceFromJson.startDateTime));
+            salePrice.endDateTime = salePriceFromJson.endDateTime
+                ? new Date(Date.parse(salePriceFromJson.endDateTime))
+                : undefined;
+        }
+        else if (salePriceFromJson === null) {
+            salePrice = null;
+        }
+        return salePrice;
+    }
+}
+exports.SalePrice = SalePrice;
+function getProductAttribute(productAttributes, attributeType) {
+    if (!productAttributes) {
+        return undefined;
+    }
+    return productAttributes.find((attribute) => attribute.attributeType === attributeType);
+}
+exports.getProductAttribute = getProductAttribute;
+function getProductAttributeTranslation(attribute, locale = "en") {
+    if (!attribute.translations) {
+        return undefined;
+    }
+    const localeToUse = utils_1.getLocaleCodeForTranslationSet(attribute.translations, locale);
+    let translation = localeToUse && attribute.translations[localeToUse];
+    if (!translation) {
+        const defaultLocale = "en";
+        translation = attribute.translations[defaultLocale];
+    }
+    return translation;
+}
+exports.getProductAttributeTranslation = getProductAttributeTranslation;
+function getMerchandiseHierarchyNodeNameTranslation(node, locale = "en") {
+    if (!node.translations) {
+        return { name: node.nodeInLevelId };
+    }
+    const localeToUse = utils_1.getLocaleCodeForTranslationSet(node.translations, locale);
+    let translation = localeToUse && node.translations[localeToUse];
+    if (!translation) {
+        const defaultLocale = "en";
+        translation = node.translations[defaultLocale];
+    }
+    if (!translation) {
+        translation = { name: node.nodeInLevelId };
+    }
+    return translation;
+}
+exports.getMerchandiseHierarchyNodeNameTranslation = getMerchandiseHierarchyNodeNameTranslation;
+/**
+ * @deprecated change to use productAttributes property of StoreItem instead
+ */
+class ItemAttributes {
+    static createFromJsonObject(attributes, locale) {
+        let itemAttributes = undefined;
+        if (attributes) {
+            itemAttributes = new ItemAttributes();
+            attributes.forEach((attribute) => {
+                switch (attribute.attributeType) {
+                    case "Color":
+                        itemAttributes.color = new ColorAttribute(attribute, locale);
+                        return;
+                    case "Size":
+                        itemAttributes.size = new SizeAttribute(attribute, locale);
+                        return;
+                    case "Style":
+                        itemAttributes.style = new StyleAttribute(attribute, locale);
+                        return;
+                    default:
+                        return;
+                }
+            });
+        }
+        else {
+            itemAttributes = null;
+        }
+        return itemAttributes;
+    }
+}
+exports.ItemAttributes = ItemAttributes;
+/**
+ * @deprecated change to use productAttributes property of StoreItem instead
+ */
+class ColorAttribute {
+    constructor(attribute, locale) {
+        this.id = attribute.id;
+        this.code = attribute.code;
+        const localeCodeToUse = attribute.translations && utils_1.getLocaleCodeForTranslationSet(attribute.translations, locale);
+        const translations = localeCodeToUse && attribute.translations[localeCodeToUse];
+        if (translations) {
+            this.name = translations.name;
+            this.description = translations.description;
+        }
+    }
+}
+exports.ColorAttribute = ColorAttribute;
+/**
+ * @deprecated change to use productAttributes property of StoreItem instead
+ */
+class StyleAttribute {
+    constructor(attribute, locale) {
+        this.id = attribute.id;
+        this.code = attribute.code;
+        const localeCodeToUse = attribute.translations && utils_1.getLocaleCodeForTranslationSet(attribute.translations, locale);
+        const translations = localeCodeToUse && attribute.translations[localeCodeToUse];
+        if (translations) {
+            this.name = translations.name;
+            this.description = translations.description;
+        }
+    }
+}
+exports.StyleAttribute = StyleAttribute;
+/**
+ * @deprecated change to use productAttributes property of StoreItem instead
+ */
+class SizeAttribute {
+    constructor(attribute, locale) {
+        this.id = attribute.id;
+        this.code = attribute.code;
+        this.subcode = attribute.subcode;
+        const localeCodeToUse = attribute.translations && utils_1.getLocaleCodeForTranslationSet(attribute.translations, locale);
+        const translations = localeCodeToUse && attribute.translations[localeCodeToUse];
+        if (translations) {
+            this.name = translations.name;
+            this.description = translations.description;
+        }
+    }
+}
+exports.SizeAttribute = SizeAttribute;
+class StoreItem {
+    constructor() {
+        // We initialize these optional fields, so that the de-serialized form matches the pre-serialized form.
+        this.additionalDescription = undefined;
+        this.longDescription = undefined;
+        this.itemPermanentPrice = undefined;
+        this.itemPermanentPriceSource = undefined;
+        this.itemTemporaryPrice = undefined;
+        this.itemTemporaryPriceSource = undefined;
+        this.itemFullPrice = undefined;
+        this.itemFullPriceSource = undefined;
+        this.itemSelectedUnitPrice = undefined;
+        this.itemEmployeeDiscountPercent = undefined;
+        this.manufacturerSuggestedPrice = undefined;
+        this.unitCost = undefined;
+        this.defaultReturnPrice = undefined;
+    }
+    static createFromJsonObject(storeItemJsonObj) {
+        const storeItem = new StoreItem();
+        storeItem.id = StoreItem.getStringFromJsonObject(storeItemJsonObj.id);
+        storeItem.uniqueId = StoreItem.getStringFromJsonObject(storeItemJsonObj.uniqueId);
+        storeItem.retailLocationIdentity = scp_component_store_selling_core_1.RetailLocationIdentity.createFromJsonObject(storeItemJsonObj.retailLocationIdentity);
+        storeItem.itemLookupKeys = StoreItem.createItemLookupKeysFromJsonObject(storeItemJsonObj.itemLookupKeys);
+        storeItem.itemGroupId = StoreItem.getStringFromJsonObject(storeItemJsonObj.itemGroupId);
+        storeItem.itemType = scp_types_commerce_transaction_1.ItemType[StoreItem.getStringFromJsonObject(storeItemJsonObj.itemType)];
+        storeItem.imageUrl = StoreItem.getStringFromJsonObject(storeItemJsonObj.imageUrl);
+        storeItem.shortDescription = StoreItem.getStringFromJsonObject(storeItemJsonObj.shortDescription);
+        storeItem.additionalDescription = StoreItem.getStringFromJsonObject(storeItemJsonObj.additionalDescription);
+        storeItem.longDescription = StoreItem.getStringFromJsonObject(storeItemJsonObj.longDescription);
+        storeItem.enteredLookupType = StoreItem.getStringFromJsonObject(storeItemJsonObj.enteredLookupType);
+        storeItem.taxGroupId = StoreItem.getStringFromJsonObject(storeItemJsonObj.taxGroupId);
+        storeItem.price = scp_component_business_core_1.Price.fromJSON(storeItemJsonObj.price);
+        storeItem.salePrice = SalePrice.createFromJsonObject(storeItemJsonObj.salePrice);
+        storeItem.stopStatusMessage = StoreItem.getStringFromJsonObject(storeItemJsonObj.stopStatusMessage);
+        if (storeItemJsonObj.itemPermanentPrice) {
+            storeItem.itemPermanentPrice = scp_component_business_core_1.Price.fromJSON(storeItemJsonObj.itemPermanentPrice);
+        }
+        if (storeItemJsonObj.itemPermanentPriceSource) {
+            storeItem.itemPermanentPriceSource = storeItemJsonObj.itemPermanentPriceSource;
+        }
+        if (storeItemJsonObj.itemTemporaryPrice) {
+            storeItem.itemTemporaryPrice = scp_component_business_core_1.Price.fromJSON(storeItemJsonObj.itemTemporaryPrice);
+        }
+        if (storeItemJsonObj.itemTemporaryPriceSource) {
+            storeItem.itemTemporaryPriceSource = storeItemJsonObj.itemTemporaryPriceSource;
+        }
+        if (storeItemJsonObj.temporaryPriceEffectiveDateTime) {
+            storeItem.temporaryPriceEffectiveDateTime = StoreItem.getStringFromJsonObject(storeItemJsonObj.temporaryPriceEffectiveDateTime);
+        }
+        if (storeItemJsonObj.temporaryPriceExpirationDateTime) {
+            storeItem.temporaryPriceExpirationDateTime = StoreItem.getStringFromJsonObject(storeItemJsonObj.temporaryPriceExpirationDateTime);
+        }
+        if (storeItemJsonObj.itemSelectedUnitPrice) {
+            storeItem.itemSelectedUnitPrice = storeItemJsonObj.itemSelectedUnitPrice;
+        }
+        if (storeItemJsonObj.itemFullPrice) {
+            storeItem.itemFullPrice = scp_component_business_core_1.Price.fromJSON(storeItemJsonObj.itemFullPrice);
+        }
+        if (storeItemJsonObj.itemFullPriceSource) {
+            storeItem.itemFullPriceSource = storeItemJsonObj.itemFullPriceSource;
+        }
+        if (storeItemJsonObj.itemEmployeeDiscountPercent) {
+            storeItem.itemEmployeeDiscountPercent = storeItemJsonObj.itemEmployeeDiscountPercent;
+        }
+        if (storeItemJsonObj.merchandiseHierarchy) {
+            storeItem.merchandiseHierarchy = StoreItem.createHierarchyNodeFromJsonObject(storeItemJsonObj.merchandiseHierarchy);
+        }
+        // From ISourceIndication
+        if (storeItemJsonObj.source || storeItemJsonObj.source === 0) {
+            storeItem.source = findSourceType(storeItemJsonObj.source);
+        }
+        if (storeItemJsonObj.manufacturerSuggestedPrice) {
+            storeItem.manufacturerSuggestedPrice = scp_component_business_core_1.Price.fromIPrice(storeItemJsonObj.manufacturerSuggestedPrice);
+        }
+        if (storeItemJsonObj.defaultReturnPrice) {
+            storeItem.defaultReturnPrice = scp_component_business_core_1.Price.fromIPrice(storeItemJsonObj.defaultReturnPrice);
+        }
+        if (storeItemJsonObj.unitCost) {
+            storeItem.unitCost = scp_component_business_core_1.Money.fromIMoney(storeItemJsonObj.unitCost);
+        }
+        if (storeItemJsonObj.externalIds) {
+            storeItem.externalIds = storeItemJsonObj.externalIds;
+        }
+        if (storeItemJsonObj.treatmentRules) {
+            storeItem.treatmentRules = storeItemJsonObj.treatmentRules;
+        }
+        if (storeItemJsonObj.attributes) {
+            storeItem.attributes = storeItemJsonObj.attributes;
+        }
+        if (storeItemJsonObj.productAttributes) {
+            storeItem.productAttributes = storeItemJsonObj.productAttributes;
+        }
+        if (storeItemJsonObj.images) {
+            storeItem.images = storeItemJsonObj.images;
+        }
+        if (storeItemJsonObj.status) {
+            storeItem.status = scp_component_store_items_1.Status[StoreItem.getStringFromJsonObject(storeItemJsonObj.status)];
+        }
+        if (storeItemJsonObj.subscriptionFrequencyCodes) {
+            storeItem.subscriptionFrequencyCodes = storeItemJsonObj.subscriptionFrequencyCodes;
+        }
+        storeItem.departmentGroupId = StoreItem.getStringFromJsonObject(storeItemJsonObj.departmentGroupId);
+        return storeItem;
+    }
+    static convertStoreItemComponentIPriceToPrice(value) {
+        return value ? new scp_component_business_core_1.Price(new scp_component_business_core_1.Money(value.amount, value.currency)) : undefined;
+    }
+    //TODO: Move createFromItemObject into the adapter.storeitem module, since it is web service API specific.
+    // See ZSPFLD-2346
+    // Moving this removes the dependency of the domain object on API-specific classes, which separates concerns and
+    // avoids circular dependencies between modules, which can be hard to resolve.
+    // If it needs to be shared between the repository and the adapter, then we need to decide, which has precedence, but
+    // the needs of those modules should not bleed-through into the domain model module.
+    // FIXME: this method needs to have its complexity cleaned-up.
+    // eslint-disable-next-line complexity
+    static createFromItemObject(configurationManager, retailLocationIdentity, accountingCurrency, itemToConvert, locale, sourceIndicator) {
+        var _a, _b;
+        const entryMessage = logger.traceEntry("createFromItemObject", itemToConvert, retailLocationIdentity);
+        const storeItem = new StoreItem();
+        try {
+            // Update the price and the tax group with the group or location information if it exist
+            const { retailStoreItem, storeGroupItem } = StoreItem.extractRetailLocationSpecificItemData(itemToConvert, retailLocationIdentity);
+            const item = Object.assign({}, itemToConvert, storeGroupItem, retailStoreItem);
+            // id
+            storeItem.id = item.id;
+            storeItem.uniqueId = item.uniqueId;
+            // retailLocationIdentity
+            storeItem.retailLocationIdentity = retailLocationIdentity;
+            // itemLookupKeys
+            storeItem.itemLookupKeys = [];
+            for (const lookupKeyAttribute of item.lookupKeys) {
+                const lookupKey = new ItemLookupKey(lookupKeyAttribute.keyType, lookupKeyAttribute.value);
+                storeItem.itemLookupKeys.push(lookupKey);
+            }
+            // itemType
+            storeItem.itemType = findItemType(item.type);
+            //sourceIndicator
+            storeItem.source = sourceIndicator;
+            // imageUrl
+            const lineItemImageConfiguration = configurationManager.getFunctionalBehaviorValues().lineItemImage;
+            const getImageUrl = (imageSource) => {
+                switch (imageSource) {
+                    case "ImageFromItemData":
+                        let imageUrl = undefined;
+                        if (item.images && item.images.length > 0) {
+                            const primaryImages = item.images.filter((x) => x.primaryImage === true);
+                            imageUrl = (primaryImages.length > 0 ? primaryImages : item.images)[0].imageUrl;
+                        }
+                        return imageUrl;
+                    case "ImageFromUrlPattern":
+                        let urlPattern = lineItemImageConfiguration.urlPattern;
+                        const aSkuKey = item.lookupKeys.find((aKey) => aKey.keyType === scp_component_store_items_1.KeyType.SKU);
+                        if (aSkuKey) {
+                            urlPattern = urlPattern.replace(/{{SKU}}/g, aSkuKey.value);
+                        }
+                        return urlPattern;
+                    default:
+                        return undefined;
+                }
+            };
+            storeItem.imageUrl = getImageUrl(lineItemImageConfiguration.imageSource);
+            if (lineItemImageConfiguration.imageSource === "ImageFromItemData" &&
+                item.images &&
+                item.images.length > 0) {
+                storeItem.images = item.images;
+            }
+            else {
+                storeItem.images = [{ imageUrl: storeItem.imageUrl, primaryImage: true }];
+            }
+            storeItem.status = item.status;
+            storeItem.productAttributes = item.attributes;
+            // shortDescription, additionalDescription, and longDescription
+            StoreItem.updateLocalizableTextsFromItemAttributeObject(storeItem, item, locale);
+            // taxGroupId
+            storeItem.taxGroupId = item.taxGroup;
+            // price
+            const itemPermanentPrice = StoreItem.calculatePermanentPrice(itemToConvert, storeGroupItem, retailStoreItem, accountingCurrency);
+            if (itemPermanentPrice) {
+                storeItem.itemPermanentPrice = itemPermanentPrice.price;
+                storeItem.itemPermanentPriceSource = itemPermanentPrice.source;
+                storeItem.itemSelectedUnitPrice = SelectedUnitPrice.PermanentPrice;
+            }
+            const itemTemporaryPrice = StoreItem.calculateTemporaryPrice(itemToConvert, storeGroupItem, retailStoreItem, accountingCurrency);
+            if (itemTemporaryPrice) {
+                storeItem.itemTemporaryPrice = itemTemporaryPrice.price;
+                storeItem.itemTemporaryPriceSource = itemTemporaryPrice.source;
+                storeItem.itemSelectedUnitPrice = SelectedUnitPrice.TemporaryPrice;
+            }
+            const itemFullPrice = StoreItem.calculateFullPrice(itemToConvert, storeGroupItem, retailStoreItem, accountingCurrency);
+            if (itemFullPrice) {
+                storeItem.itemFullPrice = itemFullPrice.price;
+                storeItem.itemFullPriceSource = itemFullPrice.source;
+            }
+            storeItem.price = storeItem.itemTemporaryPrice || storeItem.itemPermanentPrice;
+            if (!storeItem.price && item.type === scp_types_commerce_transaction_1.ItemType.ValueCard) {
+                storeItem.price = new scp_component_business_core_1.Price(new scp_component_business_core_1.Money("0", accountingCurrency));
+            }
+            storeItem.temporaryPriceEffectiveDateTime = StoreItem.temporaryPriceEffectiveDateTime(itemToConvert, storeGroupItem, retailStoreItem);
+            storeItem.temporaryPriceExpirationDateTime = StoreItem.temporaryPriceExpirationDateTime(itemToConvert, storeGroupItem, retailStoreItem);
+            storeItem.itemEmployeeDiscountPercent = item.employeeDiscountPercent;
+            // merchandiseHierarchy
+            if (item.merchandiseHierarchy && item.merchandiseHierarchy.length > 0) {
+                storeItem.merchandiseHierarchy = [];
+                for (const hierarchyNodeAttribute of item.merchandiseHierarchy) {
+                    if (((_a = hierarchyNodeAttribute) === null || _a === void 0 ? void 0 : _a.nodeId) || ((_b = hierarchyNodeAttribute) === null || _b === void 0 ? void 0 : _b.parentId)) {
+                        let nodeId;
+                        if (hierarchyNodeAttribute.nodeId &&
+                            (hierarchyNodeAttribute.nodeId.levelId ||
+                                hierarchyNodeAttribute.nodeId.nodeIdInLevel ||
+                                hierarchyNodeAttribute.nodeId.groupId)) {
+                            nodeId = new HierarchyNodeId(hierarchyNodeAttribute.nodeId.levelId, hierarchyNodeAttribute.nodeId.nodeIdInLevel, hierarchyNodeAttribute.nodeId.groupId);
+                        }
+                        let parentId;
+                        if (hierarchyNodeAttribute.parentId &&
+                            (hierarchyNodeAttribute.parentId.levelId || hierarchyNodeAttribute.parentId.nodeIdInLevel)) {
+                            parentId = new HierarchyNodeId(hierarchyNodeAttribute.parentId.levelId, hierarchyNodeAttribute.parentId.nodeIdInLevel);
+                        }
+                        const hierarchyNode = new HierarchyNode(nodeId, parentId);
+                        storeItem.merchandiseHierarchy.push(hierarchyNode);
+                    }
+                }
+            }
+            // ManufacturerSuggestedPrice & UnitCost
+            if (item.manufacturerSuggestedPrice) {
+                storeItem.manufacturerSuggestedPrice = StoreItem.getPriceFromStoreItemPrice(item.manufacturerSuggestedPrice, accountingCurrency);
+            }
+            if (item.unitCost) {
+                storeItem.unitCost = scp_component_business_core_1.Money.fromIMoney(item.unitCost);
+            }
+            if (item.externalIds) {
+                storeItem.externalIds = item.externalIds;
+            }
+            const TREATMENT_RULE_DEFAULTS = {
+                eligibleForSendSale: true,
+            };
+            if (item.treatmentRules) {
+                storeItem.treatmentRules = Object.assign(Object.assign({}, TREATMENT_RULE_DEFAULTS), item.treatmentRules);
+            }
+            if (!storeItem.price || !storeItem.price.amount) {
+                const units = storeItem.price ? storeItem.price.units : undefined;
+                const quantity = storeItem.price ? storeItem.price.quantity : undefined;
+                storeItem.price = new scp_component_business_core_1.Price(new scp_component_business_core_1.Money(0, accountingCurrency), units, quantity);
+            }
+            else {
+                //verify currency code for finalized item price
+                StoreItem.verifyCurrencyCode(storeItem, accountingCurrency);
+            }
+            if (item.defaultReturnPrice) {
+                storeItem.defaultReturnPrice = new scp_component_business_core_1.Price(new scp_component_business_core_1.Money(item.defaultReturnPrice.amount, item.defaultReturnPrice.currency || accountingCurrency));
+            }
+            if (item.subscriptionFrequencyCodes) {
+                storeItem.subscriptionFrequencyCodes = item.subscriptionFrequencyCodes;
+            }
+        }
+        catch (err) {
+            logger.catching(err, entryMessage);
+            throw logger.throwing(new scp_component_store_selling_core_1.PosError(`Error caught while populating StoreItem, ` +
+                `message: ${err.message ? err.message : err}, item: ${JSON.stringify(itemToConvert)}`, ErrorCodes_1.SSF_ERROR_POPULATING_STORE_ITEM_ERROR_CODE, err), entryMessage);
+        }
+        return logger.traceExit(entryMessage, storeItem);
+    }
+    lookupKeyByType(type) {
+        let itemLookupKey;
+        const itemLookupKeys = this.itemLookupKeys.slice();
+        const keys = itemLookupKeys.sort((a, b) => (a.value > b.value ? 1 : -1));
+        itemLookupKey = keys.find((lookupKeyToCheck) => lookupKeyToCheck.type === type);
+        if (!itemLookupKey && this.productAttributes) {
+            this.productAttributes.forEach((attribute) => {
+                if (type === attribute.attributeType) {
+                    itemLookupKey = new ItemLookupKey(attribute.attributeType, attribute.code);
+                }
+            });
+        }
+        return itemLookupKey;
+    }
+    isManualItemDiscountAllowed() {
+        return (!this.treatmentRules ||
+            this.treatmentRules.manualItemDiscount === scp_component_store_items_1.DiscountTreatmentRuleValueType.Allowed);
+    }
+    isManualTransactionDiscountAllowed() {
+        return (!this.treatmentRules ||
+            this.treatmentRules.manualTransactionDiscount === scp_component_store_items_1.DiscountTreatmentRuleValueType.Allowed);
+    }
+    isEmployeeDiscountAllowed() {
+        return (!this.treatmentRules || this.treatmentRules.employeeDiscount === scp_component_store_items_1.DiscountTreatmentRuleValueType.Allowed);
+    }
+    static extractRetailLocationSpecificItemData(item, retailLocationIdentity) {
+        let storeGroupItem = {};
+        let retailStoreItem = {};
+        if (item.retailLocations && item.retailLocations.length > 0) {
+            storeGroupItem = _.find(item.retailLocations, StoreItem.isStoreGroupItem);
+            retailStoreItem = _.find(item.retailLocations, (retailLocationItem) => retailLocationItem.retailLocationId === retailLocationIdentity.retailLocationId);
+        }
+        return { storeGroupItem, retailStoreItem };
+    }
+    static calculatePermanentPrice(itemToConvert, storeGroupItem, retailStoreItem, accountingCurrency) {
+        let permanentPrice = StoreItem.calculatePermanentPriceAtLevel(retailStoreItem, accountingCurrency);
+        if (permanentPrice) {
+            return {
+                price: permanentPrice.price,
+                source: {
+                    organizationScope: scp_component_store_items_1.OrganizationScope.OneRetailLocation,
+                    changeScope: permanentPrice.changeScope,
+                },
+            };
+        }
+        permanentPrice = StoreItem.calculatePermanentPriceAtLevel(storeGroupItem, accountingCurrency);
+        if (permanentPrice) {
+            return {
+                price: permanentPrice.price,
+                source: {
+                    organizationScope: scp_component_store_items_1.OrganizationScope.RetailLocationsGroup,
+                    changeScope: permanentPrice.changeScope,
+                },
+            };
+        }
+        permanentPrice = StoreItem.calculatePermanentPriceAtLevel(itemToConvert, accountingCurrency);
+        if (permanentPrice) {
+            return {
+                price: permanentPrice.price,
+                source: {
+                    organizationScope: scp_component_store_items_1.OrganizationScope.AllRetailLocations,
+                    changeScope: permanentPrice.changeScope,
+                },
+            };
+        }
+    }
+    static calculatePermanentPriceAtLevel(item, accountingCurrency) {
+        var _a, _b;
+        if (accountingCurrency && item) {
+            if (item.effectivePricing) {
+                const price1 = item.effectivePricing.permanentPrice;
+                if (accountingCurrency && ((_a = price1) === null || _a === void 0 ? void 0 : _a.currency) === accountingCurrency) {
+                    const price = StoreItem.convertStoreItemComponentIPriceToPrice(price1);
+                    return { price, changeScope: item.effectivePricing.permanentPriceSource };
+                }
+            }
+            const price2 = item.permanentPrice;
+            if (((_b = price2) === null || _b === void 0 ? void 0 : _b.currency) === accountingCurrency) {
+                const price = StoreItem.convertStoreItemComponentIPriceToPrice(price2);
+                return { price, changeScope: scp_component_store_items_1.PriceChangeLevelType.Item };
+            }
+        }
+        return undefined;
+    }
+    static calculateTemporaryPrice(itemToConvert, storeGroupItem, retailStoreItem, accountingCurrency) {
+        let temporaryPrice = StoreItem.calculateTemporaryPriceAtLevel(retailStoreItem, accountingCurrency);
+        if (temporaryPrice) {
+            return {
+                price: temporaryPrice.price,
+                source: {
+                    organizationScope: scp_component_store_items_1.OrganizationScope.OneRetailLocation,
+                    changeScope: temporaryPrice.changeScope,
+                },
+            };
+        }
+        temporaryPrice = StoreItem.calculateTemporaryPriceAtLevel(storeGroupItem, accountingCurrency);
+        if (temporaryPrice) {
+            return {
+                price: temporaryPrice.price,
+                source: {
+                    organizationScope: scp_component_store_items_1.OrganizationScope.RetailLocationsGroup,
+                    changeScope: temporaryPrice.changeScope,
+                },
+            };
+        }
+        temporaryPrice = StoreItem.calculateTemporaryPriceAtLevel(itemToConvert, accountingCurrency);
+        if (temporaryPrice) {
+            return {
+                price: temporaryPrice.price,
+                source: {
+                    organizationScope: scp_component_store_items_1.OrganizationScope.AllRetailLocations,
+                    changeScope: temporaryPrice.changeScope,
+                },
+            };
+        }
+    }
+    static calculateTemporaryPriceAtLevel(item, accountingCurrency) {
+        var _a, _b;
+        if (accountingCurrency && ((_a = item) === null || _a === void 0 ? void 0 : _a.effectivePricing)) {
+            const effectiveTemporaryPrice = item.effectivePricing.temporaryPrice;
+            if (((_b = effectiveTemporaryPrice) === null || _b === void 0 ? void 0 : _b.currency) === accountingCurrency) {
+                const price = StoreItem.convertStoreItemComponentIPriceToPrice(effectiveTemporaryPrice);
+                return { price, changeScope: item.effectivePricing.temporaryPriceSource };
+            }
+        }
+        return undefined;
+    }
+    static temporaryPriceEffectiveDateTime(itemToConvert, storeGroupItem, retailStoreItem) {
+        var _a, _b, _c, _d, _e, _f;
+        return (((_b = (_a = retailStoreItem) === null || _a === void 0 ? void 0 : _a.effectivePricing) === null || _b === void 0 ? void 0 : _b.temporaryPriceEffectiveDateTime) || ((_d = (_c = storeGroupItem) === null || _c === void 0 ? void 0 : _c.effectivePricing) === null || _d === void 0 ? void 0 : _d.temporaryPriceEffectiveDateTime) || ((_f = (_e = itemToConvert) === null || _e === void 0 ? void 0 : _e.effectivePricing) === null || _f === void 0 ? void 0 : _f.temporaryPriceEffectiveDateTime));
+    }
+    static temporaryPriceExpirationDateTime(itemToConvert, storeGroupItem, retailStoreItem) {
+        var _a, _b, _c, _d, _e, _f;
+        return (((_b = (_a = retailStoreItem) === null || _a === void 0 ? void 0 : _a.effectivePricing) === null || _b === void 0 ? void 0 : _b.temporaryPriceExpirationDateTime) || ((_d = (_c = storeGroupItem) === null || _c === void 0 ? void 0 : _c.effectivePricing) === null || _d === void 0 ? void 0 : _d.temporaryPriceExpirationDateTime) || ((_f = (_e = itemToConvert) === null || _e === void 0 ? void 0 : _e.effectivePricing) === null || _f === void 0 ? void 0 : _f.temporaryPriceExpirationDateTime));
+    }
+    static calculateFullPrice(itemToConvert, storeGroupItem, retailStoreItem, accountingCurrency) {
+        let fullPrice = StoreItem.calculateFullPriceAtLevel(retailStoreItem, accountingCurrency);
+        if (fullPrice) {
+            return {
+                price: fullPrice.price,
+                source: {
+                    organizationScope: scp_component_store_items_1.OrganizationScope.OneRetailLocation,
+                    changeScope: fullPrice.changeScope,
+                },
+            };
+        }
+        fullPrice = StoreItem.calculateFullPriceAtLevel(storeGroupItem, accountingCurrency);
+        if (fullPrice) {
+            return {
+                price: fullPrice.price,
+                source: {
+                    organizationScope: scp_component_store_items_1.OrganizationScope.RetailLocationsGroup,
+                    changeScope: fullPrice.changeScope,
+                },
+            };
+        }
+        fullPrice = StoreItem.calculateFullPriceAtLevel(itemToConvert, accountingCurrency);
+        if (fullPrice) {
+            return {
+                price: fullPrice.price,
+                source: {
+                    organizationScope: scp_component_store_items_1.OrganizationScope.AllRetailLocations,
+                    changeScope: fullPrice.changeScope,
+                },
+            };
+        }
+    }
+    static calculateFullPriceAtLevel(item, accountingCurrency) {
+        var _a;
+        if (accountingCurrency && item) {
+            const price2 = item.fullPrice;
+            if (((_a = price2) === null || _a === void 0 ? void 0 : _a.currency) === accountingCurrency) {
+                const price = StoreItem.convertStoreItemComponentIPriceToPrice(price2);
+                return { price, changeScope: scp_component_store_items_1.PriceChangeLevelType.Item };
+            }
+        }
+        return undefined;
+    }
+    static createItemLookupKeysFromJsonObject(itemLookupKeysFromJson) {
+        const itemLookupKeys = [];
+        if (itemLookupKeysFromJson) {
+            for (const itemLookupKeyFromJson of itemLookupKeysFromJson) {
+                const itemLookupKey = ItemLookupKey.createFromJsonObj(itemLookupKeyFromJson);
+                itemLookupKeys.push(itemLookupKey);
+            }
+        }
+        return itemLookupKeys;
+    }
+    static getStringFromJsonObject(propertyFromJsonObject) {
+        let property = undefined;
+        if (propertyFromJsonObject) {
+            property = propertyFromJsonObject;
+        }
+        else if (propertyFromJsonObject === null) {
+            property = null;
+        }
+        return property;
+    }
+    static getPriceFromStoreItemPrice(storeItem, accountingCurrency) {
+        return scp_component_business_core_1.Price.fromIPrice({
+            amount: storeItem.amount,
+            currency: storeItem.currency || accountingCurrency,
+            quantity: storeItem.quantity,
+            units: storeItem.unitOfMeasure,
+        });
+    }
+    static createHierarchyNodeFromJsonObject(hierarchyNodesFromJson) {
+        if (!hierarchyNodesFromJson) {
+            return undefined;
+        }
+        const hierarchyNodes = [];
+        for (const hierarchyNodeFromJson of hierarchyNodesFromJson) {
+            const hierarchyNode = HierarchyNode.createFromJsonObj(hierarchyNodeFromJson);
+            hierarchyNodes.push(hierarchyNode);
+        }
+        return hierarchyNodes;
+    }
+    static updateLocalizableTextsFromItemAttributeObject(storeItem, sourceItem, locale) {
+        let useDefaultValues = true;
+        if (!!locale && locale !== sourceItem.language && sourceItem.translations) {
+            const localeToUse = utils_1.getLocaleCodeForTranslationSet(sourceItem.translations, locale);
+            if (localeToUse) {
+                // ... language-specific values
+                const itemTranslationAttribute = sourceItem.translations[localeToUse];
+                storeItem.shortDescription = itemTranslationAttribute.shortDescription || "";
+                storeItem.additionalDescription = itemTranslationAttribute.additionalDescription || "";
+                storeItem.longDescription = itemTranslationAttribute.longDescription || "";
+                storeItem.name = itemTranslationAttribute.name || "";
+                storeItem.stopStatusMessage = itemTranslationAttribute.stopStatusMessage || "";
+                useDefaultValues = false;
+            }
+        }
+        if (useDefaultValues) {
+            // ... default values
+            storeItem.shortDescription = sourceItem.shortDescription || "";
+            storeItem.additionalDescription = sourceItem.additionalDescription || "";
+            storeItem.longDescription = sourceItem.longDescription || "";
+            storeItem.name = sourceItem.name || "";
+            storeItem.stopStatusMessage = sourceItem.stopStatusMessage || "";
+        }
+        storeItem.attributes = ItemAttributes.createFromJsonObject(sourceItem.attributes, locale);
+    }
+    static verifyCurrencyCode(storeItem, accountingCurrency) {
+        if (storeItem.price && storeItem.price.amount) {
+            if (accountingCurrency !== storeItem.price.amount.currency) {
+                throw new scp_component_store_selling_core_1.PosError(`Item ${storeItem.uniqueId} pricing currency code ${storeItem.price.amount.currency} ` +
+                    `does not match accountingCurrency ${accountingCurrency} set on retailLocation`, ErrorCodes_1.SSF_CURRENCY_MISMATCH_I18N_CODE);
+            }
+        }
+        else {
+            throw new scp_component_store_selling_core_1.PosError(`Pricing not found for Item ${storeItem.uniqueId}`, ErrorCodes_1.SSF_PRICE_NOT_FOUND_I18N_CODE);
+        }
+    }
+    static isStoreGroupItem(retailLocationItem) {
+        return retailLocationItem && !_.isEmpty(retailLocationItem.retailLocationGroupId);
+    }
+}
+exports.StoreItem = StoreItem;
+class PriceInquiry extends StoreItem {
+    constructor() {
+        super(...arguments);
+        this.finalPrice = undefined;
+        this.promos = undefined;
+    }
+}
+exports.PriceInquiry = PriceInquiry;
+//# sourceMappingURL=StoreItem.js.map