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

package/lib/domain/model/item/IAllLinePricingAdjustments.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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_selling_core_1 = require("@aptos-scp/scp-component-store-selling-core");
+const config_1 = require("../../../config");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.adapter.pricing.IAllLinePricingAdjustments");
+/**
+ * Group the pricing line adjustments by line number and by adjustment type (regular, sale, or promotion)
+ * @param {ISerializedLinePricingAdjustment[]} lineAdjustments  The line adjustments from the pricing component
+ * @returns {IAllLinePricingAdjustments[]} The promotion adjustments, grouped by line number
+ */
+function groupLineAdjustments(lineAdjustments, sublines) {
+    const entryMessage = logger.traceEntry("groupLineAdjustments", lineAdjustments);
+    const result = [];
+    const lookup = new Map();
+    lineAdjustments.forEach((lineAdjustment) => {
+        let groupedLineAdjustment = lookup.get(lineAdjustment.lineNumber);
+        if (!groupedLineAdjustment) {
+            groupedLineAdjustment = {
+                lineId: lineAdjustment.lineId,
+                lineNumber: lineAdjustment.lineNumber,
+                regularPriceAdjustment: null,
+                salePriceAdjustment: null,
+                promotionAdjustments: [],
+                sublineQuantities: [],
+            };
+            lookup.set(lineAdjustment.lineNumber, groupedLineAdjustment);
+            result.push(groupedLineAdjustment);
+        }
+        switch (lineAdjustment.adjustmentSource) {
+            case 0 /* ItemUnitPrice */:
+                groupedLineAdjustment.regularPriceAdjustment = lineAdjustment;
+                break;
+            case 1 /* ItemSalePrice */:
+                groupedLineAdjustment.salePriceAdjustment = lineAdjustment;
+                break;
+            case 2 /* PricingRule */:
+                groupedLineAdjustment.promotionAdjustments.push(lineAdjustment);
+                break;
+            default:
+                throw logger.throwing(new scp_component_store_selling_core_1.PosBusinessError(new scp_component_business_core_1.LocalizableMessage(config_1.SSF_PRICING_API_ERROR_I18N_CODE), `Unsupported adjustment type: ${lineAdjustment.adjustmentSource}`, config_1.SSF_PRICING_API_ERROR_CODE), entryMessage);
+        }
+    });
+    if (sublines) {
+        sublines.forEach((subline) => {
+            let groupedLineAdjustment = lookup.get(subline.lineNumber);
+            if (!groupedLineAdjustment) {
+                groupedLineAdjustment = {
+                    lineId: subline.lineId,
+                    lineNumber: subline.lineNumber,
+                    regularPriceAdjustment: null,
+                    salePriceAdjustment: null,
+                    promotionAdjustments: [],
+                    sublineQuantities: [],
+                };
+                lookup.set(subline.lineNumber, groupedLineAdjustment);
+                result.push(groupedLineAdjustment);
+            }
+            groupedLineAdjustment.sublineQuantities.push(...subline.breakdown);
+        });
+    }
+    return logger.traceExit(entryMessage, result);
+}
+exports.groupLineAdjustments = groupLineAdjustments;
+//# sourceMappingURL=IAllLinePricingAdjustments.js.map

package/lib/domain/model/item/IHardSoftStopItemInfo.d.ts

@@ -0,0 +1,11 @@
+import { Quantity } from "@aptos-scp/scp-component-business-core";
+import { Status } from "@aptos-scp/scp-component-store-items";
+import { StoreItem } from "../StoreItem";
+export interface IHardSoftStopItemInfo {
+    storeItem: StoreItem;
+    itemKey: string;
+    itemKeyType: string;
+    quantity: Quantity;
+    itemStatus: Status;
+    itemStopStatusMessage: string;
+}

package/lib/domain/model/item/IHardSoftStopItemInfo.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IHardSoftStopItemInfo.js.map

package/lib/domain/model/item/IItemLine.d.ts

