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

package/lib/domain/model/User.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//FIXME: There should be a better place to keep UIInput/CollectedData constants.
+exports.USER = "User";
+exports.PASSWORD_EXPIRING_SOON = "passwordExpiringSoon";
+exports.LOG_OFF_TYPE = "LogOffType";
+exports.AUTO_LOG_OFF_TYPE = "autoLogOff";
+exports.ENTER_ATTENDANT_MODE_LINE_TYPE = "EnterAttendantMode";
+exports.EXIT_ATTENDANT_MODE_LINE_TYPE = "ExitAttendantMode";
+class SecurityRole {
+    /**
+     * Construct a new Security Role object to be used to exchange the information
+     * with the server.
+     *
+     * @param id The id
+     * @param securityRoleId The role Id
+     * @param name The name
+     * @param description The description
+     */
+    constructor(id, securityRoleId, name, description, securityLevel) {
+        this._id = id;
+        this._securityRoleId = securityRoleId;
+        this._name = name;
+        this._description = description;
+        this._securityLevel = securityLevel;
+    }
+    static createFromJsonObject(jsonObject) {
+        if (!jsonObject) {
+            return undefined;
+        }
+        return new SecurityRole(jsonObject._id, jsonObject._securityRoleId, jsonObject._name, jsonObject._description, jsonObject._securityLevel);
+    }
+    get id() {
+        return this._id;
+    }
+    get securityRoleId() {
+        return this._securityRoleId;
+    }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._description;
+    }
+    get securityLevel() {
+        return this._securityLevel;
+    }
+}
+exports.SecurityRole = SecurityRole;
+class RetailLocationRole {
+    /**
+     * Construct a new Retail Location Role object to be used to exchange the information
+     * with the server.
+     *
+     * @param id The id
+     * @param retailLocationId The retail location Id
+     * @param securityRole The security role
+     * @param assignmentStatus The current status
+     * @param effectiveDate The effective date
+     * @param expirationDate The expiration date
+     */
+    constructor(id, retailLocationId, securityRole, assignmentStatus, effectiveDate, expirationDate) {
+        this._id = id;
+        this._retailLocationId = retailLocationId;
+        this._securityRole = securityRole;
+        this._assignmentStatus = assignmentStatus;
+        this._effectiveDate = effectiveDate;
+        this._expirationDate = expirationDate;
+    }
+    static createFromJsonObject(jsonObject) {
+        if (!jsonObject) {
+            return undefined;
+        }
+        return new RetailLocationRole(jsonObject._id, jsonObject._retailLocationId, SecurityRole.createFromJsonObject(jsonObject._securityRole), jsonObject._assignmentStatus, jsonObject._effectiveDate ? new Date(jsonObject._effectiveDate) : undefined, jsonObject._expirationDate ? new Date(jsonObject._expirationDate) : undefined);
+    }
+    get id() {
+        return this._id;
+    }
+    get retailLocationId() {
+        return this._retailLocationId;
+    }
+    get securityRole() {
+        return this._securityRole;
+    }
+    get assignmentStatus() {
+        return this._assignmentStatus;
+    }
+    get effectiveDate() {
+        return this._effectiveDate;
+    }
+    get expirationDate() {
+        return this._expirationDate;
+    }
+}
+exports.RetailLocationRole = RetailLocationRole;
+class User {
+    /**
+     * Construct a new User object to be used to exchange the information
+     * with the server.
+     *
+     * @param id The id
+     * @param username The username
+     * @param displayName The display name
+     * @param firstName The user's first name
+     * @param lastName The user's last name
+     * @param middleName The user's middle name
+     * @param preferredLanguage The user's middle name
+     * @param securityRole The security role
+     * @param retailLocationRole The retail location security role
+     * @param passwordLastChanged The date the password was last changed
+     * @param effectiveDate The effective date
+     * @param expirationDate The expiration date
+     * @param shortName The user's short name
+     */
+    constructor(id, username, displayName, firstName, lastName, middleName, preferredLanguage, securityRole, retailLocationRole, accountStatus, passwordLastChanged, effectiveDate, expirationDate, shortName) {
+        this._id = id;
+        this._username = username;
+        this._displayName = displayName;
+        this._firstName = firstName;
+        this._lastName = lastName;
+        this._firstName = firstName;
+        this._middleName = middleName;
+        this._preferredLanguage = preferredLanguage;
+        this._securityRole = securityRole;
+        this._retailLocationRole = retailLocationRole;
+        this._accountStatus = accountStatus ? accountStatus : "Active";
+        this._passwordLastChanged = passwordLastChanged;
+        this._effectiveDate = effectiveDate;
+        this._expirationDate = expirationDate;
+        this._shortName = shortName;
+    }
+    static createFromJsonObject(userFromJson) {
+        if (!userFromJson) {
+            return undefined;
+        }
+        let retailLocationRole;
+        if (userFromJson._retailLocationRole) {
+            retailLocationRole = RetailLocationRole.createFromJsonObject(userFromJson._retailLocationRole);
+        }
+        const passwordLastChanged = userFromJson._passwordLastChanged
+            ? new Date(userFromJson._passwordLastChanged)
+            : undefined;
+        return new User(userFromJson._id, userFromJson._username, userFromJson._displayName, userFromJson._firstName, userFromJson._lastName, userFromJson._middleName, userFromJson._preferredLanguage, SecurityRole.createFromJsonObject(userFromJson._securityRole), retailLocationRole, userFromJson._accountStatus, passwordLastChanged, userFromJson._effectiveDate ? new Date(userFromJson._effectiveDate) : undefined, userFromJson._expirationDate ? new Date(userFromJson._expirationDate) : undefined, userFromJson._shortName);
+    }
+    static buildUser(retailLocationIdentity, user) {
+        let securityRole;
+        let retailLocationRole;
+        if (user.securityRole) {
+            securityRole = new SecurityRole(user.securityRole.id, user.securityRole.securityRoleId, user.securityRole.name, user.securityRole.description, user.securityRole.securityLevel);
+        }
+        if (user.retailLocationRoles && user.retailLocationRoles.length) {
+            const userRetailLocationRole = user.retailLocationRoles.find((locationRole) => locationRole.retailLocationId === retailLocationIdentity.retailLocationId);
+            if (userRetailLocationRole) {
+                const retailLocationSecurityRole = new SecurityRole(userRetailLocationRole.securityRole.id, userRetailLocationRole.securityRole.securityRoleId, userRetailLocationRole.securityRole.name, userRetailLocationRole.securityRole.description, userRetailLocationRole.securityRole.securityLevel);
+                retailLocationRole = new RetailLocationRole(userRetailLocationRole.id, userRetailLocationRole.retailLocationId, retailLocationSecurityRole, userRetailLocationRole.assignmentStatus, userRetailLocationRole.effectiveDate, userRetailLocationRole.expirationDate);
+            }
+        }
+        const passwordLastChanged = user.passwordLastChanged || user.createdAt
+            ? new Date(user.passwordLastChanged || user.createdAt)
+            : undefined;
+        return new User(user.id, user.username, this.buildUserDisplayName(user), user.firstName, user.lastName, user.middleName, user.preferredLanguage, securityRole, retailLocationRole, user.accountStatus, passwordLastChanged, user.effectiveDate, user.expirationDate, user.shortName);
+    }
+    static buildUserDisplayName(user) {
+        return user ? `${user.firstName} ${user.lastName}` : "";
+    }
+    get id() {
+        return this._id;
+    }
+    get username() {
+        return this._username;
+    }
+    get firstName() {
+        return this._firstName;
+    }
+    get middleName() {
+        return this._middleName;
+    }
+    get preferredLanguage() {
+        return this._preferredLanguage;
+    }
+    get lastName() {
+        return this._lastName;
+    }
+    get displayName() {
+        return this._displayName;
+    }
+    get shortName() {
+        return this._shortName;
+    }
+    get securityRole() {
+        return this._securityRole;
+    }
+    get retailLocationRole() {
+        return this._retailLocationRole;
+    }
+    get accountStatus() {
+        return this._accountStatus;
+    }
+    get passwordLastChanged() {
+        return this._passwordLastChanged;
+    }
+    get effectiveDate() {
+        return this._effectiveDate;
+    }
+    get expirationDate() {
+        return this._expirationDate;
+    }
+}
+exports.User = User;
+//# sourceMappingURL=User.js.map

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

