@sommpicks/sommpicks-shopify 24.12.0

package/shopify/ShopifyOrderRefundsService.ts

@@ -0,0 +1,138 @@
+import { AxiosInstance, AxiosResponse } from 'axios';
+import { Logger } from '../Logger';
+import ErrorHelper from './base/ErrorHelper';
+import * as LinkHeader from 'parse-link-header';
+import APIVersion from './base/APIVersion';
+import { ShopifyOrderService } from './ShopifyOrderService';
+import { ShopifyInventoryService } from './ShopifyInventoryService';
+import { ShopifyProductService } from './ShopifyProductService';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+
+export class ShopifyOrderRefundsService {
+
+    private shopifyOrderService: ShopifyOrderService = null;
+    private shopifyInventoryService: ShopifyInventoryService = null;
+    private shopifyProductService: ShopifyProductService = null;
+
+    constructor(private axiosInstance: AxiosInstance) {
+        this.shopifyOrderService = new ShopifyOrderService(axiosInstance);
+        this.shopifyInventoryService = new ShopifyInventoryService(axiosInstance);
+        this.shopifyProductService = new ShopifyProductService(axiosInstance);
+    }
+
+    /**
+     * Gets all refunds from an order
+     *
+     * @param  {number} orderId
+     * @param  {number} limit is a test param to test the page limitation works.
+     * @returns Promise
+     */
+    public getOrderRefunds = async (orderId: number, limit?: number): Promise<IRefund[]> => {
+        return new Promise<IRefund[]>(async (resolve, reject) => {
+            try {
+                if(!limit) { limit = 250; }
+                Logger.info(`getOrderRefunds for order ID ${orderId}`);
+                let response = await this.axiosInstance.get(`/orders/${orderId}/refunds.json?limit=${limit}`);
+                let refunds = response.data.refunds;
+                
+                while(response.headers['Link'] && response.data && response.data.refunds.length > 0) {
+                    Logger.info('There seems to be another refunds page');
+                    const headerLinkParsed = LinkHeader(response.headers['Link']);
+                    if(headerLinkParsed['next']) {
+                        response = await this.getOrderRefundsByNextUrl(headerLinkParsed['next'].url);
+                        refunds = refunds.concat(response.data.refunds);
+                    } else {
+                        break;
+                    }
+                }
+                resolve(refunds);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+    
+    /**
+     * Create a refund against an order.
+     *
+     * If quantity is bigger than the line item quantity - the quantity already refunded it will only refund the available quantity not yet refunded.
+     * It will also refund the shipping if all items have already been refunded.
+     * 
+     * @param  {string} note of the refund
+     * @param  {boolean} notifyCustomer when refund has been made
+     * @param  {number} orderId 
+     * @param  {number} lineItemId of the refund
+     * @param  {number} quantity of the refund. I can not be greater then the quantity of the line item.
+     * @param  {number} restockQty If true will restock qty refunded to the location of the variant. (restockType = 'cancel' or restockType = 'no_restock')
+     * @returns Promise
+     */
+    public createRefunds = async (note: string, notifyCustomer: boolean, orderId: number, lineItemId: number, quantity: number, restockQty: boolean): Promise<IRefund> => {
+        return new Promise<IRefund>(async (resolve, reject) => {
+            try {
+                const order = await this.shopifyOrderService.getById(orderId);
+                const refunds = order.refunds;
+                const lineItemToRefund = order.line_items.find((lineItem) => lineItem.id === lineItemId);
+                const lineItemQuantity = lineItemToRefund.quantity;
+                const lineItemRefundedQuantity = refunds.reduce((r, refund) => refund.refund_line_items.reduce((i, refLineItem) => refLineItem.line_item_id === lineItemId ? refLineItem.quantity : 0, 0), 0);
+                let quantityToRefund = quantity; 
+                if(quantityToRefund > (lineItemQuantity - lineItemRefundedQuantity)) {
+                    quantityToRefund = lineItemQuantity - lineItemRefundedQuantity;
+                }
+                if(quantityToRefund < 1) {
+                    resolve({} as any);
+                } else {
+                    let refundShipping = (lineItemRefundedQuantity + quantityToRefund) === lineItemQuantity;
+                    if(refundShipping) {
+                        Logger.info(`Refunding all quantity of the line item. Already refunded ${lineItemRefundedQuantity} + quantity to refund ${quantityToRefund}. Line item total qty ${lineItemQuantity}`);
+                        for(const item of order.line_items) {
+                            if(item.id !== lineItemId) {
+                                Logger.info(`Checking item ${item.id}`);
+                                let refundLines: IRefundLineItem[] = [];
+                                for(const ref of refunds) {
+                                    refundLines = refundLines.concat(ref.refund_line_items.filter((rl) => rl.line_item_id === item.id));
+                                }
+                                const totalQtyRefunded = refundLines.reduce((r, rl) => rl.quantity, 0);
+                                Logger.info(`Checking item ${item.id}. Total refunded ${totalQtyRefunded} and item qty ${item.quantity}`);
+                                if(item.quantity !== totalQtyRefunded) {
+                                    Logger.info(`Checking item ${item.id}. No total refunded so no refunding Shipping!`);
+                                    refundShipping = false;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    Logger.info(`createRefunds for order ID ${orderId}. Already refunded ${lineItemRefundedQuantity} and line item quantity ${lineItemQuantity}. Quantity to refund ${quantityToRefund}`);
+                    let restockType = 'no_restock';
+                    let locationId = null;
+                    const refundedLineItem: IRefundLineItem = { line_item_id: lineItemId, quantity: quantityToRefund };
+                    if(restockQty) {
+                        restockType = 'cancel';
+                        const product = await this.shopifyProductService.list.getById(lineItemToRefund.product_id, { add_body_html: false, add_images: false, add_options: false, add_tags: false, add_title: false, add_variants: true, add_weight: false });
+                        const variant = product.variants.find( (v) => v.id === lineItemToRefund.variant_id);
+                        const levels = await this.shopifyInventoryService.getLevel(variant.inventory_item_id);
+                        locationId = levels[0].location_id;
+                        refundedLineItem.restock_type = restockType as any;
+                        refundedLineItem.location_id = locationId;
+                    } else {
+                        refundedLineItem.restock_type  = restockType as any;
+                    }
+                    const refundToPost = { refund: { notify: notifyCustomer, note: note, shipping:{ full_refund: refundShipping },
+                        refund_line_items: [refundedLineItem] }};
+                    Logger.info('Refunt to post', refundToPost);
+                    const response = await this.axiosInstance.post(`/orders/${orderId}/refunds.json`, refundToPost );
+                    resolve(response.data.refund);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    private getOrderRefundsByNextUrl = async (url: string): Promise<AxiosResponse> => {
+        return new Promise<AxiosResponse>(async (resolve, reject) => {
+            try {
+                Logger.info(`getOrderRefundsByNextUrl for url ${url}`);
+                const uri = url.substring(url.indexOf(APIVersion.API_URL) + APIVersion.API_URL.length);
+                Logger.info(`getOrderRefundsByNextUrl for uri ${uri}`);
+                const response = await this.axiosInstance.get(`${uri}`);
+                resolve(response);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+}

package/shopify/ShopifyOrderRiskService.ts

@@ -0,0 +1,19 @@
+import { AxiosInstance } from 'axios';
+import { Logger } from '../Logger';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+
+export class ShopifyOrderRiskService {
+
+    constructor(private axiosInstance: AxiosInstance) { }
+
+    public getFromOrderById = async (orderId: number): Promise<IRisk[]> => {
+        return new Promise<IRisk[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`getting order Risks for ID ${orderId}`);
+                const response = await this.axiosInstance.get(`/orders/${orderId}/risks.json`);
+                resolve(response.data.risks);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+}