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

package/lib/domain/processing/PosBusinessAction.d.ts

@@ -0,0 +1,9 @@
+import { Container } from "inversify";
+import { IActionContext, IDomainNotificationService, ITransaction, ITransactionLineFactory, ITransactionNumberProvider, PosBusinessAction as CorePosBusinessAction } from "@aptos-scp/scp-component-store-selling-core";
+import { ITransactionAccountingService } from "../service";
+export declare class PosBusinessAction extends CorePosBusinessAction {
+    private _transactionAccountingService;
+    constructor(transactionNumberProvider: ITransactionNumberProvider, transactionAccountingService: ITransactionAccountingService, transactionLineFactory: ITransactionLineFactory, domainNotificationService: IDomainNotificationService, diContainer: Container);
+    protected updateTransactionAccounting(context: IActionContext): Promise<ITransaction>;
+    protected transactionShouldClose(transaction: ITransaction): boolean;
+}

package/lib/domain/processing/PosBusinessAction.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const inversify_1 = require("inversify");
+const scp_component_store_selling_core_1 = require("@aptos-scp/scp-component-store-selling-core");
+const DiTypes_1 = require("../../config/DiTypes");
+const model_1 = require("../model");
+let PosBusinessAction = class PosBusinessAction extends scp_component_store_selling_core_1.PosBusinessAction {
+    constructor(transactionNumberProvider, transactionAccountingService, transactionLineFactory, domainNotificationService, diContainer) {
+        super(transactionNumberProvider, transactionLineFactory, domainNotificationService, diContainer);
+        this._transactionAccountingService = transactionAccountingService;
+    }
+    updateTransactionAccounting(context) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const transactionFlowStateObject = context.getState(model_1.TRANSACTION_FLOW_STATE);
+            const transactionFlowState = (_a = transactionFlowStateObject) === null || _a === void 0 ? void 0 : _a.state;
+            return this._transactionAccountingService.updateTransaction(context.transaction, transactionFlowState);
+        });
+    }
+    transactionShouldClose(transaction) {
+        return this._transactionAccountingService.transactionShouldClose(transaction);
+    }
+};
+PosBusinessAction = __decorate([
+    inversify_1.injectable(),
+    __param(0, inversify_1.inject(scp_component_store_selling_core_1.DI_TYPES.ITransactionNumberProvider)),
+    __param(1, inversify_1.inject(DiTypes_1.DI_TYPES.ITransactionAccountingService)),
+    __param(2, inversify_1.inject(scp_component_store_selling_core_1.DI_TYPES.ITransactionFactory)),
+    __param(3, inversify_1.inject(scp_component_store_selling_core_1.DI_TYPES.IDomainNotificationService)),
+    __param(4, inversify_1.inject(scp_component_store_selling_core_1.DI_TYPES.DependencyInjectionContainer)),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, inversify_1.Container])
+], PosBusinessAction);
+exports.PosBusinessAction = PosBusinessAction;
+//# sourceMappingURL=PosBusinessAction.js.map

package/lib/domain/processing/index.d.ts

@@ -0,0 +1 @@
+export * from "./PosBusinessAction";

package/lib/domain/processing/index.js

@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./PosBusinessAction"));
+//# sourceMappingURL=index.js.map

package/lib/domain/service/IReceiptFormattingService.d.ts