@@ -0,0 +1,36 @@
+import { IState, IUser } from "@aptos-scp/scp-component-store-selling-core";
+import { IEmployee } from "./Employee";
+export declare const USER_SESSION: string;
+export declare class UserSession implements IState {
+    private readonly _type;
+    private readonly _state;
+    private readonly _users;
+    private readonly _unattendedOperator;
+    private readonly _supervisor;
+    private readonly _defaultSalesperson;
+    static createFromJsonObject(userSessionJsonObj: any): UserSession;
+    static create(): UserSession;
+    get type(): string;
+    get loggedOn(): boolean;
+    get loggedOff(): boolean;
+    get locked(): boolean;
+    get unattended(): boolean;
+    /**
+     * The currently active user
+     */
+    get user(): IUser;
+    get unattendedOperator(): IUser;
+    get supervisor(): IUser;
+    get defaultSalesperson(): IEmployee;
+    get stateValues(): Readonly<Map<string, any>>;
+    logOn(user: IUser, unattended?: boolean): UserSession;
+    updateUser(user: IUser): UserSession;
+    logOff(): UserSession;
+    lock(): UserSession;
+    unlock(): UserSession;
+    addDefaultSalesperson(defaultSalesperson: IEmployee): UserSession;
+    clearDefaultSalesperson(): UserSession;
+    addSupervisor(supervisor: IUser): UserSession;
+    clearSupervisor(): UserSession;
+    private constructor();
+}

