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

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

@@ -0,0 +1,14 @@
+import { DeviceIdentity, ITransaction, ITransactionLineFactory, IUser } from "@aptos-scp/scp-component-store-selling-core";
+import { RetailTransaction } from "./RetailTransaction";
+export declare const TERMINAL_CONTROL_TRANSACTION_TYPE = "TerminalControlTransaction";
+export declare class TerminalControlTransaction extends RetailTransaction {
+    private _offline;
+    static createFromJsonObj(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory): TerminalControlTransaction;
+    constructor(deviceIdentity: DeviceIdentity, businessDayDate: string, transactionNumber: number, user?: IUser, offline?: boolean, transactionId?: string);
+    clone(): ITransaction;
+    get offline(): boolean;
+    get transactionStateValues(): Readonly<Map<string, any>>;
+    protected newTransaction(): RetailTransaction;
+    protected loadFromJsonObject(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory): void;
+}
+export declare const isTerminalControlTransaction: (transaction: ITransaction) => transaction is TerminalControlTransaction;

package/lib/domain/model/TerminalControlTransaction.js

@@ -0,0 +1,55 @@
+"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");
+exports.TERMINAL_CONTROL_TRANSACTION_TYPE = "TerminalControlTransaction";
+class TerminalControlTransaction extends RetailTransaction_1.RetailTransaction {
+    constructor(deviceIdentity, businessDayDate, transactionNumber, user, offline, transactionId) {
+        super(deviceIdentity, businessDayDate, transactionNumber, exports.TERMINAL_CONTROL_TRANSACTION_TYPE, user, transactionId);
+        this._offline = offline;
+    }
+    static createFromJsonObj(transactionJsonObj, transactionLineFactory) {
+        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 offline = transactionJsonObj.offline;
+        const transaction = new TerminalControlTransaction(deviceIdentity, businessDayDate, transactionNumber, performingUser, offline, transactionId);
+        transaction.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+        return transaction;
+    }
+    clone() {
+        const transaction = super.clone();
+        if (exports.isTerminalControlTransaction(transaction)) {
+            transaction._offline = this._offline;
+        }
+        else {
+            throw new scp_component_store_selling_core_1.PosError("Cannot clone TerminalControlTransaction, because new " +
+                "instance is not a TerminalControlTransaction.", config_1.SSF_TRANSACTION_ERROR_CODE);
+        }
+        return transaction;
+    }
+    get offline() {
+        return this._offline;
+    }
+    get transactionStateValues() {
+        return new Map([
+            ...super.transactionStateValues.entries(),
+            ["transaction.offline", this._offline],
+        ]);
+    }
+    newTransaction() {
+        return new TerminalControlTransaction(this.deviceIdentity, this.businessDayDate, this.transactionNumber, this.performingUser, this.offline, this.transactionId);
+    }
+    loadFromJsonObject(transactionJsonObj, transactionLineFactory) {
+        super.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+    }
+}
+exports.TerminalControlTransaction = TerminalControlTransaction;
+exports.isTerminalControlTransaction = (transaction) => {
+    return (transaction instanceof TerminalControlTransaction ||
+        transaction.transactionType === exports.TERMINAL_CONTROL_TRANSACTION_TYPE);
+};
+//# sourceMappingURL=TerminalControlTransaction.js.map

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

