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

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

@@ -0,0 +1,127 @@
+import { DeviceIdentity, ITransaction, ITransactionLine, ITransactionLineFactory, IUser } from "@aptos-scp/scp-component-store-selling-core";
+import { AccountabilityMode, CashDrawerAccessMode, ITransactionDetails, MerchandiseTransactionClosingState } from "@aptos-scp/scp-types-commerce-transaction";
+export interface ITransactionReference {
+    transactionId: string;
+    retailLocationId: string;
+    deviceId: string;
+    businessDayDate: string;
+    transactionNumber: number;
+}
+export declare abstract class RetailTransaction implements ITransaction {
+    private _transactionId;
+    private _deviceIdentity;
+    private _businessDayDate;
+    private _transactionNumber;
+    private _transactionType;
+    private _performingUser;
+    private _selfService;
+    private _startDateTime;
+    private _endDateTime;
+    private _timezoneOffsetInMinutes;
+    private _lines;
+    private _state;
+    private _originalTransactionDetails;
+    private _resumingLineNumber;
+    private _voided;
+    private _closingState;
+    private _resumeToken;
+    private _cashDrawerKey?;
+    private _cashDrawerInputSource?;
+    private _tillAccountabilityMode?;
+    private _cashDrawerAccessMode?;
+    private _taxFreeFormKey?;
+    private _taxFreeInvoiceNumber?;
+    private _taxFreeInvoiceSequenceNumber?;
+    private _taxFreeInvoiceSequenceNumberGenerator?;
+    private _taxFreeCreditNoteNumber?;
+    private _taxFreeCreditNoteSequenceNumber?;
+    private _taxFreeCreditNoteSequenceNumberGenerator?;
+    private _tillKey?;
+    static getTransactionIdFromJsonObject(transactionJsonObj: any): string;
+    static getDeviceIdentityFromJsonObject(transactionJsonObj: any): DeviceIdentity;
+    static getBusinessDayDateFromJsonObject(transactionJsonObj: any): string;
+    static getTransactionNumberFromJsonObject(transactionJsonObj: any): number;
+    static getTransactionTypeFromJsonObject(transactionJsonObj: any): string;
+    static getPerformingUserFromJsonObject(transactionJsonObj: any): IUser;
+    constructor(deviceIdentity: DeviceIdentity, businessDayDate: string, transactionNumber: number, transactionType: string, performingUser?: IUser, transactionId?: string);
+    clone(): ITransaction;
+    setTransactionProperty(propertyName: string, propertyValue: any): ITransaction;
+    setTransactionProperties(properties: Map<string, any>): ITransaction;
+    get transactionId(): string;
+    get deviceIdentity(): DeviceIdentity;
+    get businessDayDate(): string;
+    get transactionNumber(): number;
+    get transactionType(): string;
+    get performingUser(): IUser;
+    get startDateTime(): Date;
+    get endDateTime(): Date;
+    get timezoneOffsetInMinutes(): number;
+    get closingState(): MerchandiseTransactionClosingState;
+    get resumeToken(): string;
+    get originalTransactionDetails(): ITransactionDetails;
+    get resumingLineNumber(): number;
+    get voided(): boolean;
+    get state(): string;
+    get selfService(): boolean;
+    get cashDrawerKey(): string;
+    get tillKey(): string;
+    get cashDrawerInputSource(): string;
+    get tillAccountabilityMode(): AccountabilityMode;
+    get cashDrawerAccessMode(): CashDrawerAccessMode;
+    get taxFreeFormKey(): string;
+    get taxFreeInvoiceNumber(): string;
+    get taxFreeInvoiceSequenceNumber(): number;
+    get taxFreeInvoiceSequenceNumberGenerator(): string;
+    get taxFreeCreditNoteNumber(): string;
+    get taxFreeCreditNoteSequenceNumber(): number;
+    get taxFreeCreditNoteSequenceNumberGenerator(): string;
+    isNew(): boolean;
+    isOpen(): boolean;
+    isResuming(): boolean;
+    isOpenOrResuming(): boolean;
+    isWaiting(): boolean;
+    isPreparingToClose(): boolean;
+    isReadyToClose(): boolean;
+    isWaitingToClose(): boolean;
+    isClosing(): boolean;
+    isClosed(): boolean;
+    isSuspended(): boolean;
+    isVoided(): boolean;
+    isPostVoid(): boolean;
+    isPostVoidFailed(): boolean;
+    findLineByLineNumber(lineNumber: number): ITransactionLine;
+    findLineIndexByLineNumber(lineNumber: number): number;
+    findLineByLineType(lineType: string): ITransactionLine;
+    findLastLineByLineType(lineType: string): ITransactionLine;
+    start(): ITransaction;
+    prepareToClose(): ITransaction;
+    readyToClose(): ITransaction;
+    resume(originalTransactionDetails?: ITransactionDetails, currentLineNumber?: number): ITransaction;
+    finishResume(): ITransaction;
+    startWaiting(): ITransaction;
+    stopWaiting(): ITransaction;
+    startClosing(): ITransaction;
+    close(): ITransaction;
+    suspend(resumeToken?: string): ITransaction;
+    void(): ITransaction;
+    updateAccountabilityMode(accountabilityMode: AccountabilityMode, cashDrawerAccessMode: CashDrawerAccessMode): RetailTransaction;
+    postVoid(): ITransaction;
+    postVoidFailed(): ITransaction;
+    get lines(): ReadonlyArray<ITransactionLine>;
+    addLine(line: ITransactionLine): ITransaction;
+    replaceLine(transactionLineIndex: number, transactionLine: ITransactionLine): ITransaction;
+    get transactionStateValues(): Readonly<Map<string, any>>;
+    /**
+     * Create a new instance of the final transaction class in the transaction class hierarchy.  This is used by
+     * <code>clone()</code> to get an instance of the correct class.
+     *
+     * Note: Subclasses must implement this to enable clone to work properly.
+     *
+     * @return {RetailTransaction}
+     */
+    protected abstract newTransaction(): RetailTransaction;
+    protected loadFromJsonObject(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory): void;
+    private static generateTransactionId;
+    private loadTransactionLinesFromJsonObject;
+}
+export declare function isRetailTransaction(transaction: ITransaction): transaction is RetailTransaction;