@@ -0,0 +1,313 @@
+import { Money, Price, Quantity } from "@aptos-scp/scp-component-business-core";
+import { ITransactionLine, IUser } from "@aptos-scp/scp-component-store-selling-core";
+import { IAppliedTax } from "@aptos-scp/scp-component-taxation";
+import { IAuthorizationResponse } from "@aptos-scp/scp-types-commerce-devices";
+import { ActionType, IPriceChange, ISubline as IPostableSubline, ITaxByTaxAuthority, ITaxByTaxRule, ITaxExempt, ITaxOverride, ITaxOverrideDetails, ItemType, ITransactionLineReferenceType, IUser as IPostedUser, LoyaltyRedemptionType, SourceIndicator, UnitPriceSourceIndicator, ICompetitivePriceInformation, IProratedItemLineReference, IReason } from "@aptos-scp/scp-types-commerce-transaction";
+import { ISerializedSublinePricingAdjustmentWithSource, ISublinePricingAdjustmentWithSource } from "./ISerializedPriceCalculationResultsWithSource";
+import { SecurityAuthorizationStatusType } from "../Constants";
+import { Customer } from "../Customer";
+import { IEmployee } from "../Employee";
+import { IExtensibilityForm } from "../extensibilityForm/IExtensibilityForm";
+import { IFeeLine } from "../fee";
+import { IItemPriceSource, IPriceProvider, ItemLookupKey, SelectedUnitPrice, StoreItem } from "../StoreItem";
+import { ItemTaxExemptLine, TransactionTaxExemptLine } from "../taxExempt";
+import { TaxOverrideLine } from "../taxOverride/TaxOverrideLine";
+import { TenderType } from "../TenderType";
+import { IVoidableLine } from "../VoidInterfaces";
+export declare function isTransactionLineTaxesMaintainer(transactionLine: ITransactionLine): transactionLine is IItemLine | IFeeLine;
+export interface IItemLine extends ITransactionLine, IVoidableLine, IPriceProvider {
+    readonly enteredLookupKey: ItemLookupKey;
+    readonly preferredDisplayKeyType?: string;
+    readonly item: StoreItem;
+    readonly itemType: ItemType;
+    readonly originalTaxGroupId: string;
+    readonly taxGroupId: string;
+    readonly originalUnitPrice: Price;
+    readonly unitPriceBeforePriceOverride: Price;
+    readonly unitPrice: Price;
+    readonly unitPriceExcludingTransactionDiscounts: Price;
+    readonly originalQuantity: Quantity;
+    readonly quantity: Quantity;
+    readonly extendedAmountExcludingTransactionDiscounts: Money;
+    readonly originalExtendedAmount: Money;
+    readonly extendedAmountAdjustment: Money;
+    readonly originalLineSavings: Money;
+    readonly lineSavings: Money;
+    readonly annotationDescription: string;
+    readonly manuallyEnteredPrice: boolean;
+    readonly taxByAuthority: IAppliedTax[];
+    readonly taxExemptDisplayName?: string;
+    readonly totalLineTax: Money;
+    readonly taxByAuthorityBeforeVoid: IAppliedTax[];
+    readonly totalLineTaxBeforeVoid: Money;
+    readonly additionalItemInfo: IAddionalItemInfo;
+    readonly authResponse: IAuthorizationResponse;
+    readonly authorizationDeviceId: string;
+    readonly tenderType: TenderType;
+    /**
+     * The tenderId is the id of the tender associated to the item for gift card issuing
+     */
+    readonly tenderId: string;
+    /**
+     * The tenderName is the name of the tender associated to the item for gift card issuing
+     */
+    readonly tenderName: string;
+    /**
+     * The actionType is the type of action associated to the Gift Card sale, Reload or Issue
+     */
+    readonly actionType: ActionType;
+    readonly manufacturerSuggestedPrice: Price;
+    readonly unitCost: Money;
+    readonly sublines?: IItemSubline[];
+    readonly salesperson?: IEmployee;
+    readonly giftReceipt?: boolean;
+    readonly comments?: string[];
+    readonly taxExempt?: ITaxExempt;
+    readonly preTaxExemptDetails?: IAppliedTax[];
+    readonly taxOverride?: ITaxOverride;
+    /**
+     * The total tax amount being exempted for the item in case of tax exemption
+     */
+    readonly itemTaxExemptAmount?: Money;
+    /**
+     * The total tax amount being adjusted for the item in case of tax override
+     */
+    readonly itemTaxAdjustmentAmount?: Money;
+    /**
+     * The adjusted extended amount in case of tax exemption/override applied
+     */
+    readonly extendedAmountAfterTaxAdjustment?: Money;
+    /**
+     * The adjusted unit price in case of tax exemption/override applied
+     */
+    readonly unitPriceAfterTaxAdjustment?: Price;
+    readonly preTaxOverrideDetails?: ITaxByTaxRule[];
+    readonly unitPriceSourceIndicator?: UnitPriceSourceIndicator;
+    readonly inputSource?: string;
+    readonly returnReason?: IReturnReason;
+    readonly securityAuthorizationStatus?: SecurityAuthorizationStatusType;
+    readonly supervisorOverrideLineReference?: ITransactionLineReferenceType;
+    readonly isFastDiscountItem?: boolean;
+    readonly markeddownPriceLineSavings?: Money;
+    readonly pricingCalculationSourceIndicator?: SourceIndicator;
+    readonly taxationCalculationSourceIndicator?: SourceIndicator;
+    readonly pricingDataSourceIndicator?: SourceIndicator;
+    readonly taxationDataSourceIndicator?: SourceIndicator;
+    /**
+     * For pickup or delivery orders, the item fulfillment group id specifies which fulfillment group
+     * it belongs to.
+     */
+    readonly fulfillmentGroupId?: number;
+    readonly originalTransactionLineReference?: ITransactionLineReferenceType;
+    readonly originalTransactionNumber?: string;
+    /**
+     * For returnWithTransaction, the subLine of the item being return from the original transaction.
+     */
+    readonly subLineFromReturnItem?: IPostableSubline;
+    /**
+     * For returnWithTransaction, the line number of the item being return from the original transaction.
+     */
+    readonly lineNumberFromReturnTransaction?: number;
+    /**
+     * For returnWithTransaction, the index of the subline on the item being return from the original transaction.
+     */
+    readonly sublineIndexFromReturnItem?: number;
+    /**
+     * For returnWithTransaction, the line item sequence number
+     */
+    readonly lineNumberFromReturnCanonicalTransaction?: number;
+    /**
+     * For returnWithTransaction, the line item sequence number
+     */
+    readonly lineNumberFromReturnCanonicalSubItem?: number;
+    /**
+     * Treatment rule that determines if an item can be returned
+     */
+    readonly returnable?: boolean;
+    /**
+     * For return without receipt or offline return item, the defaultReturnPrice of the item.
+     */
+    readonly defaultReturnPrice?: Price;
+    /**
+     * For returnWithTransaction, the originalUnitPrice of the item being return from the original transaction.
+     * For order actions, the originalUnitPrice of the item being acted upon from the order.
+     */
+    readonly originalUnitPriceFromExternalItem?: Price;
+    /**
+     * For items returned via returnWithTransaction, the original performing user from the original transaction
+     */
+    readonly originalTransactionPerformingUser?: IUser;
+    /**
+     * For items returned via returnWithTransaction, the original customer information
+     */
+    readonly originalCustomer?: Customer;
+    /**
+     * For items returned via returnWithTransaction, the adjustment associated to the item being return from the original
+     * canonical transaction.
+     */
+    readonly originalAdjustments?: ISublinePricingAdjustmentWithSource[];
+    /**
+     * For items returned via returnWithTransaction, the original salesperson from the original transaction
+     */
+    readonly originalTransactionSalesperson?: IEmployee;
+    /**
+     * For items returned via returnWithTransaction, the original employee customer from the original transaction.
+     */
+    readonly originalEmployeeCustomer?: IEmployee;
+    /**
+     * For items returned via returnWithTransaction, the price override from the original transaction.
+     */
+    readonly originalPriceOverride?: IPriceChange;
+    /**
+     * For items fulfillment, the item discount controlled opration from the original transaction.
+     */
+    readonly originalDiscountReason?: IReason;
+    /**
+     * For items returned via returnWithTransaction, loyalty information from the original transaction.
+     */
+    readonly originalLoyaltyInformation?: IOriginalLoyaltyInformation[];
+    /**
+     * For items returned via returnWithTransaction, loyalty information from the original transaction.
+     */
+    readonly originalCompetitivePriceInformation?: IOriginalCompetitivePriceInformation;
+    /**
+     * For items returned via returnWithTransaction, supervisor override information from the original transaction.
+     */
+    readonly originalSupervisorOverrideInformation?: IOriginalSupervisorOverrideInformation[];
+    /**
+     * For items returned via returnWithTransaction, the comments from the original transaction.
+     */
+    readonly originalComments?: string[];
+    /**
+     * For items returned via returnWithTransaction, the price override from the original transaction.
+     */
+    readonly originalTaxOverride?: ITaxOverrideDetails;
+    /**
+     * Treatment rule that determines if an item can be associated with a subscription
+     */
+    readonly eligibleForSubscription?: boolean;
+    /**
+     * Treatment rule that determines if an item can be converted to sendSale
+     */
+    readonly eligibleForSendSale?: boolean;
+    readonly reservedQuantity?: number;
+    readonly reservationId?: string;
+    readonly itemReservationCode?: string;
+    /** Flag that indicates the item is sendsale */
+    readonly sendSale?: boolean;
+    /** Flag that indicates there is a subscription associated with the item */
+    readonly subscribed?: boolean;
+    /** the quantity of items in the subscription */
+    readonly subscriptionQuantity?: number;
+    /**
+     * For order actions, the line number of order reference line.
+     */
+    readonly orderLineReference?: ITransactionLineReferenceType;
+    /**
+     * List of delivery frequency codes the item is able to use.
+     */
+    readonly subscriptionFrequencyCodes?: string[];
+    /**
+     * For order actions, the line number of the item being acted upon from the order.
+     */
+    readonly lineNumberFromOrder?: number;
+    /** the permanent price */
+    readonly itemPermanentPrice?: Price;
+    /** the permanent price's source */
+    readonly itemPermanentPriceSource?: IItemPriceSource;
+    /** the temporary price */
+    readonly itemTemporaryPrice?: Price;
+    /** the temporary price's source */
+    readonly itemTemporaryPriceSource?: IItemPriceSource;
+    /** The item's full price */
+    readonly itemFullPrice?: Price;
+    /** the full price's source */
+    readonly itemFullPriceSource?: IItemPriceSource;
+    /** The discount to be applied when the employee is purchasing merchandise */
+    readonly itemEmployeeDiscountPercent?: string;
+    /** Indicates whether the unit price is the temporary, permanent or full price. */
+    readonly itemSelectedUnitPrice?: SelectedUnitPrice;
+    /**
+     * A decorator containing the presentation values. If the presentation is set, a return unit price is also set
+     * in the IItemDisplayLine line representing the return value for the item.
+     * If a promotion with presentation values is applied to the item, the presentation values will be represented by
+     * the another decorator of the same type as the one containing the return values for the item. The idea is to have
+     * both scenarios (presentation and return values) available to be used by the app when calculating taxes
+     * (return values) or showing in the basket and in the receipt (presentation values).
+     */
+    readonly presentation?: IItemLine;
+    readonly extendedPresentationAmount?: Money;
+    /** Flag that indicates that the order item is cancelled */
+    readonly cancelled?: boolean;
+    readonly extensibilityFormData?: IExtensibilityForm[];
+    readonly prepaidAmount?: Money;
+    readonly prepaidTaxAmount?: Money;
+    readonly prepaidSavingsAmount?: Money;
+    readonly extendedRegularAmount?: Money;
+    /**
+     * For returnWithTransaction, the identifiers of the redemptions applied to the original transaction.
+     */
+    readonly originalRedemptionLoyaltyTransactionKeys?: string[];
+    /**
+     * For returnWithTransaction, the identifiers of the loyalty rewards applied to the original transaction.
+     */
+    readonly originalSaleLoyaltyTransactionKeys?: string[];
+    setTransactionLineTaxes(transactionLineTaxes: ITransactionLineTaxes, extendedAmount?: Money): IItemLine;
+    setSublines(sublines: IItemSubline[]): IItemLine;
+    setTaxExemptInformation(taxExemptLine: ItemTaxExemptLine | TransactionTaxExemptLine, preTaxExemptDetails: IAppliedTax[]): IItemLine;
+    setTaxOverrideInformation(taxOverrideLine: TaxOverrideLine, preTaxOverrideDetails: ITaxByTaxRule[]): IItemLine;
+    setSupervisorOverrideLineReference(supervisorOverrideLineReference?: ITransactionLineReferenceType): IItemLine;
+    setSecurityAuthorizationStatus(value: SecurityAuthorizationStatusType): IItemLine;
+    setPricingSourceIndicator(calculationSourceIndicator?: SourceIndicator, dataSourceIndicator?: SourceIndicator): IItemLine;
+    setTaxationSourceIndicator(calculationSourceIndicator?: SourceIndicator, dataSourceIndicator?: SourceIndicator): IItemLine;
+    setExtendedRegularAmount(amount?: Money): IItemLine;
+}
+export interface ITransactionLineTaxes {
+    taxByAuthority: IAppliedTax[];
+    totalLineTax: Money;
+}
+export interface IReturnReason {
+    readonly reasonCode: string;
+    readonly reasonDescription: string;
+    readonly reasonListType: string;
+}
+export interface IOriginalLoyaltyInformation {
+    readonly loyaltyPlanKey: string;
+    readonly redemptionType?: LoyaltyRedemptionType;
+    readonly loyaltyActivityId?: string;
+    readonly redemptionCode?: string;
+    readonly redemptionName?: string;
+    readonly redemptionDescription?: string;
+    readonly originalDiscountlineNumber?: number;
+    readonly discountProratedByService?: boolean;
+    readonly itemLineReferences?: IProratedItemLineReference[];
+}
+export interface IOriginalCompetitivePriceInformation {
+    readonly pricingRuleId?: string;
+    readonly competitivePriceInformation?: ICompetitivePriceInformation;
+}
+export interface IOriginalSupervisorOverrideInformation {
+    readonly originalDiscountlineNumber?: number;
+    readonly user: IPostedUser;
+}
+export interface IItemSubline {
+    readonly quantity: number;
+    readonly adjustments: ISerializedSublinePricingAdjustmentWithSource[];
+    readonly taxByAuthority: ITaxByTaxAuthority[];
+    readonly taxExemptDisplayName?: string;
+    readonly extendedAmountExcludingTax?: Money;
+    readonly extendedAmountIncludingTax?: Money;
+    /**
+     * Tax override line information
+     */
+    readonly taxOverride?: ITaxOverride;
+    /**
+     * Pre TaxOverride details
+     */
+    readonly preTaxOverrideDetails?: ITaxByTaxRule[];
+    readonly extendedAmount?: Money;
+    readonly extendedAmountAfterTaxAdjustment?: Money;
+}
+export interface IAddionalItemInfo {
+    cardNumber: string;
+}