package/lib/domain/model/UserSession.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const Employee_1 = require("./Employee");
+const User_1 = require("./User");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.domain.model.UserSession");
+/**
+ * Note: The Locked state is a sub-state of LoggedOn. The user session can only be locked or unlocked, while a user is
+ * logged on.
+ * Note: The Unattended state is a sub-state of LoggedOn. The user session can be logged on normally or logged on for
+ * self checkout (customer) mode with an unattended operator.
+ */
+var UserSessionState;
+(function (UserSessionState) {
+    UserSessionState["LoggedOff"] = "LoggedOff";
+    UserSessionState["LoggedOn"] = "LoggedOn";
+    UserSessionState["Locked"] = "Locked";
+    UserSessionState["Unattended"] = "Unattended";
+})(UserSessionState || (UserSessionState = {}));
+exports.USER_SESSION = "UserSession";
+const UserSessionStateNumericMap = {
+    0: "LoggedOff",
+    1: "LoggedOn",
+    2: "Locked",
+};
+class UserSession {
+    constructor(state, users, supervisor, unattendedOperator, defaultSalesperson) {
+        this._type = exports.USER_SESSION;
+        this._state = state;
+        this._users = users;
+        this._supervisor = supervisor;
+        this._defaultSalesperson = defaultSalesperson;
+        if (unattendedOperator) {
+            this._unattendedOperator = unattendedOperator;
+        }
+    }
+    static createFromJsonObject(userSessionJsonObj) {
+        logger.traceEntry("createFromJsonObject");
+        const state = typeof userSessionJsonObj._state === "number"
+            ? UserSessionStateNumericMap[userSessionJsonObj._state]
+            : userSessionJsonObj._state;
+        const defaultSalesperson = Employee_1.Employee.createFromJsonObject(userSessionJsonObj._defaultSalesperson);
+        let users = [];
+        if (userSessionJsonObj._users) {
+            users = userSessionJsonObj._users.map((currentUser) => User_1.User.createFromJsonObject(currentUser));
+        }
+        else if (userSessionJsonObj._user) {
+            users = [User_1.User.createFromJsonObject(userSessionJsonObj._user)];
+        }
+        let unattendedOperator = undefined;
+        if (userSessionJsonObj._unattendedOperator) {
+            unattendedOperator = User_1.User.createFromJsonObject(userSessionJsonObj._unattendedOperator);
+        }
+        else if (state === UserSessionState.Unattended && users) {
+            // Note: Needed for consistency with app upgrades, since self checkout only signs in once after provisioning.
+            unattendedOperator = peekUsers(users);
+        }
+        // FIXME: Do we need to restore the supervisor here?
+        return new UserSession(state, users, undefined, unattendedOperator, defaultSalesperson);
+    }
+    static create() {
+        logger.traceEntry("create");
+        return new UserSession(UserSessionState.LoggedOff, [], undefined, undefined);
+    }
+    get type() {
+        return this._type;
+    }
+    get loggedOn() {
+        return this._state === UserSessionState.LoggedOn || this._state === UserSessionState.Unattended;
+    }
+    get loggedOff() {
+        return this._state === UserSessionState.LoggedOff;
+    }
+    get locked() {
+        return this._state === UserSessionState.Locked;
+    }
+    get unattended() {
+        return this._state === UserSessionState.Unattended;
+    }
+    /**
+     * The currently active user
+     */
+    get user() {
+        return peekUsers(this._users);
+    }
+    get unattendedOperator() {
+        return this._unattendedOperator;
+    }
+    get supervisor() {
+        return this._supervisor;
+    }
+    get defaultSalesperson() {
+        return this._defaultSalesperson;
+    }
+    get stateValues() {
+        var _a, _b, _c;
+        logger.traceEntry("get stateValues");
+        return new Map([
+            ["UserSession.defaultSalesperson", this.defaultSalesperson],
+            ["UserSession.loggedOn", this.loggedOn || this.locked || this.unattended],
+            ["UserSession.locked", this.locked],
+            ["UserSession.unattended", this.unattended],
+            ["UserSession.unattendedOperator", this.unattendedOperator],
+            ["UserSession.user.id", this.user && this.user.id],
+            ["UserSession.user.username", this.user && this.user.username],
+            ["UserSession.user.firstName", this.user && this.user.firstName],
+            ["UserSession.user.preferredLanguage", this.user && this.user.preferredLanguage],
+            ["UserSession.user.middleName", this.user && this.user.middleName],
+            ["UserSession.user.lastName", this.user && this.user.lastName],
+            ["UserSession.user.displayName", this.user && this.user.displayName],
+            ["UserSession.user.shortName", this.user && ((_a = this.user) === null || _a === void 0 ? void 0 : _a.shortName)],
+            ["UserSession.user.securityRole", this.user && ((_b = this.user) === null || _b === void 0 ? void 0 : _b.securityRole)],
+            ["UserSession.user.retailLocationRole", this.user && ((_c = this.user) === null || _c === void 0 ? void 0 : _c.retailLocationRole)],
+        ]);
+    }
+    logOn(user, unattended) {
+        logger.traceEntry("logOn");
+        let userSession;
+        if (this.loggedOff) {
+            if (unattended) {
+                userSession = new UserSession(UserSessionState.Unattended, [user], this._supervisor, user);
+            }
+            else {
+                userSession = new UserSession(UserSessionState.LoggedOn, [user], this._supervisor, this.unattendedOperator, this._defaultSalesperson);
+            }
+        }
+        else if (this.unattended) {
+            // push the newest user onto the stack
+            userSession = new UserSession(UserSessionState.LoggedOn, [...this._users, user], this._supervisor, peekUsers(this._users), this._defaultSalesperson);
+        }
+        return userSession || this;
+    }
+    updateUser(user) {
+        logger.traceEntry("updateUser");
+        let userSession;
+        if (this.updateUser) {
+            const users = [...this._users.slice(0, this._users.length - 1)];
+            userSession = new UserSession(UserSessionState.LoggedOn, [...users, user], this._supervisor, this._unattendedOperator, this._defaultSalesperson);
+        }
+        return userSession || this;
+    }
+    logOff() {
+        logger.traceEntry("logOff");
+        let userSession;
+        if (this.loggedOn || this.locked) {
+            // pop off the most recent user
+            const users = [...this._users.slice(0, this._users.length - 1)];
+            if (users && users.length) {
+                userSession = new UserSession(UserSessionState.Unattended, users, undefined, peekUsers(users));
+            }
+            else {
+                userSession = new UserSession(UserSessionState.LoggedOff, [], undefined, this.unattendedOperator, this._defaultSalesperson);
+            }
+        }
+        return userSession || this;
+    }
+    lock() {
+        logger.traceEntry("lock");
+        return this.loggedOn
+            ? new UserSession(UserSessionState.Locked, this._users, this._supervisor, this._unattendedOperator, this._defaultSalesperson)
+            : this;
+    }
+    unlock() {
+        logger.traceEntry("unlock");
+        return this.locked
+            ? new UserSession(UserSessionState.LoggedOn, this._users, this._supervisor, this._unattendedOperator, this._defaultSalesperson)
+            : this;
+    }
+    addDefaultSalesperson(defaultSalesperson) {
+        return new UserSession(this._state, this._users, this._supervisor, this._unattendedOperator, defaultSalesperson);
+    }
+    clearDefaultSalesperson() {
+        return new UserSession(this._state, this._users, this._supervisor, this._unattendedOperator, undefined);
+    }
+    addSupervisor(supervisor) {
+        return new UserSession(this._state, this._users, supervisor, this._unattendedOperator, this._defaultSalesperson);
+    }
+    clearSupervisor() {
+        return new UserSession(this._state, this._users, undefined, this._unattendedOperator, this._defaultSalesperson);
+    }
+}
+exports.UserSession = UserSession;
+function peekUsers(users) {
+    return users && users[users.length > 0 ? users.length - 1 : 0];
+}
+//# sourceMappingURL=UserSession.js.map

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

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