@@ -0,0 +1,49 @@
+import { IState } from "@aptos-scp/scp-component-store-selling-core";
+import { AccountabilityMode as PostableTillAccountabilityMode, CashDrawerAccessMode } from "@aptos-scp/scp-types-commerce-transaction";
+export declare const TERMINAL_SESSION: string;
+export declare enum TerminalPendingUpdate {
+    Open = "Open",
+    Closed = "Closed",
+    None = "None",
+    BusinessDateChange = "BusinessDateChange"
+}
+export declare enum TerminalSessionState {
+    Open = "Open",
+    Closed = "Closed",
+    Unknown = "Unknown"
+}
+export declare enum AccountabilityMode {
+    Shared = "Shared",
+    Terminal = "Terminal",
+    Operator = "Operator"
+}
+export declare class TerminalSession implements IState {
+    private _pendingUpdate;
+    private _state;
+    private _type;
+    private _lastActiveBusinessDay;
+    private _openingTransactionNumber;
+    private _closingTransactionNumber;
+    private _accountabilityMode;
+    private _cashDrawerKey;
+    static create(): TerminalSession;
+    static createFromJsonObject(terminalSessionJsonObject: any): TerminalSession;
+    get hasPendingUpdate(): boolean;
+    get isClosed(): boolean;
+    get isOpen(): boolean;
+    get pendingUpdate(): TerminalPendingUpdate;
+    get stateIsKnown(): boolean;
+    get lastActiveBusinessDay(): Date;
+    get openingTransactionNumber(): number;
+    get closingTransactionNumber(): number;
+    get accountabilityMode(): AccountabilityMode;
+    get cashDrawerKey(): string;
+    get tillAccountabilityMode(): PostableTillAccountabilityMode;
+    get cashDrawerAccessMode(): CashDrawerAccessMode;
+    get stateValues(): Readonly<Map<string, any>>;
+    get type(): Readonly<string>;
+    closeTerminal(closingTransactionNumber: number, accountabilityMode?: AccountabilityMode, cashDrawerKey?: string): TerminalSession;
+    openTerminal(businessDayDate: Date, openingTransactionNumber: number, accountabilityMode?: AccountabilityMode, cashDrawerKey?: string): TerminalSession;
+    recordPendingUpdate(pendingUpdate: TerminalPendingUpdate): TerminalSession;
+    private constructor();
+}

