@delicity/client-cart 1.2.13 → 1.2.14

package/src/classes/Cart.ts

@@ -1,563 +0,0 @@
-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

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

package/src/service/CartService.ts

@@ -1,139 +0,0 @@
-import {
-    ICart,
-    ICartItem,
-    ICartModifierGroup,
-    IClientConfig,
-    Menu,
-    MenuItem,
-    OrderModesEnum
-} from "@delicity/client-types";
-import axios from "axios";
-
-export function getProductPriceSum(cart:ICart): number{
-    return cart.items.reduce((acc, item) => acc + item.totalPrice, 0);
-}
-export function getProductCount(cart:ICart): number{
-    return cart.items.reduce((acc, item) => acc + item.quantity, 0);
-}
-
-export function getItemModifierValue(item:ICartItem): string {
-    return getItemModifierValueArray(item).join(', ');
-}
-export function getItemModifierValueArray(item:ICartItem): string[] {
-    return item.modifierGroups
-        .filter(mg => mg.modifiers.length > 0)
-        .map(mg => {
-            return mg.item.name + ': ' + mg.modifiers.map(m => m.item.name).join(', ');
-        })
-}
-
-export function mandatoryModifierCheck(item: MenuItem, cartModifier: ICartModifierGroup[], menu: Menu): boolean{
-    if(!item.children) return true;
-
-    // get all mandatory modifiers in this item.
-    const modifierGroups = menu.modifierGroups.filter((m:any) => item.children?.includes(m.uid) && m.min>0 && m.min);
-
-    for(let modifier of modifierGroups){
-        const m = cartModifier.find((m:any) => m.item.uid === modifier.uid);
-        if(!m) return false;
-        if(modifier.min === null) continue;
-
-        const selectedOption = m.modifiers.reduce((acc:any, m:any) => acc + m.quantity, 0);
-        if(selectedOption < modifier.min) return false;
-    }
-
-    return true;
-}
-
-export function isItemAvailable(item: MenuItem, menu: Menu){
-    const menuItem = menu.items.find((i:any) => i.uid === item.uid);
-    if(!menuItem) return false;
-    return !menuItem.unavailable;
-}
-
-
-export function getProductPrice(item:MenuItem, mode:OrderModesEnum): number{
-    if(!item.price){
-        throw new Error('price_not_set');
-    }
-    if(typeof item.price === 'number'){
-        return item.price;
-    }
-    if(mode === 'delivery'){
-        return item.price.delivery;
-    }
-    else if(mode === 'pickup'){
-        return item.price.pickup;
-    }
-    else if(mode === 'on_site_counter'){
-        return item.price.onsite;
-    }
-    return item.price.delivery;
-}
-
-export function getTotalModifiersUnitPrice(modifierGroup:ICartModifierGroup[]): number{
-    return modifierGroup.reduce((acc, mg) => acc + mg.modifiers.reduce((bcc, m) => bcc + m.price, 0), 0);
-}
-
-export function isItemAlreadyInCart(item:MenuItem, modifierGroups:ICartModifierGroup[], cart:ICart, comment?:string): number{
-    // Check if item is already in cart
-    const sameCartProducts = cart.items
-        .filter((i) => i.item.uid === item.uid)
-        .filter((i) => i.comment === (comment||null))
-        .filter((c) => {
-            if(c.modifierGroups.length !== modifierGroups.length) return false;
-            const newItemModifierGroupsKey = modifierGroups.flatMap((m) => {
-                return m.modifiers.map((o) => {return {id: o.item.id, quantity: o.quantity}});
-            }).sort((a, b) => a.id - b.id).map((m) => m.id + ':' + m.quantity).join('|');
-            const CartItemModifierGroupsKey = c.modifierGroups.flatMap((m) => {
-                return m.modifiers.map((o) => {return {id: o.item.id, quantity: o.quantity}});
-            }).sort((a, b) => a.id - b.id).map((m) => m.id + ':' + m.quantity).join('|');
-            return newItemModifierGroupsKey === CartItemModifierGroupsKey;
-        })
-
-    // If not existing in cart, return -1
-    if(sameCartProducts.length === 0) return -1;
-
-    return cart.items.findIndex((c) => c.uuid === sameCartProducts[0].uuid);
-}
-
-
-export function synchronizeCart(config:IClientConfig, cart: ICart){
-    return new Promise(((resolve, reject) => {
-        config.axiosClient.post(config.apiUrl+'/v1/client/cart/'+cart.uuid, cart)
-            .then((response) => {
-                resolve(response.data);
-            })
-            .catch((error) => {
-                reject(error);
-            })
-    }));
-}
-
-
-export function addDiscountCode(config:IClientConfig, cart: ICart, code: string){
-    return new Promise(((resolve, reject) => {
-        config.axiosClient.put(config.apiUrl+'/v1/client/cart/'+cart.uuid+"/coupon", {code})
-            .then((response) => {
-                resolve(response.data);
-            })
-            .catch((error) => {
-                reject(error);
-            })
-    }));
-}
-
-
-export function removeDiscountCode(config:IClientConfig, cart: ICart, discountId: number){
-    return new Promise(((resolve, reject) => {
-        config.axiosClient.delete(config.apiUrl+'/v1/client/cart/'+cart.uuid+'/coupon/'+discountId)
-            .then((response) => {
-                resolve(response.data);
-            })
-            .catch((error) => {
-                reject(error);
-            })
-    }));
-}
-
-