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

package/lib/domain/model/TenderAuthorizationSession.js

@@ -0,0 +1,337 @@
+"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 logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.domain.model.TenderAuthorizationSession");
+var TenderAuthorizationState;
+(function (TenderAuthorizationState) {
+    TenderAuthorizationState["InProgress"] = "InProgress";
+    TenderAuthorizationState["WaitingForSignature"] = "WaitingForSignature";
+    TenderAuthorizationState["WaitingForReversal"] = "WaitingForReversal";
+    TenderAuthorizationState["WaitingForTransactionVoid"] = "WaitingForTransactionVoid";
+    TenderAuthorizationState["WaitingForCallforAuthorization"] = "WaitingForCallforAuthorization";
+    TenderAuthorizationState["Completed"] = "Completed";
+    TenderAuthorizationState["BalanceInquiryInProgress"] = "BalanceInquiryInProgress";
+    TenderAuthorizationState["GiftCardIssueInProgress"] = "GiftCardIssueInProgress";
+    TenderAuthorizationState["GiftCardRefundInProgress"] = "GiftCardRefundInProgress";
+    TenderAuthorizationState["WaitingForPartialAuthorizationApproval"] = "waitingForPartialAuthorizationApproval";
+    TenderAuthorizationState["WaitingForRetryLastAuthorization"] = "WaitingForRetryLastAuthorization";
+    TenderAuthorizationState["WaitingForNonIntegratedInput"] = "WaitingForNonIntegratedInput";
+    TenderAuthorizationState["WaitingForTenderAuthManualReversal"] = "WaitingForTenderAuthManualReversal";
+    TenderAuthorizationState["CancelInProgress"] = "CancelInProgress";
+    TenderAuthorizationState["TokenRetrievalInProgress"] = "TokenRetrievalInProgress";
+    TenderAuthorizationState["TenderVoidInProgress"] = "TenderVoidInProgress";
+    TenderAuthorizationState["WaitingForCashoutConfirmation"] = "WaitingForCashoutConfirmation";
+})(TenderAuthorizationState = exports.TenderAuthorizationState || (exports.TenderAuthorizationState = {}));
+var AuthorizationMode;
+(function (AuthorizationMode) {
+    AuthorizationMode["Item"] = "Item";
+    AuthorizationMode["Tender"] = "Tender";
+})(AuthorizationMode = exports.AuthorizationMode || (exports.AuthorizationMode = {}));
+const TenderAuthorizationStateNumericMap = {
+    0: "InProgress",
+    1: "WaitingForSignature",
+    2: "WaitingForReversal",
+    3: "WaitingForTransactionVoid",
+    4: "WaitingForCallforAuthorization",
+    5: "Completed",
+    6: "BalanceInquiryInProgress",
+    7: "GiftCardIssueInProgress",
+    8: "waitingForPartialAuthorizationApproval",
+    9: "GiftCardRefundInProgress",
+    10: "TenderVoidInProgress",
+};
+exports.TENDER_AUTH_SESSION = "TenderAuthSession";
+class TenderAuthorizationSession {
+    constructor(state, lineNumber, inputs, offlineAuthorizationFields, authorizationMode = AuthorizationMode.Tender, requiredInputs = undefined, nonIntegratedFields, cashoutAmount, cashoutThreshold, tenderAuthCategory) {
+        this._type = exports.TENDER_AUTH_SESSION;
+        this._state = state;
+        this._lineNumber = lineNumber;
+        this._offlineAuthorizationFields = offlineAuthorizationFields;
+        this._authorizationMode = authorizationMode;
+        this._inputs = inputs;
+        this._requiredInputs = requiredInputs;
+        this._nonIntegratedFields = nonIntegratedFields;
+        this._cashoutAmount = cashoutAmount;
+        this._cashoutThreshold = cashoutThreshold;
+        this._tenderAuthCategory = tenderAuthCategory;
+    }
+    static createFromJsonObject(tenderAuthorizationSessionJsonObj) {
+        logger.traceEntry("createFromJsonObject");
+        // Note: the _type property is set by the constructor to a constant value.
+        const state = typeof tenderAuthorizationSessionJsonObj._state === "number"
+            ? TenderAuthorizationStateNumericMap[tenderAuthorizationSessionJsonObj._state]
+            : tenderAuthorizationSessionJsonObj._state;
+        const lineNumber = tenderAuthorizationSessionJsonObj._lineNumber;
+        const offlineAuthorizationFields = loadOfflineAuthorizationFields(tenderAuthorizationSessionJsonObj);
+        const authorizationMode = tenderAuthorizationSessionJsonObj._authorizationMode;
+        let inputs = undefined;
+        //deserialize inputs from json into UiInput objects
+        if (tenderAuthorizationSessionJsonObj._inputs) {
+            inputs = [];
+            if (tenderAuthorizationSessionJsonObj._inputs) {
+                for (const input of tenderAuthorizationSessionJsonObj._inputs) {
+                    inputs.push(new scp_component_store_selling_core_1.UiInput(input._inputKey, input._inputValue, input._inputType, input._inputOptions));
+                }
+            }
+        }
+        const requiredInputs = tenderAuthorizationSessionJsonObj._requiredInputs;
+        const cashoutAmount = tenderAuthorizationSessionJsonObj._cashoutAmount &&
+            scp_component_business_core_1.Money.fromJSON(tenderAuthorizationSessionJsonObj._cashoutAmount);
+        const cashoutThreshold = tenderAuthorizationSessionJsonObj._cashoutThreshold &&
+            scp_component_business_core_1.Money.fromJSON(tenderAuthorizationSessionJsonObj._cashoutThreshold);
+        return new TenderAuthorizationSession(state, lineNumber, inputs, offlineAuthorizationFields, authorizationMode, requiredInputs, undefined, cashoutAmount, cashoutThreshold);
+    }
+    static create() {
+        logger.traceEntry("create");
+        return new TenderAuthorizationSession(TenderAuthorizationState.Completed, undefined, undefined, undefined);
+    }
+    get type() {
+        return this._type;
+    }
+    get lineNumber() {
+        return this._lineNumber;
+    }
+    get offlineAuthorizationFields() {
+        return this._offlineAuthorizationFields;
+    }
+    get authorizationAmount() {
+        return this._offlineAuthorizationFields && this._offlineAuthorizationFields.authorizationAmount;
+    }
+    get authorizationMode() {
+        return this._authorizationMode;
+    }
+    get state() {
+        return this._state;
+    }
+    get inputs() {
+        return this._inputs;
+    }
+    get nonIntegratedFields() {
+        return this._nonIntegratedFields;
+    }
+    get cashoutAmount() {
+        return this._cashoutAmount;
+    }
+    get cashoutThreshold() {
+        return this._cashoutThreshold;
+    }
+    get requiredInputs() {
+        return this._requiredInputs;
+    }
+    get tenderAuthCategory() {
+        return this._tenderAuthCategory;
+    }
+    get stateValues() {
+        logger.traceEntry("get stateValues");
+        return new Map([
+            ["TenderAuthorizationSession.authorizationAmount", this.authorizationAmount],
+            ["TenderAuthorizationSession.lineNumber", this.lineNumber],
+            ["TenderAuthorizationSession.authorizationMode", this.authorizationMode],
+            ["TenderAuthorizationSession.state", this._state],
+            ["TenderAuthorizationSession.requiredInputs", this._requiredInputs],
+            ["TenderAuthorizationSession.offlineAuthorizationFields", this._offlineAuthorizationFields],
+            ["TenderAuthorizationSession.nonIntegratedFields", this._nonIntegratedFields],
+            ["TenderAuthorizationSession.isAuthorizationDeviceActive", this.isAuthorizationDeviceActive],
+            ["TenderAuthorizationSession.inWaitingForCashoutConfirmation", this.inWaitingForCashoutConfirmation],
+            ["TenderAuthorizationSession.cashoutAmount", this.cashoutAmount],
+            ["TenderAuthorizationSession.cashoutThreshold", this.cashoutThreshold],
+            ["TenderAuthorizationSession.tenderAuthCategory", this.tenderAuthCategory],
+            [
+                "TenderAuthorizationSession.inWaitingForPartialAuthorizationApproval",
+                this.inWaitingForPartialAuthorizationApproval,
+            ],
+        ]);
+    }
+    get inProgress() {
+        return (this._state === TenderAuthorizationState.InProgress ||
+            this._state === TenderAuthorizationState.TenderVoidInProgress);
+    }
+    get inWaitingForSignature() {
+        return this._state === TenderAuthorizationState.WaitingForSignature;
+    }
+    get inWaitingForCashoutConfirmation() {
+        return this._state === TenderAuthorizationState.WaitingForCashoutConfirmation;
+    }
+    get inWaitingForReversal() {
+        return this._state === TenderAuthorizationState.WaitingForReversal;
+    }
+    get inWaitingForCallforAuthorization() {
+        return this._state === TenderAuthorizationState.WaitingForCallforAuthorization;
+    }
+    get inWaitingForRetryLastAuthorization() {
+        return this._state === TenderAuthorizationState.WaitingForRetryLastAuthorization;
+    }
+    get inWaitingForTenderAuthManualReversal() {
+        return this._state === TenderAuthorizationState.WaitingForTenderAuthManualReversal;
+    }
+    get inCancelInProgress() {
+        return this._state === TenderAuthorizationState.CancelInProgress;
+    }
+    get completed() {
+        return this._state === TenderAuthorizationState.Completed;
+    }
+    get inBalanceInquiryInProgress() {
+        return this._state === TenderAuthorizationState.BalanceInquiryInProgress;
+    }
+    get inGiftCardIssueInProgress() {
+        return this._state === TenderAuthorizationState.GiftCardIssueInProgress;
+    }
+    get inGiftCardRefundInProgress() {
+        return this._state === TenderAuthorizationState.GiftCardRefundInProgress;
+    }
+    get inWaitingForPartialAuthorizationApproval() {
+        return this._state === TenderAuthorizationState.WaitingForPartialAuthorizationApproval;
+    }
+    get inWaitingForTransactionVoid() {
+        return this._state === TenderAuthorizationState.WaitingForTransactionVoid;
+    }
+    get inWaitingForNonIntegratedInput() {
+        return this._state === TenderAuthorizationState.WaitingForNonIntegratedInput;
+    }
+    get inTokenRetrievalInProgress() {
+        return this._state === TenderAuthorizationState.TokenRetrievalInProgress;
+    }
+    get inTenderVoidInProgress() {
+        return this._state === TenderAuthorizationState.TenderVoidInProgress;
+    }
+    get isAuthorizationDeviceActive() {
+        return (this.inGiftCardIssueInProgress ||
+            this.inBalanceInquiryInProgress ||
+            this.inWaitingForReversal ||
+            this.inWaitingForTransactionVoid ||
+            this.inCancelInProgress ||
+            this.inProgress ||
+            this.inGiftCardRefundInProgress ||
+            this.inTokenRetrievalInProgress ||
+            this.inTenderVoidInProgress);
+    }
+    startAuthorization(lineNumber, tenderAuthCategory) {
+        logger.traceEntry("startAuthorization");
+        if (this.inWaitingForTransactionVoid) {
+            return new TenderAuthorizationSession(TenderAuthorizationState.WaitingForTransactionVoid, lineNumber, this.inputs, undefined);
+        }
+        else {
+            return this.startInProgress(lineNumber, tenderAuthCategory);
+        }
+    }
+    startInProgress(lineNumber, tenderAuthCategory, authorizationMode = AuthorizationMode.Tender) {
+        logger.traceEntry("startInProgress");
+        return this.inProgress
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.InProgress, lineNumber, undefined, undefined, authorizationMode, undefined, undefined, undefined, undefined, tenderAuthCategory);
+    }
+    startTenderVoid(lineNumber, tenderAuthCategory) {
+        logger.traceEntry("startTenderVoid");
+        return this.inTenderVoidInProgress
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.TenderVoidInProgress, lineNumber, undefined, undefined, undefined, undefined, undefined, undefined, undefined, tenderAuthCategory);
+    }
+    startBalanceInquiry(lineNumber) {
+        logger.traceEntry("startBalanceInquiry");
+        return this.inBalanceInquiryInProgress
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.BalanceInquiryInProgress, lineNumber, undefined, undefined);
+    }
+    startGiftCardIssue(lineNumber) {
+        logger.traceEntry("startGiftCardIssue");
+        return this.inGiftCardIssueInProgress
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.GiftCardIssueInProgress, lineNumber, undefined, undefined, AuthorizationMode.Item);
+    }
+    startGiftCardRefund(lineNumber) {
+        logger.traceEntry("startGiftCardRefund");
+        return this.inGiftCardRefundInProgress
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.GiftCardRefundInProgress, lineNumber, undefined, undefined);
+    }
+    startWaitingForPartialAuthorizationApproval(lineNumber) {
+        logger.traceEntry("startWaitingForPartialAuthorizationApproval");
+        return this.inWaitingForPartialAuthorizationApproval
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.WaitingForPartialAuthorizationApproval, lineNumber, undefined, undefined);
+    }
+    waitForSignature() {
+        logger.traceEntry("startSignature");
+        return this.inWaitingForSignature
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.WaitingForSignature, undefined, undefined, undefined);
+    }
+    waitForCashoutConfirmation(lineNumber, amount, threshold) {
+        logger.traceEntry("waitForCashoutConfirmation");
+        return this.inWaitingForCashoutConfirmation
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.WaitingForCashoutConfirmation, lineNumber, undefined, undefined, undefined, undefined, undefined, amount, threshold);
+    }
+    waitForCallforAuthorization(lineNumber, offlineAuthorizationFields, authorizationMode) {
+        logger.traceEntry("waitForCallforAuthorization");
+        return this.inWaitingForCallforAuthorization
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.WaitingForCallforAuthorization, lineNumber, undefined, offlineAuthorizationFields, authorizationMode);
+    }
+    waitForTokenRetrieval(lineNumber) {
+        logger.traceEntry("waitForTokenRetrieval");
+        return this.inTokenRetrievalInProgress
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.TokenRetrievalInProgress, lineNumber, undefined, undefined, AuthorizationMode.Item);
+    }
+    waitForRetryLastAuthorization(lineNumber) {
+        logger.traceEntry("waitForRetryLastAuthorization");
+        return this.inWaitingForCallforAuthorization
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.WaitingForRetryLastAuthorization, lineNumber, undefined, undefined);
+    }
+    waitForNonIntegratedInput(lineNumber, requiredInputs, nonIntegratedFields) {
+        logger.traceEntry("waitForNonIntegratedInput");
+        return this.inWaitingForNonIntegratedInput
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.WaitingForNonIntegratedInput, lineNumber, this._inputs, undefined, undefined, requiredInputs, nonIntegratedFields);
+    }
+    waitForTenderAuthManualReversal(lineNumber) {
+        logger.traceEntry("waitForTenderAuthManualReversal");
+        return this.inWaitingForTenderAuthManualReversal
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.WaitingForTenderAuthManualReversal, lineNumber, undefined, undefined);
+    }
+    startTenderAuthManualReversal(lineNumber) {
+        logger.traceEntry("startTenderAuthManualReversal");
+        return this.inCancelInProgress
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.CancelInProgress, lineNumber, undefined, undefined);
+    }
+    startReversal(lineNumber) {
+        logger.traceEntry("startReversal");
+        return this.inWaitingForReversal
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.WaitingForReversal, lineNumber, undefined, undefined);
+    }
+    saveInputs(uiInputs) {
+        logger.traceEntry("saveInputs");
+        return new TenderAuthorizationSession(this._state, this._lineNumber, uiInputs, undefined);
+    }
+    stop() {
+        logger.traceEntry("stop");
+        return this.completed
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.Completed, undefined, undefined, undefined);
+    }
+    startVoidTransaction(lineNumber) {
+        logger.traceEntry("startVoidTransaction");
+        return this.inWaitingForTransactionVoid
+            ? this
+            : new TenderAuthorizationSession(TenderAuthorizationState.WaitingForTransactionVoid, lineNumber, this._inputs, undefined);
+    }
+}
+exports.TenderAuthorizationSession = TenderAuthorizationSession;
+function loadOfflineAuthorizationFields(tenderAuthorizationSessionJsonObj) {
+    return (tenderAuthorizationSessionJsonObj &&
+        tenderAuthorizationSessionJsonObj._offlineAuthorizationFields && {
+        phoneNumber: tenderAuthorizationSessionJsonObj._offlineAuthorizationFields.phoneNumber,
+        maskedCardNumber: tenderAuthorizationSessionJsonObj._offlineAuthorizationFields.maskedCardNumber,
+        authorizationAmount: tenderAuthorizationSessionJsonObj._offlineAuthorizationFields.authorizationAmount &&
+            new scp_component_business_core_1.Money(tenderAuthorizationSessionJsonObj._offlineAuthorizationFields.authorizationAmount.amount, tenderAuthorizationSessionJsonObj._offlineAuthorizationFields.authorizationAmount.currency),
+        originalRequestType: tenderAuthorizationSessionJsonObj._offlineAuthorizationFields.originalRequestType,
+    });
+}
+//# sourceMappingURL=TenderAuthorizationSession.js.map

