@sommpicks/sommpicks-shopify 24.12.0

package/shopify/ShopifyOrderService.ts

@@ -0,0 +1,1143 @@
+import { AbstractService } from './base/AbstractService';
+import { AxiosInstance } from 'axios';
+import CountryCodeService from '../services/CountryCodeService';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+import { Logger } from '../Logger';
+import { ShopifyShopService } from './ShopifyShopService';
+import gql from 'graphql-tag';
+import { print } from 'graphql';
+import InspiraShopifyCustomError from './errors/InspiraShopifyCustomError';
+import InspiraShopifyUnableToReserveInventoryError from './errors/InspiraShopifyUnableToReserveInventoryError';
+
+export class ShopifyOrderService extends AbstractService{
+
+    private shopifyShopService: ShopifyShopService;
+
+    private draftOrderGraphQLMutation = gql`
+        mutation draftOrderCalculate($input: DraftOrderInput!) {
+            draftOrderCalculate(input: $input) {
+                calculatedDraftOrder {
+                    totalTax
+                    taxLines {
+                        priceSet {
+                            shopMoney{
+                                amount
+                                currencyCode
+                            }
+                        }
+                        title
+                        rate
+                    }
+                    shippingLine {
+                        taxLines {
+                            rate
+                            title
+                            priceSet {
+                                shopMoney {
+                                    amount
+                                    currencyCode
+                                }
+                            }
+                        }
+                    }
+                    availableShippingRates{
+                        handle
+                        title
+                        price {
+                            amount
+                            currencyCode
+                        }
+                    }
+                }
+                userErrors {
+                    field
+                    message
+                }
+            }
+        }
+    `;
+
+    constructor(private axiosInstance: AxiosInstance) { 
+        super();
+        this.shopifyShopService = new ShopifyShopService(axiosInstance);
+    }
+
+    public getFulfillments = async (orderId: number): Promise<IFulFillment[]> => {
+        return new Promise<IFulFillment[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - getFulfillments -> for order ID ${orderId}`);
+                const response = await this.axiosInstance.get(`/orders/${orderId}/fulfillments.json`);
+                resolve(response.data.fulfillments);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getFulfillmentOrders = async (orderId: number): Promise<IFulFillmentOrder[]> => {
+        return new Promise<IFulFillmentOrder[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - getFulfillmentOrders -> for order ID ${orderId}`);
+                const response = await this.axiosInstance.get(`/orders/${orderId}/fulfillment_orders.json`);
+                resolve(response.data.fulfillment_orders);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Gets all orders after the date given, can also take a timestring
+     * 
+     * @param  {string} dateTime
+     * @returns Promise
+     */
+    public getByMinDateUpdated = async (dateTime: string): Promise<IOrder[]> => {
+        return new Promise<IOrder[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - getByMinDateUpdated -> getting order from the: ${dateTime}`);
+                const response = await this.axiosInstance.get(`/orders.json?status=open&created_at_min=${dateTime}`);
+                resolve(response.data.orders);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Gets all orders before the date given
+     * 
+     * @param  {string} dateTime
+     * @returns Promise
+     */
+    public getByMaxDateUpdated = async (dateTime: string): Promise<IOrder[]> => {
+        return new Promise<IOrder[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - getByMaxDateUpdated ->getting order past the: ${dateTime}`);
+                const response = await this.axiosInstance.get(`/orders.json?status=open&created_at_max=${dateTime}`);
+                resolve(response.data.orders);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getById = async (orderId: number): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - getById -> getting order for ID ${orderId}`);
+                const response = await this.axiosInstance.get(`/orders/${orderId}.json`);
+                resolve(response.data.order);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getByIdWithOptions = async (orderId: number, options: { add_tx?: boolean; }): Promise<IOrder> => {
+        try {
+            Logger.info(`ShopifyOrderService - getByIdWithOptions -> Get product with id ${orderId}`);
+            let ordderToReturn: IOrder = null;
+
+            const orderQuery = `{ order(id: "${this.getGraphOrderIdFromId(orderId)}")  {
+                    id
+                    name
+                    ${options.add_tx === false ? '' : 'transactions { formattedGateway gateway authorizationCode }'}
+                }
+            }`;
+            Logger.info(`ShopifyOrderService - getByIdWithOptions -> Order graphQL query going in ${orderQuery}`);
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(gql`${orderQuery}`) }, { query_cost: 80 });
+            if (response && response.data && response.data.data && response.data.data.order) {
+                const responseOrder: ShopifygraphQl.IGenericOrderResponse = response.data.data.order;
+                ordderToReturn = {
+                    id: this.getIdFromGraphId(responseOrder.id),
+                    name: responseOrder.name,
+                    transaction: responseOrder.transaction ? responseOrder.transaction : null
+                };
+            }
+            Logger.info(`ShopifyOrderService - getByIdWithOptions -> ${ordderToReturn?.id} Products returning`);
+            return ordderToReturn;
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    public getInBatchGraphQL = async (channel: 'web', gateWay: 'shopify_payments', cursor: string): Promise<IOrderBatch> => {
+        try {
+            Logger.info(`ShopifyOrderService - getInBatchGraphQL - channel ${channel}, gateWay: ${gateWay}`);
+            let ordersToReturn: IOrderInBatch[] = [];
+            const queryParams = `channel:${channel},gateway:${gateWay}`;
+
+            const orderQuery = `{ orders(first: 250, ${ cursor ? `after: "${cursor}",` : ''} sortKey: ID, reverse: true, query:  "${queryParams}")  {
+                    pageInfo {
+                        hasNextPage
+                        hasPreviousPage
+                        startCursor
+                        endCursor
+                    }
+                    edges {
+                        cursor
+                        node {
+                            id
+                            createdAt
+                            email
+                            customAttributes {
+                                key
+                                value
+                            }
+                            customer {
+                                    id
+                                    tags
+                                    defaultEmailAddress {
+                                        marketingOptInLevel
+                                        marketingState
+                                        marketingUpdatedAt
+                                }
+                            }
+                        }
+                    }
+                   
+                }
+            }`;
+            Logger.info(`ShopifyProductListService - getInBatchGraphQL -> Order graphQL query going in ${orderQuery}`);
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(gql`${orderQuery}`) }, { query_cost: 250 });
+            let nextCursor: string = null;
+            if (response && response.data && response.data.data && response.data.data.orders) {
+                const responseOrder: { pageInfo: ShopifygraphQl.IPageInfo, edges: { cursor: string; node: IOrderInBatch; }[]} = response.data.data.orders;
+                nextCursor = responseOrder.pageInfo.hasNextPage ? responseOrder.pageInfo.endCursor : null;
+                ordersToReturn = responseOrder.edges.map(edge => edge.node);
+            }
+            Logger.info(`ShopifyProductListService - getInBatchGraphQL -> ${ordersToReturn?.length} Orders returning`);
+            return { orders: ordersToReturn, nextCursor: nextCursor };
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    public getInBatch = async (sinceId: number, pageNumber: number, getBachesNumber: boolean, orderstatus?: IOrderStatus): Promise<IOrderBatch_DEPRECATED> => {
+        return new Promise<IOrderBatch_DEPRECATED>(async (resolve, reject) => {
+            try {
+                Logger.info(`Getting orders since id ${sinceId}`);
+                if(!orderstatus) { orderstatus = 'any'; }
+                let batches = 0;
+                let count = 0;
+                if(getBachesNumber) {
+                    const response = await this.axiosInstance.get('/orders/count.json?status=any');
+                    count = response.data.count;
+                    batches = parseInt(((count / pageNumber) + 1).toString());
+                }
+                const orderBatch: IOrderBatch_DEPRECATED = { count: count, batches : batches, orders: [], nextSinceId: 0 }; 
+                const ordersGetURL = `/orders.json?status=${orderstatus}&limit=${pageNumber}&since_id=${sinceId}`;
+                Logger.info(`Getting orders since id URL ${ordersGetURL}`);
+                const ordersRetrieved = await this.axiosInstance.get(ordersGetURL);
+                if(ordersRetrieved.data.orders && ordersRetrieved.data.orders.length > 0) {
+                    orderBatch.orders = ordersRetrieved.data.orders;
+                    orderBatch.nextSinceId = orderBatch.orders[orderBatch.orders.length - 1].id;
+                } else {
+                    Logger.info('Getting orders is returned empty');
+                    orderBatch.orders = [];
+                    orderBatch.nextSinceId = 0;
+                }
+                resolve(orderBatch);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getAll = async (orderstatus?: IOrderStatus): Promise<IOrder[]> => {
+        return new Promise<IOrder[]>(async (resolve, reject) => {
+            try {
+                if(!orderstatus) { orderstatus = 'any'; }
+                Logger.info('ShopifyOrderService - getAll -> getting orders');
+                let orders: IOrder[] = [];
+                const response = await this.axiosInstance.get('/orders/count.json');
+                const count = response.data.count;
+                Logger.info(`ShopifyOrderService - getAll -> Getting ${count} orders`);
+                while (orders.length < count) {
+                    let ordersGetURL = `/orders.json?status=${orderstatus}&limit=250&since_id=`;
+                    if(orders.length > 1) {
+                        ordersGetURL += orders[orders.length - 1].id;
+                    } else {
+                        ordersGetURL += '0';  
+                    }
+                    const currentPage = (parseInt((orders.length / 250).toFixed(0)) + 1);
+                    Logger.info('ShopifyOrderService - getAll -> Orders Get URL  -> ', ordersGetURL );
+                    const ordersRetrieved = await this.axiosInstance.get(ordersGetURL);
+                    orders = orders.concat(ordersRetrieved.data.orders);
+                    Logger.info('ShopifyOrderService - getAll -> Orders retrieved -> ' + orders.length);
+                    const nextPage = (parseInt((orders.length / 250).toFixed(0)) + 1);
+                    if(currentPage === nextPage) {
+                        Logger.info('ShopifyOrderService - getAll -> Orders next page is the current page so, we are breaking the loop!');
+                        break;
+                    }
+                }
+                resolve(orders);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Adds a metafield.
+     *
+     * @param  {number} id - order ID
+     * @param  {IMetafield} metafield to be saved
+     * @returns Promise
+     */
+    public addMetafield = async (id: number, metafield: IMetafield): Promise<IMetafield> => {
+        return new Promise<IMetafield>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - addMetafield -> Adding Metafield for order id ->  ${id}`);
+                const response =  await this.axiosInstance.post(`/orders/${id}/metafields.json`, { metafield: metafield });
+                resolve(response.data.metafield);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Gets an order only with attributes and line item ids. Gets a max of 200 lineitems 
+     * 
+     * @param  {number} orderId
+     * @returns Promise
+     */
+    public getOrderMinimalById = async (orderId: number): Promise<IOrderMinimal> => {
+        return new Promise<IOrderMinimal>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - getOrderMinimalById -> Get Minimal order with ID: ${orderId}`);
+                const query = gql`{ 
+                    order(id: "gid://shopify/Order/${orderId}")  {
+                        lineItems(first: 200) {
+                            edges {
+                                node {
+                                    id
+                                    unfulfilledQuantity
+                                    customAttributes {
+                                        key
+                                        value
+                                    }
+                                    product {
+                                        id
+                                    }
+                                    variant {
+                                        id
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }`;
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 803 });
+                if(response && response.data && response.data.data && response.data.data.order){
+                    const orderGraph = response.data.data.order;
+
+                    resolve({   id: orderId,
+                        line_items: orderGraph.lineItems.edges.map( (gi) => 
+                            ({  id: this.getIdFromGraphId(gi.node.id),
+                                unfulfilledQuantity: gi.node.unfulfilledQuantity,
+                                properties: gi.node.customAttributes.map( (attr) => ({ value: attr.value, name: attr.key } as IProperty) ),
+                                variant_id: gi.node.variant ? this.getIdFromGraphId(gi.node.variant.id) : null,
+                                product_id: gi.node.product ? this.getIdFromGraphId(gi.node.product.id) : null } as ILineItemMinimal ) )});
+                } else {
+                    Logger.error(`ShopifyOrderService - getOrderMinimalById -> getOrderMinimalById not the expected response. Data ${JSON.stringify(response.data.data)}. Error is ${JSON.stringify(response.data.errors)}` );
+                    resolve(null);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Gets an order only with attributes and line item ids. Gets a max of 200 line items 
+     * 
+     * @param  {number} orderId
+     * @returns Promise
+     */
+    public getOrderProductTagsById = async (orderId: number): Promise<IOrderProductTags> => {
+        return new Promise<IOrderProductTags>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - getOrderProductTagsById ->Get getOrderProductTagsById order with ID: ${orderId}`);
+                const query = gql`{ 
+                    order(id: "gid://shopify/Order/${orderId}")  {
+                        phone
+                        email
+                        customer {
+                            firstName
+                            lastName
+                        }
+                        customAttributes {
+                            key
+                            value
+                        }
+                        shippingAddress {
+                            address1
+                            zip
+                            firstName
+                            lastName
+                            city
+                            province
+                            address2
+                        }
+                        billingAddress {
+                            address1
+                            zip
+                            firstName
+                            lastName
+                            city
+                            province
+                            address2
+                        }
+                        note
+                        lineItems(first: 200) {
+                            edges {
+                                node {
+                                    id
+                                    product {
+                                        id
+                                        tags
+                                    }
+                                    variant {
+                                        title
+                                        id
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }`;
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 803 });
+                if(response && response.data && response.data.data && response.data.data.order){
+                    const orderGraph = response.data.data.order;
+
+                    resolve({   id: orderId,
+                        phone: orderGraph.phone,
+                        note: orderGraph.note,
+                        note_attributes: (orderGraph.customAttributes && orderGraph.customAttributes.length ? orderGraph.customAttributes.map(attr => ({ name: attr.key, value: attr.value})): []) as IAttr[],
+                        email: orderGraph.email,
+                        shipping_address: orderGraph.shippingAddress ? { address1: orderGraph.shippingAddress.address1, address2: orderGraph.shippingAddress.address2, zip: orderGraph.shippingAddress.zip, 
+                            city: orderGraph.shippingAddress.city, last_name: orderGraph.shippingAddress.lastName, first_name: orderGraph.shippingAddress.firstName, country: orderGraph.shippingAddress.country,
+                            province: orderGraph.shippingAddress.province, phone: orderGraph.shippingAddress.phone } as IAddress : null,
+                        billing_address: orderGraph.billingAddress ? { address1: orderGraph.billingAddress.address1, address2: orderGraph.billingAddress.address2, zip: orderGraph.billingAddress.zip, 
+                            city: orderGraph.billingAddress.city, last_name: orderGraph.billingAddress.lastName, first_name: orderGraph.billingAddress.firstName, country: orderGraph.billingAddress.country,
+                            province: orderGraph.billingAddress.province, phone: orderGraph.billingAddress.phone } as IAddress : null,
+                        customer: { first_name: orderGraph.customer.firstName, last_name: orderGraph.customer.lastName },
+                        line_items: orderGraph.lineItems.edges.map( (gi) => 
+                            ({  id: this.getIdFromGraphId(gi.node.id), title: gi.node.variant?.title ? gi.node.variant?.title : '',
+                                variant_id: gi.node.variant ? this.getIdFromGraphId(gi.node.variant.id) : null,
+                                product: gi.node.product ? { id: this.getIdFromGraphId(gi.node.product.id), tags: gi.node.product.tags } : null } as any ) )});
+                } else {
+                    Logger.error(`ShopifyOrderService - getOrderProductTagsById -> not the expected response. Data ${JSON.stringify(response.data.data)}. Error is ${JSON.stringify(response.data.errors)}` );
+                    resolve(null);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getCount = async (orderstatus?: IOrderStatus): Promise<number> => {
+        return new Promise<number>(async (resolve, reject) => {
+            try {
+                if(!orderstatus) { orderstatus = 'any'; }
+                Logger.info('ShopifyOrderService - getCount -> getting orders count');
+                const response = await this.axiosInstance.get('/orders/count.json');
+                const count = response.data.count;
+                resolve(count);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public createFulfillments = async (orderId: number, orderFulfillmentPetitions: IFulFillmentLine[], notifyCustomer: boolean, shipmentStatus: IShipmentStatus): Promise<IFulFillment> => {
+        return new Promise<IFulFillment>(async (resolve, reject) => {
+            try {
+                const fulfillmentOrders = await this.getFulfillmentOrders(orderId);
+                Logger.info(`ShopifyOrderService - createFulfillments -> Retrieved fulfillment Orders for order ID ${orderId}`, `${JSON.stringify(fulfillmentOrders)}`);
+                Logger.info(`ShopifyOrderService - createFulfillments -> Fulfillment Petitions for order ID ${orderId}`, `${JSON.stringify(orderFulfillmentPetitions)}`);
+                const fulfillment: IFulfillmentsPost = { notify_customer: notifyCustomer, line_items_by_fulfillment_order: [] };
+                for(const fulfillmentOrder of fulfillmentOrders) {
+                    for(const fulfillmentOrderLineItem of fulfillmentOrder.line_items) {
+                        if(fulfillmentOrderLineItem.fulfillable_quantity > 0) {
+                            const orderFulfillmentPetitionIndex = orderFulfillmentPetitions.findIndex((orf) => orf && orf.line_item_id === fulfillmentOrderLineItem.line_item_id);
+                            if(orderFulfillmentPetitionIndex > -1) {
+                                const orderFulfillmentPetition = orderFulfillmentPetitions[orderFulfillmentPetitionIndex];
+                                if(orderFulfillmentPetition) {
+                                    const quantityToFulfill = fulfillmentOrderLineItem.fulfillable_quantity >= orderFulfillmentPetition.quantity_delivered ? orderFulfillmentPetition.quantity_delivered : fulfillmentOrderLineItem.fulfillable_quantity;
+                                    const existingFulfilmentToPost = fulfillment.line_items_by_fulfillment_order.findIndex(f => f.fulfillment_order_id === fulfillmentOrder.id);
+                                    if(existingFulfilmentToPost > -1) {
+                                        fulfillment.line_items_by_fulfillment_order[existingFulfilmentToPost].fulfillment_order_line_items.push({ id: fulfillmentOrderLineItem.id, quantity: quantityToFulfill });
+                                    } else {
+                                        fulfillment.line_items_by_fulfillment_order.push({ fulfillment_order_id: fulfillmentOrder.id, fulfillment_order_line_items: [ { id: fulfillmentOrderLineItem.id, quantity: quantityToFulfill }]});
+                                    }
+                                    if(quantityToFulfill < orderFulfillmentPetition.quantity_delivered) {
+                                        orderFulfillmentPetition.quantity_delivered = orderFulfillmentPetition.quantity_delivered - quantityToFulfill;
+                                    } else {
+                                        delete orderFulfillmentPetitions[orderFulfillmentPetitionIndex];
+                                    }
+                                }
+                            } else {
+                                Logger.info(`ShopifyOrderService - createFulfillments ->  petition found for ${JSON.stringify(fulfillmentOrderLineItem)}`);
+                            }
+                        } else {
+                            Logger.info(`ShopifyOrderService - createFulfillments -> Fulfillment order line item does does not have fulfillable_quantity ${JSON.stringify(fulfillmentOrderLineItem)}`);
+                        }
+                    }
+                }
+                Logger.info(`ShopifyOrderService - createFulfillments -> Petitions not being attended ${JSON.stringify(orderFulfillmentPetitions)}`);
+                if(fulfillment.line_items_by_fulfillment_order && fulfillment.line_items_by_fulfillment_order.length > 0) {
+                    const response = await this.axiosInstance.post('/fulfillments.json', { fulfillment: fulfillment });
+                    const fulfillmentCreated: IFulFillment = response.data.fulfillment;
+                    Logger.info(`ShopifyOrderService - createFulfillments -> Fulfillment created ${JSON.stringify(fulfillmentCreated)}`);
+                    if(shipmentStatus) {
+                        try {
+                            const event = await this.addShipmentStatusToFulfillment(orderId, fulfillmentCreated.id, shipmentStatus);
+                            Logger.info(`ShopifyOrderService - createFulfillments ->Event created ${JSON.stringify(event)}`);
+                        } catch(e) {
+                            Logger.error(`ShopifyOrderService - createFulfillments -> Failed to add event to fulfillment ${e.message}`);
+                        }
+                    } else {
+                        Logger.info('ShopifyOrderService - createFulfillments -> Shipment status was empty');
+                    }
+                    resolve(fulfillmentCreated);
+                } else {
+                    Logger.info(`ShopifyOrderService - createFulfillments -> Nothing to fulfill from petitions ${JSON.stringify(orderFulfillmentPetitions)}`);
+                    resolve(null);
+                }
+            } catch (error) { Logger.error(`ShopifyOrderService - createFulfillments -> Error while creating fulfillments for orderId ${orderId}`, error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public addShipmentStatusToFulfillment = async (orderId: number, fulfillmentid: number, shipmentStatus: IShipmentStatus): Promise<IFulfillmentEvent> => {
+        return new Promise<IFulfillmentEvent>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - addShipmentStatusToFulfillment -> Creating fulfillment event (status ${shipmentStatus}) for order id ${orderId} and fulfillment id ${fulfillmentid}`);
+                const response = await this.axiosInstance.post(`/orders/${orderId}/fulfillments/${fulfillmentid}/events.json`, { event: { status: shipmentStatus } });
+                resolve(response.data.fulfillment_event);
+            } catch (error) { Logger.error(`ShopifyOrderService - addShipmentStatusToFulfillment -> Error while creating fulfillment event for orderId ${orderId} and fulfillment ${fulfillmentid}`, error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getMinMaxDateOrders = (min: string, max: string): Promise<IOrder[]> => {
+        return new Promise<IOrder[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - getMinMaxDateOrders -> Getting orders from min ${min} and max ${max}`);
+                const response = await this.axiosInstance.get(`/orders.json?status=any&created_at_max=${max}&created_at_min=${min}&limit=250`);
+                resolve(response.data.orders);
+            } catch (error) { Logger.error('ShopifyOrderService - getMinMaxDateOrders -> Error while getting min max orders ', error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public completeFulfillment = async (orderId: number, fullfilmentId: number): Promise<IFulFillment> => {
+        return new Promise<IFulFillment>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - completeFulfillment -> Compliting fulfillment for order ID ${orderId}`);
+                const response = await this.axiosInstance.post(`/orders/${orderId}/fulfillments/${fullfilmentId}/complete.json`);
+                resolve(response.data.fulfillment);
+            } catch (error) { Logger.error('ShopifyOrderService - completeFulfillment -> Error while compliting fulfillment for orderId ' + orderId, error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public openFulfillment = async (orderId: number, fullfilmentId: number): Promise<IFulFillment> => {
+        return new Promise<IFulFillment>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - openFulfillment -> Opening fulfillment for order ID ${orderId}`);
+                const response = await this.axiosInstance.post(`/orders/${orderId}/fulfillments/${fullfilmentId}/open.json`);
+                resolve(response.data.fulfillment);
+            } catch (error) { Logger.error('ShopifyOrderService - openFulfillment -> Error while opening fulfillment for orderId ' + orderId, error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public cancelFulfillment = async (orderId: number, fullfilmentId: number): Promise<IFulFillment> => {
+        return new Promise<IFulFillment>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - cancelFulfillment -> Canceling fulfillment for order ID ${orderId}`);
+                const response = await this.axiosInstance.post(`/orders/${orderId}/fulfillments/${fullfilmentId}/cancel.json`);
+                resolve(response.data.fulfillment);
+            } catch (error) { Logger.error('ShopifyOrderService - cancelFulfillment -> Error while canceling fulfillment for orderId ' + orderId, error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public addAdditionalAttribute = async (orderId: number, attributeName: string, attributeValue: string): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - addAdditionalAttribute -> Adding attribute to order with ID ${orderId}`);
+                let additionalAttributes: IAttr[] = [];
+                const orderFromShopify = await this.getById(orderId);
+                if(orderFromShopify.note_attributes) {
+                    additionalAttributes = orderFromShopify.note_attributes;
+                    const attr = additionalAttributes.find(a => a.name === attributeName);
+                    if(attr) { attr.value = attributeValue; }
+                    else { additionalAttributes.push({name: attributeName, value: attributeValue}); }
+                } else {
+                    additionalAttributes.push({name: attributeName, value: attributeValue});
+                }
+                Logger.info('ShopifyOrderService - addAdditionalAttribute -> Adding attributes to order ', additionalAttributes);
+                const order = { id: orderId, note_attributes: additionalAttributes };
+                const response = await this.axiosInstance.put(`/orders/${orderId}.json`, { order: order });
+                resolve(response.data.order);
+            } catch (error) { Logger.error('ShopifyOrderService - addAdditionalAttribute -> Error while adding note attribute to order with Id ' + orderId, error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+
+    /**
+     * Adds attr on top of the existing ones.
+     *
+     * @param {number} orderId 
+     * @param {{attributeName: string, attributeValue: string}[]} attributes to be added
+     * @returns 
+     */
+    public addAdditionalAttributes = async (orderId: number, attributes: {attributeName: string, attributeValue: string}[]): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - addAdditionalAttributes -> Adding attributes to order with ID ${orderId}`);
+                let additionalAttributes: IAttr[] = [];
+                const orderFromShopify = await this.getById(orderId);
+                if(orderFromShopify.note_attributes) {
+                    additionalAttributes = orderFromShopify.note_attributes;
+                    for (const attribute of attributes) {
+                        const attr = additionalAttributes.find(a => a.name === attribute.attributeName);
+                        if(attr) { attr.value = attribute.attributeValue; }
+                        else { additionalAttributes.push({name: attribute.attributeName, value: attribute.attributeValue}); } 
+                    }
+                } else {
+                    for (const attribute of attributes) {
+                        additionalAttributes.push({name: attribute.attributeName, value: attribute.attributeValue});
+                    }
+                }
+                Logger.info('ShopifyOrderService - addAdditionalAttributes -> Adding attributes to order ', additionalAttributes);
+                const order = { id: orderId, note_attributes: additionalAttributes };
+                const response = await this.axiosInstance.put(`/orders/${orderId}.json`, { order: order });
+                resolve(response.data.order);
+            } catch (error) { Logger.error('Error while adding note attribute to order with Id ' + orderId, error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Sets a new tags to the order. Tags on the order will getoverwritten by this ones.
+     * 
+     * @param  {number} orderId
+     * @param  {string} tags
+     * @returns Promise
+     */
+    public setTags = async (orderId: number, tags: string): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - setTags -> Adding tags to order with ID ${orderId}, overwrites`);
+                const order = { id: orderId, tags: tags };
+                const response = await this.axiosInstance.put(`/orders/${orderId}.json`, { order: order });
+                resolve(response.data.order);
+            } catch (error) { Logger.error('ShopifyOrderService - setTags -> Error while adding tags to order with Id ' + orderId, error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * 
+     * Adds one or more tags to an order. It does add them toghether with the existing ones.
+     * 
+     * @param {number} orderId order id number
+     * @param {string} tagsToAdd tags to add separated by coma
+     * @returns Promise array with errors
+    */
+    public addTags = async (orderId: number, tagsToAdd: string): Promise<string[]> => {
+        return new Promise<string[]>(async (resolve, reject) => {
+            try {
+                const query = gql`mutation {
+                    tagsAdd(id: "${this.getGraphOrderIdFromId(orderId)}", tags: "${this.escapeQuotes(tagsToAdd)}") {
+                        node {
+                            id
+                        }
+                        userErrors {
+                            field
+                            message
+                        }
+                    }
+                }`;
+
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 100 });
+                const errors: string[] = [];
+                Logger.info(`ShopifyOrderService - addTags -> Add tags to order response: ${JSON.stringify(response.data)} `);
+                if(response && response.data && response.data.data){
+                    const updatesResponse = response.data.data;
+                    for(const key in updatesResponse){
+                        const err = updatesResponse[key].userErrors;
+                        if(err && err.length > 0) {
+                            errors.push(err);
+                        }
+                    }
+                } else {
+                    errors.push('No response arrived');
+                }
+                resolve(errors);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * 
+     * Removes one or more tags to an order.
+     * 
+     * @param {number} orderId order id number
+     * @param {string} tagsToRemove tags to remove separated by coma
+     * @returns Promise array with errors
+    */
+    public removeTags = async (orderId: number, tagsToRemove: string): Promise<string[]> => {
+        return new Promise<string[]>(async (resolve, reject) => {
+            try {
+                const query = gql`mutation {
+                    tagsRemove(id: "${this.getGraphOrderIdFromId(orderId)}", tags: "${this.escapeQuotes(tagsToRemove)}") {
+                        node {
+                            id
+                        }
+                        userErrors {
+                            field
+                            message
+                        }
+                    }
+                }`;
+
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 100 });
+                const errors: string[] = [];
+                Logger.info(`ShopifyOrderService - removeTags -> Remove tags to order response: ${JSON.stringify(response.data)} `);
+                if(response && response.data && response.data.data){
+                    const updatesResponse = response.data.data;
+                    for(const key in updatesResponse){
+                        const err = updatesResponse[key].userErrors;
+                        if(err && err.length > 0) {
+                            errors.push(err);
+                        }
+                    }
+                } else {
+                    errors.push('No response arrived');
+                }
+                resolve(errors);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Creates an order in the store. 
+     * If 'inventoryPolicy' is not set, then, the default one is 'decrement_obeying_policy'
+     * 
+     * @param  {IOrder} order
+     * @param  {'bypass'|'decrement_ignoring_policy'|'decrement_obeying_policy'} inventoryBehaviour?
+     * @returns Promise
+     */
+    public create = async (order: IOrder, inventoryBehaviour?: 'bypass' | 'decrement_ignoring_policy' | 'decrement_obeying_policy'): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                Logger.info('ShopifyOrderService - create -> Creating order', order);
+                order.inventory_behaviour = inventoryBehaviour ? inventoryBehaviour : 'decrement_obeying_policy';
+                const response = await this.axiosInstance.post('/orders.json', { order: order });
+                resolve(response.data.order);
+            } catch (error) {
+                const errorMsg = ErrorHelper.getErrorFromResponse(error);
+                Logger.error('ShopifyOrderService - create -> Error while creating order', error, errorMsg);
+                if(errorMsg && errorMsg.toString().indexOf('Unable to reserve inventory') > -1) {
+                    reject(new InspiraShopifyUnableToReserveInventoryError(errorMsg)); 
+                } else {
+                    reject(new InspiraShopifyError(errorMsg)); 
+                }
+            }
+        });
+    };
+
+    /**
+     * Creates transaction (set 'source' as 'external' to create without needing authorisation)
+     * 
+     * @param  {number} orderId
+     * @param  {ITransaction} transaction
+     * @returns Promise
+     */
+    public createTransaction = async (orderId: number, transaction: ITransaction): Promise<ITransaction> => {
+        return new Promise<ITransaction>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - createTransaction -> Creating transaction for order: ${orderId}, amount: ${transaction.amount}`);
+                const response = await this.axiosInstance.post(`/orders/${orderId}/transactions.json`, { transaction: transaction });
+                resolve(response.data.transaction);
+            } catch (error) { Logger.error('ShopifyOrderService - createTransaction -> Error while creating transaction', error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Duplicates an order
+     * 
+     * @param  {number} orderId
+     * @returns Promise
+     */
+    public duplicate = async (orderId: number): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - duplicate -> Duplicating order: ${orderId}`);
+                const order = await this.getById(orderId);
+                const orderClone: IOrder = JSON.parse( JSON.stringify(order));
+                delete orderClone.id;
+                delete orderClone.order_number;
+                delete orderClone.order_status_url;
+                delete orderClone.processed_at;
+                delete orderClone.created_at;
+                delete orderClone.updated_at;
+                delete orderClone.name;
+                delete orderClone.number;
+                delete orderClone.token;
+                delete orderClone.customer;
+                delete orderClone.admin_graphql_api_id;
+                orderClone.customer = { id: order.customer.id } as any;
+                for (const item of orderClone.line_items) {
+                    delete item.id;
+                    delete item.fulfillable_quantity;
+                    delete item.fulfillment_service;
+                    delete item.fulfillment_status;
+                    delete item.admin_graphql_api_id;
+                }
+                for(const shippingLine of orderClone.shipping_lines) {
+                    delete shippingLine.id;
+                }
+                const duplicatedOrder = await this.create(orderClone);
+                resolve(duplicatedOrder);
+            } catch (error) { Logger.error('ShopifyOrderService - duplicate -> Error while duplicating order', error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Updates Shipping Address in a order.
+     * 
+     * @param  {number} orderId
+     * @param  {IAddress} shippingAddress
+     * @returns Promise
+     */
+    public updateShippingAddress = async (orderId: number, shippingAddress: IAddress): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - updateShippingAddress -> Updating order shipping address with id ${orderId}`, shippingAddress);
+                const response = await this.axiosInstance.put(`/orders/${orderId}.json`, { order: { id: orderId, shipping_address: shippingAddress} });
+                resolve(response.data.order);
+            } catch (error) { Logger.error('ShopifyOrderService - updateShippingAddress -> Error updating order shipping address', error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public cancel = async (orderId: number): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                Logger.info('ShopifyOrderService - cancel -> Cancelling order', orderId);
+                const response = await this.axiosInstance.post(`orders/${orderId}/cancel.json`, {});
+                resolve(response.data.order);
+            } catch (error) { Logger.error('ShopifyOrderService - cancel -> Error while cancelling order', error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public applyWeightAndCountryBasedShippingToOrder = async (order: IOrder): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                const shippingZones = await this.shopifyShopService.getShippingRates();
+                const countryCode = this.getCountryCodeFromOrder(order);
+                Logger.info(`ShopifyOrderService - applyWeightAndCountryBasedShippingToOrder -> Country code identified ${countryCode}`);
+                const orderTotalWeight = order.line_items.reduce((a: number,b: ILineItem) => { if(b.requires_shipping) { return (a + b.quantity * b.grams); } else { return a; }}, 0) / 1000;
+                let shippingZoneSelected = shippingZones.find(zone => (zone.countries.map(country => country.code).join(',') + ',').indexOf(`${countryCode},`) > -1);
+                if(!shippingZoneSelected) {
+                    Logger.info(`ShopifyOrderService - applyWeightAndCountryBasedShippingToOrder -> Country code not found on existing specific rates. Looking for Rest of the world rate using * instead of ${countryCode}`);
+                    shippingZoneSelected = shippingZones.find(zone => (zone.countries.map(country => country.code).join(',') + ',').indexOf('*,') > -1);
+                }
+                Logger.info(`ShopifyOrderService - applyWeightAndCountryBasedShippingToOrder -> Shipping Zone ${JSON.stringify(shippingZoneSelected)}`);
+                if(shippingZoneSelected){
+                    Logger.info(`ShopifyOrderService - applyWeightAndCountryBasedShippingToOrder -> Shipping Zone found for country ${countryCode}`, shippingZoneSelected);
+                    if(shippingZoneSelected.weight_based_shipping_rates && shippingZoneSelected.weight_based_shipping_rates.length > 0) {
+                        const shippingRateSelected = shippingZoneSelected.weight_based_shipping_rates.find(shippingRate => ((shippingRate.weight_low < orderTotalWeight && shippingRate.weight_high > orderTotalWeight) || shippingRate.weight_low === orderTotalWeight));
+                        if(shippingRateSelected){
+                            Logger.info('ShopifyOrderService - applyWeightAndCountryBasedShippingToOrder -> Adding SHIPPING RATE to order', shippingRateSelected);
+                            order.shipping_lines = [{code: shippingZoneSelected.name, title: shippingZoneSelected.name, price: shippingRateSelected.price, source: 'shopify', tax_lines: []}];
+                        } else {
+                            Logger.info(`ShopifyOrderService - applyWeightAndCountryBasedShippingToOrder -> No Shipping Rate found for weight ${orderTotalWeight}`);
+                        }
+                    } else {
+                        Logger.info('ShopifyOrderService - applyWeightAndCountryBasedShippingToOrder -> Shipping Zone is not Weight based');
+                    }
+                } else {
+                    Logger.info(`ShopifyOrderService - applyWeightAndCountryBasedShippingToOrder -> NO Shipping Zone found for country ${countryCode}`);
+                }
+                resolve(order);
+            } catch (error) { Logger.error('ShopifyOrderService - applyWeightAndCountryBasedShippingToOrder -> Error while cancelling order', error); reject(Error(error)); }
+        });
+    };
+
+    public getShippingByWeight = async (country: string, weight: number): Promise<IShippingLine> => {
+        return new Promise<IShippingLine>(async (resolve, reject) => {
+            try {
+                let shippingLine: IShippingLine = null;
+                const shippingZones = await this.shopifyShopService.getShippingRates();
+                const countryCode = CountryCodeService.getCountryCode(country);
+                const shippingZoneSelected = shippingZones.find(zone => (zone.countries.map(country => country.code).join(',') + ',').indexOf(countryCode + ',') > -1);
+                if(shippingZoneSelected){
+                    Logger.info(`ShopifyOrderService - getShippingByWeight -> Shipping Zone found for country ${countryCode}`, shippingZoneSelected);
+                    if(shippingZoneSelected.weight_based_shipping_rates && shippingZoneSelected.weight_based_shipping_rates.length > 0) {
+                        const shippingRateSelected = shippingZoneSelected.weight_based_shipping_rates.find(shippingRate => (shippingRate.weight_low <= weight && shippingRate.weight_high >= weight));
+                        if(shippingRateSelected){
+                            Logger.info('ShopifyOrderService - getShippingByWeight -> Adding SHIPPING RATE to order', shippingRateSelected);
+                            shippingLine = {code: shippingZoneSelected.name, title: shippingZoneSelected.name, price: shippingRateSelected.price, source: 'shopify', tax_lines: []};
+                        } else {
+                            Logger.info(`ShopifyOrderService - getShippingByWeight -> No Shipping Rate found for weight ${weight}`);
+                        }
+                    } else {
+                        Logger.info('ShopifyOrderService - getShippingByWeight -> Shipping Zone is not Weight based');
+                    }
+                } else {
+                    Logger.info(`ShopifyOrderService - getShippingByWeight -> NO Shipping Zone found for country ${countryCode}`);
+                }
+                resolve(shippingLine);
+            } catch (error) { Logger.error('ShopifyOrderService - getShippingByWeight -> Error while cancelling order', error); reject(Error(error)); }
+        });
+    };
+
+    public createLineItemForOrderCalculation = (lineItems : ILineItem[], applyTaxesUsing: 'variantId' | 'price'): ILineItemForDraftCalculation[] => {
+        const lineItemsForCalculation: ILineItemForDraftCalculation[] = lineItems.map( (li) => {
+            const qty =parseInt(`${li.quantity}`, 10);
+            if(li.variant_id && applyTaxesUsing === 'variantId') {
+                return { variantId: `gid://shopify/ProductVariant/${li.variant_id}`, quantity: qty };
+            } else {
+                return { originalUnitPrice: `${li.price}`, taxable: li.taxable ?? false, requiresShipping: true, title: li.title ? li.title : `fake title ${li.price}`, quantity: qty };
+            }
+        });
+        Logger.info(`ShopifyOrderService - createLineItemForOrderCalculation -> LineItems. Original ${JSON.stringify(lineItems)} and final input ${JSON.stringify(lineItemsForCalculation)}`);
+        return lineItemsForCalculation;
+    };
+
+    /**
+     * Returns taxes & available shippings
+     * If variant id is provided and applyTaxesUsing is variantId then the variant is used if not uses the price provided
+     * 
+     * @param  {ILineItem[]} lineItems
+     * @param  {IAddress} address
+     * @param  {IShippingInput} shipping of the order or null if no shipping
+     * @param  {'variantId' | 'price'} applyTaxesUsing
+     * 
+     * @returns Promise
+     */
+    public getAvailableShippingRatesByAddress = async (lineItems: ILineItem[], address: IAddress, shipping: IShippingInput, applyTaxesUsing: 'variantId' | 'price'): Promise<ICalculatedDraftOrder> => {
+        return new Promise<ICalculatedDraftOrder>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - getAvailableShippingRatesByAddress: items ${JSON.stringify(lineItems)} and address ${JSON.stringify(address)}`);
+
+                const countryCode = (!address.country_code || (address.country_code && (address.country_code.toLowerCase() === 'uk' || address.country_code.toLowerCase() === '*'))) ? 'GB' : address.country_code; 
+                const shippingAddress = {  provinceCode: address.province_code, province: address.province, firstName: address.first_name,
+                    address1: address.address1, address2: address.address2, city: address.city, country: address.country, 
+                    countryCode: countryCode };
+                    
+                if(address.zip) {
+                    (shippingAddress as any).zip = address.zip;
+                }
+
+                const orderInput = { lineItems: this.createLineItemForOrderCalculation(lineItems, applyTaxesUsing), shippingAddress: shippingAddress };
+
+                if(shipping) { (orderInput as any).shippingLine = shipping; }
+
+                Logger.info(`ShopifyOrderService - getAvailableShippingRatesByAddress: input variable ${JSON.stringify(orderInput)}`);
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(this.draftOrderGraphQLMutation), variables: { input: orderInput } }, { query_cost: 16 });
+                const taxLines: ITaxLine[] = this.getOrderTaxLines(response.data.data.draftOrderCalculate);
+                let shippingTaxLines: ITaxLine[] = [];
+                if(shipping) {
+                    shippingTaxLines = this.getOrderShippingTaxLines(response.data.data.draftOrderCalculate);
+                }
+                resolve({ shippingTaxLines: shippingTaxLines, taxLines: taxLines, availableShippings: response.data.data.draftOrderCalculate.calculatedDraftOrder.availableShippingRates, totalTaxes: response.data.data.draftOrderCalculate.calculatedDraftOrder.totalTax} as ICalculatedDraftOrder);
+            } catch (error) { Logger.error(`ShopifyOrderService - getAvailableShippingRatesByAddress -> ${error.message}`, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+    
+    /**
+     * If variant id is provided and applyTaxesUsing is variantId then the variant is used if not uses the price provided
+     * 
+     * @param  {ILineItem[]} lineItems of the order
+     * @param  {number} customerId of the order
+     * @param  {IShippingInput} shipping of the order or null if no shipping
+     * @returns Promise
+     */
+    public getAvailableShippingRatesByCustomerDefaultAddress = async (lineItems: ILineItem[], customerId: number, shipping: IShippingInput, applyTaxesUsing: 'variantId' | 'price'): Promise<ICalculatedDraftOrder> => {
+        return new Promise<ICalculatedDraftOrder>(async (resolve, reject) => {
+            try {
+                Logger.info(`ShopifyOrderService - getAvailableShippingRatesByCustomerDefaultAddress: items ${JSON.stringify(lineItems)} and customer ${customerId}`);
+                const orderInput = {
+                    lineItems: this.createLineItemForOrderCalculation(lineItems, applyTaxesUsing),
+                    customerId: `gid://shopify/Customer/${customerId}`,
+                    useCustomerDefaultAddress: true
+                };
+                if(shipping) { (orderInput as any).shippingLine = shipping; }
+                Logger.info(`ShopifyOrderService - getAvailableShippingRatesByCustomerDefaultAddress: input variable ${JSON.stringify(orderInput)}`);
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(this.draftOrderGraphQLMutation), variables: { input: orderInput } }, { query_cost: 16 });
+                Logger.info(`ShopifyOrderService - getAvailableShippingRatesByCustomerDefaultAddress: calculated draft order ${JSON.stringify(response.data.data.draftOrderCalculate)}`);
+                const taxLines: ITaxLine[] = this.getOrderTaxLines(response.data.data.draftOrderCalculate);
+                let shippingTaxLines: ITaxLine[] = [];
+                if(shipping) {
+                    shippingTaxLines = this.getOrderShippingTaxLines(response.data.data.draftOrderCalculate);
+                }
+                resolve({ shippingTaxLines: shippingTaxLines, taxLines: taxLines, availableShippings: response.data.data.draftOrderCalculate.calculatedDraftOrder.availableShippingRates, totalTaxes: response.data.data.draftOrderCalculate.calculatedDraftOrder.totalTax} as ICalculatedDraftOrder);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Apply Shipping and taxes to an order.
+     * If variant id is provided and applyTaxesUsing is variantId then the variant is used if not uses the price provided.
+     * 
+     * @param  {IOrder} order. Order needs to have a customer or a shipping address set
+     * @param  {'cheapest'|'expensivest'} method
+     * @param  {boolean} addTaxes
+     * @param  {'variantId'|'price'} applyTaxesUsing
+     * @returns Promise returns order with Shipping lines applied.
+     */
+    public applyShippingToOrder = async (order: IOrder, method: 'cheapest' | 'expensivest', addTaxes: boolean, applyTaxesUsing: 'variantId' | 'price'): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                const countryCode = this.getCountryCodeFromOrder(order);
+                Logger.info(`ShopifyOrderService - applyShippingToOrder -> Country code identified ${countryCode}`);
+                let shippingRates: IAvailableShippingRate[] = [];
+                let calculatedDraftOrder: ICalculatedDraftOrder = null;
+                if(order.shipping_address) {
+                    order.shipping_address.country_code = countryCode;
+                    calculatedDraftOrder = await this.getAvailableShippingRatesByAddress(order.line_items, order.shipping_address, null, applyTaxesUsing);
+                } else if(order.customer) {
+                    calculatedDraftOrder = await this.getAvailableShippingRatesByCustomerDefaultAddress(order.line_items, order.customer.id, null, applyTaxesUsing);
+                } else {
+                    reject(new InspiraShopifyCustomError('Order misses Shipping Address and Customer so noShipping rate can be calculated'));
+                }
+                shippingRates = calculatedDraftOrder.availableShippings;
+                if(shippingRates && shippingRates.length > 0){
+                    shippingRates.sort((sr1, sr2) => parseFloat(sr1.price.amount) - parseFloat(sr2.price.amount) );
+                    const shippingRateSelected = method === 'cheapest' ? shippingRates[0] : shippingRates[shippingRates.length - 1];
+                    Logger.info(`ShopifyOrderService - applyShippingToOrder -> Shipping Rate selected ${JSON.stringify(shippingRateSelected)}`);
+                    if(shippingRateSelected) {
+                        order.shipping_lines = [{code: shippingRateSelected.handle, title: shippingRateSelected.title, price: shippingRateSelected.price.amount, source: 'shopify', tax_lines: []}];
+                    } else {
+                        Logger.info('ShopifyOrderService - applyShippingToOrder -> No shipping rate found');
+                    }
+                } else {
+                    Logger.info('ShopifyOrderService - applyShippingToOrder -> NO Shipping Rates are applicable to the order');
+                }
+                if(addTaxes) {
+                    order = await this.applyTaxesToOrder(order, applyTaxesUsing);
+                }
+                resolve(order);
+            } catch (error) { Logger.error('ShopifyOrderService - applyShippingToOrder -> Error while cancelling order', error); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Apply taxes to an order.
+     * If variant id is provided and applyTaxesUsing is variantId then the variant is used if not uses the price provided.
+     * 
+     * @param  {IOrder} order. Order needs to have a customer or a shipping address set
+     * @param  {'variantId'|'price'} applyTaxesUsing
+     * @returns Promise returns order with taxes applied.
+     */
+    public applyTaxesToOrder = async (order: IOrder, applyTaxesUsing: 'variantId' | 'price' ): Promise<IOrder> => {
+        return new Promise<IOrder>(async (resolve, reject) => {
+            try {
+                const countryCode = this.getCountryCodeFromOrder(order);
+                Logger.info(`ShopifyOrderService -> applyTaxesToOrder -> Country code identified ${countryCode}`);
+                let totalTaxes: number = 0;
+                let taxLines: ITaxLine[] = [];
+                let shippingTaxLines: ITaxLine[] = [];
+                let calculatedDraftOrder = null;
+                if(order.shipping_address) {
+                    order.shipping_address.country_code = countryCode;
+                    calculatedDraftOrder = await this.getAvailableShippingRatesByAddress(order.line_items, order.shipping_address, this.getShippingInput(order), applyTaxesUsing);
+                } else if(order.customer) {
+                    calculatedDraftOrder = await this.getAvailableShippingRatesByCustomerDefaultAddress(order.line_items, order.customer.id, this.getShippingInput(order), applyTaxesUsing);
+                } else {
+                    reject(new InspiraShopifyCustomError('ShopifyOrderService -> applyTaxesToOrder -> Order misses Shipping Address and Customer so taxes can be calculated'));
+                }
+                totalTaxes = calculatedDraftOrder.totalTaxes;
+                taxLines = calculatedDraftOrder.taxLines;
+                shippingTaxLines = calculatedDraftOrder.shippingTaxLines;
+                order.total_tax = totalTaxes;
+                order.tax_lines = this.substractShippingFromGlobalTaxLines(taxLines, shippingTaxLines);
+                if(order.shipping_lines && order.shipping_lines.length > 0 && shippingTaxLines.length > 0) {
+                    order.shipping_lines[0].tax_lines = shippingTaxLines;
+                }
+                resolve(order);
+            } catch (error) { Logger.error('ShopifyOrderService -> applyTaxesToOrder -> Error while cancelling order', error); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * 
+     * @param {number} orderId
+     * @param metafield
+     * @returns order with the metafield
+     */
+    public getOrderWithMetafiled = async (orderId: number, metafield: {namespace: string; key: string; }): Promise<IOrderMetafield> => {
+        return new Promise<IOrderMetafield>(async (resolve, reject) => {
+            try {
+                if(metafield && metafield.namespace && metafield.key) {
+                    Logger.info(`ShopifyOrderService -> getOrderWithMetafiled -> Get order with metafield: order id ${orderId} and metafield ${JSON.stringify(metafield)}`);
+                    const query = gql`{ 
+                        order(id: "${this.getGraphOrderIdFromId(orderId)}") {
+                            metafield(namespace: "${metafield.namespace}", key: "${metafield.key}") {
+                                        value
+                            }
+                        }
+                    }`;
+                    const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 4 });
+                    if(response && response.data && response.data.data && response.data.data.order){
+                        const orderGraph = response.data.data.order;
+                        resolve({ id: orderId, metafield: { namespace: metafield.namespace, key: metafield.key, value: orderGraph.metafield && orderGraph.metafield.value ? orderGraph.metafield.value : null }});
+                    } else {
+                        reject(new InspiraShopifyError({ message: JSON.stringify(response.data.errors) }));
+                    }
+                } else {
+                    Logger.info('ShopifyOrderService -> getOrderWithMetafiled -> No metafield provided');
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    private substractShippingFromGlobalTaxLines = (taxLines: ITaxLine[], shippingTaxLines : ITaxLine[]): ITaxLine[] => {
+        if(shippingTaxLines && shippingTaxLines.length > 0) {
+            for(const shippingTaxLine of shippingTaxLines) {
+                const globalTaxLine = taxLines.find((txLine) => txLine.title === shippingTaxLine.title);
+                const globalTxLinePrice = parseFloat(globalTaxLine.price);
+                const shippingTxLinePrice = parseFloat(shippingTaxLine.price);
+                if(globalTxLinePrice > shippingTxLinePrice) {
+                    globalTaxLine.price = (parseFloat(globalTaxLine.price) - parseFloat(shippingTaxLine.price)).toFixed(2);
+                }
+            }
+        }
+        return taxLines;
+    };
+
+    private getShippingInput = (order: IOrder): IShippingInput => {
+        try {
+            if(order.shipping_lines && order.shipping_lines.length > 0) {
+                let price = 0;
+                for(const shippingLine of order.shipping_lines) {
+                    price += parseFloat(shippingLine.price);
+                }
+                return { price: price.toString(), title: 'Shipping Sum'};
+            } else {
+                return null;
+            }
+        } catch(e) {
+            return null;
+        }
+    };
+
+    private getCountryCodeFromOrder = (order: IOrder): string => {
+        let countryCode = '';
+        let country = '';
+        if(order.shipping_address) {
+            countryCode = order.shipping_address.country_code;
+            country = order.shipping_address.country;
+        }
+        if(!countryCode && !country) { 
+            countryCode = 'GB'; 
+        } else if (!countryCode && country) {
+            countryCode = CountryCodeService.getCountryCode(country);
+        }
+        return countryCode;
+    };
+
+    private getOrderTaxLines  = (draftOrderCalculate: IShopifyDraftOrderCalculate): ITaxLine[] => {
+        Logger.info('ShopifyOrderService -> getOrderTaxLines Draft order calculated', JSON.stringify(draftOrderCalculate.calculatedDraftOrder));
+        const taxLines: ITaxLine[] = this.getTaxLines(draftOrderCalculate.calculatedDraftOrder.taxLines);
+        return taxLines;
+    };
+ 
+    private getOrderShippingTaxLines  = (draftOrderCalculate: IShopifyDraftOrderCalculate): ITaxLine[] => {
+        Logger.info('ShopifyOrderService -> getOrderShippingTaxLines  Draft order calculated', JSON.stringify(draftOrderCalculate.calculatedDraftOrder));
+        const taxLines: ITaxLine[] =    draftOrderCalculate.calculatedDraftOrder.shippingLine && 
+                                        draftOrderCalculate.calculatedDraftOrder.shippingLine.taxLines &&
+                                        draftOrderCalculate.calculatedDraftOrder.shippingLine.taxLines.length > 0 ? 
+            this.getTaxLines(draftOrderCalculate.calculatedDraftOrder.shippingLine.taxLines) : [];
+        return taxLines;
+    };
+
+    private getTaxLines  = (shopifyTaxLines: IShopifyTaxLine[]): ITaxLine[] => {
+        const taxLines: ITaxLine[] = [];
+        for(const taxLine of shopifyTaxLines) {
+            try {
+                taxLines.push({ price: taxLine.priceSet.shopMoney.amount, title: taxLine.title, rate: taxLine.rate });
+            }catch(e) {
+                Logger.error('Error while adding Tax Line', e);
+            }
+        }
+        return taxLines;
+    };
+}