package/lib/domain/model/TerminalSession.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_types_commerce_transaction_1 = require("@aptos-scp/scp-types-commerce-transaction");
+exports.TERMINAL_SESSION = "TerminalSession";
+var TerminalPendingUpdate;
+(function (TerminalPendingUpdate) {
+    TerminalPendingUpdate["Open"] = "Open";
+    TerminalPendingUpdate["Closed"] = "Closed";
+    TerminalPendingUpdate["None"] = "None";
+    TerminalPendingUpdate["BusinessDateChange"] = "BusinessDateChange";
+})(TerminalPendingUpdate = exports.TerminalPendingUpdate || (exports.TerminalPendingUpdate = {}));
+var TerminalSessionState;
+(function (TerminalSessionState) {
+    TerminalSessionState["Open"] = "Open";
+    TerminalSessionState["Closed"] = "Closed";
+    TerminalSessionState["Unknown"] = "Unknown";
+})(TerminalSessionState = exports.TerminalSessionState || (exports.TerminalSessionState = {}));
+var AccountabilityMode;
+(function (AccountabilityMode) {
+    AccountabilityMode["Shared"] = "Shared";
+    AccountabilityMode["Terminal"] = "Terminal";
+    AccountabilityMode["Operator"] = "Operator";
+})(AccountabilityMode = exports.AccountabilityMode || (exports.AccountabilityMode = {}));
+const mapAccountabilityMode = new Map([
+    [AccountabilityMode.Shared, scp_types_commerce_transaction_1.AccountabilityMode.Shared],
+    [AccountabilityMode.Operator, scp_types_commerce_transaction_1.AccountabilityMode.Operator],
+    [AccountabilityMode.Terminal, scp_types_commerce_transaction_1.AccountabilityMode.Shared],
+]);
+const mapCashDrawerAccessMode = new Map([
+    [AccountabilityMode.Shared, scp_types_commerce_transaction_1.CashDrawerAccessMode.Shared],
+    [AccountabilityMode.Terminal, scp_types_commerce_transaction_1.CashDrawerAccessMode.Dedicated],
+    [AccountabilityMode.Operator, scp_types_commerce_transaction_1.CashDrawerAccessMode.Unknown],
+    [undefined, scp_types_commerce_transaction_1.CashDrawerAccessMode.Unknown],
+]);
+class TerminalSession {
+    constructor(state, pendingUpdate, businessDayDate, openingTransactionNumber, closingTransactionNumber, accountabilityMode, cashDrawerKey) {
+        this._pendingUpdate = pendingUpdate;
+        this._state = state;
+        this._type = exports.TERMINAL_SESSION;
+        this._lastActiveBusinessDay = businessDayDate;
+        this._openingTransactionNumber = openingTransactionNumber;
+        this._closingTransactionNumber = closingTransactionNumber;
+        this._accountabilityMode = accountabilityMode;
+        this._cashDrawerKey = cashDrawerKey;
+    }
+    static create() {
+        return new TerminalSession(TerminalSessionState.Unknown, TerminalPendingUpdate.None);
+    }
+    static createFromJsonObject(terminalSessionJsonObject) {
+        const businessDayDate = terminalSessionJsonObject._lastActiveBusinessDay &&
+            new Date(terminalSessionJsonObject._lastActiveBusinessDay);
+        return new TerminalSession(terminalSessionJsonObject._state, terminalSessionJsonObject._pendingUpdate, businessDayDate, terminalSessionJsonObject._openingTransactionNumber, terminalSessionJsonObject._closingTransactionNumber, terminalSessionJsonObject._accountabilityMode, terminalSessionJsonObject._cashDrawerKey);
+    }
+    get hasPendingUpdate() {
+        return this._pendingUpdate !== TerminalPendingUpdate.None;
+    }
+    get isClosed() {
+        return this._state === TerminalSessionState.Closed && this.stateIsKnown;
+    }
+    get isOpen() {
+        return this._state === TerminalSessionState.Open;
+    }
+    get pendingUpdate() {
+        return this._pendingUpdate;
+    }
+    get stateIsKnown() {
+        return this._state !== TerminalSessionState.Unknown;
+    }
+    get lastActiveBusinessDay() {
+        return this._lastActiveBusinessDay;
+    }
+    get openingTransactionNumber() {
+        return this._openingTransactionNumber;
+    }
+    get closingTransactionNumber() {
+        return this._closingTransactionNumber;
+    }
+    get accountabilityMode() {
+        return this._accountabilityMode;
+    }
+    get cashDrawerKey() {
+        return this._cashDrawerKey;
+    }
+    get tillAccountabilityMode() {
+        return mapAccountabilityMode.get(this._accountabilityMode);
+    }
+    get cashDrawerAccessMode() {
+        return mapCashDrawerAccessMode.get(this._accountabilityMode);
+    }
+    get stateValues() {
+        return new Map([
+            ["TerminalSession.hasPendingUpdate", this.hasPendingUpdate],
+            ["TerminalSession.isClosed", this.isClosed],
+            ["TerminalSession.isOpen", this.isOpen],
+            ["TerminalSession.pendingUpdate", this.pendingUpdate],
+            ["TerminalSession.lastActiveBusinessDay", this.lastActiveBusinessDay],
+            ["TerminalSession.openingTransactionNumber", this.openingTransactionNumber],
+            ["TerminalSession.closingTransactionNumber", this.closingTransactionNumber],
+            ["TerminalSession.accountabilityMode", this.accountabilityMode],
+            ["TerminalSession.cashDrawerKey", this.cashDrawerKey],
+        ]);
+    }
+    get type() {
+        return this._type;
+    }
+    closeTerminal(closingTransactionNumber, accountabilityMode, cashDrawerKey) {
+        if (this.pendingUpdate === TerminalPendingUpdate.BusinessDateChange) {
+            return new TerminalSession(TerminalSessionState.Closed, TerminalPendingUpdate.Open, this._lastActiveBusinessDay, undefined, closingTransactionNumber, accountabilityMode || this.accountabilityMode, cashDrawerKey || this.cashDrawerKey);
+        }
+        return new TerminalSession(TerminalSessionState.Closed, TerminalPendingUpdate.None, this._lastActiveBusinessDay, undefined, closingTransactionNumber, accountabilityMode || this.accountabilityMode, cashDrawerKey || this.cashDrawerKey);
+    }
+    openTerminal(businessDayDate, openingTransactionNumber, accountabilityMode, cashDrawerKey) {
+        const newAccountabilityMode = accountabilityMode || this.accountabilityMode;
+        const newCashDrawerKey = newAccountabilityMode === AccountabilityMode.Terminal ? cashDrawerKey || this.cashDrawerKey : undefined;
+        return new TerminalSession(TerminalSessionState.Open, TerminalPendingUpdate.None, businessDayDate, openingTransactionNumber, undefined, newAccountabilityMode, newCashDrawerKey);
+    }
+    recordPendingUpdate(pendingUpdate) {
+        return new TerminalSession(this._state, pendingUpdate, this._lastActiveBusinessDay, this._openingTransactionNumber, this._closingTransactionNumber, this.accountabilityMode, this.cashDrawerKey);
+    }
+}
+exports.TerminalSession = TerminalSession;
+//# sourceMappingURL=TerminalSession.js.map

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