package/lib/domain/model/item/IItemLine.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isTransactionLineTaxesMaintainer(transactionLine) {
+    return transactionLine && transactionLine.setTransactionLineTaxes !== undefined;
+}
+exports.isTransactionLineTaxesMaintainer = isTransactionLineTaxesMaintainer;
+//# sourceMappingURL=IItemLine.js.map

package/lib/domain/model/item/ISerializedPriceCalculationResultsWithSource.d.ts

@@ -0,0 +1,45 @@
+import { IPricingMetadataPersistanceObject, ISerializedLinePricingAdjustment, ISerializedSubline, ISerializedSublinePricingAdjustment, ISublinePricingAdjustment, RewardIssue } from "@aptos-scp/scp-component-pricing";
+import { ISerializedNonFinancialReward } from "@aptos-scp/scp-component-pricing/lib/interfaces/ILineNonFinancialReward";
+import { ICompetitivePriceInformation, ILoyaltyInformation, ISupervisorOverrideInformation, SourceIndicator } from "@aptos-scp/scp-types-commerce-transaction";
+export interface ISerializedPriceCalculationResultsWithSource {
+    readonly lineAdjustments: ISerializedLinePricingAdjustmentWithSource[];
+    readonly sublines?: ISerializedSublineWithSource[];
+    readonly issues: RewardIssue[];
+    readonly nonFinancialRewards?: ISerializedNonFinancialRewardWithSource[];
+    metadata?: IPricingMetadataPersistanceObject;
+}
+export interface ISerializedLinePricingAdjustmentWithSource extends ISerializedLinePricingAdjustment {
+    sourceIndicator?: SourceIndicator;
+}
+export interface ISerializedNonFinancialRewardWithSource extends ISerializedNonFinancialReward {
+    sourceIndicator?: SourceIndicator;
+}
+export interface ISerializedSublineWithSource extends ISerializedSubline {
+    readonly lineId?: string;
+    readonly lineNumber?: number;
+    readonly breakdown: ISerializedSublineQuantityWithSource[];
+}
+/**
+ * A unique grouping of a part of the line item, split into different groups based on what adjustments were
+ * applied to the quantity.
+ */
+export interface ISerializedSublineQuantityWithSource {
+    quantity: number;
+    adjustments: ISerializedSublinePricingAdjustmentWithSource[];
+}
+export interface ISerializedSublinePricingAdjustmentWithSource extends ISerializedSublinePricingAdjustment {
+    sourceIndicator?: SourceIndicator;
+    isEmployeeDiscount?: boolean;
+}
+export interface ISublinePricingAdjustmentWithSource extends ISublinePricingAdjustment {
+    sourceIndicator?: SourceIndicator;
+    reasonCode?: string;
+    reasonListType?: string;
+    reasonDescription?: string;
+    employeeFlag?: boolean;
+    externalCouponCode?: string;
+    autoApplied?: boolean;
+    loyaltyInformation?: ILoyaltyInformation;
+    competitivePriceInformation?: ICompetitivePriceInformation;
+    supervisorOverrideInformation?: ISupervisorOverrideInformation;
+}

package/lib/domain/model/item/ISerializedPriceCalculationResultsWithSource.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ISerializedPriceCalculationResultsWithSource.js.map