@delicity/client-cart 1.2.11 → 1.2.13

package/jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+    transform: {
+        '^.+\\.(ts|tsx)$': 'ts-jest',
+    },
+    moduleNameMapper: {
+        '^@/(.*)$': '<rootDir>/src/$1'
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delicity/client-cart",
-  "version": "1.2.11",
+  "version": "1.2.13",
   "description": "Cart Client Package",
   "main": "index.js",
   "scripts": {

package/src/classes/Cart.ts

@@ -0,0 +1,563 @@
+import {
+    IAddress,
+    ICart,
+    ICartDelivery, ICartDiscount,
+    ICartItem,
+    ICartModifierGroup,
+    ICartPaymentMethod,
+    ICartPrice,
+    IClientConfig,
+    Menu,
+    MenuItem, MenuModifierGroup,
+    Merchant,
+    OrderModesEnum
+} from "@delicity/client-types";
+import {DateTime} from 'luxon';
+
+import {v4 as uuidv4} from 'uuid';
+
+import {
+    addDiscountCode,
+    getProductCount,
+    getProductPrice,
+    getProductPriceSum,
+    getTotalModifiersUnitPrice,
+    isItemAlreadyInCart,
+    isItemAvailable,
+    mandatoryModifierCheck, removeDiscountCode,
+    synchronizeCart
+} from "../service/CartService";
+
+import {getDeliveryDetails} from "../service/DeliveryService";
+import {formatPrice} from "../service/HelperService";
+// @ts-ignore
+import ScheduleManagement from "@delicity/backend-schedule-management";
+import {categoryAvailable} from "../service/CategoryAvailabilityService";
+
+export interface CartClass {
+    // Setters
+    setMenu(menu:Menu): Cart
+    setCart(cart:ICart): Cart
+    setWhen(when:string|null): Cart
+    setOrderMode(mode:OrderModesEnum): Cart
+    setAddress(address:IAddress): Promise<Cart>
+    setAddressComment(comment: string|null): Cart
+    setCartComment(comment:string|null): Cart
+    setAcceptCondition(acceptCondition:boolean):Cart
+    setPaymentMethods(paymentMethod:ICartPaymentMethod[]):Cart
+    pushError(field:string, code:string, vars:any): Cart
+    setErrors(errors:{field:string, code:string, vars:any}[]): Cart
+
+    // Getters
+    getCart(): ICart
+    getItems(): ICartItem[]
+    getTotalItems(): number
+    getTotalItemPrice(): number
+    getMerchantId():number
+    getCartUUID():string|undefined
+    getOrderMode(): OrderModesEnum
+    getCartComment():string|null
+    getDeliveryInfos():ICartDelivery|undefined
+    getPrices():null|ICartPrice
+    getWhen():null|string
+    getAcceptCondition():boolean
+    getPreparationDurationBetween():number[]|null
+    getPaymentMethods(): ICartPaymentMethod[]
+    getErrors(): {field:string, code:string, vars:any}[]
+    getDiscounts(): ICartDiscount[]
+    getCoupons(): ICartDiscount[]
+    canBePayOnsite(): boolean
+    getRemoteErrors(): any
+
+    // Methods
+    synchronize(): Promise<Cart>
+    addToCart(item: MenuItem, modifierGroup:ICartModifierGroup[], quantity:number, comment?:string): Cart
+    updateCart(cartItem:ICartItem, modifierGroup:ICartModifierGroup[], quantity:number, comment?:string): Cart
+    removeFromCart(cartItem: ICartItem): Cart
+    paymentMethodCard(type: 'card_token' | 'payment_method_id', token: string, brand:string, last4:string, expiration: string, amount?:number): Cart
+    paymentMethodWallet(type: 'apple_pay' | 'google_pay', amount?:number): Cart
+    paymentMethodOnsite(amount?:number): Cart
+    validateCart(): Cart
+    validateMerchantSchedule(): Cart
+    validateCartIfError(): Cart
+    resetErrors(): Cart
+    cartIntegrity(): void
+}
+
+export class Cart implements CartClass{
+    private cart: ICart
+    private merchant: Merchant
+    private menu: Menu
+    private config: IClientConfig;
+    private acceptCondition: boolean = false;
+    private errors:{field:string, code:string, vars: any}[] = []
+    private listeners:any = {};
+    private isPriceLoading: boolean = false;
+    private isDeliveryLoading: boolean = false;
+    private merchantSchedule: ScheduleManagement | undefined;
+    private remoteErrors: any;
+
+    constructor(config: IClientConfig, merchant: Merchant, menu: Menu, OrderMode: OrderModesEnum, when: string|null) {
+        this.merchant = merchant
+        this.menu = JSON.parse(JSON.stringify(menu))
+        this.config = config;
+        this.remoteErrors = {};
+
+        if(this.merchant.schedule){
+            this.merchantSchedule = new ScheduleManagement(this.merchant.schedule.slots, this.merchant.schedule.closes, this.merchant.schedule.options);
+        }
+
+        this.cart = {
+            uuid: uuidv4(),
+            createdAt: DateTime.now().toISO(),
+            merchantId: merchant.id,
+            preparationDurationBetween: null,
+            items: [],
+            totalItems: 0,
+            totalItemPrice: 0,
+            when: when,
+            comment: null,
+            type: OrderMode,
+        } as ICart;
+    }
+
+
+    on(event:string, callback:any) {
+        if (!this.listeners[event]) {
+            this.listeners[event] = [];
+        }
+        this.listeners[event].push(callback);
+    }
+
+    off(event:string, callback:any) {
+        if (!this.listeners[event]) return;
+        this.listeners[event] = [];
+    }
+
+    trigger(event:string, ...args:any) {
+        if (this.listeners[event]) {
+            this.listeners[event].forEach((callback: (arg0: any) => void) => {
+                // @ts-ignore
+                callback(...args);
+            });
+        }
+    }
+
+
+    setMenu(menu:Menu): Cart{
+        this.menu = JSON.parse(JSON.stringify(menu));
+        this.cartIntegrity();
+        this.updateCartProductPrices();
+        this.trigger('update-cart');
+        return this;
+    }
+    setCart(cart:ICart): Cart{
+        this.cart = cart;
+        this.cartIntegrity();
+        this.trigger('update-cart');
+        return this;
+    }
+
+    getPrices():null|ICartPrice{
+        return this.cart.prices||null;
+    }
+    getAcceptCondition():boolean{
+        return this.acceptCondition;
+    }
+    setAcceptCondition(acceptCondition:boolean):Cart{
+        this.acceptCondition = acceptCondition;
+        return this;
+    }
+    getPreparationDurationBetween():number[]|null{
+        return this.cart.preparationDurationBetween;
+    }
+
+    getIsDeliveryLoading():boolean{
+        return this.isDeliveryLoading
+    }
+    getIsPriceLoading():boolean{
+        return this.isPriceLoading
+    }
+    getRemoteErrors(): any{
+        return this.remoteErrors;
+    }
+
+    async setAddress(address:IAddress):Promise<Cart>{
+        if(this.cart.type !== OrderModesEnum.DELIVERY) throw new Error('invalid_order_mode');
+        this.isDeliveryLoading = true;
+        const delivery:ICartDelivery = await getDeliveryDetails(this.config, this.merchant.id, address.position);
+        this.cart.delivery = {
+            address,
+            ...delivery
+        };
+        this.isDeliveryLoading = false;
+        this.trigger('update-cart');
+        return this;
+    }
+    getDeliveryInfos():ICartDelivery|undefined{
+        return this.cart.delivery;
+    }
+
+    setCartComment(comment:string|null): Cart{
+        this.cart.comment = comment;
+        return this;
+    }
+    getCartComment():string|null{
+        return this.cart.comment;
+    }
+
+    updateCartProductPrices(){
+
+        for(let index in this.cart.items){
+            const menuItem: MenuItem = this.menu.items.find(m => m.id === this.cart.items[index].item.id) as MenuItem;
+            if(!menuItem) this.cart.items.splice(parseInt(index), 1);
+
+            const modifierGroups = this.cart.items[index].modifierGroups;
+            const quantity: number = this.cart.items[index].quantity;
+
+            this.cart.items[index].item = menuItem;
+            this.cart.items[index].unitPrice = getProductPrice(menuItem, this.cart.type) + getTotalModifiersUnitPrice(modifierGroups)
+            this.cart.items[index].totalPrice = (getProductPrice(menuItem, this.cart.type) + getTotalModifiersUnitPrice(modifierGroups)) * quantity
+        }
+        this.cart.totalItems = getProductCount(this.cart);
+        this.cart.totalItemPrice = getProductPriceSum(this.cart);
+        if(this.cart.paymentMethods && this.cart.paymentMethods.length>0){
+            this.updatePaymentMethodAmount();
+        }
+        this.validateCartIfError();
+    }
+
+    setOrderMode(mode:OrderModesEnum): Cart{
+        this.cart.type = mode;
+        if(!this.canBePayOnsite() && this.getPaymentMethods().some(e => e.type === 'cash')){
+            this.cart.paymentMethods = [];
+        }
+        this.updateCartProductPrices();
+        this.trigger('update-cart');
+        return this;
+    }
+    setWhen(when:string|null): Cart{
+        this.cart.when = when;
+        this.trigger('update-cart');
+        this.cartIntegrity(true);
+        this.validateCartIfError();
+        return this;
+    }
+    setAddressComment(comment: string|null): Cart {
+        if(this.cart.delivery?.address){
+            this.cart.delivery.address.additional_informations = comment;
+        }
+        return this;
+    }
+    getMerchantId():number{
+        return this.merchant.id;
+    }
+    getCartUUID():string|undefined{
+        return this.cart.uuid;
+    }
+    getOrderMode(): OrderModesEnum {
+        return this.cart.type;
+    }
+    getWhen(): null|string {
+        return this.cart.when;
+    }
+    getPaymentMethods(): ICartPaymentMethod[]{
+        return this.cart.paymentMethods||[];
+    }
+    setPaymentMethods(paymentMethods:ICartPaymentMethod[]):Cart{
+        this.cart.paymentMethods = paymentMethods;
+        return this;
+    }
+
+
+    getPaymentMethodTotalAmount():number{
+        if(!this.cart.paymentMethods) return 0;
+        return this.cart.paymentMethods.reduce((a, b) => a + b.amount, 0)
+    }
+
+    paymentMethodCard(type: 'card_token' | 'payment_method_id', token: string, brand:string, last4:string, expiration: string, amount?:number): Cart{
+        let leftToPay = this.getTotalPrice();
+        if(!this.cart.paymentMethods) this.cart.paymentMethods = [];
+
+        if(this.cart.paymentMethods){
+            const sum = this.getPaymentMethodTotalAmount();
+            if(sum === this.getTotalPrice()) this.cart.paymentMethods = [];
+            else leftToPay -= sum;
+        }
+        if(amount && leftToPay < amount){
+            this.cart.paymentMethods = [];
+        }
+        this.cart.paymentMethods.push({
+            type: 'card',
+            amount: amount ? amount : leftToPay,
+            card: {type, token, brand, last4, expiration}
+        });
+        return this;
+    }
+
+    paymentMethodWallet(type: 'apple_pay' | 'google_pay', amount?:number): Cart{
+        let leftToPay = this.getTotalPrice();
+        if(!this.cart.paymentMethods) this.cart.paymentMethods = [];
+
+        if(this.cart.paymentMethods){
+            const sum = this.getPaymentMethodTotalAmount();
+            if(sum === this.getTotalPrice()) this.cart.paymentMethods = [];
+            else leftToPay -= sum;
+        }
+        if(amount && leftToPay < amount){
+            this.cart.paymentMethods = [];
+        }
+        this.cart.paymentMethods.push({
+            type: "wallet",
+            wallet: {type},
+            amount: amount ? amount : leftToPay,
+        });
+        return this;
+    }
+
+    paymentMethodOnsite(amount?:number): Cart{
+        let leftToPay:number = this.getTotalPrice();
+        if(!this.cart.paymentMethods) this.cart.paymentMethods = [];
+        if(this.cart.paymentMethods){
+            const sum = this.getPaymentMethodTotalAmount();
+            if(sum === this.getTotalPrice()) this.cart.paymentMethods = [];
+            else leftToPay -= sum;
+        }
+        if(amount && leftToPay < amount){
+            this.cart.paymentMethods = [];
+        }
+        this.cart.paymentMethods.push({
+            type: 'cash',
+            amount: amount ? amount : leftToPay,
+        });
+        return this;
+    }
+
+
+
+    addToCart(item: MenuItem, modifierGroups:ICartModifierGroup[], quantity: number, comment?:string, replace?:ICartItem): Cart {
+        // Check if item have mandatory modifiers
+        if(!mandatoryModifierCheck(item, modifierGroups, this.menu)){
+            throw new Error('mandatory_field_missing');
+        }
+        // Check if item is available
+        if(!isItemAvailable(item, this.menu)){
+            throw new Error('item_not_available');
+        }
+
+        const index = isItemAlreadyInCart(item, modifierGroups, this.cart, comment);
+        if(index !== -1 && !replace){
+            this.cart.items[index].quantity += quantity;
+            this.cart.items[index].totalPrice = (getProductPrice(item, this.cart.type) + getTotalModifiersUnitPrice(modifierGroups)) * this.cart.items[index].quantity;
+        }
+        else{
+            const cartItem: ICartItem = {
+                uuid: uuidv4(),
+                item,
+                modifierGroups,
+                quantity,
+                comment: comment || null,
+                unitPrice: getProductPrice(item, this.cart.type) + getTotalModifiersUnitPrice(modifierGroups),
+                totalPrice: (getProductPrice(item, this.cart.type) + getTotalModifiersUnitPrice(modifierGroups)) * quantity
+            }
+            if(replace){
+                const index = this.cart.items.findIndex(i => i.uuid === replace.uuid);
+                this.cart.items.splice(index, 1, cartItem);
+            }
+            else{
+                this.cart.items.push(cartItem);
+            }
+        }
+
+        this.cart.totalItems = getProductCount(this.cart);
+        this.cart.totalItemPrice = getProductPriceSum(this.cart);
+        if(this.cart.paymentMethods && this.cart.paymentMethods.length>0){
+            this.updatePaymentMethodAmount();
+        }
+        this.validateCartIfError();
+        this.cartIntegrity(true);
+        this.trigger('update-cart');
+        return this;
+    }
+
+    removeFromCart(cartItem: ICartItem): Cart {
+        this.cart.items = this.cart.items.filter((item) => item.uuid !== cartItem.uuid);
+        this.cart.totalItems = getProductCount(this.cart);
+        this.cart.totalItemPrice = getProductPriceSum(this.cart);
+        if(this.cart.paymentMethods){
+            this.updatePaymentMethodAmount();
+        }
+        this.cartIntegrity(true);
+        this.trigger('update-cart');
+        return this;
+    }
+
+    updateCart(cartItem: ICartItem, modifierGroup:ICartModifierGroup[], quantity: number, comment?:string): Cart {
+        return this.addToCart(cartItem.item, modifierGroup, quantity, comment, cartItem);
+    }
+
+    getCart(): ICart {
+        return this.cart;
+    }
+    getItems(): ICartItem[] {
+        return this.cart.items;
+    }
+    getTotalItems(): number {
+        return this.cart.totalItems;
+    }
+    getTotalItemPrice(): number {
+        return this.cart.totalItemPrice;
+    }
+    getTotalPrice(): number {
+        return this.cart.prices?.total || this.cart.totalItemPrice;
+    }
+
+    canBePayOnsite(): boolean {
+        return [OrderModesEnum.PICKUP, OrderModesEnum.ON_SITE_COUNTER].includes(this.cart.type) && this.merchant.features.onsitePayment;
+    }
+
+    async synchronize(): Promise<Cart>{
+        if(this.cart.type === OrderModesEnum.DELIVERY && !this.cart.delivery){
+            throw new Error('no_delivery_address')
+        }
+        this.isPriceLoading = true;
+        const request:any = await synchronizeCart(this.config, this.cart);
+        if(this.cart.delivery && request.delivery){
+            this.cart.delivery = {
+                address: this.cart.delivery?.address,
+                ...request.delivery
+            };
+        }
+        this.cart.preparationDurationBetween = request.preparationDurationBetween;
+        this.cart.discounts = request.discounts;
+        this.cart.prices = request.prices;
+        this.remoteErrors = request.errors;
+        if(this.cart.paymentMethods && this.cart.paymentMethods.length>0){
+            this.updatePaymentMethodAmount();
+        }
+        this.isPriceLoading = false;
+        return this;
+    }
+
+
+    validateMerchantSchedule(): Cart{
+        this.errors = this.errors.filter(e => e.field !== 'schedule')
+        if(this.merchantSchedule){
+            const when = this.getWhen() !== null ? DateTime.fromISO(<string>this.getWhen()) : DateTime.now();
+            if(!this.merchantSchedule.isOpenAt(when)) this.errors.push({field: 'schedule', code: 'merchant_currently_close', vars: {}});
+        }
+        return this;
+    }
+    validateCart(): Cart{
+        this.errors = [];
+        if(this.cart.type === OrderModesEnum.DELIVERY && !this.cart.delivery) this.errors.push({field: 'address', code: 'no_address_defined', vars: {}});
+        if(this.cart.type === OrderModesEnum.DELIVERY && this.cart.delivery && !this.cart.delivery.available) this.errors.push({field: 'address', code: 'address_not_available', vars: {}});
+        if(!this.cart.paymentMethods || this.cart.paymentMethods?.length === 0) this.errors.push({field: 'payment_method', code: 'missing_payment_method', vars: {}});
+        if(!this.acceptCondition) this.errors.push({field: 'conditions', code: 'condition_not_accepted', vars: {}});
+        if(this.cart.type === OrderModesEnum.DELIVERY && this.merchant.settings.minDeliveryOrderPrice > this.cart.totalItemPrice) this.errors.push({field: 'prices', code: 'minium_delivery_product_price', vars: {min: formatPrice(this.merchant.settings.minDeliveryOrderPrice)}});
+        this.validateMerchantSchedule();
+        return this;
+    }
+    validateCartIfError(): Cart{
+        if(this.errors.length>0) this.validateCart();
+        return this;
+    }
+    resetErrors(): Cart{
+        this.errors = [];
+        return this;
+    }
+    getErrors(): {field:string, code:string, vars:any}[]{
+        return this.errors;
+    }
+    pushError(field:string, code:string, vars:any): Cart{
+        this.errors.push({field, code, vars});
+        return this;
+    }
+    setErrors(errors:{field:string, code:string, vars:any}[]): Cart{
+        this.errors = errors;
+        return this;
+    }
+    updatePaymentMethodAmount(){
+        const totalPrice = this.getTotalPrice();
+        if(this.cart.paymentMethods?.length === 1){
+            this.cart.paymentMethods[0].amount = totalPrice;
+        }
+        else if(this.cart.paymentMethods?.length === 2 && this.cart.paymentMethods?.some(p => p.type === 'meal-voucher')){
+            // if voucher, product price = voucher (max voucher limit)
+            // rest = payment method
+        }
+        else{
+            // If multiple payment methods, split amount
+        }
+    }
+
+    async addDiscountCoupon(code:string): Promise<Cart>{
+        await addDiscountCode(this.config, this.cart, code);
+        this.trigger('update-cart');
+        return this;
+    }
+    getDiscounts(): ICartDiscount[]{
+        return this.cart.discounts ?? [];
+    }
+    getCoupons(): ICartDiscount[]{
+        return this.cart.discounts?.filter(d => d.type === 'coupon') ?? [];
+    }
+    async removeDiscount(discount: number): Promise<Cart>{
+        await removeDiscountCode(this.config, this.cart, discount);
+        this.trigger('update-cart');
+        return this;
+    }
+
+
+    cartIntegrity(event:boolean=false): void{
+        // Check if cart products are still available in menu
+        if(this.cart.items.length>0){
+            const merchantSchedule = new ScheduleManagement(this.merchant.schedule.slots, this.merchant.schedule.closes, this.merchant.schedule.options);
+
+            const toRemove:ICartItem[] = [];
+            for(const i in this.cart.items){
+                // Remove from cart if item not in menu anymore
+                const menuItem = this.menu.items.find(m => m.id === this.cart.items[i].item.id);
+                const category = this.menu.categories.find(c => c.itemIds?.includes(this.cart.items[i].item.uid))
+                if(!menuItem){
+                    toRemove.push(this.cart.items[i]);
+                    continue;
+                }
+                // Remove from cart if item not available
+                if(menuItem.unavailable){
+                    toRemove.push(this.cart.items[i]);
+                    continue;
+                }
+                // Check if product is available
+                if(category?.availability){
+                    const atDate = this.cart.when ? DateTime.fromISO(this.cart.when) : DateTime.now();
+                    // @ts-ignore
+                    const categoryAvailability = categoryAvailable(category.availability, atDate, merchantSchedule);
+                    if(!categoryAvailability.isAvailable){
+                        toRemove.push(this.cart.items[i]);
+                        if(event){
+                            // Used when cart update check.
+                            this.trigger('product-removed:not-available-at-date', this.cart.items[i])
+                        }
+                        continue;
+                    }
+                }
+                // Update from menu
+                this.cart.items[i].item = menuItem;
+            }
+
+            // Remove item from cart when necessary
+            toRemove.forEach((cartItem) => {
+                this.cart.items = this.cart.items.filter((item) => item.uuid !== cartItem.uuid);
+            });
+
+            // Update cart
+            this.cart.totalItems = getProductCount(this.cart);
+            this.cart.totalItemPrice = getProductPriceSum(this.cart);
+            if(this.cart.paymentMethods && this.cart.paymentMethods.length>0){
+                this.updatePaymentMethodAmount();
+            }
+        }
+    }
+
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './classes/Cart'
+export * from './service/CartService'
+export * from './service/CategoryAvailabilityService'