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

package/lib/domain/model/BaseLineDecorator.js

@@ -0,0 +1,216 @@
+"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 VoidInterfaces_1 = require("./VoidInterfaces");
+const BaseTransactionLine_1 = require("./BaseTransactionLine");
+exports.isDecorator = (transactionLine) => {
+    // tslint:disable-next-line:no-use-before-declare
+    return transactionLine instanceof BaseLineDecorator;
+};
+/**
+ * Get the first decorated transaction line of the specified decorator type found while ascending the
+ * decoratedTransactionLine tree.
+ * @param {ITransactionLine} transactionLine
+ * @param {string} decoratorType
+ * @returns {ITransactionLine} The decoratedTransactionLine found, or null if not found.
+ */
+function getDecoratedTransactionLine(transactionLine, decoratorType) {
+    let line = transactionLine;
+    while (exports.isDecorator(line)) {
+        if (line.lineDecoratorType === decoratorType) {
+            return line;
+        }
+        line = line.decoratedTransactionLine;
+    }
+    return undefined;
+}
+exports.getDecoratedTransactionLine = getDecoratedTransactionLine;
+/**
+ * Get the base transaction line after all the decorators while ascending the decoratedTransactionLine tree.
+ * @param {ITransactionLine} transactionLine
+ * @returns {ITransactionLine} The base transaction line found.
+ */
+function getBaseTransactionLine(transactionLine) {
+    let line = transactionLine;
+    while (exports.isDecorator(line)) {
+        line = line.decoratedTransactionLine;
+    }
+    return line;
+}
+exports.getBaseTransactionLine = getBaseTransactionLine;
+/**
+ * Gets all the decorated transaction lines of the specified decorator type found while ascending the
+ * decoratedTransactionLine tree.
+ * @param {ITransactionLine} transactionLine
+ * @param {string} decoratorTypes  Decorator types being looked for.
+ *        Transaction lines matching any of these will be included.
+ * @returns {ITransactionLine} The decoratedTransactionLines found, or any empty array if not found.
+ */
+function getDecoratedTransactionLines(transactionLine, decoratorTypes) {
+    const result = [];
+    let line = transactionLine;
+    while (exports.isDecorator(line)) {
+        // check if the line decorator type matches any of the decorator types being looked for
+        if (decoratorTypes.indexOf(line.lineDecoratorType) >= 0) {
+            result.push(line);
+        }
+        line = line.decoratedTransactionLine;
+    }
+    return result;
+}
+exports.getDecoratedTransactionLines = getDecoratedTransactionLines;
+/**
+ * Does there exist a decorator of the specific type for the transaction line?
+ * @param {ITransactionLine} transactionLine
+ * @param {string} decoratorType
+ * @returns {boolean}
+ */
+function isDecoratorOfType(transactionLine, decoratorType) {
+    return !!getDecoratedTransactionLine(transactionLine, decoratorType);
+}
+exports.isDecoratorOfType = isDecoratorOfType;
+/**
+ * BaseLineDecorator acts as the base class for all line decorators, handling the essentials of line decorating.
+ *
+ * Note: Subclasses must also implement/extend T (the type of line that they decorate), but this cannot be enforced in
+ * the class signature.
+ *
+ * T is the class or interface of line that is decorated by the subclass.
+ */
+class BaseLineDecorator extends BaseTransactionLine_1.BaseTransactionLine {
+    // End of BaseTransactionLine API --------------------------------------------------------------
+    // Since this class is abstract, only subclasses need access to the constructor.
+    constructor(lineDecoratorType, decoratedTransactionLine, annotationDescription, annotationSourceType, annotationSourceLineNumber, couldDecoratorAffectPricing, couldDecoratorAffectTaxation) {
+        super(decoratedTransactionLine.lineNumber, decoratedTransactionLine.lineType);
+        this._lineDecoratorType = lineDecoratorType;
+        this._decoratedTransactionLine = decoratedTransactionLine;
+        this._annotationDescription = annotationDescription;
+        this._annotationSourceType = annotationSourceType;
+        this._annotationSourceLineNumber = annotationSourceLineNumber;
+        this._couldDecoratorAffectPricing = couldDecoratorAffectPricing;
+        this._couldDecoratorAffectTaxation = couldDecoratorAffectTaxation;
+    }
+    static getLineDecoratorTypeFromJsonObject(transactionLineJsonObject) {
+        return transactionLineJsonObject._lineDecoratorType;
+    }
+    static getDecoratedTransactionLineJsonObjectFromJsonObject(transactionLineJsonObject) {
+        return transactionLineJsonObject._decoratedTransactionLine;
+    }
+    static getAnnotationDescriptionFromJsonObject(transactionLineJsonObject) {
+        return transactionLineJsonObject._annotationDescription;
+    }
+    static getAnnotationSourceTypeFromJsonObject(transactionLineJsonObject) {
+        return transactionLineJsonObject._annotationSourceType;
+    }
+    static getAnnotationSourceLineNumberFromJsonObject(transactionLineJsonObject) {
+        return transactionLineJsonObject._annotationSourceLineNumber;
+    }
+    static getCouldDecoratorAffectPricingFromJsonObject(transactionLineJsonObject) {
+        return transactionLineJsonObject._couldDecoratorAffectPricing;
+    }
+    static getCouldDecoratorAffectTaxationFromJsonObject(transactionLineJsonObject) {
+        return transactionLineJsonObject._couldDecoratorAffectTaxation;
+    }
+    // Decorator API -------------------------------------------------------------
+    get lineDecoratorType() {
+        return this._lineDecoratorType;
+    }
+    get decoratedTransactionLine() {
+        return this._decoratedTransactionLine;
+    }
+    get annotationDescription() {
+        return this._annotationDescription;
+    }
+    get annotationSourceType() {
+        return this._annotationSourceType;
+    }
+    get annotationSourceLineNumber() {
+        return this._annotationSourceLineNumber;
+    }
+    get couldDecoratorAffectPricing() {
+        return this._couldDecoratorAffectPricing;
+    }
+    get couldDecoratorAffectTaxation() {
+        return this._couldDecoratorAffectTaxation;
+    }
+    updateDecoratedTransactionLine(transactionLine) {
+        const updatedItemLineDecorator = this.clone();
+        updatedItemLineDecorator._decoratedTransactionLine = transactionLine;
+        // Fixme: this comment is no longer true with the updated typescript version
+        // Unfortunately, TS can't know that BaseLineDecorator<T> must implement T, because we cannot declare that
+        // BaseLineDecorator<T> implements T.
+        return updatedItemLineDecorator;
+    }
+    hasDecorator(lineDecoratorType) {
+        let transactionLine = this;
+        while (transactionLine && exports.isDecorator(transactionLine)) {
+            if (transactionLine.lineDecoratorType === lineDecoratorType) {
+                return true;
+            }
+            transactionLine = transactionLine.decoratedTransactionLine;
+        }
+        return false;
+    }
+    // BaseTransactionLine API --------------------------------------------------------------
+    get lineNumber() {
+        return this._decoratedTransactionLine.lineNumber;
+    }
+    get lineType() {
+        return this._decoratedTransactionLine.lineType;
+    }
+    get performingUser() {
+        return this._decoratedTransactionLine.performingUser;
+    }
+    get originalLineNumber() {
+        return this._decoratedTransactionLine.originalLineNumber;
+    }
+    get extendedAmount() {
+        return this._decoratedTransactionLine.extendedAmount;
+    }
+    get extendedAmountExcludingTax() {
+        return this._decoratedTransactionLine.extendedAmountExcludingTax;
+    }
+    get extendedAmountIncludingTax() {
+        return this._decoratedTransactionLine.extendedAmountIncludingTax;
+    }
+    get endDateTime() {
+        // If the endDate time has been set on the decorator, then use that, but if not, use the one on the decorated line.
+        // This avoids issues with undefined endDateTimes on decorated lines that do not have the endDateTime set on the
+        // decorator.
+        return super.endDateTime || this._decoratedTransactionLine.endDateTime;
+    }
+    get couldAffectPricing() {
+        return this._decoratedTransactionLine.couldAffectPricing;
+    }
+    get couldAffectTaxation() {
+        return this._decoratedTransactionLine.couldAffectTaxation;
+    }
+    get voided() {
+        // We don't want the decorator to make it look like all decorated lines are voidable, so we check that, first.
+        return VoidInterfaces_1.isVoidableLine(this._decoratedTransactionLine) ? this._decoratedTransactionLine.voided : undefined;
+    }
+    get voidSource() {
+        // We don't want the decorator to make it look like all decorated lines are voidable, so we check that, first.
+        return VoidInterfaces_1.isVoidableLine(this._decoratedTransactionLine)
+            ? this._decoratedTransactionLine.voidSource
+            : undefined;
+    }
+    clone() {
+        const newBaseLineDecorator = super.clone();
+        newBaseLineDecorator._lineDecoratorType = this._lineDecoratorType;
+        newBaseLineDecorator._decoratedTransactionLine = this._decoratedTransactionLine;
+        newBaseLineDecorator._annotationDescription = this._annotationDescription;
+        newBaseLineDecorator._annotationSourceType = this._annotationSourceType;
+        newBaseLineDecorator._annotationSourceLineNumber = this._annotationSourceLineNumber;
+        newBaseLineDecorator._couldDecoratorAffectPricing = this._couldDecoratorAffectPricing;
+        newBaseLineDecorator._couldDecoratorAffectPricing = this._couldDecoratorAffectTaxation;
+        return newBaseLineDecorator;
+    }
+    loadFromJsonObject(transactionLineJsonObj) {
+        // Decorators use a createFromJsonObject instead of this.
+        throw new scp_component_store_selling_core_1.PosError("Decorator creation from JSON is expected to use createFromJsonObject, not loadFromJsonObject", ErrorCodes_1.SSF_DECORATOR_ERROR_CODE);
+    }
+}
+exports.BaseLineDecorator = BaseLineDecorator;
+//# sourceMappingURL=BaseLineDecorator.js.map

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