package/lib/domain/model/TenderControlTransaction.d.ts

@@ -0,0 +1,30 @@
+import { DeviceIdentity, ITransaction, ITransactionLine, ITransactionLineFactory, IUser } from "@aptos-scp/scp-component-store-selling-core";
+import { ITransactionReferenceFormatter } from "../service";
+import { RetailTransaction } from "./RetailTransaction";
+import { IFiscalSignature } from "@aptos-scp/scp-types-commerce-transaction";
+export declare const TENDER_CONTROL_TRANSACTION_TYPE = "TenderControlTransaction";
+export declare class TenderControlTransaction extends RetailTransaction {
+    private _accountingCurrency;
+    private _referenceNumber;
+    private _transactionReferenceFormatter;
+    private _fiscalTransactionNumber;
+    private _fiscalSignature;
+    static createFromJsonObj(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory, transactionReferenceFormatter: ITransactionReferenceFormatter): TenderControlTransaction;
+    constructor(deviceIdentity: DeviceIdentity, businessDayDate: string, transactionNumber: number, user?: IUser, transactionId?: string, accountingCurrency?: string, transactionReferenceFormatter?: ITransactionReferenceFormatter, fiscalTransactionNumber?: string, fiscalSignature?: IFiscalSignature);
+    clone(): ITransaction;
+    assignFiscalSignature(signatureData: IFiscalSignature): ITransaction;
+    assignFiscalTransactionNumber(fiscalTransactionNumber: string): ITransaction;
+    get accountingCurrency(): string;
+    get referenceNumber(): string;
+    get isTenderExchangeTransaction(): boolean;
+    get isCompleteTenderExchangeTransaction(): boolean;
+    get transactionStateValues(): Readonly<Map<string, any>>;
+    get fiscalTransactionNumber(): string;
+    get fiscalSignature(): IFiscalSignature;
+    findLineByLineNumber(lineNumber: number): ITransactionLine;
+    toJSON(): object;
+    protected newTransaction(): RetailTransaction;
+    protected loadFromJsonObject(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory): void;
+    private generateTransactionReferenceNumber;
+}
+export declare const isTenderControlTransaction: (transaction: ITransaction) => transaction is TenderControlTransaction;

