@shopfront/bridge 1.16.0 → 1.18.0

package/lib/APIs/Sale/CurrentSale.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrentSale = void 0;
+const BaseSale_1 = require("./BaseSale");
+const SaleUpdate_1 = require("../../Actions/SaleUpdate");
+const Exceptions_1 = require("./Exceptions");
+const Sale_1 = require("./Sale");
+class CurrentSale extends BaseSale_1.BaseSale {
+    /**
+     * Create a sale from a sale state.
+     * It's highly recommend to not construct a sale manually, instead use application.getCurrentSale().
+     *
+     * @param {Application} application
+     * @param {ShopfrontSaleState} saleState
+     */
+    constructor(application, saleState) {
+        super(Sale_1.Sale.buildSaleData(saleState));
+        this.application = application;
+        this.cancelled = false;
+    }
+    /**
+     * Update the sale to be the latest sale that exists on the sell screen.
+     *
+     * @returns {Promise<void>}
+     */
+    async refreshSale() {
+        this.checkIfCancelled();
+        const newSale = await this.application.getCurrentSale();
+        if (newSale === false) {
+            throw new Exceptions_1.InvalidSaleDeviceError();
+        }
+        this.hydrate(newSale);
+    }
+    /**
+     * Check if the sale has already been cancelled, if it has, throw a SaleCancelledError.
+     *
+     * @protected
+     */
+    checkIfCancelled() {
+        if (this.cancelled) {
+            throw new Exceptions_1.SaleCancelledError();
+        }
+    }
+    /**
+     * Send a sale update to Shopfront.
+     *
+     * @protected
+     * @param {SaleUpdate} update
+     * @returns {Promise<void>}
+     */
+    sendSaleUpdate(update) {
+        this.checkIfCancelled();
+        this.application.send(update);
+        return this.refreshSale();
+    }
+    /**
+     * Cancel the current sale in progress.
+     *
+     * @returns {Promise<void>}
+     */
+    async cancelSale() {
+        await this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("SALE_CANCEL", {}));
+        this.cancelled = true;
+    }
+    /**
+     * Add a product to the sale.
+     *
+     * @param {SaleProduct} product
+     * @returns {Promise<void>}
+     */
+    addProduct(product) {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("PRODUCT_ADD", {
+            id: product.getId(),
+            quantity: product.getQuantity(),
+            price: product.getPrice(),
+            indexAddress: product.getIndexAddress(),
+            metaData: product.getMetaData(),
+        }));
+    }
+    /**
+     * Remove a product from the sale.
+     * It's highly recommended that you pass in a product that has been retrieved using sale.getProducts().
+     *
+     * @param {SaleProduct} product
+     * @returns {Promise<void>}
+     */
+    removeProduct(product) {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("PRODUCT_REMOVE", {
+            id: product.getId(),
+            indexAddress: product.getIndexAddress(),
+        }));
+    }
+    /**
+     * Add a payment to the sell screen.
+     *
+     * If you specify a payment with a status, it will bypass the payment gateway (i.e. it won't request that the
+     * user takes money from the customer).
+     *
+     * If you don't specify a cashout amount, it will automatically determine if the payment method normally requests
+     * cashout (from the payment method settings).
+     *
+     * @param {SalePayment} payment
+     * @returns {Promise<void>}
+     */
+    addPayment(payment) {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("PAYMENT_ADD", {
+            id: payment.getId(),
+            amount: payment.getAmount(),
+            cashout: payment.getCashout(),
+            status: payment.getStatus(),
+        }));
+    }
+    /**
+     * Reverse a payment on the sell screen.
+     *
+     * This is used to issue a refund to the customer. The sale payment amount should be positive.
+     *
+     * @param {SalePayment} payment
+     * @returns {Promise<void>}
+     */
+    reversePayment(payment) {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("PAYMENT_REVERSE", {
+            id: payment.getId(),
+            amount: payment.getAmount(),
+            cashout: payment.getCashout(),
+            status: payment.getStatus(),
+        }));
+    }
+    /**
+     * Add a customer to the sale.
+     * If there is already a customer on the sale this will override that customer.
+     *
+     * @param {SaleCustomer} customer
+     * @returns {Promise<void>}
+     */
+    addCustomer(customer) {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("CUSTOMER_ADD", {
+            id: customer.getId(),
+        }));
+    }
+    /**
+     * Remove the customer from the current sale.
+     * If there is no customer currently on the sale this will be ignored.
+     * If there are "on account" or loyalty payments still on the sale, this will be ignored.
+     *
+     * @returns {Promise<void>}
+     */
+    removeCustomer() {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("CUSTOMER_REMOVE", {}));
+    }
+    /**
+     * Set the external note for the sale.
+     *
+     * @param {string} note The note to set.
+     * @param {boolean} append Whether to append the note to the current sale note.
+     * @returns {Promise<void>}
+     */
+    setExternalNote(note, append = false) {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("SALE_EXTERNAL_NOTE", {
+            note,
+            append,
+        }));
+    }
+    /**
+     * Set the internal note for the sale.
+     *
+     * @param {string} note The note to set.
+     * @param {boolean} append Whether to append the note to the current sale note.
+     * @returns {Promise<void>}
+     */
+    setInternalNote(note, append = false) {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("SALE_INTERNAL_NOTE", {
+            note,
+            append,
+        }));
+    }
+    /**
+     * Set the order reference to the provided string.
+     *
+     * @param {string} reference
+     * @returns {Promise<void>}
+     */
+    setOrderReference(reference) {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("SALE_ORDER_REFERENCE", {
+            reference,
+        }));
+    }
+    /**
+     * Set the meta data of the sale, this will override the previous meta data.
+     *
+     * @param metaData
+     */
+    setMetaData(metaData) {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("SALE_META_DATA", {
+            metaData,
+        }));
+    }
+    /**
+     * Update a product's details, currently this only updates the top-level meta data
+     * @param product
+     */
+    updateProduct(product) {
+        return this.sendSaleUpdate(new SaleUpdate_1.SaleUpdate("PRODUCT_UPDATE", {
+            id: product.getId(),
+            indexAddress: product.getIndexAddress(),
+            metaData: product.getMetaData(),
+        }));
+    }
+}
+exports.CurrentSale = CurrentSale;