@@ -0,0 +1,20 @@
+import { DeviceIdentity, ITransaction, ITransactionLine, ITransactionLineFactory, IUser } from "@aptos-scp/scp-component-store-selling-core";
+import { RetailTransaction } from "./RetailTransaction";
+import { IFiscalSignature } from "@aptos-scp/scp-types-commerce-transaction";
+export declare const TILL_CONTROL_TRANSACTION_TYPE = "TillControlTransaction";
+export declare class TillControlTransaction extends RetailTransaction {
+    private _fiscalSignature;
+    private _fiscalTransactionNumber;
+    static createFromJsonObj(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory): TillControlTransaction;
+    constructor(deviceIdentity: DeviceIdentity, businessDayDate: string, transactionNumber: number, user?: IUser, transactionId?: string, fiscalSignature?: IFiscalSignature, fiscalTransactionNumber?: string);
+    clone(): ITransaction;
+    get fiscalSignature(): IFiscalSignature;
+    get fiscalTransactionNumber(): string;
+    get transactionStateValues(): Readonly<Map<string, any>>;
+    assignFiscalSignature(signatureData: IFiscalSignature): ITransaction;
+    assignFiscalTransactionNumber(fiscalTransactionNumber: string): ITransaction;
+    findLineByLineNumber(lineNumber: number): ITransactionLine;
+    protected newTransaction(): RetailTransaction;
+    protected loadFromJsonObject(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory): void;
+}
+export declare const isTillControlTransaction: (transaction: ITransaction) => transaction is TillControlTransaction;

package/lib/domain/model/TillControlTransaction.js