package/lib/domain/model/RetailTransaction.js

@@ -0,0 +1,556 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const uuid = require("uuid");
+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 User_1 = require("./User");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.domain.model.RetailTransaction");
+var RetailTransactionState;
+(function (RetailTransactionState) {
+    RetailTransactionState["New"] = "New";
+    RetailTransactionState["Open"] = "Open";
+    RetailTransactionState["Resuming"] = "Resuming";
+    RetailTransactionState["ResumingWaiting"] = "ResumingWaiting";
+    RetailTransactionState["Waiting"] = "Waiting";
+    RetailTransactionState["PreparingToClose"] = "PreparingToClose";
+    RetailTransactionState["ReadyToClose"] = "ReadyToClose";
+    RetailTransactionState["WaitingToClose"] = "WaitingToClose";
+    RetailTransactionState["Closing"] = "Closing";
+    RetailTransactionState["Closed"] = "Closed";
+})(RetailTransactionState || (RetailTransactionState = {}));
+function findRetailTransactionState(state) {
+    switch (state) {
+        case "New":
+            return RetailTransactionState.New;
+        case "Open":
+            return RetailTransactionState.Open;
+        case "Waiting":
+            return RetailTransactionState.Waiting;
+        case "PreparingToClose":
+            return RetailTransactionState.PreparingToClose;
+        case "ReadyToClose":
+            return RetailTransactionState.ReadyToClose;
+        case "WaitingToClose":
+            return RetailTransactionState.WaitingToClose;
+        case "Closing":
+            return RetailTransactionState.Closing;
+        case "Closed":
+            return RetailTransactionState.Closed;
+        case "Resuming":
+            return RetailTransactionState.Resuming;
+        case "ResumingWaiting":
+            return RetailTransactionState.ResumingWaiting;
+        default:
+            throw new scp_component_store_selling_core_1.PosError(`Unable to determine RetailTransactionState for state: ${state}`, ErrorCodes_1.SSF_TRANSACTION_ERROR_CODE);
+    }
+}
+class RetailTransaction {
+    constructor(deviceIdentity, businessDayDate, transactionNumber, transactionType, performingUser, transactionId) {
+        this._transactionId = transactionId ? transactionId : RetailTransaction.generateTransactionId();
+        this._deviceIdentity = deviceIdentity;
+        this._businessDayDate = businessDayDate;
+        this._transactionNumber = transactionNumber;
+        this._transactionType = transactionType;
+        this._performingUser = performingUser;
+        this._state = RetailTransactionState.New;
+        this._lines = [];
+        this._originalTransactionDetails = undefined;
+        this._resumingLineNumber = undefined;
+        this._voided = false;
+        this._closingState = undefined;
+        this._resumeToken = undefined;
+        this._selfService = undefined;
+        this._cashDrawerKey = undefined;
+        this._cashDrawerInputSource = undefined;
+        this._taxFreeFormKey = undefined;
+        this._tillKey = undefined;
+    }
+    static getTransactionIdFromJsonObject(transactionJsonObj) {
+        return transactionJsonObj._transactionId;
+    }
+    static getDeviceIdentityFromJsonObject(transactionJsonObj) {
+        return scp_component_store_selling_core_1.DeviceIdentity.createFromJsonObject(transactionJsonObj._deviceIdentity);
+    }
+    static getBusinessDayDateFromJsonObject(transactionJsonObj) {
+        return transactionJsonObj._businessDayDate;
+    }
+    static getTransactionNumberFromJsonObject(transactionJsonObj) {
+        return transactionJsonObj._transactionNumber;
+    }
+    static getTransactionTypeFromJsonObject(transactionJsonObj) {
+        return transactionJsonObj._transactionType;
+    }
+    static getPerformingUserFromJsonObject(transactionJsonObj) {
+        return User_1.User.createFromJsonObject(transactionJsonObj._performingUser);
+    }
+    clone() {
+        const transaction = this.newTransaction();
+        transaction._startDateTime = this._startDateTime;
+        transaction._endDateTime = this._endDateTime;
+        transaction._timezoneOffsetInMinutes = this._timezoneOffsetInMinutes;
+        transaction._state = this._state;
+        transaction._performingUser = this._performingUser;
+        // Note: This new lines array still references the original line objects.
+        transaction._lines = [...this._lines];
+        transaction._voided = this._voided;
+        transaction._closingState = this._closingState;
+        transaction._resumeToken = this._resumeToken;
+        transaction._originalTransactionDetails = this._originalTransactionDetails;
+        transaction._resumingLineNumber = this._resumingLineNumber;
+        transaction._selfService = this._selfService;
+        transaction._cashDrawerKey = this._cashDrawerKey;
+        transaction._tillKey = this._tillKey;
+        transaction._cashDrawerInputSource = this._cashDrawerInputSource;
+        transaction._tillAccountabilityMode = this._tillAccountabilityMode;
+        transaction._cashDrawerAccessMode = this._cashDrawerAccessMode;
+        transaction._taxFreeFormKey = this._taxFreeFormKey;
+        transaction._taxFreeInvoiceNumber = this._taxFreeInvoiceNumber;
+        transaction._taxFreeInvoiceSequenceNumber = this._taxFreeInvoiceSequenceNumber;
+        transaction._taxFreeInvoiceSequenceNumberGenerator = this._taxFreeInvoiceSequenceNumberGenerator;
+        transaction._taxFreeCreditNoteNumber = this._taxFreeCreditNoteNumber;
+        transaction._taxFreeCreditNoteSequenceNumber = this._taxFreeCreditNoteSequenceNumber;
+        transaction._taxFreeCreditNoteSequenceNumberGenerator = this._taxFreeCreditNoteSequenceNumberGenerator;
+        return transaction;
+    }
+    setTransactionProperty(propertyName, propertyValue) {
+        const newTransaction = this.clone();
+        const propName = "_" + propertyName;
+        if (newTransaction.hasOwnProperty(propName)) {
+            newTransaction[propName] = propertyValue;
+        }
+        else {
+            throw new scp_component_store_selling_core_1.PosError(`Cannot set property with name ${propertyName} on transaction, ` +
+                `because that property does not exist.`, ErrorCodes_1.SSF_TRANSACTION_ERROR_CODE);
+        }
+        return newTransaction;
+    }
+    setTransactionProperties(properties) {
+        const newTransaction = this.clone();
+        [...properties.entries()].forEach((entry) => {
+            const propName = "_" + entry[0];
+            const value = entry[1];
+            if (newTransaction.hasOwnProperty(propName)) {
+                newTransaction[propName] = value;
+            }
+            else {
+                throw new scp_component_store_selling_core_1.PosError(`Cannot set property with name ${propName} on transaction, ` +
+                    `because that property does not exist.`, ErrorCodes_1.SSF_TRANSACTION_ERROR_CODE);
+            }
+        });
+        return newTransaction;
+    }
+    get transactionId() {
+        return this._transactionId;
+    }
+    get deviceIdentity() {
+        return this._deviceIdentity;
+    }
+    get businessDayDate() {
+        return this._businessDayDate;
+    }
+    get transactionNumber() {
+        return this._transactionNumber;
+    }
+    get transactionType() {
+        return this._transactionType;
+    }
+    get performingUser() {
+        return this._performingUser;
+    }
+    get startDateTime() {
+        return this._startDateTime;
+    }
+    get endDateTime() {
+        return this._endDateTime;
+    }
+    get timezoneOffsetInMinutes() {
+        return this._timezoneOffsetInMinutes;
+    }
+    get closingState() {
+        return this._closingState;
+    }
+    get resumeToken() {
+        return this._resumeToken;
+    }
+    get originalTransactionDetails() {
+        return this._originalTransactionDetails;
+    }
+    get resumingLineNumber() {
+        return this._resumingLineNumber;
+    }
+    get voided() {
+        return this._voided;
+    }
+    get state() {
+        return this._state;
+    }
+    get selfService() {
+        return this._selfService;
+    }
+    get cashDrawerKey() {
+        return this._cashDrawerKey;
+    }
+    get tillKey() {
+        return this._tillKey;
+    }
+    get cashDrawerInputSource() {
+        return this._cashDrawerInputSource;
+    }
+    get tillAccountabilityMode() {
+        return this._tillAccountabilityMode;
+    }
+    get cashDrawerAccessMode() {
+        return this._cashDrawerAccessMode;
+    }
+    get taxFreeFormKey() {
+        return this._taxFreeFormKey;
+    }
+    get taxFreeInvoiceNumber() {
+        return this._taxFreeInvoiceNumber;
+    }
+    get taxFreeInvoiceSequenceNumber() {
+        return this._taxFreeInvoiceSequenceNumber;
+    }
+    get taxFreeInvoiceSequenceNumberGenerator() {
+        return this._taxFreeInvoiceSequenceNumberGenerator;
+    }
+    get taxFreeCreditNoteNumber() {
+        return this._taxFreeCreditNoteNumber;
+    }
+    get taxFreeCreditNoteSequenceNumber() {
+        return this._taxFreeCreditNoteSequenceNumber;
+    }
+    get taxFreeCreditNoteSequenceNumberGenerator() {
+        return this._taxFreeCreditNoteSequenceNumberGenerator;
+    }
+    isNew() {
+        return this._state === RetailTransactionState.New;
+    }
+    isOpen() {
+        return this._state === RetailTransactionState.Open;
+    }
+    isResuming() {
+        return (this._state === RetailTransactionState.Resuming ||
+            this._state === RetailTransactionState.ResumingWaiting);
+    }
+    isOpenOrResuming() {
+        return this.isOpen() || this._state === RetailTransactionState.Resuming;
+    }
+    isWaiting() {
+        return (this._state === RetailTransactionState.Waiting || this._state === RetailTransactionState.ResumingWaiting);
+    }
+    isPreparingToClose() {
+        return this._state === RetailTransactionState.PreparingToClose;
+    }
+    isReadyToClose() {
+        return this._state === RetailTransactionState.ReadyToClose;
+    }
+    isWaitingToClose() {
+        return this._state === RetailTransactionState.WaitingToClose;
+    }
+    isClosing() {
+        return this._state === RetailTransactionState.Closing;
+    }
+    isClosed() {
+        return this._state === RetailTransactionState.Closed;
+    }
+    isSuspended() {
+        return this._closingState === scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.Suspended;
+    }
+    isVoided() {
+        return this._closingState === scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.Voided;
+    }
+    isPostVoid() {
+        return this._closingState === scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.PostVoidCompleted;
+    }
+    isPostVoidFailed() {
+        return this._closingState === scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.PostVoidFailed;
+    }
+    findLineByLineNumber(lineNumber) {
+        return this._lines.find((lineToExamine) => lineToExamine.lineNumber === lineNumber);
+    }
+    findLineIndexByLineNumber(lineNumber) {
+        return this._lines.findIndex((lineToExamine) => lineToExamine.lineNumber === lineNumber);
+    }
+    findLineByLineType(lineType) {
+        return this._lines.find((lineToExamine) => lineToExamine.lineType === lineType);
+    }
+    findLastLineByLineType(lineType) {
+        return [...this._lines]
+            .reverse()
+            .find((lineToExamine) => lineToExamine.lineType === lineType);
+    }
+    start() {
+        let transaction = this;
+        if (this._state === RetailTransactionState.New) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.Open;
+            transaction._startDateTime = new Date();
+            transaction._timezoneOffsetInMinutes = transaction._startDateTime.getTimezoneOffset();
+        }
+        return transaction;
+    }
+    prepareToClose() {
+        let transaction = this;
+        if (this.isOpen()) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.PreparingToClose;
+        }
+        return transaction;
+    }
+    readyToClose() {
+        let transaction = this;
+        if (this.isPreparingToClose()) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.ReadyToClose;
+            // We need the endDateTime for things like receipt formatting that happen at end of transaction.
+            // Receipt formatting happens in the ReadyToClose state, not while in Closing or Closed, so we need to set the
+            // endDateTime here.  It would be more appropriate to set it, when we transition to Closing, since from there, the
+            // transaction state can only go to Closed, and nothing can re-open it at that point.  Unfortunately, that is too
+            // late to get the endDateTime for the receipt, so we set it here.
+            // In the future, we might need to allow a transition from ReadyToClose to Open, but that is not currently allowed
+            // or needed.  If we do need to support that, we need to review whether this should only get set once, or what.
+            // Maybe it should only be set, here, if it is not set, and it should be cleared, if we go back to Open/Waiting.
+            // Or maybe it is OK to always set it here, if the readyToClose method is only used for the transition from Open
+            // to ReadyToClose.
+            transaction._endDateTime = new Date();
+        }
+        return transaction;
+    }
+    resume(originalTransactionDetails, currentLineNumber) {
+        let transaction = this;
+        if (this._state === RetailTransactionState.Open || this._state === RetailTransactionState.Resuming) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.Resuming;
+            transaction._originalTransactionDetails = originalTransactionDetails;
+            transaction._resumingLineNumber = currentLineNumber;
+        }
+        return transaction;
+    }
+    finishResume() {
+        let transaction = this;
+        if (this._state === RetailTransactionState.Resuming) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.Open;
+            transaction._resumingLineNumber = undefined;
+        }
+        return transaction;
+    }
+    // Note: It is up-to the state objects to track what is being waited-for.
+    startWaiting() {
+        let transaction = this;
+        if (this._state === RetailTransactionState.Open) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.Waiting;
+        }
+        else if (this._state === RetailTransactionState.ReadyToClose) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.WaitingToClose;
+        }
+        else if (this._state === RetailTransactionState.Resuming) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.ResumingWaiting;
+        }
+        return transaction;
+    }
+    stopWaiting() {
+        let transaction = this;
+        if (this._state === RetailTransactionState.Waiting) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.Open;
+        }
+        else if (this._state === RetailTransactionState.WaitingToClose) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.ReadyToClose;
+        }
+        else if (this._state === RetailTransactionState.ResumingWaiting) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.Resuming;
+        }
+        return transaction;
+    }
+    startClosing() {
+        let transaction = this;
+        if (this._state === RetailTransactionState.ReadyToClose) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.Closing;
+        }
+        return transaction;
+    }
+    close() {
+        let transaction = this;
+        if (this._state === RetailTransactionState.Closing) {
+            transaction = this.clone();
+            transaction._state = RetailTransactionState.Closed;
+        }
+        return transaction;
+    }
+    suspend(resumeToken) {
+        let transaction = this;
+        if (this._closingState === undefined) {
+            transaction = this.clone();
+            transaction._closingState = scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.Suspended;
+            transaction._resumeToken = resumeToken;
+        }
+        return transaction;
+    }
+    void() {
+        let transaction = this;
+        if (this._closingState === undefined) {
+            transaction = this.clone();
+            transaction._closingState = scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.Voided;
+        }
+        return transaction;
+    }
+    updateAccountabilityMode(accountabilityMode, cashDrawerAccessMode) {
+        const newTransaction = this.clone();
+        newTransaction._tillAccountabilityMode = accountabilityMode;
+        newTransaction._cashDrawerAccessMode = cashDrawerAccessMode;
+        return newTransaction;
+    }
+    postVoid() {
+        let transaction = this;
+        if (this._closingState === undefined) {
+            transaction = this.clone();
+            transaction._closingState = scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.PostVoidCompleted;
+        }
+        return transaction;
+    }
+    postVoidFailed() {
+        let transaction = this;
+        if (this._closingState === undefined ||
+            this._closingState === scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.PostVoidCompleted) {
+            transaction = this.clone();
+            transaction._closingState = scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.PostVoidFailed;
+        }
+        return transaction;
+    }
+    get lines() {
+        return this._lines;
+    }
+    addLine(line) {
+        const logEntryMessage = logger.traceEntry("addLine", line);
+        let transaction = this;
+        if (this._state !== RetailTransactionState.New && this._state !== RetailTransactionState.Closed) {
+            transaction = transaction.clone();
+            transaction._lines = [...this._lines, line];
+            logger.trace("Added new line to (copy of) transaction.");
+        }
+        else {
+            logger.trace("Line was not added, because the transaction was not open.");
+            throw logger.throwing(new scp_component_store_selling_core_1.PosError("Cannot add a line to a transaction that is not open.", ErrorCodes_1.SSF_TRANSACTION_ERROR_CODE), logEntryMessage, scp_component_logging_1.LogLevel.DEBUG);
+        }
+        return logger.traceExit(logEntryMessage, transaction);
+    }
+    replaceLine(transactionLineIndex, transactionLine) {
+        const logEntryMessage = logger.traceEntry("replaceLine", transactionLineIndex, transactionLine);
+        if (this._state === RetailTransactionState.New || this._state === RetailTransactionState.Closed) {
+            throw logger.throwing(new scp_component_store_selling_core_1.PosError("Cannot replace a line in a transaction that is not open.", ErrorCodes_1.SSF_TRANSACTION_ERROR_CODE), logEntryMessage, scp_component_logging_1.LogLevel.DEBUG);
+        }
+        if (transactionLineIndex < 0 || this._lines.length <= transactionLineIndex) {
+            throw logger.throwing(new scp_component_store_selling_core_1.PosError(`Cannot replace a line that is not in the transaction ` +
+                `(index ${transactionLineIndex} out of bounds 0...${this._lines.length - 1}).`, ErrorCodes_1.SSF_TRANSACTION_ERROR_CODE), logEntryMessage, scp_component_logging_1.LogLevel.DEBUG);
+        }
+        const transaction = this.clone();
+        transaction._lines = this._lines.map((lineInTransaction, index) => index === transactionLineIndex ? transactionLine : lineInTransaction);
+        return logger.traceExit(logEntryMessage, transaction);
+    }
+    get transactionStateValues() {
+        return new Map([
+            ["transaction.id", this._transactionId],
+            ["transaction.number", this._transactionNumber],
+            ["transaction.type", this._transactionType],
+            ["transaction.startDateTime", this._startDateTime],
+            ["transaction.endDateTime", this._endDateTime],
+            ["transaction.timezoneOffsetInMinutes", this._timezoneOffsetInMinutes],
+            ["transaction.performingUser.username", this._performingUser && this._performingUser.username],
+            ["transaction.performingUser.firstName", this._performingUser && this._performingUser.firstName],
+            ["transaction.performingUser.lastName", this._performingUser && this._performingUser.lastName],
+            ["transaction.performingUser.middleName", this._performingUser && this._performingUser.middleName],
+            [
+                "transaction.performingUser.preferredLanguage",
+                this._performingUser && this._performingUser.preferredLanguage,
+            ],
+            ["transaction.performingUser.displayName", this._performingUser && this._performingUser.displayName],
+            ["transaction.selfService", this._selfService],
+            ["transaction.open", this.isOpen()],
+            ["transaction.waiting", this.isWaiting()],
+            ["transaction.waitingToClose", this.isWaitingToClose()],
+            ["transaction.closed", this.isClosed()],
+            ["transaction.voided", this.isVoided()],
+            ["transaction.postVoid", this.isPostVoid()],
+            ["transaction.resuming", this.isResuming()],
+            ["transaction.closingState", this._closingState],
+            ["transaction.cashDrawerKey", this._cashDrawerKey],
+            ["transaction.cashDrawerInputSource", this._cashDrawerInputSource],
+            ["transaction.tillAccountabilityMode", this._tillAccountabilityMode],
+            ["transaction.cashDrawerAccessMode", this._cashDrawerAccessMode],
+            ["transaction.taxFreeFormKey", this._taxFreeFormKey],
+            ["transaction.tillKey", this._tillKey],
+        ]);
+    }
+    loadFromJsonObject(transactionJsonObj, transactionLineFactory) {
+        // Note: _transactionId, _deviceIdentity, _businessDayDate, _transactionNumber, _referenceNumber, _transactionType
+        // and _performingUser are set by the constructor.
+        this._startDateTime = new Date(transactionJsonObj._startDateTime);
+        this._endDateTime = transactionJsonObj._endDateTime
+            ? new Date(transactionJsonObj._endDateTime)
+            : undefined;
+        this._timezoneOffsetInMinutes = transactionJsonObj._timezoneOffsetInMinutes;
+        this._lines = this.loadTransactionLinesFromJsonObject(transactionJsonObj._lines, transactionLineFactory);
+        this._state = findRetailTransactionState(transactionJsonObj._state);
+        this._voided = transactionJsonObj._voided;
+        this._closingState = findMerchandiseTransactionClosingState(transactionJsonObj._closingState);
+        this._resumeToken = transactionJsonObj._resumeToken;
+        this._originalTransactionDetails = transactionJsonObj._originalTransactionDetails;
+        this._cashDrawerKey = transactionJsonObj._cashDrawerKey;
+        this._cashDrawerInputSource = transactionJsonObj._cashDrawerInputSource;
+        this._tillAccountabilityMode = transactionJsonObj._tillAccountabilityMode;
+        this._cashDrawerAccessMode = transactionJsonObj._cashDrawerAccessMode;
+        this._taxFreeFormKey = transactionJsonObj._taxFreeFormKey;
+        this._taxFreeInvoiceNumber = transactionJsonObj._taxFreeInvoiceNumber;
+        this._taxFreeInvoiceSequenceNumber = transactionJsonObj._taxFreeInvoiceSequenceNumber;
+        this._taxFreeInvoiceSequenceNumberGenerator = transactionJsonObj._taxFreeInvoiceSequenceNumberGenerator;
+        this._taxFreeCreditNoteNumber = transactionJsonObj._taxFreeCreditNoteNumber;
+        this._taxFreeCreditNoteSequenceNumber = transactionJsonObj._taxFreeCreditNoteSequenceNumber;
+        this._taxFreeCreditNoteSequenceNumberGenerator =
+            transactionJsonObj._taxFreeCreditNoteSequenceNumberGenerator;
+        this._tillKey = transactionJsonObj._tillKey;
+    }
+    static generateTransactionId() {
+        return uuid.v4();
+    }
+    loadTransactionLinesFromJsonObject(linesFromJson, transactionLineFactory) {
+        const transactionLines = [];
+        for (const lineFromJson of linesFromJson) {
+            const transactionLine = transactionLineFactory.createTransactionLineFromJsonObj(lineFromJson);
+            transactionLines.push(transactionLine);
+        }
+        return transactionLines;
+    }
+}
+exports.RetailTransaction = RetailTransaction;
+function isRetailTransaction(transaction) {
+    return (transaction instanceof RetailTransaction ||
+        transaction.transactionType !== undefined);
+    // Note: To be more robust, this should also check for the presence of other required properties.
+}
+exports.isRetailTransaction = isRetailTransaction;
+function findMerchandiseTransactionClosingState(state) {
+    switch (state) {
+        case "Completed":
+            return scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.Completed;
+        case "Suspended":
+            return scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.Suspended;
+        case "Voided":
+            return scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.Voided;
+        case "PostVoidCompleted":
+            return scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.PostVoidCompleted;
+        default:
+            logger.debug(`Unable to determine MerchandiseTransactionClosingState for state: ${state}`);
+            return undefined;
+    }
+}
+//# sourceMappingURL=RetailTransaction.js.map

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

@@ -0,0 +1,4 @@
+export interface ISendSaleInfo {
+    lineNumber: number;
+    sendSale: boolean;
+}