package/lib/APIs/Sale/Exceptions.d.ts

@@ -0,0 +1,6 @@
+export declare class SaleCancelledError extends Error {
+    constructor();
+}
+export declare class InvalidSaleDeviceError extends Error {
+    constructor();
+}

package/lib/APIs/Sale/Exceptions.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidSaleDeviceError = exports.SaleCancelledError = void 0;
+class SaleCancelledError extends Error {
+    constructor() {
+        super("The sale is no longer active.");
+    }
+}
+exports.SaleCancelledError = SaleCancelledError;
+class InvalidSaleDeviceError extends Error {
+    constructor() {
+        super("This device is no longer a register able to perform a sale.");
+    }
+}
+exports.InvalidSaleDeviceError = InvalidSaleDeviceError;

package/lib/APIs/Sale/Sale.d.ts

@@ -0,0 +1,34 @@
+import { BaseSale, SaleData } from "./BaseSale";
+import { SaleCustomer } from "./SaleCustomer";
+import { SalePayment } from "./SalePayment";
+import { SaleProduct } from "./SaleProduct";
+import { Application } from "../../Application";
+import { ShopfrontSaleState } from "./ShopfrontSaleState";
+export declare class Sale extends BaseSale {
+    protected created: boolean;
+    protected creating: boolean;
+    constructor(data: SaleData);
+    addCustomer(customer: SaleCustomer): Promise<void>;
+    addPayment(payment: SalePayment): Promise<void>;
+    addProduct(product: SaleProduct): Promise<void>;
+    removeCustomer(): Promise<void>;
+    removeProduct(product: SaleProduct): Promise<void>;
+    removePayment(payment: SalePayment): Promise<void>;
+    setExternalNote(note: string, append?: boolean): Promise<void>;
+    setInternalNote(note: string, append?: boolean): Promise<void>;
+    setMetaData(metaData: Record<string, unknown>): Promise<void>;
+    setOrderReference(reference: string): Promise<void>;
+    updateProduct(product: SaleProduct): Promise<void>;
+    /**
+     * Create the sale on the server
+     */
+    create(application: Application): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Converts the sale state to the sale data
+     * @param saleState
+     */
+    static buildSaleData(saleState: ShopfrontSaleState): SaleData;
+}