@@ -0,0 +1,48 @@
+import { DeviceIdentity, IReceiptFormattingService as ICoreReceiptFormattingService, ITransaction, Receipt as CoreReceipt } from "@aptos-scp/scp-component-store-selling-core";
+import { IPrinterInfo, IReceiptRequiredData, ItemLine, ReceiptCategory } from "../../";
+export interface IReceiptFormattingService extends ICoreReceiptFormattingService {
+    formatBalanceInquiryReceipt(transaction: ITransaction, locale: string, printer?: IPrinterInfo): Promise<Receipt>;
+    formatReceiptByCategory(transaction: ITransaction, locale: string, receiptCategory: ReceiptCategory, lineNumbers?: number[], printer?: IPrinterInfo, receiptRequiredData?: IReceiptRequiredData[]): Promise<Receipt>;
+    formatReprintReceipt(lines: string[], deviceIdentity: DeviceIdentity, locale?: string, originalReceiptCategory?: ReceiptCategory, printer?: IPrinterInfo): Promise<Receipt>;
+    formatGiftReceipt(transaction: ITransaction, giftitems: Array<ItemLine>, locale: string, printer?: IPrinterInfo): Promise<Receipt>;
+    formatCouponReceipt(transaction: ITransaction, locale: string, receiptRequiredData: IReceiptRequiredData[], printer?: IPrinterInfo): Promise<Receipt>;
+    formatPostVoidReceipts(transaction: ITransaction, locale?: string, printer?: IPrinterInfo): Promise<Receipt[]>;
+    formatReceiptTemplate(transaction: ITransaction, locale?: string, printer?: IPrinterInfo, selectedReceiptCategory?: string): Promise<ReceiptTemplate[]>;
+    formatReceiptTemplateValue(transaction: ITransaction, lines: string[], locale?: string, additionalInfo?: AdditionalReprintInfo, printer?: IPrinterInfo, reprintCount?: number): Promise<Receipt>;
+    formatTillReceipt(transaction: ITransaction, locale: string, printer?: IPrinterInfo): Promise<Receipt>;
+    formatNoSaleReceipt(transaction: ITransaction, locale: string, printer?: IPrinterInfo): Promise<Receipt>;
+    formatPaidOperationReceipt(transaction: ITransaction, locale: string, printer?: IPrinterInfo): Promise<Receipt>;
+    removeReceiptTemplateValue(receiptLines: string[]): string[];
+    formatPostVoidReceiptTemplate(transaction: ITransaction, locale?: string, printer?: IPrinterInfo): Promise<ReceiptTemplate[]>;
+    formatSendSaleReceipt(transaction: ITransaction, sendsaleitems: Array<ItemLine>, locale: string, printer?: IPrinterInfo): Promise<Receipt>;
+}
+export interface AdditionalReprintInfo {
+    originalTransactionEndDateTime?: Date;
+    originalTransactionDeviceId: string;
+    originalTransactionNumber: number;
+    currentReceiptCategory: ReceiptCategory;
+    duplicateCopy: boolean;
+    taxInvoiceNumber?: string;
+    taxInvoicePrintDate?: Date;
+    invoiceTransactionNumber?: number;
+    invoiceFiscalTransactionNumber?: string;
+}
+export interface ReceiptTypeCount {
+    print: ReceiptCount;
+    email: ReceiptCount;
+}
+export interface ReceiptCount {
+    sale?: number;
+    invoice?: number;
+    vatReceipt?: number;
+    fullPageInvoice?: number;
+    japanRSS?: number;
+    postVoid?: number;
+}
+export interface Receipt extends CoreReceipt {
+    isTemplate?: boolean;
+    htmlDocument?: string;
+}
+export interface ReceiptTemplate extends Receipt {
+    receiptCategory: ReceiptCategory;
+}

package/lib/domain/service/IReceiptFormattingService.js

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

package/lib/domain/service/ITransactionAccountingService.d.ts

@@ -0,0 +1,6 @@
+import { ITransaction } from "@aptos-scp/scp-component-store-selling-core";
+import { TransactionFlowSessionState } from "../model";
+export interface ITransactionAccountingService {
+    updateTransaction(transaction: ITransaction, transactionFlowState?: TransactionFlowSessionState): Promise<ITransaction>;
+    transactionShouldClose(transaction: ITransaction): boolean;
+}

package/lib/domain/service/ITransactionAccountingService.js

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

package/lib/domain/service/ITransactionReferenceFormatter.d.ts

@@ -0,0 +1,4 @@
+import { ITransaction } from "@aptos-scp/scp-component-store-selling-core";
+export interface ITransactionReferenceFormatter {
+    generateTransactionReference(transaction: ITransaction): string;
+}

package/lib/domain/service/ITransactionReferenceFormatter.js

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

package/lib/domain/service/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IReceiptFormattingService";
+export * from "./ITransactionAccountingService";
+export * from "./ITransactionReferenceFormatter";

package/lib/domain/service/index.js

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

package/lib/domain/utility/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./orderUtils";
+export * from "./supervisorOverride";
+export * from "./utils";

package/lib/domain/utility/index.js

@@ -0,0 +1,9 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./orderUtils"));
+__export(require("./supervisorOverride"));
+__export(require("./utils"));
+//# sourceMappingURL=index.js.map

package/lib/domain/utility/orderUtils.d.ts

@@ -0,0 +1,6 @@
+import { ITransaction, ITransactionLine } from "@aptos-scp/scp-component-store-selling-core";
+import { OrderReferenceLine } from "../model";
+import { FulfillmentType, ITransactionLineReferenceType } from "@aptos-scp/scp-types-commerce-transaction";
+export declare function getOrderFulfillmentTypeFromOrderReferenceLine(line: OrderReferenceLine): FulfillmentType;
+export declare function getOrderFulfillmentType(transaction: ITransaction, fulfillmentGroupId: number, orderLineReferenceLine?: ITransactionLineReferenceType): string;
+export declare function hasPickupItemFulfillment(transactionLine: ITransactionLine): boolean;