@@ -0,0 +1,71 @@
+import { Money } from "@aptos-scp/scp-component-business-core";
+import { ITransactionLine, IUser } from "@aptos-scp/scp-component-store-selling-core";
+export declare abstract class BaseTransactionLine implements ITransactionLine {
+    private _lineNumber;
+    private _lineType;
+    private _extendedAmount;
+    private _extendedAmountExcludingTax?;
+    private _extendedAmountIncludingTax?;
+    private _endDateTime;
+    private _performingUser;
+    private _originalLineNumber;
+    static lineNumberFromJsonObject(transactionLineJsonObj: any): number;
+    static lineTypeFromJsonObject(transactionLineJsonObj: any): string;
+    static copiedFromLineNumberFromJsonObject(transactionLineJsonObj: any): number;
+    static zReportFromJsonObject(transactionLineJsonObj: any): string;
+    static fiscalIdFromJsonObject(transactionLineJsonObj: any): string;
+    static printerStatusFromJsonObject(transactionLineJsonObj: any): string;
+    static printerReportTypeFromJsonObject(transactionLineJsonObj: any): string;
+    static requestDataFromJsonObject(transactionLineJsonObj: any): string;
+    static printerSyncTypeFromJsonObject(transactionLineJsonObj: any): string;
+    static extendedAmountFromJsonObject(transactionLineJsonObj: any): Money;
+    static extendedAmountExcludingTaxFromJsonObject(transactionLineJsonObj: any): Money;
+    static extendedAmountIncludingTaxFromJsonObject(transactionLineJsonObj: any): Money;
+    static endDateTimeFromJsonObject(transactionLineJsonObj: any): Date;
+    get endDateTime(): Date;
+    /**
+     * Return TRUE if adding this line to a transaction should cause pricing for the transaction to be recalculated and
+     * FALSE otherwise.  This value is used to improve performance by avoiding unnecessary requests to calculate pricing.
+     * @returns {boolean}
+     */
+    abstract get couldAffectPricing(): boolean;
+    /**
+     * Return TRUE if adding this line to a transaction should cause taxation for the transaction to be recalculated and
+     * FALSE otherwise.  This value is used to improve performance by avoiding unnecessary requests to calculate taxes.
+     * @returns {boolean}
+     */
+    get couldAffectTaxation(): boolean;
+    get lineNumber(): number;
+    get lineType(): string;
+    get extendedAmount(): Money;
+    get extendedAmountExcludingTax(): Money;
+    get extendedAmountIncludingTax(): Money;
+    get performingUser(): IUser;
+    get originalLineNumber(): number;
+    setEndDate(endDateTime: Date): ITransactionLine;
+    setPerformingUser(performingUser: IUser): ITransactionLine;
+    setOriginalLineNumber(lineNumber: number): ITransactionLine;
+    protected constructor(lineNumber: number, lineType: string, extendedAmount?: Money, extendedAmountExcludingTax?: Money, extendedAmountIncludingTax?: Money, endDateTime?: Date, performingUser?: IUser, originalLineNumber?: number);
+    /**
+     * In general, line numbers should not be changed as they are part
+     * of the business key for a transaction line.  The updateLineNumber
+     * method should only be called by the line's copyLineWithNewLineNumber
+     * so that it is only used on a freshly copied line.
+     *
+     *  @param {number} lineNumber The line number to be used by the transaction line
+     *
+     * @return {ITransactionLine} The new line object that has the provided line number.
+     */
+    protected updateLineNumber(lineNumber: number): ITransactionLine;
+    protected clone(): BaseTransactionLine;
+    protected updateExtendedAmountValue(amount: Money): ITransactionLine;
+    protected updateExtendedAmountExcludingTaxValue(amount: Money): ITransactionLine;
+    protected updateExtendedAmountIncludingTaxValue(amount: Money): ITransactionLine;
+    /**
+     * All subclass must implement this, so that clone can get an instance of the correct class.
+     *
+     * @return {ITransactionLine}
+     */
+    protected abstract newTransactionLine(): BaseTransactionLine;
+    protected loadFromJsonObject(transactionLineJsonObj: any): void;
+}