package/lib/domain/model/UserTransaction.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RetailTransaction_1 = require("./RetailTransaction");
+exports.USER_TRANSACTION_TYPE = "UserTransaction";
+class UserTransaction extends RetailTransaction_1.RetailTransaction {
+    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 userTransaction = new UserTransaction(deviceIdentity, businessDayDate, transactionNumber, performingUser, transactionId);
+        userTransaction.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+        return userTransaction;
+    }
+    constructor(deviceIdentity, businessDayDate, transactionNumber, user, transactionId) {
+        super(deviceIdentity, businessDayDate, transactionNumber, exports.USER_TRANSACTION_TYPE, user, transactionId);
+    }
+    clone() {
+        const transaction = super.clone();
+        return transaction;
+    }
+    get transactionStateValues() {
+        return super.transactionStateValues;
+    }
+    newTransaction() {
+        return new UserTransaction(this.deviceIdentity, this.businessDayDate, this.transactionNumber, this.performingUser, this.transactionId);
+    }
+    loadFromJsonObject(transactionJsonObj, transactionLineFactory) {
+        super.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+    }
+}
+exports.UserTransaction = UserTransaction;
+exports.isUserTransaction = (transaction) => {
+    return (transaction instanceof UserTransaction ||
+        transaction.transactionType === exports.USER_TRANSACTION_TYPE);
+};
+//# sourceMappingURL=UserTransaction.js.map

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