package/lib/domain/model/TenderControlTransaction.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_store_selling_core_1 = require("@aptos-scp/scp-component-store-selling-core");
+const config_1 = require("../../config");
+const RetailTransaction_1 = require("./RetailTransaction");
+const tender_1 = require("./tender");
+exports.TENDER_CONTROL_TRANSACTION_TYPE = "TenderControlTransaction";
+class TenderControlTransaction extends RetailTransaction_1.RetailTransaction {
+    constructor(deviceIdentity, businessDayDate, transactionNumber, user, transactionId, accountingCurrency, transactionReferenceFormatter, fiscalTransactionNumber, fiscalSignature) {
+        super(deviceIdentity, businessDayDate, transactionNumber, exports.TENDER_CONTROL_TRANSACTION_TYPE, user, transactionId);
+        this._accountingCurrency = accountingCurrency;
+        this._transactionReferenceFormatter = transactionReferenceFormatter;
+        this._fiscalTransactionNumber = fiscalTransactionNumber;
+        this._fiscalSignature = fiscalSignature;
+    }
+    static createFromJsonObj(transactionJsonObj, transactionLineFactory, transactionReferenceFormatter) {
+        const transactionId = RetailTransaction_1.RetailTransaction.getTransactionIdFromJsonObject(transactionJsonObj);
+        const deviceIdentity = RetailTransaction_1.RetailTransaction.getDeviceIdentityFromJsonObject(transactionJsonObj);
+        const businessDayDate = RetailTransaction_1.RetailTransaction.getBusinessDayDateFromJsonObject(transactionJsonObj);
+        const transactionNumber = RetailTransaction_1.RetailTransaction.getTransactionNumberFromJsonObject(transactionJsonObj);
+        const performingUser = RetailTransaction_1.RetailTransaction.getPerformingUserFromJsonObject(transactionJsonObj);
+        const accountingCurrency = transactionJsonObj._accountingCurrency;
+        const transaction = new TenderControlTransaction(deviceIdentity, businessDayDate, transactionNumber, performingUser, transactionId, accountingCurrency, transactionReferenceFormatter);
+        transaction.updateAccountabilityMode(transactionJsonObj._tillAccountabilityMode, transactionJsonObj._cashDrawerAccessMode);
+        transaction.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+        return transaction;
+    }
+    clone() {
+        const transaction = super.clone();
+        if (exports.isTenderControlTransaction(transaction)) {
+            transaction._accountingCurrency = this._accountingCurrency;
+            transaction._transactionReferenceFormatter = this._transactionReferenceFormatter;
+            transaction._referenceNumber = this._referenceNumber;
+            transaction._fiscalTransactionNumber = this._fiscalTransactionNumber;
+            transaction._fiscalSignature = this._fiscalSignature;
+        }
+        else {
+            throw new scp_component_store_selling_core_1.PosError("Cannot clone TenderControlTransaction, because new " + "instance is not a TenderControlTransaction.", config_1.SSF_TRANSACTION_ERROR_CODE);
+        }
+        return transaction;
+    }
+    assignFiscalSignature(signatureData) {
+        const newTransaction = this.clone();
+        newTransaction._fiscalSignature = signatureData;
+        return newTransaction;
+    }
+    assignFiscalTransactionNumber(fiscalTransactionNumber) {
+        const newTransaction = this.clone();
+        newTransaction._fiscalTransactionNumber = fiscalTransactionNumber;
+        return newTransaction;
+    }
+    get accountingCurrency() {
+        return this._accountingCurrency;
+    }
+    get referenceNumber() {
+        if (super.isOpen() && this._referenceNumber === undefined) {
+            this.generateTransactionReferenceNumber(this);
+        }
+        return this._referenceNumber;
+    }
+    get isTenderExchangeTransaction() {
+        return !!(this.lines && this.lines.find(tender_1.isStartTenderExchangeLine));
+    }
+    get isCompleteTenderExchangeTransaction() {
+        return (this.isTenderExchangeTransaction &&
+            !!(this.lines.find((line) => tender_1.isTenderExchangeLine && line.lineType === tender_1.TENDER_EXCHANGE_IN_LINE_TYPE) &&
+                this.lines.find((line) => tender_1.isTenderExchangeLine && line.lineType === tender_1.TENDER_EXCHANGE_OUT_LINE_TYPE)));
+    }
+    get transactionStateValues() {
+        return new Map([
+            ...super.transactionStateValues.entries(),
+            ["transaction.referenceNumber", this._referenceNumber],
+            ["transaction.accountingCurrency", this._accountingCurrency],
+            ["transaction.isTenderExchangeTransaction", this.isTenderExchangeTransaction],
+        ]);
+    }
+    get fiscalTransactionNumber() {
+        return this._fiscalTransactionNumber;
+    }
+    get fiscalSignature() {
+        return this._fiscalSignature;
+    }
+    findLineByLineNumber(lineNumber) {
+        if (lineNumber && super.lines.length > 0) {
+            return super.findLineByLineNumber(lineNumber);
+        }
+        return undefined;
+    }
+    //Any new property needs to added here as well.
+    //Overridden toJSON to ensure that circular reference does not fail the transaction
+    //when storing in local memory and loading back as json object
+    toJSON() {
+        return {
+            _transactionId: super.transactionId,
+            _deviceIdentity: super.deviceIdentity,
+            _businessDayDate: super.businessDayDate,
+            _transactionNumber: super.transactionNumber,
+            _transactionType: super.transactionType,
+            _performingUser: super.performingUser,
+            _startDateTime: super.startDateTime,
+            _endDateTime: super.endDateTime,
+            _timezoneOffsetInMinutes: super.timezoneOffsetInMinutes,
+            _lines: super.lines,
+            _state: super.state,
+            _voided: super.voided,
+            _closingState: super.closingState,
+            _resumeToken: super.resumeToken,
+            _accountingCurrency: this.accountingCurrency,
+            _referenceNumber: this.referenceNumber,
+            _fiscalTransactionNumber: this.fiscalTransactionNumber,
+            _fiscalSignature: this.fiscalSignature,
+        };
+    }
+    newTransaction() {
+        return new TenderControlTransaction(this.deviceIdentity, this.businessDayDate, this.transactionNumber, this.performingUser, this.transactionId, this.accountingCurrency, this._transactionReferenceFormatter, this.fiscalTransactionNumber, this.fiscalSignature);
+    }
+    loadFromJsonObject(transactionJsonObj, transactionLineFactory) {
+        var _a, _b;
+        super.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+        this._referenceNumber = transactionJsonObj._referenceNumber;
+        if ((_a = transactionJsonObj) === null || _a === void 0 ? void 0 : _a._fiscalTransactionNumber) {
+            this._fiscalTransactionNumber = transactionJsonObj._fiscalTransactionNumber;
+        }
+        if ((_b = transactionJsonObj) === null || _b === void 0 ? void 0 : _b._fiscalSignature) {
+            this._fiscalSignature = transactionJsonObj._fiscalSignature;
+        }
+    }
+    generateTransactionReferenceNumber(transaction) {
+        this._referenceNumber = this._transactionReferenceFormatter.generateTransactionReference(transaction);
+    }
+}
+exports.TenderControlTransaction = TenderControlTransaction;
+exports.isTenderControlTransaction = (transaction) => {
+    var _a;
+    return (transaction instanceof TenderControlTransaction ||
+        ((_a = transaction) === null || _a === void 0 ? void 0 : _a.transactionType) === exports.TENDER_CONTROL_TRANSACTION_TYPE);
+};
+//# sourceMappingURL=TenderControlTransaction.js.map