package/lib/domain/model/BaseTransactionLine.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_business_core_1 = require("@aptos-scp/scp-component-business-core");
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const User_1 = require("./User");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.domain.model.BaseTransactionLine");
+class BaseTransactionLine {
+    // Since this is an abstract class, only subclasses need access to the constructor
+    constructor(lineNumber, lineType, extendedAmount, extendedAmountExcludingTax, extendedAmountIncludingTax, endDateTime, performingUser, originalLineNumber) {
+        this._lineNumber = lineNumber;
+        this._lineType = lineType;
+        this._extendedAmount = extendedAmount;
+        this._extendedAmountExcludingTax = extendedAmountExcludingTax;
+        this._extendedAmountIncludingTax = extendedAmountIncludingTax;
+        this._endDateTime = endDateTime;
+        this._performingUser = performingUser;
+        this._originalLineNumber = originalLineNumber;
+    }
+    static lineNumberFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._lineNumber;
+    }
+    static lineTypeFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._lineType;
+    }
+    static copiedFromLineNumberFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._copiedFromLineNumber;
+    }
+    static zReportFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._zReportNumber;
+    }
+    static fiscalIdFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._fiscalId;
+    }
+    static printerStatusFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._printerStatus;
+    }
+    static printerReportTypeFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._reportType;
+    }
+    static requestDataFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._requestData;
+    }
+    static printerSyncTypeFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._syncType;
+    }
+    static extendedAmountFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._extendedAmount
+            ? scp_component_business_core_1.Money.fromJSON(transactionLineJsonObj._extendedAmount)
+            : undefined;
+    }
+    static extendedAmountExcludingTaxFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._extendedAmountExcludingTax
+            ? scp_component_business_core_1.Money.fromJSON(transactionLineJsonObj._extendedAmountExcludingTax)
+            : undefined;
+    }
+    static extendedAmountIncludingTaxFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._extendedAmountIncludingTax
+            ? scp_component_business_core_1.Money.fromJSON(transactionLineJsonObj._extendedAmountIncludingTax)
+            : undefined;
+    }
+    static endDateTimeFromJsonObject(transactionLineJsonObj) {
+        return transactionLineJsonObj._endDateTime ? new Date(transactionLineJsonObj._endDateTime) : undefined;
+    }
+    get endDateTime() {
+        return this._endDateTime;
+    }
+    /**
+     * Return TRUE if adding this line to a transaction should cause taxation for the transaction to be recalculated and
+     * FALSE otherwise.  This value is used to improve performance by avoiding unnecessary requests to calculate taxes.
+     * @returns {boolean}
+     */
+    // NOTE: Logically, whenever a line can affect pricing, it also can affect taxation.
+    //       Further, it's expected to be rather rare for a line to affect taxation but NOT affect pricing
+    //       (consider the example of some kinds of tender such as WIC).
+    //       Therefore we provide this default implementation here in the base class.
+    get couldAffectTaxation() {
+        return this.couldAffectPricing;
+    }
+    get lineNumber() {
+        return this._lineNumber;
+    }
+    get lineType() {
+        return this._lineType;
+    }
+    get extendedAmount() {
+        return this._extendedAmount;
+    }
+    get extendedAmountExcludingTax() {
+        return this._extendedAmountExcludingTax;
+    }
+    get extendedAmountIncludingTax() {
+        return this._extendedAmountIncludingTax;
+    }
+    get performingUser() {
+        return this._performingUser;
+    }
+    get originalLineNumber() {
+        return this._originalLineNumber;
+    }
+    setEndDate(endDateTime) {
+        const entryMessage = logger.traceEntry("setEndDate", endDateTime);
+        const newLine = this.clone();
+        newLine._endDateTime = endDateTime;
+        return logger.traceExit(entryMessage, newLine);
+    }
+    setPerformingUser(performingUser) {
+        const entryMessage = logger.traceEntry("setPerformingUser");
+        const newLine = this.clone();
+        newLine._performingUser = performingUser;
+        return logger.traceExit(entryMessage, newLine);
+    }
+    setOriginalLineNumber(lineNumber) {
+        const entryMessage = logger.traceEntry("setPerformingUser");
+        const newLine = this.clone();
+        newLine._originalLineNumber = lineNumber;
+        return logger.traceExit(entryMessage, newLine);
+    }
+    /**
+     * In general, line numbers should not be changed as they are part
+     * of the business key for a transaction line.  The updateLineNumber
+     * method should only be called by the line's copyLineWithNewLineNumber
+     * so that it is only used on a freshly copied line.
+     *
+     *  @param {number} lineNumber The line number to be used by the transaction line
+     *
+     * @return {ITransactionLine} The new line object that has the provided line number.
+     */
+    updateLineNumber(lineNumber) {
+        const entryMessage = logger.traceEntry("updateLineNumber");
+        const newLine = this.clone();
+        newLine._lineNumber = lineNumber;
+        return logger.traceExit(entryMessage, newLine);
+    }
+    clone() {
+        const newTransactionLine = this.newTransactionLine();
+        newTransactionLine._lineNumber = this._lineNumber;
+        newTransactionLine._lineType = this._lineType;
+        newTransactionLine._extendedAmount = this._extendedAmount;
+        newTransactionLine._extendedAmountExcludingTax = this._extendedAmountExcludingTax;
+        newTransactionLine._extendedAmountIncludingTax = this._extendedAmountIncludingTax;
+        newTransactionLine._endDateTime = this._endDateTime;
+        newTransactionLine._performingUser = this._performingUser;
+        newTransactionLine._originalLineNumber = this._originalLineNumber;
+        return newTransactionLine;
+    }
+    updateExtendedAmountValue(amount) {
+        const newLine = this.clone();
+        newLine._extendedAmount = amount;
+        return newLine;
+    }
+    updateExtendedAmountExcludingTaxValue(amount) {
+        const newLine = this.clone();
+        newLine._extendedAmountExcludingTax = amount;
+        return newLine;
+    }
+    updateExtendedAmountIncludingTaxValue(amount) {
+        const newLine = this.clone();
+        newLine._extendedAmountIncludingTax = amount;
+        return newLine;
+    }
+    loadFromJsonObject(transactionLineJsonObj) {
+        // Note: _lineNumber and _lineType are handled by the constructor, but the extendedAmount and endDateTime are
+        // optional on the constructor, so we handle them here, if not handled previously.
+        if (!this._extendedAmount && transactionLineJsonObj._extendedAmount) {
+            this._extendedAmount = scp_component_business_core_1.Money.fromJSON(transactionLineJsonObj._extendedAmount);
+        }
+        if (!this._extendedAmountExcludingTax && transactionLineJsonObj._extendedAmountExcludingTax) {
+            this._extendedAmountExcludingTax = scp_component_business_core_1.Money.fromJSON(transactionLineJsonObj._extendedAmountExcludingTax);
+        }
+        if (!this._extendedAmountIncludingTax && transactionLineJsonObj._extendedAmountIncludingTax) {
+            this._extendedAmountIncludingTax = scp_component_business_core_1.Money.fromJSON(transactionLineJsonObj._extendedAmountIncludingTax);
+        }
+        if (!this._endDateTime && transactionLineJsonObj._endDateTime) {
+            this._endDateTime = new Date(transactionLineJsonObj._endDateTime);
+        }
+        if (!this._performingUser && transactionLineJsonObj._performingUser) {
+            this._performingUser = User_1.User.createFromJsonObject(transactionLineJsonObj._performingUser);
+        }
+        this._originalLineNumber = transactionLineJsonObj._originalLineNumber;
+    }
+}
+exports.BaseTransactionLine = BaseTransactionLine;
+//# sourceMappingURL=BaseTransactionLine.js.map

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

@@ -0,0 +1,21 @@
+export interface ICashDrawerResponse {
+    data?: ICashDrawer[];
+    limit?: number;
+    offset?: number;
+    totalCount?: number;
+}
+export interface ICashDrawer {
+    id: string;
+    alternateKey: string;
+    cashDrawerKey: string;
+    hasTerminal: boolean;
+}
+export interface ICashDrawerDetail extends ICashDrawer {
+    retailLocationKey: string;
+    terminalKey?: string;
+    till: TillSummary;
+}
+export interface TillSummary {
+    id: string;
+    tillKey: string;
+}

package/lib/domain/model/CashDrawerDetail.js

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