@@ -0,0 +1,15 @@
+import { ITransactionLine } from "@aptos-scp/scp-component-store-selling-core";
+import { VoidSource } from "./Constants";
+export interface IVoidableLine extends ITransactionLine {
+    readonly voided: boolean;
+    readonly voidSource: VoidSource;
+    readonly preventsTransactionVoid: boolean;
+    readonly allowVoid: boolean;
+}
+export declare function isVoidableLine(transactionLine: ITransactionLine): transactionLine is IVoidableLine;
+export declare function lineCanBeVoided(transactionLine: ITransactionLine): boolean;
+export declare function linePreventsTransactionVoid(transactionLine: ITransactionLine): boolean;
+export interface IVoidingLine extends ITransactionLine {
+    readonly voidingLine: boolean;
+}
+export declare function isVoidingLine(transactionLine: ITransactionLine): transactionLine is IVoidingLine;

package/lib/domain/model/VoidInterfaces.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isVoidableLine(transactionLine) {
+    return (transactionLine.voided !== undefined &&
+        transactionLine.preventsTransactionVoid !== undefined);
+}
+exports.isVoidableLine = isVoidableLine;
+function lineCanBeVoided(transactionLine) {
+    return (isVoidableLine(transactionLine) && transactionLine.voided === false && !isVoidingLine(transactionLine));
+}
+exports.lineCanBeVoided = lineCanBeVoided;
+function linePreventsTransactionVoid(transactionLine) {
+    return (isVoidableLine(transactionLine) &&
+        (transactionLine.preventsTransactionVoid || !transactionLine.allowVoid) &&
+        !transactionLine.voided &&
+        !isVoidingLine(transactionLine));
+}
+exports.linePreventsTransactionVoid = linePreventsTransactionVoid;
+function isVoidingLine(transactionLine) {
+    return transactionLine.voidingLine === true;
+}
+exports.isVoidingLine = isVoidingLine;
+//# sourceMappingURL=VoidInterfaces.js.map