package/lib/domain/model/TenderHandlingSession.d.ts

@@ -0,0 +1,100 @@
+import { Money } from "@aptos-scp/scp-component-business-core";
+import { IConfigurationValues, IState } from "@aptos-scp/scp-component-store-selling-core";
+import { IPaymentProviderSpecificInfo, TenderSubType, TenderType } from "@aptos-scp/scp-types-commerce-devices";
+import { IOtherTransactionLineReference, ITransactionReference } from "@aptos-scp/scp-types-commerce-transaction";
+import { TransactionWithAdditionalData } from "@aptos-scp/scp-types-ss-transaction-history";
+import { TenderAdjustmentType, TenderAuthCategory } from "./Constants";
+import { TenderAuthorizationStatusLine } from "./tender";
+export declare const TENDER_SESSION: string;
+export declare enum TenderHandlingSessionState {
+    InProgress = "InProgress",
+    Completed = "Completed"
+}
+export interface IOriginalTransactionDetails {
+    originalTransactionId: string;
+    originalTenders: IOriginalTender[];
+    originalTransactionReferenceNumber: string;
+    orderReferenceNumber: string;
+    returnTotalAmount: Money;
+    cancelTotalAmount: Money;
+    refundedAmount: Money;
+}
+export interface IOriginalTender {
+    /**
+     * Total amount that can be refunded to the tender
+     */
+    originalTenderAmount: Money;
+    /**
+     * Total amount refunded in the current return for the referenced tender
+     */
+    refundedAmount: Money;
+    /**
+     * Total amount refunded from previous transactions
+     */
+    previouslyRefundedAmount: Money;
+    /**
+     * Refunds is not allowed if:
+     *  The tender has had its full originalTenderAmount refunded outside of the current return
+     */
+    refundAllowed: boolean;
+    showReference: boolean;
+    tenderName: string;
+    tenderId: string;
+    tenderType?: TenderType;
+    tenderAuthCategory: TenderAuthCategory;
+    referenceNumber?: string;
+    maskedCardNumber?: string;
+    cardToken?: string;
+    originalLineReferences: IOriginalLineReference[];
+    paymentProviderSpecificInfo?: IPaymentProviderSpecificInfo;
+    adjustmentType?: TenderAdjustmentType;
+    adjustmentAmount?: Money;
+    subType?: TenderSubType;
+    isForeignTender?: boolean;
+    originalTransactionReferences?: IOriginalTransactionRefundReference[];
+    lastFour?: string;
+    currencyCode?: string;
+    isMappedTender?: boolean;
+    refundableAmount?: Money;
+    mappedOriginTenderId?: string;
+    additionalTenderAuthCategories?: TenderAuthCategory[];
+}
+export interface IOriginalLineReference {
+    lineNumber: number;
+    canonicalSequenceNumber: number;
+    /**
+     * Total amount from the original tender, used to keep track of original tender when unreferenced tenders are combined
+     */
+    originalReferenceTenderAmount?: Money;
+    /**
+     * Previously refunded amount from the original tender,
+     * used to keep track of original tender when unreferenced tenders are combined
+     */
+    originalReferencePreviouslyRefundedAmount?: Money;
+}
+export interface IOriginalTransactionRefundReference {
+    transactionLineReference: IOtherTransactionLineReference;
+    refundableAmount: Money;
+    transactionReference?: ITransactionReference;
+}
+export declare class TenderHandlingSession implements IState {
+    private readonly _type;
+    private readonly _state;
+    private readonly _originalTransactionDetails;
+    static createFromJsonObject(tenderSessionJsonObj: any): TenderHandlingSession;
+    static create(): TenderHandlingSession;
+    get type(): string;
+    get stateValues(): Readonly<Map<string, any>>;
+    complete(): TenderHandlingSession;
+    addOriginalTransaction(originalTransaction: TransactionWithAdditionalData, configuredTenders: IConfigurationValues): TenderHandlingSession;
+    updateOriginalTransactionDetails(originalTransactionDetails: IOriginalTransactionDetails, originalTransactionId: string): TenderHandlingSession;
+    getReferencedOriginalTender(reference: IOriginalTransactionRefundReference): IOriginalTender;
+    getOriginalReferenceNumber(statusLine: TenderAuthorizationStatusLine): string;
+    getOriginalTenderReferenceLineSequenceNumber(reference: IOriginalTransactionRefundReference): number;
+    get activeOriginalTransactionDetails(): IOriginalTransactionDetails[];
+    get originalTransactionDetails(): IOriginalTransactionDetails[];
+    get inProgress(): boolean;
+    private constructor();
+}
+export declare function originalTenderHasOriginalLineNumber(originalTender: IOriginalTender, lineNumber: number): boolean;
+export declare function getOriginalTransactionReferences(transactionId: string, originalLineReferences: IOriginalLineReference[]): IOriginalTransactionRefundReference[];