@@ -0,0 +1,79 @@
+"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");
+exports.TILL_CONTROL_TRANSACTION_TYPE = "TillControlTransaction";
+class TillControlTransaction extends RetailTransaction_1.RetailTransaction {
+    constructor(deviceIdentity, businessDayDate, transactionNumber, user, transactionId, fiscalSignature, fiscalTransactionNumber) {
+        super(deviceIdentity, businessDayDate, transactionNumber, exports.TILL_CONTROL_TRANSACTION_TYPE, user, transactionId);
+        this._fiscalSignature = fiscalSignature;
+        this._fiscalTransactionNumber = fiscalTransactionNumber;
+    }
+    static createFromJsonObj(transactionJsonObj, transactionLineFactory) {
+        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 transaction = new TillControlTransaction(deviceIdentity, businessDayDate, transactionNumber, performingUser, transactionId);
+        transaction.updateAccountabilityMode(transactionJsonObj._tillAccountabilityMode, transactionJsonObj._cashDrawerAccessMode);
+        transaction.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+        return transaction;
+    }
+    clone() {
+        const transaction = super.clone();
+        if (exports.isTillControlTransaction(transaction)) {
+            transaction._fiscalSignature = this._fiscalSignature;
+            transaction._fiscalTransactionNumber = this._fiscalTransactionNumber;
+        }
+        else {
+            throw new scp_component_store_selling_core_1.PosError("Cannot clone TillControlTransaction, because new " + "instance is not a TillControlTransaction.", config_1.SSF_TRANSACTION_ERROR_CODE);
+        }
+        return transaction;
+    }
+    get fiscalSignature() {
+        return this._fiscalSignature;
+    }
+    get fiscalTransactionNumber() {
+        return this._fiscalTransactionNumber;
+    }
+    get transactionStateValues() {
+        return new Map([...super.transactionStateValues.entries()]);
+    }
+    assignFiscalSignature(signatureData) {
+        const newTransaction = this.clone();
+        newTransaction._fiscalSignature = signatureData;
+        return newTransaction;
+    }
+    assignFiscalTransactionNumber(fiscalTransactionNumber) {
+        const newTransaction = this.clone();
+        newTransaction._fiscalTransactionNumber = fiscalTransactionNumber;
+        return newTransaction;
+    }
+    findLineByLineNumber(lineNumber) {
+        if (lineNumber && super.lines.length > 0) {
+            return super.findLineByLineNumber(lineNumber);
+        }
+        return undefined;
+    }
+    newTransaction() {
+        return new TillControlTransaction(this.deviceIdentity, this.businessDayDate, this.transactionNumber, this.performingUser, this.transactionId, this._fiscalSignature, this._fiscalTransactionNumber);
+    }
+    loadFromJsonObject(transactionJsonObj, transactionLineFactory) {
+        var _a, _b;
+        super.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+        if ((_a = transactionJsonObj) === null || _a === void 0 ? void 0 : _a._fiscalSignature) {
+            this._fiscalSignature = transactionJsonObj._fiscalSignature;
+        }
+        if ((_b = transactionJsonObj) === null || _b === void 0 ? void 0 : _b._fiscalTransactionNumber) {
+            this._fiscalTransactionNumber = transactionJsonObj._fiscalTransactionNumber;
+        }
+    }
+}
+exports.TillControlTransaction = TillControlTransaction;
+exports.isTillControlTransaction = (transaction) => {
+    return (transaction instanceof TillControlTransaction ||
+        transaction.transactionType === exports.TILL_CONTROL_TRANSACTION_TYPE);
+};
+//# sourceMappingURL=TillControlTransaction.js.map

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

@@ -0,0 +1,67 @@
+import { Money } from "@aptos-scp/scp-component-business-core";
+import { IState } from "@aptos-scp/scp-component-store-selling-core";
+export declare const TILL_SESSION: string;
+export declare enum TillSessionState {
+    /**
+     * till state after provisioning the app and before initial till in
+     */
+    Unknown = "Unknown",
+    /**
+     * till state between till in and till out
+     */
+    InDrawer = "InDrawer",
+    /**
+     * till state after till out until next till in takes place
+     */
+    NotInDrawer = "NotInDrawer",
+    /**
+     * till state between till reconciliation and next till count
+     */
+    Inactive = "Inactive"
+}
+export interface ITenderBalance {
+    tenderId: string;
+    tenderName?: string;
+    amount: Money;
+    /**
+     * Counting tenders (like checks) is a future functionality.
+     */
+    count?: number;
+}
+export declare class TillSession implements IState {
+    private _type;
+    private _tillKey?;
+    private _cashDrawerKey?;
+    private _state;
+    private _tenderBalances;
+    private _lastFloats;
+    static create(): TillSession;
+    static createFromJsonObject(tillSessionJsonObject: any): TillSession;
+    get hasState(): boolean;
+    get inactive(): boolean;
+    get inDrawer(): boolean;
+    get notInDrawer(): boolean;
+    get tenderBalances(): ITenderBalance[];
+    get tillKey(): string;
+    get cashDrawerKey(): string;
+    get state(): TillSessionState;
+    get lastFloats(): ITenderBalance[];
+    get stateValues(): Readonly<Map<string, any>>;
+    get type(): Readonly<string>;
+    tillIn(tillKey: string, cashDrawerKey?: string): TillSession;
+    tillOut(): TillSession;
+    tillAdjustment(tenderBalances: ITenderBalance[], isPartOfTillIn?: boolean): TillSession;
+    deactivateTill(): TillSession;
+    activateTill(): TillSession;
+    tenderIn(tenderBalances: ITenderBalance[]): TillSession;
+    tenderOut(tenderBalances: ITenderBalance[]): TillSession;
+    private constructor();
+    /**
+     * Adjust the tender balances by the amounts provided in the tenderBalanceAdjustments.
+     */
+    private updateBalance;
+    private findTenderBalance;
+    private applyBalanceAdjustment;
+    private applyAmountAdjustment;
+    private applyCountAdjustment;
+}

