@sommpicks/sommpicks-shopify 24.12.0

package/shopify/ShopifyCollectionService.ts

@@ -0,0 +1,523 @@
+import { Logger } from '../Logger';
+import * as TimerQueue from 'timer-queue';
+import { print } from 'graphql';
+import gql from 'graphql-tag';
+import { AxiosInstance } from 'axios';
+import ErrorHelper from './base/ErrorHelper';
+import { ShopifyProductService } from './ShopifyProductService';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+import { AbstractService } from './base/AbstractService';
+import * as parseLink from 'parse-link-header';
+import moment = require('moment');
+
+export class ShopifyCollectionService extends AbstractService {
+
+    private ShopifyProductService: ShopifyProductService;
+
+    constructor(private axiosInstance: AxiosInstance) {
+        super();
+        this.ShopifyProductService = new ShopifyProductService(axiosInstance);
+    }
+
+    public create = async (collection: ICollection): Promise<ICollection> => {
+        return new Promise<ICollection>(async (resolve, reject) => {
+            try {
+                Logger.info('Creating collection', collection);
+                const response = await this.axiosInstance.post('/custom_collections.json', { custom_collection: collection });
+                resolve(response.data.custom_collection);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Creates a collect at the end of the collection
+     * 
+     * @param  {ICollect} collect
+     * @returns Promise
+     */
+    public createCollect = async (collect: ICollect): Promise<ICollect> => {
+        return new Promise<ICollect>(async (resolve, reject) => {
+            try {
+                Logger.info('Creating collect', collect);
+                const response = await this.axiosInstance.post('/collects.json', { collect: collect });
+                resolve(response.data.collect);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Creates a collect at a certain position in the collection
+     * 
+     * @param  {collectionId}
+     * @param  {productId}
+     * @param  {position} Position within the collection
+     * @returns Promise
+     */
+    public createCollectAtPosition = async (collectionId: number, productId: number, position: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Creating collect for product ${productId} and collection ${collectionId} at position ${position}`);
+                await this.axiosInstance.put(`/custom_collections/${collectionId}.json`, { custom_collection: {id: collectionId, collects: [{ product_id: productId, position: position}] } });
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Removes all collects from Shopify.
+     * 
+     * @param  {number} collectionId
+     * @param  {number} interval in ms of every delete call to Shopify. Set to 0 or leave it empty to not queue the calls.
+     * @returns Promise
+     */
+    public removeCollects = async (collectionId: number, interval?: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Delete All collects for collection with ID: ${collectionId} and using interval of ${interval} between API calls`);
+                const collects = await this.getCollects(collectionId);
+            
+                if(interval && interval > 0) {
+                    const collectsQueue = new TimerQueue({ interval: interval, timeout: 10000, retry: 3, retryInterval: 500, autostart: false});
+                    for (const collect of collects) {
+                        collectsQueue.push( async () => {
+                            Logger.info(`Removing collect ${collect.id} for collection ${collectionId}`);
+                            await this.axiosInstance.delete(`/collects/${collect.id}.json`);
+                        });
+                    }
+
+                    collectsQueue.on('end', () => {
+                        Logger.info('End Collects Remove Queue');
+                        resolve();
+                    });
+
+                    collectsQueue.on('error', () => { 
+                        Logger.info('End Collects Queue with errors'); 
+                        resolve(); 
+                    });
+
+                    collectsQueue.start();
+                } else {
+                    for (const collect of collects) {
+                        Logger.info(`Removing collect ${collect.id} for collection ${collectionId} without Queue`);
+                        await this.axiosInstance.delete(`/collects/${collect.id}.json`);
+                    }
+                    resolve();
+                }
+                  
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Removes a collect from a Shopify collection.
+     * 
+     * @param  {number} collectId 
+     * @returns Promise
+     */
+    public removeCollect = async (collectId: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Delete a collect for collection with ID: ${collectId}`);
+                await this.axiosInstance.delete(`/collects/${collectId}.json`);
+                resolve();   
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Removes a list of products from a collection.
+     * 
+     * @param  {number} collectionId 
+     * @param  {number[]} products 
+     * @returns Promise
+     */
+    public removeProducts = async (collectionId: number, products: number[]): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Delete products from collection with ID: ${collectionId}`);
+                if(products && products.length > 0) {
+                    const productschunks: number[][] = this.sliceIntoChunks<number[]>(products, 249);
+                    const mutation = gql`
+                        mutation collectionRemoveProducts($id: ID!, $productIds: [ID!]!) {
+                            collectionRemoveProducts(id: $id, productIds: $productIds) {
+                            job {
+                                id
+                            }
+                            userErrors {
+                                field
+                                message
+                            }
+                            }
+                        }
+                    `;
+                    for(const productschunk of productschunks) {
+                        const response = await this.axiosInstance.post('/graphql.json', {
+                            query: print(mutation),
+                            variables: {
+                                id: `gid://shopify/Collection/${collectionId}`,
+                                productIds: productschunk.map((pId) => `gid://shopify/Product/${pId}`)
+                            }
+                        }, { query_cost: 10 });
+                        if(response.data.errors && response.data.errors.length > 0) {
+                            throw new Error(JSON.stringify(response.data.errors));
+                        }
+                        Logger.info(`Deleted product's chunck from collection with ID: ${collectionId}`, JSON.stringify(response.data));
+                    }
+                    Logger.info(`END Deleted products fromn collection with ID: ${collectionId}`);
+                } else {
+                    Logger.info(`No product to delete from collection with ID: ${collectionId}`);
+                }
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+    
+    /**
+     * Adds automatic discount x for y on a collection
+     * 
+     * @param  {number} collectionId 
+     * @param  {number[]} products 
+     * @returns Promise
+     */
+    public addBuyXGetYDiscount = async (collectionId: number, productsToBuy: number, productsToGet: number): Promise<{ id: number, title: string}> => {
+        return new Promise<{id: number; title: string; }>(async (resolve, reject) => {
+            try {
+                Logger.info(`Adds discount into collection with ID: ${collectionId}, Buy ${productsToBuy} Get ${productsToGet}`);
+                if(productsToBuy && productsToBuy > 0 && productsToGet && productsToGet > 0) {
+                    const mutation = gql`
+                    mutation {
+                        discountAutomaticBxgyCreate(automaticBxgyDiscount: {
+                          title: "BXGY discount test",
+                          startsAt: "${moment().format('YYYY-MM-DD')}",
+                          customerBuys: {
+                            value: {
+                              quantity: "${productsToBuy}"
+                            }
+                            items: {
+                              collections: {
+                                add: ["gid://shopify/Collection/${collectionId}"]
+                              }
+                            }
+                          },
+                          customerGets: {
+                            value: {
+                              discountOnQuantity: {
+                                quantity: "${productsToGet}",
+                                effect: {
+                                  percentage: 1.00
+                                }
+                              }
+                            }
+                            items: {
+                              collections: {
+                                add: ["gid://shopify/Collection/${collectionId}"]
+                              }
+                            }
+                          }}) {
+                          userErrors {
+                            field
+                            message
+                            code
+                          }
+                          automaticDiscountNode {
+                              automaticDiscount {
+                              ... on DiscountAutomaticBxgy {
+                                title
+                                summary
+                                status
+                              }
+                            }
+                          }
+                        }
+                      }
+                    `;
+                    const response = await this.axiosInstance.post('/graphql.json', { query: print(mutation) }, { query_cost: 15 });
+                    if(response.data.errors && response.data.errors.length > 0) {
+                        throw new Error(JSON.stringify(response.data.errors));
+                    }
+                    if(response.data.discountAutomaticBxgyCreate.userErrors && response.data.discountAutomaticBxgyCreate.userErrors.length > 0) {
+                        throw new Error(JSON.stringify(response.data.discountAutomaticBxgyCreate.userErrors));
+                    }
+                    Logger.info(`Add discount to collection with ID: ${collectionId}`, JSON.stringify(response.data));
+                    resolve({ id: this.getIdFromGraphId(response.data.discountAutomaticBxgyCreate.automaticDiscountNode.automaticDiscount.id), title: response.data.discountAutomaticBxgyCreate.automaticDiscountNode.automaticDiscount.title });
+                } else {
+                    Logger.info(`No products to buy or to get applied to delete from collection with ID: ${collectionId}`);
+                }
+                resolve(null);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Overwrites Collection Metafield
+     * 
+     * @param  {number} collectionId
+     * @param  {string} metafieldVal
+     * @param  {string} namespace
+     * @param  {string} key
+     * @returns Promise
+     */
+    public updateMetafield = async (collectionId: number, metafieldVal: string, namespace: string, key: string): Promise<{id: number;}> => {
+        return new Promise<{id: number;}>(async (resolve, reject) => {
+            try {
+                Logger.info(`Collection ${collectionId} updated with ${metafieldVal}`);
+                const metafieldQuery = gql `mutation MetafieldsSet($collectionId: ID!, $value: String!) {
+                  metafieldsSet(metafields: [
+                    {
+                      ownerId: $collectionId
+                      namespace: "${namespace}"
+                      key: "${key}"
+                      value: $value
+                      type: "json"
+                    }
+                  ]) {
+                    metafields {
+                      id
+                    }
+                    userErrors {
+                      message
+                    }
+                  }
+                }`;
+                    
+                const metafieldResponse = await this.axiosInstance.post('/graphql.json', { query: print(metafieldQuery), 
+                    variables: { collectionId: this.getGraphCollectionIdFromId(collectionId), value: metafieldVal }}, { query_cost: 803 });
+                
+                if(metafieldResponse.data.errors) {
+                    reject(`Error ${JSON.stringify(metafieldResponse.data.errors)}`);
+                } else {
+                    Logger.info(`Meta coll response ${JSON.stringify(metafieldResponse.data)}`);
+                    resolve({ id: collectionId });
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Gets metafield of a collection
+     * 
+     * @param  {number} collectioId
+     * @param  {string} namespace
+     * @param  {string} key
+     * @returns Promise
+     */
+    public getMetafield = async (collectioId: number, namespace: string, key: string): Promise<IMetafield[]> => {
+        return new Promise<IMetafield[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`Getting metafield for collectio id ->  ${collectioId}`);
+                const response =  await this.axiosInstance.get(`/collections/${collectioId}/metafields.json?key=${key}&namespace=${namespace}`);
+                resolve(response.data.metafields);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getCollection = async (collectionId: number): Promise<ICollection> => {
+        return new Promise<ICollection>(async (resolve, reject) => {
+            try {
+                Logger.info('Getting collection', collectionId);
+                const collectionResponse = await this.axiosInstance.get(`/collections/${collectionId}.json`);
+                const collection = collectionResponse.data.collection;
+                resolve(collection);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getCollects = async (collectionId: number, productLimit?: number): Promise<ICollect[]> => {
+        return new Promise<ICollect[]>(async (resolve, reject) => {
+            try {
+                Logger.info('Getting collects for collection', collectionId);
+                let collects: ICollect[] = [];
+                const countResponse = await this.axiosInstance.get(`/collects/count.json?collection_id=${collectionId}`);
+                const count = countResponse.data.count;
+                Logger.info(`Counted collects ${count}`);
+                while (collects.length < count) {
+                    let getCollectsUrl = `/collects.json?collection_id=${collectionId}&limit=250`;
+                    if(collects.length > 1){
+                        getCollectsUrl += `&since_id=${collects[collects.length - 1].id}`;
+                    } else {
+                        getCollectsUrl += '&since_id=0';
+                    }
+                    Logger.info(`Get collects URL ${getCollectsUrl}`);
+                    const collectsRetrieved = await this.axiosInstance.get(getCollectsUrl);
+                    collects = collects.concat(collectsRetrieved.data.collects);
+                    if(productLimit && collects.length > productLimit) {
+                        break;
+                    }
+                }
+                resolve(collects);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getProductIdsOfCollection = async (collectionId: number, productLimit: number): Promise<number[]> => {
+        return new Promise<number[]>(async (resolve, reject) => {
+            try {
+                Logger.info('Getting product Ids for collection', collectionId);
+                let productIds: number[] = [];
+                const firstResponse = await this.axiosInstance.get(`/collections/${collectionId}/products.json?fields=id&limit=100`);
+                if(firstResponse && firstResponse.data.products && firstResponse.data.products.length > 0) {
+                    productIds = productIds.concat(firstResponse.data.products.map( (p) => p.id));
+                }
+                const links: string = firstResponse.headers['link'];
+                Logger.info(`Links ${links}`);
+                if(links){
+                    let parsedLinks = parseLink(links);
+                    if (parsedLinks['next']) {
+                        while(parsedLinks && parsedLinks['next']) {
+                            const response = await this.axiosInstance.get(parsedLinks['next'].url);
+                            const nlinks = response.headers['link'];
+                            Logger.info(`Links ${nlinks} ${parsedLinks['next'].url}`);
+                            if(nlinks) {
+                                parsedLinks = parseLink(nlinks);
+                            } else {
+                                parsedLinks = null;
+                            }
+                            if(response && response.data.products && response.data.products.length > 0) {
+                                productIds = productIds.concat(response.data.products.map( (p) => p.id));
+                            }
+                            if(productIds.length > productLimit) {
+                                break;
+                            }
+                        }
+                    }
+                }
+                resolve(productIds);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public get = async (num: number): Promise<IProduct[]> => {
+        return new Promise<IProduct[]>(async (resolve, reject) => {
+            try {
+                Logger.info('getting customers');
+                let products: IProduct[] = [];
+                const response = await this.axiosInstance.get('/products/count.json');
+                const count = response.data.count > num ? num : response.data.count;
+                while (products.length < count) {
+                    let productsGetURL = '/products.json?limit=250&since_id=';
+                    if(products.length > 1) {
+                        productsGetURL += `${products[products.length -1].id}`;
+                    } else {
+                        productsGetURL += '0';
+                    }
+                    const productsRetrieved = await this.axiosInstance.get(productsGetURL);
+                    products = products.concat(productsRetrieved.data.orders);
+                }
+                resolve(products.slice(0,count));
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getAll = async (collectionType: 'smart' | 'custom'): Promise<ICollection[]> => {
+        return new Promise<ICollection[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`getting ${collectionType} collections`);
+                const response = await this.axiosInstance.get(`/${collectionType}_collections/count.json`);
+                const count = response.data.count;
+                Logger.info(`Getting ${count} collections`);
+                let collections: ICollection[] = [];
+                while (collections.length < count) {
+                    let collectionsGetURL = `/${collectionType}_collections.json?limit=250&since_id=`;
+                    if(collections.length > 1) {
+                        collectionsGetURL += collections[collections.length - 1].id;
+                    } else {
+                        collectionsGetURL += '0';  
+                    }
+                    const currentPage = (parseInt((collections.length / 250).toFixed(0)) + 1);
+                    Logger.info(`Collections Get URL  -> ${collectionsGetURL}`);
+                    const collectionsRetrieved = await this.axiosInstance.get(collectionsGetURL);
+                    collections = collections.concat(collectionsRetrieved.data[`${collectionType}_collections`]);
+                    Logger.info('Collections retrieved -> ' + collections.length);
+                    const nextPage = (parseInt((collections.length / 250).toFixed(0)) + 1);
+                    if(currentPage === nextPage) {
+                        Logger.info('Collections next page is the current page so, we are breaking the loop!');
+                        break;
+                    }
+                }
+                resolve(collections);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public delete = async (id: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`deleting custom collections ${id}`);
+                await this.axiosInstance.delete(`/custom_collections/${id}.json`);
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public deleteProductsWithTag = async (collectionId: number, productTag: string): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                const collects: ICollect[] = await this.getCollects(collectionId);
+                collects.forEach(async collect => {
+                    const product:IProduct = await this.ShopifyProductService.list.getById(collect.product_id, { add_body_html: false, add_images: false, add_options: false, add_tags: true, add_title: false, add_variants: false, add_weight: false });
+                    let deleteProduct = false;
+                    if (product.tags) {
+                        Logger.info(`Product ID: ${product.id} has tags: ${product.tags}`);
+                        (product.tags as string[]).forEach((tag) => {
+                            if (tag.trim() === productTag) {
+                                deleteProduct = true;
+                            }
+                        });
+                    }
+                    if (deleteProduct) {
+                        Logger.info(`Product ID: ${product.id} has tag ${productTag} so we should delete it`);
+                        await this.ShopifyProductService.delete(collect.product_id);
+                    }
+                });
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public update = async (collection: ICollection): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Updating custom collections ${collection.id}`);
+                await this.axiosInstance.put(`/custom_collections/${collection.id}.json`, { custom_collection: collection });
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public updateCollects = async (collection: ICollection): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Updating custom collections ${collection.id}`);
+                if(!collection.collects) {
+                    collection.collects = [];
+                }
+                const collectChunks = this.sliceIntoChunks<ICollect[]>(collection.collects, 500);
+                for(const collectChunk of collectChunks) {
+                    Logger.info(`Updating custom collection chunk with ${collectChunk.length} id${collection.id}`);
+                    await this.axiosInstance.put(`/custom_collections/${collection.id}.json`, { custom_collection: { id: collection.id, collects: collectChunk } });
+                }
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public publish = async (id: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Publish custom collections ${id}`);
+                await this.update({ id: id, published: true });
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public unpublish = async (id: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`UnPublish custom collections ${id}`);
+                await this.update({ id: id, published: false });
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+}