@sommpicks/sommpicks-shopify 24.12.0

package/shopify/ShopifyDeliveryCustomisationService.ts

@@ -0,0 +1,220 @@
+import { AxiosInstance } from 'axios';
+import { print } from 'graphql';
+import gql from 'graphql-tag';
+import { Logger } from '../Logger';
+import { AbstractService } from './base/AbstractService';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+
+export class ShopifyDeliveryCustomisationService extends AbstractService{
+
+    constructor(private axiosInstance: AxiosInstance) { 
+        super();
+    }
+
+    /**
+     * Creates Delivery Customization 
+     * 
+     * @param  {string} functionId
+     * @param  {string} message
+     * @param  {boolean} enabled
+     * @param  {string} metaKey
+     * @param  {string} metafieldVal
+     * @returns Promise
+     */
+    public create = async (functionId: string, message: string, enabled: boolean, metaKey: string, metafieldVal: string): Promise<{id: number;}> => {
+        return new Promise<{id: number;}>(async (resolve, reject) => {
+            try {
+                Logger.info(`Creating customisation: ${functionId} and message ${message} and metafield val ${metafieldVal}`);
+                const query = gql `mutation DeliveryCustomizationCreate($input: DeliveryCustomizationInput!) {
+                    deliveryCustomizationCreate(deliveryCustomization: $input) {
+                      deliveryCustomization {
+                        id
+                      }
+                      userErrors {
+                        message
+                      }
+                    }
+                }`;
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(query), 
+                    variables: { input: { functionId: functionId, title: message, enabled: enabled } }}, { query_cost: 803 });
+
+                if(response && response.data && response.data.data && response.data.data.deliveryCustomizationCreate && response.data.data.deliveryCustomizationCreate.deliveryCustomization ){
+                    const customisationGraph = response.data.data.deliveryCustomizationCreate.deliveryCustomization;
+                    Logger.info(`Customisation created with ${JSON.stringify(customisationGraph)}`);
+                    const customizationId = customisationGraph.id;
+                    Logger.info(`Customisation created with id ${customizationId}`);
+                    const metafieldQuery = gql `mutation MetafieldsSet($customizationId: ID!, $configurationValue: String!) {
+                        metafieldsSet(metafields: [
+                          {
+                            ownerId: $customizationId
+                            namespace: "$app:delivery-customization"
+                            key: "${metaKey}"
+                            value: $configurationValue
+                            type: "json"
+                          }
+                        ]) {
+                          metafields {
+                            id
+                          }
+                          userErrors {
+                            message
+                          }
+                        }
+                      }`;
+                    
+                    const metafieldResponse = await this.axiosInstance.post('/graphql.json', { query: print(metafieldQuery), 
+                        variables: { customizationId: customizationId, configurationValue: metafieldVal }}, { query_cost: 803 });
+
+                    Logger.info(`Meta response ${JSON.stringify(metafieldResponse.data)}`);
+                    resolve({ id: this.getIdFromGraphId(customizationId) });
+                } else {
+                    Logger.error(`Create customisation. Error is ${JSON.stringify(response.data.errors)}. All data is ${JSON.stringify(response.data)}` );
+                    resolve(null);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Updates Delivery Customization 
+     * 
+     * @param  {string} functionId
+     * @param  {string} message
+     * @param  {string} metafieldVal
+     * @returns Promise
+     */
+    public update = async (customisationId: number, functionId: string, message: string, metakey: string, metafieldVal: string, updateCustomisation: boolean): Promise<{id: number;}> => {
+        return new Promise<{id: number;}>(async (resolve, reject) => {
+            try {
+                Logger.info(`Update customisation: ${functionId} and key ${metakey}`);
+                if(metafieldVal.length > 9500) {
+                    throw new Error(`ShopifyDeliveryCustomisationService -> update - The metafield value exceeds 9000 chars. It has ${metafieldVal.length}`);
+                } else {
+                    let isSuccess = false;
+                    let errors = '';
+                    if(updateCustomisation) {
+
+                        const query = gql `mutation DeliveryCustomizationUpdate($id: ID!, $input: DeliveryCustomizationInput!) {
+                          deliveryCustomizationUpdate(id: $id, deliveryCustomization: $input) {
+                            deliveryCustomization {
+                              id
+                            }
+                            userErrors {
+                              message
+                            }
+                          }
+                        }`;
+                        const response = await this.axiosInstance.post('/graphql.json', { query: print(query), 
+                            variables: { input: { functionId: functionId, title: message, enabled: true }, id: this.getGraphDeliveryCustomisationIdFromId(customisationId) }}, { query_cost: 803 });
+                        if(response && response.data && response.data.data && response.data.data.deliveryCustomizationUpdate ){
+                            isSuccess = true;
+                            Logger.info(`Customisation updated with ${JSON.stringify(response.data.data.deliveryCustomizationUpdate)}`);
+                        } else {
+                            errors = JSON.stringify(response.data.errors);
+                            Logger.error(`Update customisation. Error is ${JSON.stringify(response.data.errors)}` );
+                        }
+                    } else {
+                        isSuccess = true;
+                    }
+
+                    if(isSuccess) {
+                        const metafieldQuery = gql `mutation MetafieldsSet($customizationId: ID!, $configurationValue: String!) {
+                            metafieldsSet(metafields: [
+                              {
+                                ownerId: $customizationId
+                                namespace: "$app:delivery-customization"
+                                key: "${metakey}"
+                                value: $configurationValue
+                                type: "json"
+                              }
+                            ]) {
+                              metafields {
+                                id
+                              }
+                              userErrors {
+                                message
+                              }
+                            }
+                          }`;
+                        
+                        const metafieldResponse = await this.axiosInstance.post('/graphql.json', { query: print(metafieldQuery), 
+                            variables: { customizationId: this.getGraphDeliveryCustomisationIdFromId(customisationId), configurationValue: metafieldVal }}, { query_cost: 803 });
+    
+                        Logger.info(`Meta response ${JSON.stringify(metafieldResponse.data)}`);
+                        resolve({ id: customisationId });
+                    } else {
+                        Logger.error(`Update customisation. Error is ${errors}` );
+                        resolve(null);
+                    }
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getDeliveryCustomisation = async (customisationId: number, namespace: string, key: string): Promise<IDeliveryCustomisation> => {
+        const query = gql `query DeliveryCustomization($id: ID!) {
+            deliveryCustomization(id: $id) {
+            id
+            title
+            enabled
+            metafield(namespace: "${namespace}", key: "${key}") {
+                value
+            }
+            }
+        }`;
+        const variables = {
+            id: `gid://shopify/DeliveryCustomization/${customisationId}`
+        };
+        const customisationResponse = await this.axiosInstance.post('/graphql.json', { query: print(query),  variables: variables }, { query_cost: 10 });
+        if(customisationResponse && customisationResponse.data && customisationResponse.data.data && customisationResponse.data.data.deliveryCustomization) {
+            console.log('getDeliveryCustomisation', customisationResponse.data.data);
+            customisationResponse.data.data.deliveryCustomization.id = customisationId;
+            return customisationResponse.data.data.deliveryCustomization;
+        } else if (customisationResponse && customisationResponse.data && customisationResponse.data.errors ){
+            Logger.error(`getDeliveryCustomisation ${JSON.stringify(customisationResponse.data.errors)}`);
+        } else {
+            return null;
+        }
+    };
+
+    /**
+     * setMetafield in Delivery Customisation
+     * 
+     * @param  {number} customisationId
+     * @param  {string} metafieldVal
+     * @param  {string} key
+     * @returns Promise
+     */
+    public setMetafield = async (customisationId: number, metafieldVal: string, key: string): Promise<{id: number;}> => {
+        return new Promise<{id: number;}>(async (resolve, reject) => {
+            try {
+                Logger.info(`Cart transform updated with ${customisationId}`);
+                const metafieldQuery = gql `mutation MetafieldsSet($customizationId: ID!, $configurationValue: String!) {
+                    metafieldsSet(metafields: [
+                    {
+                        ownerId: $customizationId
+                        namespace: "$app:delivery-customization"
+                        key: "${key}"
+                        value: $configurationValue
+                        type: "json"
+                    }
+                    ]) {
+                    metafields {
+                        id
+                    }
+                    userErrors {
+                        message
+                    }
+                    }
+                }`;
+                    
+                const metafieldResponse = await this.axiosInstance.post('/graphql.json', { query: print(metafieldQuery), 
+                    variables: { customizationId: this.getGraphDeliveryCustomisationIdFromId(customisationId), configurationValue: metafieldVal }}, { query_cost: 803 });
+
+                Logger.info(`Meta response ${JSON.stringify(metafieldResponse.data)}`);
+                resolve({ id: customisationId });
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+}

package/shopify/ShopifyDiscountService.ts

@@ -0,0 +1,131 @@
+import gql from 'graphql-tag';
+import { print } from 'graphql';
+import { AxiosInstance } from 'axios';
+import { Logger } from '../Logger';
+import ErrorHelper from './base/ErrorHelper';
+import * as moment from 'moment';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+import { AbstractService } from './base/AbstractService';
+
+export class ShopifyDiscountService extends AbstractService {
+
+    constructor(private axiosInstance: AxiosInstance) { 
+        super();
+    }
+
+    public deleteAutomaticDiscount = async (id: number): Promise<void> => {
+        const mutation = gql`mutation {
+            discountAutomaticDelete(id: "${this.getGraphAutomaticDiscountIdFromId(id)}") {
+              deletedAutomaticDiscountId
+              userErrors {
+                field
+                message
+              }
+            }
+          }`;
+        const response = await this.axiosInstance.post('/graphql.json', { query: print(mutation) }, { query_cost: 5 });
+        if(response.data.errors && response.data.errors.length > 0) {
+            throw new Error(JSON.stringify(response.data.errors));
+        }
+        if(response.data.discountAutomaticDelete && response.data.discountAutomaticDelete.userErrors.length > 0) {
+            throw new Error(JSON.stringify(response.data.discountAutomaticDelete.userError));
+        }
+    };
+
+    public getAutomaticDiscount = async (id: number): Promise<{ id: number; }> => {
+        const query = gql`{
+            automaticDiscountNode(id: "gid://shopify/DiscountAutomaticNode/${id}") {
+                id
+              automaticDiscount { 
+                __typename
+                ... on DiscountAutomaticBasic {
+                  status
+                }
+                ... on DiscountAutomaticBxgy {
+                  status
+                }
+              }
+            }
+        }`;
+        const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 5 });
+
+        if(response.data.errors && response.data.errors.length > 0) {
+            throw new Error(JSON.stringify(response.data.errors));
+        }
+        return { id: response.data.automaticDiscountNode && response.data.automaticDiscountNode.id ? this.getIdFromGraphId(response.data.automaticDiscountNode.id) : null };
+    };
+    /**
+     * Creates a discount code. For a percentage on a product with a minimum quantity.
+     * 
+     * @param  {string} title and code of the discount
+     * @param  {number} percentageOff % value off the item
+     * @param  {number} productId where to be applied.
+     * @param  {number} minItemsRequired minimum quantity of items of the product to be present for the discount
+     * @returns Promise
+     */
+    public getPercentageDiscountCodeForItem = async (title: string, percentageOff: number, productId: number, minItemsRequired: number): Promise<IDiscount> => {
+        return new Promise<IDiscount>(async (resolve, reject) => {
+            try {
+                const priceRule = { title: title, value: -percentageOff, value_type: 'percentage',
+                    prerequisite_quantity_range: {greater_than_or_equal_to: minItemsRequired },
+                    target_selection: 'entitled', entitled_product_ids: [productId], allocation_method: 'each',
+                    customer_selection: 'all', target_type: 'line_item', starts_at: moment().format('YYYY-MM-DDTHH:mm:ss') + 'Z'};
+                resolve(await this.createRuleAndCode(priceRule));
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Creates a 1 time discount code. For a Fixed amount on the order total for a number of products with a total minimum quantity.
+     * 
+     * @param  {string} title and code of the discount
+     * @param  {number} amount to be discounted on the order total.
+     * @param  {number} productId where to be applied.
+     * @param  {number} minItemsRequired minimum quantity of discounted items of the product to be present for the discount.
+     * @param  {number} customerId where the discount can be applied
+     * @returns Promise
+     */
+    public getFixedDiscountCodeForOrder = async (title: string, amount: number, productIds: number[], minItemsRequired: number, customerId: number): Promise<IDiscount> => {
+        return new Promise<IDiscount>(async (resolve, reject) => {
+            try {
+                const priceRule = { title: title, value: -amount, value_type: 'fixed_amount',
+                    prerequisite_quantity_range: {greater_than_or_equal_to: minItemsRequired },
+                    target_selection: 'entitled', entitled_product_ids: productIds, allocation_method: 'across',
+                    customer_selection: 'prerequisite', prerequisite_customer_ids: [customerId], target_type: 'line_item',
+                    usage_limit: 1, once_per_customer: true, starts_at: moment().format('YYYY-MM-DDTHH:mm:ss') + 'Z'};
+                resolve(await this.createRuleAndCode(priceRule));
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Removes Rule and Discount code
+     * 
+     * @param  {number} ruleId
+     * @param  {number} codeId
+     * @returns Promise
+     */
+    public removeDiscount = async (ruleId: number, codeId: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`removeDiscount code ${codeId}`);
+                await this.axiosInstance.delete(`/price_rules/${ruleId}/discount_codes/${codeId}.json`);
+                Logger.info(`removeDiscount rule ${ruleId}`);
+                await this.axiosInstance.delete(`/price_rules/${ruleId}.json`);
+                Logger.info(`Discount removed. Rule ${ruleId} and code ${codeId}`);
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    private createRuleAndCode = async (priceRule: { title: string; value: number; value_type: string; prerequisite_quantity_range: { greater_than_or_equal_to: number; }; target_selection: string; entitled_product_ids: number[]; allocation_method: string; }): Promise<IDiscount> => {
+        Logger.info(`getDiscountCodeForItem for ${JSON.stringify(priceRule)}`);
+        const ruleResponse = await this.axiosInstance.post('/price_rules.json', { price_rule: priceRule });
+        const createdRule: IPriceRule = ruleResponse.data.price_rule;
+        Logger.info(`Hash of the discount for ${priceRule.title}`);
+        const codeResponse = await this.axiosInstance.post(`/price_rules/${createdRule.id}/discount_codes.json`, { discount_code: { code: priceRule.title } });
+        Logger.info(`Code response ${codeResponse}`);
+        return { code: codeResponse.data.discount_code, rule: createdRule };
+    };
+
+}

package/shopify/ShopifyDraftOrderService.ts

@@ -0,0 +1,125 @@
+import { AxiosInstance } from 'axios';
+import { Logger } from '../Logger';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+
+export class ShopifyDraftOrderService {
+
+    constructor(private axiosInstance: AxiosInstance) { }
+
+    public create = async (order: IOrderToCreate): Promise<IDraftOrder> => {
+        return new Promise<IDraftOrder>(async (resolve, reject) => {
+            try {
+                Logger.info('Creating draft order', order);
+                const response = await this.axiosInstance.post('/draft_orders.json', { draft_order: order });
+                resolve(response.data.draft_order);
+            } catch (error) {
+                const extractedErrorFromResponse = ErrorHelper.getErrorFromResponse(error);
+                Logger.error('Error while creating draft order', error, extractedErrorFromResponse); 
+                reject(Error(extractedErrorFromResponse)); 
+            }
+        });
+    };
+
+    /**
+     * Sends Shopify invoice to customer
+     *
+     * @param orderId {number}
+     * @returns
+     */
+    public send = async (orderId: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Sending invoice for Draft Order: ${orderId}`);
+                await this.axiosInstance.post(`/draft_orders/${orderId}/send_invoice.json`, { draft_order_invoice: {} });
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public createAndSendInvoice = async (order: IOrderToCreate): Promise<IDraftOrder> => {
+        return new Promise<IDraftOrder>(async (resolve, reject) => {
+            try {
+                Logger.info('Creating draft order and sending invoice');
+                const orderCreated = await this.create(order);
+                await this.send(orderCreated.id);
+                resolve(orderCreated);
+            } catch (error) { 
+                const extractedErrorFromResponse = ErrorHelper.getErrorFromResponse(error);
+                Logger.error('Error while creating draft order and sending invoice', error, extractedErrorFromResponse); 
+                reject(reject(new InspiraShopifyError(error))); 
+            }
+        });
+    };
+
+    /**
+     * Updates Shipping Address in a draft order.
+     * 
+     * @param  {number} orderId
+     * @param  {IAddress} shippingAddress
+     * @returns Promise
+     */
+    public updateShippingAddress = async (orderId: number, shippingAddress: IAddress): Promise<IDraftOrder> => {
+        return new Promise<IDraftOrder>(async (resolve, reject) => {
+            try {
+                Logger.info(`Updating draft order shipping address with id ${orderId}`, shippingAddress);
+                const response = await this.axiosInstance.put(`/draft_orders/${orderId}.json`, { draft_order: { id: orderId, shipping_address: shippingAddress} });
+                resolve(response.data.draft_order);
+            } catch (error) { Logger.error('Error updating order shipping address', error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Deletes a draft order.
+     * 
+     * @param  {number} orderId
+     * @returns Promise
+     */
+    public delete = async (orderId: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Updating draft order shipping address with id ${orderId}`);
+                await this.axiosInstance.delete(`/draft_orders/${orderId}.json`);
+                resolve();
+            } catch (error) { Logger.error('Error deleting draft order', error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Transforms a Cart to a draft Order. If the cart has the line items applied_discount field filled it will create the draft order with the discount applied. 
+     * 
+     * @param  {ICart} cart
+     * @param  {number} customerId
+     * @returns IDraftOrder
+     */
+    public fromCartToDraft = (cart: ICart, customerId: number): IDraftOrder => {
+        const draftorder: IDraftOrder = {
+            customer:  { id: customerId } as ICustomer,
+            note: cart.note,
+            note_attributes: [],
+            line_items: cart.items.map( (it) => ({ price: (it.price / 100).toFixed(2), title: it.title, quantity: it.quantity, taxable: it.taxable, product_id: it.product_id, variant_id: it.variant_id,
+                properties: (it.properties && it.properties.length) ? it.properties : [], requires_shipping: it.requires_shipping, sku: it.sku, applied_discount: it.applied_discount } as ILineItem))
+        };
+        if(cart.attributes && cart.attributes !== undefined) {
+            for (const [key, val] of Object.entries(cart.attributes)) {
+                draftorder.note_attributes.push({ name: key, value: val as string });
+            }
+        }
+        return draftorder;
+    };
+    
+    public createFromCart = async (cart: ICart, customerId: number): Promise<IDraftOrder> => {
+        return new Promise<IDraftOrder>(async (resolve, reject) => {
+            try {
+                Logger.info('Creating draft order from cart', cart);
+                const draftOrder = this.fromCartToDraft(cart, customerId);
+                const createdDraftOrder = await this.create(draftOrder);
+                resolve(createdDraftOrder);
+            } catch (error) {
+                const extractedErrorFromResponse = ErrorHelper.getErrorFromResponse(error);
+                Logger.error('Error while creating draft order', error, extractedErrorFromResponse); 
+                reject(Error(extractedErrorFromResponse)); 
+            }
+        });
+    };
+}

package/shopify/ShopifyFulfillmentService.ts

@@ -0,0 +1,41 @@
+import { AxiosInstance } from 'axios';
+import { Logger } from '../Logger';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+
+export class ShopifyFulfillmentService {
+
+    constructor(private axiosInstance: AxiosInstance) { }
+
+    public create = async (fulfillment: IFulfillmentService): Promise<IFulfillmentService> => {
+        return new Promise<IFulfillmentService>(async (resolve, reject) => {
+            try {
+                Logger.info('setting fulfillment service', fulfillment);
+                const response = await this.axiosInstance.post('/fulfillment_services.json', { fulfillment_service: fulfillment });
+                resolve(response.data.fulfillment_service);
+            } catch (error) {Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public addTrackingInfoToFulfillment = async (fulfillmentId: number, company: string, trackingNumber: string, trackingUrl: string, notifyCustomer: boolean): Promise<IFulFillment> => {
+        return new Promise<IFulFillment>(async (resolve, reject) => {
+            try {
+                Logger.info(`Adding tracking information to fulfillment ${fulfillmentId}`);
+                const fulfillmentUpdate = { fulfillment: {  notify_customer: notifyCustomer, tracking_info: { number: trackingNumber, url: trackingUrl, company: company } }};
+                Logger.info(`New tracking information to fulfillment ${fulfillmentId}`, fulfillmentUpdate);
+                const response = await this.axiosInstance.post(`/fulfillments/${fulfillmentId}/update_tracking.json`, fulfillmentUpdate);
+                resolve(response.data.fulfillment);
+            } catch (error) {Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getAll = async (): Promise<IFulfillmentService[]> => {
+        return new Promise<IFulfillmentService[]>(async (resolve, reject) => {
+            try {
+                Logger.info('getting fulfillment services');
+                const response = await this.axiosInstance.get('/fulfillment_services.json');
+                resolve(response.data.fulfillment_services);
+            } catch (error) {Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+}