package/lib/APIs/Sale/Sale.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sale = void 0;
+const BaseSale_1 = require("./BaseSale");
+const SaleCustomer_1 = require("./SaleCustomer");
+const SalePayment_1 = require("./SalePayment");
+const SaleProduct_1 = require("./SaleProduct");
+class Sale extends BaseSale_1.BaseSale {
+    constructor(data) {
+        super(data);
+        this.created = false;
+        this.creating = false;
+    }
+    async addCustomer(customer) {
+        this.customer = customer;
+    }
+    async addPayment(payment) {
+        if (this.payments.find(p => p.internalId === payment.internalId)) {
+            throw new TypeError("Payment has already been added to sale.");
+        }
+        this.payments.push(payment);
+    }
+    async addProduct(product) {
+        if (this.products.find(p => p.internalId === product.internalId)) {
+            throw new TypeError("Product has already been added to sale.");
+        }
+        this.products.push(product);
+    }
+    async removeCustomer() {
+        this.customer = null;
+    }
+    async removeProduct(product) {
+        const index = this.products.findIndex(p => p.internalId === product.internalId);
+        if (index === -1) {
+            throw new TypeError("Product could not be found in the sale.");
+        }
+        this.products.splice(index, 1);
+    }
+    async removePayment(payment) {
+        const index = this.payments.findIndex(p => p.internalId === payment.internalId);
+        if (index === -1) {
+            throw new TypeError("Payment could not be found in the sale.");
+        }
+        this.payments.splice(index, 1);
+    }
+    async setExternalNote(note, append) {
+        if (append) {
+            this.sale.notes.sale += note;
+        }
+        else {
+            this.sale.notes.sale = note;
+        }
+    }
+    async setInternalNote(note, append) {
+        if (append) {
+            this.sale.notes.internal += note;
+        }
+        else {
+            this.sale.notes.internal = note;
+        }
+    }
+    async setMetaData(metaData) {
+        this.sale.metaData = metaData;
+    }
+    async setOrderReference(reference) {
+        this.sale.orderReference = reference;
+    }
+    async updateProduct(product) {
+        const index = this.products.findIndex(p => p.internalId === product.internalId);
+        if (index === -1) {
+            throw new TypeError("Product could not be found in the sale.");
+        }
+        this.products[index] = product;
+    }
+    /**
+     * Create the sale on the server
+     */
+    async create(application) {
+        if (this.creating) {
+            throw new TypeError("Create function is currently running");
+        }
+        if (this.created) {
+            throw new TypeError("Sale has already been created");
+        }
+        this.creating = true;
+        const results = await application.createSale(this);
+        if (results.success) {
+            this.created = true;
+        }
+        this.creating = false;
+        return results;
+    }
+    /**
+     * Converts the sale state to the sale data
+     * @param saleState
+     */
+    static buildSaleData(saleState) {
+        return {
+            register: saleState.register,
+            clientId: saleState.clientId,
+            notes: saleState.notes,
+            totals: saleState.totals,
+            linkedTo: saleState.linkedTo,
+            orderReference: saleState.orderReference,
+            refundReason: saleState.refundReason,
+            priceSet: saleState.priceSet,
+            metaData: saleState.metaData,
+            customer: saleState.customer ? new SaleCustomer_1.SaleCustomer(saleState.customer.uuid) : null,
+            payments: saleState.payments.map(SalePayment_1.SalePayment.HydrateFromState),
+            products: saleState.products.map((product, index) => {
+                return SaleProduct_1.SaleProduct.HydrateFromState(product, [index]);
+            }),
+        };
+    }
+}
+exports.Sale = Sale;

package/lib/APIs/Sale/SaleCustomer.d.ts

@@ -0,0 +1,10 @@
+export declare class SaleCustomer {
+    protected id: string;
+    constructor(id: string);
+    /**
+     * Get the ID of the customer.
+     *
+     * @returns {string}
+     */
+    getId(): string;
+}

package/lib/APIs/Sale/SaleCustomer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaleCustomer = void 0;
+class SaleCustomer {
+    constructor(id) {
+        this.id = id;
+    }
+    /**
+     * Get the ID of the customer.
+     *
+     * @returns {string}
+     */
+    getId() {
+        return this.id;
+    }
+}
+exports.SaleCustomer = SaleCustomer;

package/lib/APIs/Sale/SalePayment.d.ts