package/lib/domain/model/cashDrawer/CashDrawerRequestLine.d.ts

@@ -0,0 +1,17 @@
+import { ITransactionLine, UiBusinessEvent } from "@aptos-scp/scp-component-store-selling-core";
+import { CashDrawerRequestType, ITransactionLineReferenceType } from "@aptos-scp/scp-types-commerce-transaction";
+import { BaseTransactionLine } from "../BaseTransactionLine";
+import { ICashDrawerRequestLine } from "./ICashDrawerRequestLine";
+export declare const CASH_DRAWER_REQUEST_LINE_TYPE: string;
+export declare class CashDrawerRequestLine extends BaseTransactionLine implements ICashDrawerRequestLine {
+    private _requestType;
+    private _supervisorOverrideLineReference;
+    static create(lineNumber: number, lineType: string, uiBusinessEvent: UiBusinessEvent, collectedData: Readonly<Map<string, any>>): CashDrawerRequestLine;
+    static createFromJsonObject(transactionLineJsonObj: any): CashDrawerRequestLine;
+    get supervisorOverrideLineReference(): ITransactionLineReferenceType;
+    get couldAffectPricing(): boolean;
+    get requestType(): CashDrawerRequestType;
+    protected constructor(lineNumber: number, lineType: string, requestType: CashDrawerRequestType, supervisorOverrideLineReference?: ITransactionLineReferenceType);
+    protected newTransactionLine(): CashDrawerRequestLine;
+}
+export declare function isCashDrawerRequestLine(transactionLine: ITransactionLine): transactionLine is CashDrawerRequestLine;

package/lib/domain/model/cashDrawer/CashDrawerRequestLine.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_store_selling_core_1 = require("@aptos-scp/scp-component-store-selling-core");
+const ErrorCodes_1 = require("../../../config/ErrorCodes");
+const BaseTransactionLine_1 = require("../BaseTransactionLine");
+const Constants_1 = require("../Constants");
+exports.CASH_DRAWER_REQUEST_LINE_TYPE = "CashDrawerRequestLineType";
+class CashDrawerRequestLine extends BaseTransactionLine_1.BaseTransactionLine {
+    constructor(lineNumber, lineType, requestType, supervisorOverrideLineReference) {
+        super(lineNumber, lineType);
+        this._requestType = requestType;
+        this._supervisorOverrideLineReference = supervisorOverrideLineReference;
+    }
+    static create(lineNumber, lineType, uiBusinessEvent, collectedData) {
+        if (lineType !== exports.CASH_DRAWER_REQUEST_LINE_TYPE) {
+            throw new scp_component_store_selling_core_1.PosError(`CashDrawerRequestLine does not support the line type "${lineType}".`, ErrorCodes_1.SSF_LINE_TYPE_ERROR_CODE);
+        }
+        const requestType = collectedData.get(Constants_1.CollectedDataKey.CashDrawerRequestType);
+        const supervisorOverrideLineReference = collectedData.get(Constants_1.CollectedDataKey.SupervisorOverrideLineReference) || undefined;
+        return new CashDrawerRequestLine(lineNumber, lineType, requestType, supervisorOverrideLineReference);
+    }
+    static createFromJsonObject(transactionLineJsonObj) {
+        const lineNumber = BaseTransactionLine_1.BaseTransactionLine.lineNumberFromJsonObject(transactionLineJsonObj);
+        const lineType = BaseTransactionLine_1.BaseTransactionLine.lineTypeFromJsonObject(transactionLineJsonObj);
+        const requestType = transactionLineJsonObj._requestType;
+        const supervisorOverrideLineReference = transactionLineJsonObj._supervisorOverrideLineReference;
+        const cashDrawerRequestLine = new CashDrawerRequestLine(lineNumber, lineType, requestType, supervisorOverrideLineReference);
+        cashDrawerRequestLine.loadFromJsonObject(transactionLineJsonObj);
+        return cashDrawerRequestLine;
+    }
+    get supervisorOverrideLineReference() {
+        return this._supervisorOverrideLineReference;
+    }
+    get couldAffectPricing() {
+        return false;
+    }
+    get requestType() {
+        return this._requestType;
+    }
+    newTransactionLine() {
+        return new CashDrawerRequestLine(this.lineNumber, this.lineType, this._requestType, this.supervisorOverrideLineReference);
+    }
+}
+exports.CashDrawerRequestLine = CashDrawerRequestLine;
+function isCashDrawerRequestLine(transactionLine) {
+    return (transactionLine instanceof CashDrawerRequestLine ||
+        transactionLine.lineType === exports.CASH_DRAWER_REQUEST_LINE_TYPE);
+}
+exports.isCashDrawerRequestLine = isCashDrawerRequestLine;
+//# sourceMappingURL=CashDrawerRequestLine.js.map