package/lib/domain/utility/orderUtils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_1 = require("../model");
+function getOrderFulfillmentTypeFromOrderReferenceLine(line) {
+    if (line && line.orderReference && line.orderReference.order) {
+        const order = line.orderReference.order;
+        if (order && order.fulfillmentGroups && order.fulfillmentGroups.length > 1) {
+            return order.fulfillmentGroups[0].fulfillmentType;
+        }
+    }
+    return undefined;
+}
+exports.getOrderFulfillmentTypeFromOrderReferenceLine = getOrderFulfillmentTypeFromOrderReferenceLine;
+function getOrderFulfillmentType(transaction, fulfillmentGroupId, orderLineReferenceLine) {
+    var _a, _b;
+    let fulfillmentType = undefined;
+    if (model_1.isMerchandiseTransaction(transaction)) {
+        if (fulfillmentGroupId > 0) {
+            if (transaction.order) {
+                const fulfillmentGroup = (_a = transaction.order.fulfillmentGroups) === null || _a === void 0 ? void 0 : _a.find((group) => group.fulfillmentGroupId === fulfillmentGroupId);
+                if (fulfillmentGroup) {
+                    fulfillmentType = fulfillmentGroup.fulfillmentType.toString();
+                }
+            }
+            else if (orderLineReferenceLine) {
+                const orderReferenceLine = ((_b = orderLineReferenceLine) === null || _b === void 0 ? void 0 : _b.lineNumber) &&
+                    transaction.findLineByLineNumber(orderLineReferenceLine.lineNumber);
+                fulfillmentType = getOrderFulfillmentTypeFromOrderReferenceLine(orderReferenceLine);
+            }
+        }
+    }
+    return fulfillmentType;
+}
+exports.getOrderFulfillmentType = getOrderFulfillmentType;
+function hasPickupItemFulfillment(transactionLine) {
+    if (!(model_1.isVoidableLine(transactionLine) && transactionLine.voided) && !model_1.isVoidingLine(transactionLine)) {
+        if (model_1.isSaleLine(transactionLine) &&
+            transactionLine.fulfillmentGroupId > 0 &&
+            !transactionLine.subscribed &&
+            !transactionLine.sendSale) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.hasPickupItemFulfillment = hasPickupItemFulfillment;
+//# sourceMappingURL=orderUtils.js.map

package/lib/domain/utility/supervisorOverride.d.ts

@@ -0,0 +1,28 @@
+import { IQualificationContext, ITransaction, IUser, QualificationResult, UiBusinessEvent } from "@aptos-scp/scp-component-store-selling-core";
+import { ManualDiscountType } from "@aptos-scp/scp-types-commerce-transaction";
+import { Container } from "inversify";
+import { AllowedDiscountTypes, IAccessPolicyConfig, IAmountLevelThreshold, IFeatureAccessConfig, IPercentLevelThreshold, ISupervisorCredentials } from "../model";
+export declare function eventToConfigKeyMap(): Map<string, string>;
+export declare function getStandardPoliciesPermissionConfigs(diContainer: Container, securityPolicyId: string): IAccessPolicyConfig;
+export declare function getEventConfigs(diContainer: Container, eventType: string): IAccessPolicyConfig;
+export declare function isUserValid(user: IUser): boolean;
+export declare function checkUserSecurityLevel(user: IUser, requiredSecurityLevel: number): boolean;
+export declare function skipSecurityCheck(transaction: ITransaction, eventType: string, supervisor: ISupervisorCredentials, qualificationResult: QualificationResult): boolean;
+export declare function convertDateTimeToDateOnly(date: Date): Date;
+export declare function getOverridableThresholdPercentConfig(diContainer: Container, allowedDiscountType: AllowedDiscountTypes, discountType: ManualDiscountType, uiBusinessEventType: string): IPercentLevelThreshold;
+export declare function getOverridableThresholdAmountConfig(diContainer: Container, allowedDiscountType: AllowedDiscountTypes, discountType: ManualDiscountType, uiBusinessEventType: string): IAmountLevelThreshold;
+export declare function getSecurityPolicyByDiscountTypeConfig(diContainer: Container, allowedDiscountType: AllowedDiscountTypes, uiBusinessEventType: string): string;
+export declare function getMaximumPercentConfig(diContainer: Container, allowedDiscountType: AllowedDiscountTypes, discountType: ManualDiscountType, uiBusinessEventType: string): number;
+export declare function getMaximumAmountConfig(diContainer: Container, allowedDiscountType: AllowedDiscountTypes, discountType: ManualDiscountType, uiBusinessEventType: string): string;
+export declare function getSameDiscountAllowedConfig(diContainer: Container, allowedDiscountType: AllowedDiscountTypes, discountType: ManualDiscountType, uiBusinessEventType: string): number;
+export declare function getDiscountTypeModifier(discountType: ManualDiscountType): string;
+export declare function getPreconfiguredEmployeeOverride(diContainer: Container, discountType: string): string;
+export declare function getFeatureConfig(diContainer: Container, eventType: string): IFeatureAccessConfig;
+/**
+ * UserValidationQualifier is not included in the UiBusinessEvent associated with tax override and tax exempt
+ * (both at item and transaction level) when transaction is resumed. Supervisor override security check is not needed
+ *  on resume since it was already performed on the original suspended transaction,
+ *  hence adding this function to set collected data to add supervisor override line on resumed transaction.
+ */
+export declare function setRestoredSupervisor(uiBusinessEvent: UiBusinessEvent, qualificationResult: QualificationResult): void;
+export declare function bypassConfiguredEmployeeDiscountValueCheck(uiBusinessEvent: UiBusinessEvent, context: IQualificationContext): boolean;

package/lib/domain/utility/supervisorOverride.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 model_1 = require("../model");
+const UIBusinessEventTypes_1 = require("../UIBusinessEventTypes");
+function eventToConfigKeyMap() {
+    return new Map([
+        [UIBusinessEventTypes_1.VOID_ITEM_LINE_EVENT, "itemVoid"],
+        [UIBusinessEventTypes_1.VOID_TRANSACTION_EVENT, "transactionVoid"],
+        [UIBusinessEventTypes_1.MANUAL_ITEM_DISCOUNT_EVENT, "itemDiscounts"],
+        [UIBusinessEventTypes_1.MANUAL_TRANSACTION_DISCOUNT_EVENT, "transactionDiscounts"],
+        [UIBusinessEventTypes_1.FAST_DISCOUNT_EVENT, "fastDiscount"],
+        [UIBusinessEventTypes_1.APPLY_DISCOUNT_EVENT, "applyDiscount"],
+        [UIBusinessEventTypes_1.PRICE_CHANGE_EVENT, "priceOverride"],
+        [UIBusinessEventTypes_1.APPLY_EMPLOYEE_DISCOUNT_EVENT, "associateDiscounts"],
+        [UIBusinessEventTypes_1.APPLY_EMPLOYEE_TRANSACTION_DISCOUNT_EVENT, "associateDiscounts"],
+        [UIBusinessEventTypes_1.ADD_EMPLOYEE_CUSTOMER_EVENT, "addEmployeeCustomer"],
+        [UIBusinessEventTypes_1.MODIFY_EMPLOYEE_MANUAL_DISCOUNT_EVENT, "associateDiscounts"],
+        [UIBusinessEventTypes_1.MODIFY_ITEM_MANUAL_DISCOUNT_EVENT, "itemDiscounts"],
+        [UIBusinessEventTypes_1.MODIFY_TRANSACTION_MANUAL_DISCOUNT_EVENT, "transactionDiscounts"],
+        [UIBusinessEventTypes_1.POST_VOID_TRANSACTION_EVENT, "postVoid"],
+        [UIBusinessEventTypes_1.POST_VOID_RESTORED_TRANSACTION_EVENT, "postVoid"],
+        [UIBusinessEventTypes_1.CLOSE_TERMINAL_EVENT, "openCloseTerminal"],
+        [UIBusinessEventTypes_1.OPEN_TERMINAL_EVENT, "openCloseTerminal"],
+        [UIBusinessEventTypes_1.RETURN_TOTAL_EVENT, "returnItemsWithoutReceipt"],
+        [UIBusinessEventTypes_1.EXIT_RETURN_MODE_EVENT, "returnItemsWithoutReceipt"],
+        [UIBusinessEventTypes_1.QUANTITY_CHANGE_EVENT, "changeQuantity"],
+        [UIBusinessEventTypes_1.APPLY_SINGLE_USE_COUPON_EVENT, "expiredValidatedCoupons"],
+        [UIBusinessEventTypes_1.LOG_ON_EVENT, "login"],
+        [UIBusinessEventTypes_1.ENTER_ATTENDANT_MODE_EVENT, "login"],
+        [UIBusinessEventTypes_1.TRANSACTION_TAX_EXEMPT_EVENT, "transactionTaxExempt"],
+        [UIBusinessEventTypes_1.ITEM_TAX_EXEMPT_EVENT, "itemTaxExempt"],
+        [UIBusinessEventTypes_1.START_TILL_OUT_EVENT, "tillOut"],
+        [UIBusinessEventTypes_1.START_TILL_IN_EVENT, "tillIn"],
+        [UIBusinessEventTypes_1.START_NO_SALE_EVENT, "noSale"],
+        [UIBusinessEventTypes_1.START_PAID_OUT_EVENT, "paidOut"],
+        [UIBusinessEventTypes_1.START_PAID_IN_EVENT, "paidIn"],
+        [UIBusinessEventTypes_1.START_TILL_AUDIT_EVENT, "tillAudit"],
+        [UIBusinessEventTypes_1.START_TILL_COUNT_EVENT, "tillCount"],
+        [UIBusinessEventTypes_1.START_TILL_TO_BANK_EVENT, "tillToBank"],
+        [UIBusinessEventTypes_1.START_SAFE_TO_TILL_EVENT, "safeToTill"],
+        [UIBusinessEventTypes_1.START_TILL_TO_SAFE_EVENT, "tillToSafe"],
+        [UIBusinessEventTypes_1.APPLY_RETURN_WITH_TRANSACTION_EVENT, "returnWithTransaction"],
+        [UIBusinessEventTypes_1.START_TILL_RECONCILIATION_EVENT, "tillReconciliation"],
+        [UIBusinessEventTypes_1.TRANSACTION_TAX_OVERRIDE_EVENT, "transactionTaxOverride"],
+        [UIBusinessEventTypes_1.ITEM_TAX_OVERRIDE_EVENT, "itemTaxOverride"],
+        [UIBusinessEventTypes_1.TENDER_EXCHANGE_EVENT, "tenderExchange"],
+        [UIBusinessEventTypes_1.START_EXCHANGE_RATE_ENTRY_EVENT, "exchangeRateEntry"],
+        [UIBusinessEventTypes_1.UPLOAD_DEVICE_LOGS_EVENT, "uploadPaymentLogs"],
+        [UIBusinessEventTypes_1.BYPASS_REFUNDED_TAX_FREE_WARNING_EVENT, "bypassRefundedTaxFreeWarning"],
+        [UIBusinessEventTypes_1.REPRINT_LAST_TRANSACTION_RECEIPTS_EVENT, "reprintReceipt"],
+        [UIBusinessEventTypes_1.REPRINT_TRANSACTION_RECEIPTS_EVENT, "reprintReceipt"],
+        [UIBusinessEventTypes_1.REPLACE_FISCAL_DEVICE_EVENT, "swapFiscalDevice"],
+        [UIBusinessEventTypes_1.REPLACE_FISCAL_DEVICE_HOST_EVENT, "swapFiscalDeviceHost"],
+        [UIBusinessEventTypes_1.SETUP_FISCAL_DEVICE_EVENT, "setUpFiscalDevice"],
+    ]);
+}
+exports.eventToConfigKeyMap = eventToConfigKeyMap;
+function getStandardPoliciesPermissionConfigs(diContainer, securityPolicyId) {
+    return diContainer
+        .get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager)
+        .getFunctionalBehaviorValues().securityPolicies.standardPolicies[securityPolicyId];
+}
+exports.getStandardPoliciesPermissionConfigs = getStandardPoliciesPermissionConfigs;
+function getEventConfigs(diContainer, eventType) {
+    const configKey = eventToConfigKeyMap().get(eventType);
+    return diContainer
+        .get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager)
+        .getFunctionalBehaviorValues().securityPolicies.accessPolicies[configKey];
+}
+exports.getEventConfigs = getEventConfigs;
+function isUserValid(user) {
+    if (!user) {
+        return false;
+    }
+    let mergedUser = mergeGlobalUserAndLocationUser(user);
+    return !!(mergedUser && isMergedUserValid(mergedUser));
+}
+exports.isUserValid = isUserValid;
+function checkUserSecurityLevel(user, requiredSecurityLevel) {
+    if (!user) {
+        return false;
+    }
+    let mergedUser = mergeGlobalUserAndLocationUser(user);
+    return !!(mergedUser &&
+        isMergedUserValid(mergedUser) &&
+        mergedUser.securityRole &&
+        parseInt(mergedUser.securityRole.securityLevel, 10) >= requiredSecurityLevel);
+}
+exports.checkUserSecurityLevel = checkUserSecurityLevel;
+function skipSecurityCheck(transaction, eventType, supervisor, qualificationResult) {
+    /**
+     * Security check can be skip when the transaction is resuming for either a transaction resume or transaction
+     * post void
+     * Don't skip security requirements when a supervisor is provided for POST_VOID_RESTORED_TRANSACTION_EVENT
+     */
+    const transactionResumeOrPostVoid = transaction &&
+        transaction.isResuming() &&
+        !(supervisor && eventType === UIBusinessEventTypes_1.POST_VOID_RESTORED_TRANSACTION_EVENT);
+    /**
+     * The security check was disabled by a previous qualifier
+     */
+    const directlyDisabled = qualificationResult.collectedData.get(model_1.CollectedDataKey.DisableSupervisorOverride);
+    return transactionResumeOrPostVoid || directlyDisabled;
+}
+exports.skipSecurityCheck = skipSecurityCheck;
+function convertDateTimeToDateOnly(date) {
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+exports.convertDateTimeToDateOnly = convertDateTimeToDateOnly;
+function mergeGlobalUserAndLocationUser(user) {
+    var _a, _b, _c, _d;
+    return {
+        id: user.id,
+        username: user.username,
+        displayName: user.displayName,
+        firstName: user.firstName,
+        lastName: user.lastName,
+        middleName: user.middleName,
+        preferredLanguage: user.preferredLanguage,
+        securityRole: ((_a = user.retailLocationRole) === null || _a === void 0 ? void 0 : _a.securityRole) ? user.retailLocationRole.securityRole
+            : user.securityRole,
+        accountStatus: ((_b = user.retailLocationRole) === null || _b === void 0 ? void 0 : _b.assignmentStatus) ? convertAssignmentStatusToAccountStatus(user.retailLocationRole.assignmentStatus)
+            : user.accountStatus,
+        effectiveDate: ((_c = user.retailLocationRole) === null || _c === void 0 ? void 0 : _c.effectiveDate) ? user.retailLocationRole.effectiveDate
+            : user.effectiveDate,
+        expirationDate: ((_d = user.retailLocationRole) === null || _d === void 0 ? void 0 : _d.expirationDate) ? user.retailLocationRole.expirationDate
+            : user.expirationDate,
+    };
+}
+function convertAssignmentStatusToAccountStatus(assignmentStatus) {
+    switch (assignmentStatus) {
+        case "Active":
+        case "Inactive":
+        case "Deleted":
+        case "Locked":
+            return assignmentStatus;
+        default:
+            return undefined;
+    }
+}
+function isMergedUserValid(user) {
+    const accountStatus = user.accountStatus;
+    if (!accountStatus || accountStatus !== "Active") {
+        return false;
+    }
+    const nowAsUTC = convertDateTimeToDateOnly(new Date());
+    const expirationDate = user.expirationDate && convertDateTimeToDateOnly(new Date(user.expirationDate));
+    if (expirationDate && expirationDate < nowAsUTC) {
+        return false;
+    }
+    const effectiveDate = user.effectiveDate && convertDateTimeToDateOnly(new Date(user.effectiveDate));
+    if (effectiveDate && effectiveDate > nowAsUTC) {
+        return false;
+    }
+    return true;
+}
+function getFeatureAccessConfig(diContainer, uiBusinessEventType) {
+    const configurationManager = diContainer.get(scp_component_store_selling_core_1.DI_TYPES.IConfigurationManager);
+    const configuredFeatures = configurationManager.getFeaturesValues();
+    const event = configuredFeatures.find((item) => item.uiBusinessEventType === uiBusinessEventType);
+    return event;
+}
+function getPriceChangeInputLimitsConfig(diContainer, uiBusinessEventType) {
+    const event = getFeatureAccessConfig(diContainer, uiBusinessEventType);
+    const priceChangeInputLimits = event && event.limits;
+    return priceChangeInputLimits;
+}
+function getDiscountTypeInputLimitsConfig(diContainer, allowedDiscountType, uiBusinessEventType) {
+    const event = getFeatureAccessConfig(diContainer, uiBusinessEventType);
+    const allowedDiscountTypeInputLimits = event && event.limits && event.limits[allowedDiscountType];
+    return allowedDiscountTypeInputLimits;
+}
+function getDiscountInputLimitsConfig(diContainer, allowedDiscountType, discountTypeLevel, uiBusinessEventType) {
+    const allowedDiscountTypeInputLimits = getDiscountTypeInputLimitsConfig(diContainer, allowedDiscountType, uiBusinessEventType);
+    const inputLimitsConfig = allowedDiscountTypeInputLimits && discountTypeLevel && allowedDiscountTypeInputLimits[discountTypeLevel];
+    return inputLimitsConfig;
+}
+function getOverridableThresholdsConfig(diContainer, allowedDiscountType, discountTypeLevel, uiBusinessEventType) {
+    let inputLimitsConfig;
+    if (uiBusinessEventType === UIBusinessEventTypes_1.PRICE_CHANGE_EVENT) {
+        inputLimitsConfig = getPriceChangeInputLimitsConfig(diContainer, uiBusinessEventType);
+    }
+    else {
+        inputLimitsConfig = getDiscountInputLimitsConfig(diContainer, allowedDiscountType, discountTypeLevel, uiBusinessEventType);
+    }
+    const overridableThresholds = inputLimitsConfig && inputLimitsConfig.overridableThresholds;
+    return overridableThresholds;
+}
+function getOverridableThresholdPercentConfig(diContainer, allowedDiscountType, discountType, uiBusinessEventType) {
+    const discountTypeModifierLevel = discountType && getDiscountTypeModifier(discountType);
+    const overridableThresholds = getOverridableThresholdsConfig(diContainer, allowedDiscountType, discountTypeModifierLevel, uiBusinessEventType);
+    const overridablePercentThresholds = overridableThresholds && overridableThresholds.percent;
+    return overridablePercentThresholds;
+}
+exports.getOverridableThresholdPercentConfig = getOverridableThresholdPercentConfig;
+function getOverridableThresholdAmountConfig(diContainer, allowedDiscountType, discountType, uiBusinessEventType) {
+    const discountTypeModifierLevel = discountType && getDiscountTypeModifier(discountType);
+    const overridableThresholds = getOverridableThresholdsConfig(diContainer, allowedDiscountType, discountTypeModifierLevel, uiBusinessEventType);
+    const overridableAmountThresholds = overridableThresholds && overridableThresholds.amount;
+    return overridableAmountThresholds;
+}
+exports.getOverridableThresholdAmountConfig = getOverridableThresholdAmountConfig;
+function getSecurityPolicyByDiscountTypeConfig(diContainer, allowedDiscountType, uiBusinessEventType) {
+    const event = getFeatureAccessConfig(diContainer, uiBusinessEventType);
+    const securityPolicy = event && event.securityPolicyByDiscountType && event.securityPolicyByDiscountType[allowedDiscountType];
+    return securityPolicy;
+}
+exports.getSecurityPolicyByDiscountTypeConfig = getSecurityPolicyByDiscountTypeConfig;
+function getMaximumPercentConfig(diContainer, allowedDiscountType, discountType, uiBusinessEventType) {
+    const discountTypeModifierLevel = discountType && getDiscountTypeModifier(discountType);
+    const inputLimitsConfig = getDiscountInputLimitsConfig(diContainer, allowedDiscountType, discountTypeModifierLevel, uiBusinessEventType);
+    const overridablePercentThreshold = inputLimitsConfig && inputLimitsConfig.maxPercent;
+    return overridablePercentThreshold;
+}
+exports.getMaximumPercentConfig = getMaximumPercentConfig;
+function getMaximumAmountConfig(diContainer, allowedDiscountType, discountType, uiBusinessEventType) {
+    const discountTypeModifierLevel = discountType && getDiscountTypeModifier(discountType);
+    const inputLimitsConfig = getDiscountInputLimitsConfig(diContainer, allowedDiscountType, discountTypeModifierLevel, uiBusinessEventType);
+    const maximumAmount = inputLimitsConfig && inputLimitsConfig.maxAmount ? inputLimitsConfig.maxAmount : "0";
+    return maximumAmount;
+}
+exports.getMaximumAmountConfig = getMaximumAmountConfig;
+function getSameDiscountAllowedConfig(diContainer, allowedDiscountType, discountType, uiBusinessEventType) {
+    const discountTypeModifierLevel = discountType && getDiscountTypeModifier(discountType);
+    const inputLimitsConfig = getDiscountInputLimitsConfig(diContainer, allowedDiscountType, discountTypeModifierLevel, uiBusinessEventType);
+    const sameDiscountAllowedConfig = inputLimitsConfig && inputLimitsConfig.maximumNumberOfSameDiscountAllowed
+        ? inputLimitsConfig.maximumNumberOfSameDiscountAllowed
+        : 0;
+    return sameDiscountAllowedConfig;
+}
+exports.getSameDiscountAllowedConfig = getSameDiscountAllowedConfig;
+function getDiscountTypeModifier(discountType) {
+    switch (discountType) {
+        case scp_types_commerce_transaction_1.ManualDiscountType.PercentOff:
+            return "percent";
+        case scp_types_commerce_transaction_1.ManualDiscountType.ReplacementUnitPrice:
+        case scp_types_commerce_transaction_1.ManualDiscountType.AmountOff:
+            return "amount";
+        default:
+            return undefined;
+    }
+}
+exports.getDiscountTypeModifier = getDiscountTypeModifier;
+function getPreconfiguredEmployeeOverride(diContainer, discountType) {
+    const event = getFeatureAccessConfig(diContainer, discountType);
+    return (event &&
+        event.preconfiguredOverrides &&
+        event.preconfiguredOverrides.employee &&
+        event.preconfiguredOverrides.employee.valueOverrideSecurityPolicy);
+}
+exports.getPreconfiguredEmployeeOverride = getPreconfiguredEmployeeOverride;
+function getFeatureConfig(diContainer, eventType) {
+    return getFeatureAccessConfig(diContainer, eventType);
+}
+exports.getFeatureConfig = getFeatureConfig;
+/**
+ * UserValidationQualifier is not included in the UiBusinessEvent associated with tax override and tax exempt
+ * (both at item and transaction level) when transaction is resumed. Supervisor override security check is not needed
+ *  on resume since it was already performed on the original suspended transaction,
+ *  hence adding this function to set collected data to add supervisor override line on resumed transaction.
+ */
+function setRestoredSupervisor(uiBusinessEvent, qualificationResult) {
+    const supervisorOverideRestoreInput = uiBusinessEvent.findInput("restoredSupervisorUser");
+    const restoredSupervisor = supervisorOverideRestoreInput && supervisorOverideRestoreInput.inputValue;
+    if (restoredSupervisor) {
+        qualificationResult.setCollectedData(model_1.CollectedDataKey.QualifiedUserRestriction, restoredSupervisor);
+    }
+}
+exports.setRestoredSupervisor = setRestoredSupervisor;
+function bypassConfiguredEmployeeDiscountValueCheck(uiBusinessEvent, context) {
+    const employeeDiscountInput = uiBusinessEvent.findInput(model_1.UiInputKey.EMPLOYEE_DISCOUNT_OVERRIDE);
+    const employeeDiscountOverride = employeeDiscountInput && employeeDiscountInput.inputValue;
+    const isRestoredTransaction = context.transaction.isResuming();
+    const validatedEmployeeDiscountInput = uiBusinessEvent.findInput(model_1.UiInputKey.EMPLOYEE_DISCOUNT_VALIDATED);
+    const validatedEmployeeDiscount = validatedEmployeeDiscountInput && validatedEmployeeDiscountInput.inputValue;
+    if (validatedEmployeeDiscount) {
+        return true;
+    }
+    if (uiBusinessEvent.type === UIBusinessEventTypes_1.APPLY_EMPLOYEE_DISCOUNT_EVENT) {
+        return employeeDiscountOverride || isRestoredTransaction;
+    }
+    else if (uiBusinessEvent.type === UIBusinessEventTypes_1.APPLY_EMPLOYEE_TRANSACTION_DISCOUNT_EVENT) {
+        return employeeDiscountOverride || isRestoredTransaction;
+    }
+    else if (uiBusinessEvent.type === UIBusinessEventTypes_1.MANUAL_TRANSACTION_DISCOUNT_EVENT) {
+        return isRestoredTransaction;
+    }
+    else if (uiBusinessEvent.type === UIBusinessEventTypes_1.MANUAL_ITEM_DISCOUNT_EVENT) {
+        return employeeDiscountOverride || isRestoredTransaction;
+    }
+    else {
+        return false;
+    }
+}
+exports.bypassConfiguredEmployeeDiscountValueCheck = bypassConfiguredEmployeeDiscountValueCheck;
+//# sourceMappingURL=supervisorOverride.js.map

package/lib/domain/utility/utils.d.ts

@@ -0,0 +1,12 @@
+import { IConfigurationManager, ITransaction, PosError } from "@aptos-scp/scp-component-store-selling-core";
+import { IServiceResult, MerchandiseTransactionTradeType } from "@aptos-scp/scp-types-commerce-transaction";
+import { CountryAddressFormat } from "../model";
+export declare function getAddressFormatorDefault(configurationManager: IConfigurationManager, countryCode: string, i18nLocation: string): CountryAddressFormat;
+export declare function getLocaleCodeForTranslationSet<T>(translationSet: {
+    [key: string]: T;
+}, locale: string): string;
+export declare const getTradeType: (transaction: ITransaction) => MerchandiseTransactionTradeType;
+export declare const isTimeOutError: (error: PosError) => boolean;
+export declare const getServiceResult: (isSuccess: boolean, error?: Error, statusCode?: number) => IServiceResult;
+export declare function mapStartTillEventTypeToLineType(): Map<string, string>;
+export declare function mapEventTypeToTransferType(): Map<string, string>;