@@ -0,0 +1,69 @@
+import { ShopfrontSalePayment } from "./ShopfrontSaleState";
+export declare enum SalePaymentStatus {
+    APPROVED = "completed",
+    DECLINED = "failed",
+    CANCELLED = "cancelled"
+}
+export declare class SalePayment {
+    readonly internalId: string;
+    protected id: string;
+    protected type?: string;
+    protected status?: SalePaymentStatus;
+    protected amount: number;
+    protected cashout?: number;
+    protected rounding?: number;
+    constructor(id: string, amount: number, cashout?: number, status?: SalePaymentStatus);
+    /**
+     * Hydrate a sale payment from the SaleState.
+     *
+     * @internal
+     * @param {ShopfrontSalePayment} payment
+     * @returns {SalePayment}
+     * @constructor
+     */
+    static HydrateFromState(payment: ShopfrontSalePayment): SalePayment;
+    /**
+     * Set the internal data for the payment.
+     * This method is for hydration of the payment from Shopfront, it's highly recommend that you DO NOT use this method.
+     *
+     * @internal
+     * @param {ShopfrontSalePayment} data
+     */
+    setInternal(data: ShopfrontSalePayment): void;
+    /**
+     * Get the ID of the sale payment method.
+     *
+     * @returns {string}
+     */
+    getId(): string;
+    /**
+     * Get the type of payment method this is.
+     *
+     * @returns {string | undefined}
+     */
+    getType(): string | undefined;
+    /**
+     * Get the status of this payment method.
+     *
+     * @returns {SalePaymentStatus | undefined}
+     */
+    getStatus(): SalePaymentStatus | undefined;
+    /**
+     * Get the value of this payment method.
+     *
+     * @returns {number}
+     */
+    getAmount(): number;
+    /**
+     * Get the cashout amount paid for on this payment method.
+     *
+     * @returns {number | undefined}
+     */
+    getCashout(): number | undefined;
+    /**
+     * Get the amount of rounding applied to this payment method.
+     *
+     * @returns {number | undefined}
+     */
+    getRounding(): number | undefined;
+}

package/lib/APIs/Sale/SalePayment.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SalePayment = exports.SalePaymentStatus = void 0;
+const UUID_1 = __importDefault(require("../../Utilities/UUID"));
+var SalePaymentStatus;
+(function (SalePaymentStatus) {
+    SalePaymentStatus["APPROVED"] = "completed";
+    SalePaymentStatus["DECLINED"] = "failed";
+    SalePaymentStatus["CANCELLED"] = "cancelled";
+})(SalePaymentStatus = exports.SalePaymentStatus || (exports.SalePaymentStatus = {}));
+class SalePayment {
+    constructor(id, amount, cashout, status) {
+        this.internalId = UUID_1.default.generate();
+        this.id = id;
+        this.amount = amount;
+        this.cashout = cashout;
+        this.status = status;
+    }
+    /**
+     * Hydrate a sale payment from the SaleState.
+     *
+     * @internal
+     * @param {ShopfrontSalePayment} payment
+     * @returns {SalePayment}
+     * @constructor
+     */
+    static HydrateFromState(payment) {
+        let status = SalePaymentStatus.APPROVED;
+        switch (payment.status) {
+            case "failed":
+                status = SalePaymentStatus.DECLINED;
+                break;
+            case "cancelled":
+                status = SalePaymentStatus.CANCELLED;
+                break;
+        }
+        const hydrated = new SalePayment(payment.method, payment.amount, payment.cashout, status);
+        hydrated.setInternal(payment);
+        return hydrated;
+    }
+    /**
+     * Set the internal data for the payment.
+     * This method is for hydration of the payment from Shopfront, it's highly recommend that you DO NOT use this method.
+     *
+     * @internal
+     * @param {ShopfrontSalePayment} data
+     */
+    setInternal(data) {
+        this.type = data.type;
+        this.rounding = data.rounding;
+    }
+    /**
+     * Get the ID of the sale payment method.
+     *
+     * @returns {string}
+     */
+    getId() {
+        return this.id;
+    }
+    /**
+     * Get the type of payment method this is.
+     *
+     * @returns {string | undefined}
+     */
+    getType() {
+        return this.type;
+    }
+    /**
+     * Get the status of this payment method.
+     *
+     * @returns {SalePaymentStatus | undefined}
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Get the value of this payment method.
+     *
+     * @returns {number}
+     */
+    getAmount() {
+        return this.amount;
+    }
+    /**
+     * Get the cashout amount paid for on this payment method.
+     *
+     * @returns {number | undefined}
+     */
+    getCashout() {
+        return this.cashout;
+    }
+    /**
+     * Get the amount of rounding applied to this payment method.
+     *
+     * @returns {number | undefined}
+     */
+    getRounding() {
+        return this.rounding;
+    }
+}
+exports.SalePayment = SalePayment;