package/lib/domain/model/cashDrawer/CashDrawerSession.d.ts

@@ -0,0 +1,67 @@
+import { Money } from "@aptos-scp/scp-component-business-core";
+import { IState, IUser } from "@aptos-scp/scp-component-store-selling-core";
+import { CashDrawerStatusCode } from "@aptos-scp/scp-types-commerce-devices";
+import { IExpectedTender } from "@aptos-scp/scp-types-commerce-transaction";
+export declare const CASH_DRAWER_SESSION: string;
+export declare enum CashDrawerSessionState {
+    Closed = "Closed",
+    WaitingForOpenDrawerResponse = "WaitingForOpenDrawerResponse",
+    Open = "Open",
+    WaitingForDrawerClosedResponse = "WaitingForDrawerClosedResponse",
+    WaitingForUserToSelectCashDrawer = "WaitingForUserToSelectCashDrawer",
+    NoCashDrawer = "NoCashDrawer"
+}
+export interface GiftCertificateState {
+    isRetry: boolean;
+    supervisor: IUser;
+    tenderId: number;
+    action: string;
+}
+export interface ExpectedTender {
+    amount: Money;
+    tenderId?: string;
+}
+export declare class CashDrawerSession implements IState {
+    private _type;
+    private _state;
+    private _cashDrawerKey;
+    private _cashDrawerStatusCode;
+    private _expectedAmounts;
+    private _expectedFloatAmounts;
+    private _inputSource;
+    private _skipConfirmClose;
+    private _lineNumber;
+    private _giftCertificateState;
+    static createFromJsonObject(cashDrawerSessionJsonObj: any): CashDrawerSession;
+    static create(): CashDrawerSession;
+    recordExpectedAmount(expectedAmount: IExpectedTender[]): CashDrawerSession;
+    recordExpectedFloatAmount(expectedFloatAmount: ExpectedTender[]): CashDrawerSession;
+    recordIsForGiftCertificate(giftCertState: GiftCertificateState): CashDrawerSession;
+    confirmingCashDrawerClosed(cashDrawerKey: string, lineNumber: number): CashDrawerSession;
+    skipConfirmCashDrawerClosed(): CashDrawerSession;
+    openingCashDrawer(cashDrawerKey: string, inputSource: string, lineNumber: number): CashDrawerSession;
+    promptUserInteractionToSelectCashDrawer(): CashDrawerSession;
+    recordStatusCode(incomingStatusCode: CashDrawerStatusCode): CashDrawerSession;
+    resetCashDrawerState(): CashDrawerSession;
+    userContinueOpen(skipConfirmClose?: boolean): CashDrawerSession;
+    get stateValues(): Readonly<Map<string, any>>;
+    get expectedAmounts(): IExpectedTender[];
+    get cashDrawerKey(): string;
+    get cashDrawerStatusCode(): CashDrawerStatusCode;
+    get skipConfirmClose(): boolean;
+    get isForGiftCertificate(): boolean;
+    get giftCertificateState(): GiftCertificateState;
+    get isWaitingForDrawerResponse(): boolean;
+    get isWaitingForUserToSelectCashDrawer(): boolean;
+    get isWaitingForDrawerClosedResponse(): boolean;
+    get isWaitingForOpenDrawerResponse(): boolean;
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    get isClosedOrNoCashDrawer(): boolean;
+    get state(): CashDrawerSessionState;
+    get type(): string;
+    get inputSource(): string;
+    get lineNumber(): number;
+    get expectedFloatAmounts(): ExpectedTender[];
+    private constructor();
+}