package/lib/domain/model/TillSession.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = require("lodash");
+const scp_component_business_core_1 = require("@aptos-scp/scp-component-business-core");
+exports.TILL_SESSION = "TillSession";
+var TillSessionState;
+(function (TillSessionState) {
+    /**
+     * till state after provisioning the app and before initial till in
+     */
+    TillSessionState["Unknown"] = "Unknown";
+    /**
+     * till state between till in and till out
+     */
+    TillSessionState["InDrawer"] = "InDrawer";
+    /**
+     * till state after till out until next till in takes place
+     */
+    TillSessionState["NotInDrawer"] = "NotInDrawer";
+    /**
+     * till state between till reconciliation and next till count
+     */
+    TillSessionState["Inactive"] = "Inactive";
+})(TillSessionState = exports.TillSessionState || (exports.TillSessionState = {}));
+var TillOperation;
+(function (TillOperation) {
+    TillOperation["Add"] = "Add";
+    TillOperation["Subtract"] = "Subtract";
+})(TillOperation || (TillOperation = {}));
+class TillSession {
+    constructor(state, tenderBalances, tillKey, cashDrawerKey, lastFloats) {
+        this._type = exports.TILL_SESSION;
+        this._state = state;
+        this._tenderBalances = tenderBalances;
+        this._tillKey = tillKey;
+        this._cashDrawerKey = cashDrawerKey;
+        this._lastFloats = lastFloats;
+    }
+    static create() {
+        return new TillSession(TillSessionState.Unknown, [], undefined, undefined, []);
+    }
+    static createFromJsonObject(tillSessionJsonObject) {
+        const tenderBalances = tillSessionJsonObject._tenderBalances
+            ? tillSessionJsonObject._tenderBalances.map((tenderBalance) => (Object.assign(Object.assign({}, tenderBalance), { amount: scp_component_business_core_1.Money.fromJSON(tenderBalance.amount) })))
+            : undefined;
+        const lastFloats = tillSessionJsonObject._lastFloats
+            ? tillSessionJsonObject._lastFloats.map((lastFloat) => (Object.assign(Object.assign({}, lastFloat), { amount: scp_component_business_core_1.Money.fromJSON(lastFloat.amount) })))
+            : undefined;
+        return new TillSession(tillSessionJsonObject._state, tenderBalances, tillSessionJsonObject._tillKey, tillSessionJsonObject._cashDrawerKey, lastFloats);
+    }
+    get hasState() {
+        return this._state !== TillSessionState.Unknown;
+    }
+    get inactive() {
+        return this._state === TillSessionState.Inactive;
+    }
+    get inDrawer() {
+        return this._state === TillSessionState.InDrawer;
+    }
+    get notInDrawer() {
+        return this._state === TillSessionState.NotInDrawer;
+    }
+    get tenderBalances() {
+        return this._tenderBalances;
+    }
+    get tillKey() {
+        return this._tillKey;
+    }
+    get cashDrawerKey() {
+        return this._cashDrawerKey;
+    }
+    get state() {
+        return this._state;
+    }
+    get lastFloats() {
+        return _.cloneDeep(this._lastFloats);
+    }
+    get stateValues() {
+        return new Map([
+            ["TillSession.hasState", this.hasState],
+            ["TillSession.inactive", this.inactive],
+            ["TillSession.inDrawer", this.inDrawer],
+            ["TillSession.notInDrawer", this.notInDrawer],
+            ["TillSession.tenderBalances", _.cloneDeep(this.tenderBalances)],
+            ["TillSession.tillKey", this.tillKey],
+            ["TillSession.cashDrawerKey", this.cashDrawerKey],
+            ["TillSession.lastFloats", _.cloneDeep(this.lastFloats)],
+        ]);
+    }
+    get type() {
+        return this._type;
+    }
+    tillIn(tillKey, cashDrawerKey) {
+        if (this.state !== TillSessionState.InDrawer) {
+            return new TillSession(TillSessionState.InDrawer, this.tenderBalances, tillKey, cashDrawerKey, _.cloneDeep(this.tenderBalances));
+        }
+        else {
+            return this;
+        }
+    }
+    tillOut() {
+        if (this.state !== TillSessionState.NotInDrawer) {
+            return new TillSession(TillSessionState.NotInDrawer, [], undefined, undefined, []);
+        }
+        else {
+            return this;
+        }
+    }
+    tillAdjustment(tenderBalances, isPartOfTillIn = false) {
+        if (this.state === TillSessionState.InDrawer ||
+            this.state === TillSessionState.Inactive ||
+            ((this.state === TillSessionState.NotInDrawer || this.state === TillSessionState.Unknown) &&
+                isPartOfTillIn)) {
+            return new TillSession(this.state, _.cloneDeep(tenderBalances), this.tillKey, this.cashDrawerKey, this.lastFloats);
+        }
+        else {
+            return this;
+        }
+    }
+    deactivateTill() {
+        if (this.state === TillSessionState.InDrawer) {
+            return new TillSession(TillSessionState.Inactive, this.tenderBalances, this.tillKey, this.cashDrawerKey, this.lastFloats);
+        }
+        else {
+            return this;
+        }
+    }
+    activateTill() {
+        if (this.state === TillSessionState.Inactive) {
+            return new TillSession(TillSessionState.InDrawer, this.tenderBalances, this.tillKey, this.cashDrawerKey, this.lastFloats);
+        }
+        else {
+            return this;
+        }
+    }
+    tenderIn(tenderBalances) {
+        if (((this.state === TillSessionState.InDrawer || this.state === TillSessionState.Inactive) &&
+            !_.isEmpty(this.tenderBalances)) ||
+            !(this.state === TillSessionState.InDrawer || this.state === TillSessionState.Inactive)) {
+            return new TillSession(this.state, this.updateBalance(_.cloneDeep(tenderBalances), TillOperation.Add), this.tillKey, this.cashDrawerKey, this.lastFloats);
+        }
+        else {
+            return this;
+        }
+    }
+    tenderOut(tenderBalances) {
+        if (this.state === TillSessionState.InDrawer || this.state === TillSessionState.Inactive) {
+            return new TillSession(this.state, this.updateBalance(_.cloneDeep(tenderBalances), TillOperation.Subtract), this.tillKey, this.cashDrawerKey, this.lastFloats);
+        }
+        else {
+            return this;
+        }
+    }
+    /**
+     * Adjust the tender balances by the amounts provided in the tenderBalanceAdjustments.
+     */
+    updateBalance(tenderBalanceAdjustments, op) {
+        var _a;
+        // Update current set of tender balances, as needed.
+        const newBalances = (this.tenderBalances || []).map((tenderBalance) => {
+            const balanceAdjustment = this.findTenderBalance(tenderBalanceAdjustments, tenderBalance.tenderId);
+            return balanceAdjustment
+                ? this.applyBalanceAdjustment(tenderBalance, balanceAdjustment, op)
+                : tenderBalance;
+        }, []);
+        // Add balances for any new tenders.
+        (_a = tenderBalanceAdjustments) === null || _a === void 0 ? void 0 : _a.forEach((balanceAdjustment) => {
+            if (!this.findTenderBalance(newBalances, balanceAdjustment.tenderId)) {
+                // Treat the prior amount as zero, and adjust from there.
+                const priorBalance = new scp_component_business_core_1.Money("0", balanceAdjustment.amount.currency);
+                newBalances.push({
+                    tenderId: balanceAdjustment.tenderId,
+                    tenderName: balanceAdjustment.tenderName,
+                    amount: this.applyAmountAdjustment(priorBalance, balanceAdjustment.amount, op),
+                    count: this.applyCountAdjustment(0, balanceAdjustment.count, op),
+                });
+            }
+        });
+        return newBalances;
+    }
+    findTenderBalance(tenderBalances, tenderId) {
+        var _a;
+        return (_a = tenderBalances) === null || _a === void 0 ? void 0 : _a.find((tenderBalance) => tenderBalance.tenderId === tenderId);
+    }
+    applyBalanceAdjustment(tenderBalance, balanceAdjustment, op) {
+        var _a, _b, _c, _d;
+        let updatedBalance;
+        if (((_a = tenderBalance) === null || _a === void 0 ? void 0 : _a.tenderId) === ((_b = balanceAdjustment) === null || _b === void 0 ? void 0 : _b.tenderId)) {
+            updatedBalance = {
+                tenderId: (_c = balanceAdjustment) === null || _c === void 0 ? void 0 : _c.tenderId,
+                tenderName: (_d = balanceAdjustment) === null || _d === void 0 ? void 0 : _d.tenderName,
+                amount: this.applyAmountAdjustment(tenderBalance.amount, balanceAdjustment.amount, op),
+                count: this.applyCountAdjustment(tenderBalance.count, balanceAdjustment.count, op),
+            };
+        }
+        return updatedBalance;
+    }
+    applyAmountAdjustment(tenderBalance, balanceAdjustment, op) {
+        let updatedAmount;
+        if (balanceAdjustment) {
+            if (op === TillOperation.Add) {
+                updatedAmount = tenderBalance.plus(balanceAdjustment);
+            }
+            else {
+                updatedAmount = tenderBalance.minus(balanceAdjustment);
+            }
+        }
+        return updatedAmount;
+    }
+    applyCountAdjustment(tenderBalance, balanceAdjustment, op) {
+        let updatedCount = 0;
+        if (op === TillOperation.Add) {
+            updatedCount = tenderBalance + balanceAdjustment;
+        }
+        else {
+            updatedCount = tenderBalance - balanceAdjustment;
+        }
+        return updatedCount;
+    }
+}
+exports.TillSession = TillSession;
+//# sourceMappingURL=TillSession.js.map

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

@@ -0,0 +1,26 @@
+import { IState } from "@aptos-scp/scp-component-store-selling-core";
+export declare enum TransactionFlowSessionState {
+    BasketUpdate = "BasketUpdate",
+    Totaled = "Totaled",
+    BasketUpdatePostTotal = "BasketUpdatePostTotal",
+    Tendering = "Tendering",
+    FlowNotTracked = "FlowNotTracked",
+    NotInTransaction = "NotInTransaction"
+}
+export declare const TRANSACTION_FLOW_STATE: string;
+export declare class TransactionFlowState implements IState {
+    private readonly _type;
+    private readonly _state;
+    static create(): TransactionFlowState;
+    static createFromJsonObject(userSessionJsonObj: any): TransactionFlowState;
+    get type(): string;
+    get state(): TransactionFlowSessionState;
+    startedMerchandiseTransaction(): TransactionFlowState;
+    totaledTransaction(): TransactionFlowState;
+    tendered(): TransactionFlowState;
+    modifiedTransaction(): TransactionFlowState;
+    startedOtherTransaction(): TransactionFlowState;
+    closedTransaction(): TransactionFlowState;
+    get stateValues(): Readonly<Map<string, any>>;
+    private constructor();
+}