@sommpicks/sommpicks-shopify 24.12.0

package/shopify/ShopifyCustomerService.ts

@@ -0,0 +1,472 @@
+import { Logger } from '../Logger';
+import { AxiosInstance } from 'axios';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+import moment = require('moment');
+import { AbstractService } from './base/AbstractService';
+
+export class ShopifyCustomerService extends AbstractService {
+
+    constructor(private axiosInstance: AxiosInstance) { super(); }
+
+    public getById = async (customerId: number): Promise<ICustomer> => {
+        return new Promise<ICustomer>(async (resolve, reject) => {
+            try {
+                Logger.info(`Get customer By Id ${customerId}`);
+                const response = await this.axiosInstance.get(`/customers/${customerId}.json`);
+                Logger.info('Customer found', response.data.customer);
+                resolve(response.data.customer);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getByEmail = async (email: string): Promise<ICustomer[]> => {
+        return new Promise<ICustomer[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`Get customers By Email ${email}`);
+                const response = await this.axiosInstance.get(`/customers/search.json?query=email:${email}`);
+                Logger.info('Customers found', response.data.customers);
+                resolve(response.data.customers);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+
+    /**
+     * 
+     * Searches using /customers/search.json?query= and returns the customers that has the tag doing a filter on the endpoint results.
+     * 
+     * @param  {string} tag to search for.
+     * @returns Promise
+     */
+    public getByTag = async (tag: string): Promise<ICustomer[]> => {
+        return new Promise<ICustomer[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`Get customers By Tag ${tag}`);
+                const response = await this.axiosInstance.get(`/customers/search.json?query=${tag.trim()}`);
+                const customers = response.data.customers;
+                Logger.info('Initial Customers found', response.data.customers);
+                const foundCustomers: ICustomer[] = [];
+                for (const customer of customers) {
+                    if (customer.tags && (customer.tags as string).trim().toLowerCase().indexOf(tag.trim().toLowerCase()) > -1) {
+                        foundCustomers.push(customer);
+                    }
+                }
+                Logger.info('Customers found', response.data.customers);
+                resolve(foundCustomers);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * 
+     * Searches using /customers/search.json?query= and returns the customers that contains the string in the last name field.
+     * 
+     * @param  {string} text to search for.
+     * @returns Promise
+     */
+    public getByLastNameContains = async (text: string): Promise<ICustomer[]> => {
+        return new Promise<ICustomer[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`Get customers By Last Name ${text}`);
+                const response = await this.axiosInstance.get(`/customers/search.json?query=${text.trim()}`);
+                const customers: ICustomer[] = response.data.customers;
+                Logger.info('Initial Customers found', response.data.customers);
+                const foundCustomers: ICustomer[] = [];
+                for (const customer of customers) {
+                    if (customer.last_name && customer.last_name.trim().toLowerCase().indexOf(text.trim().toLowerCase()) > -1) {
+                        foundCustomers.push(customer);
+                    }
+                }
+                Logger.info('Customers found', response.data.customers);
+                resolve(foundCustomers);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public create = async (customer: ICustomer): Promise<ICustomer> => {
+        return new Promise<ICustomer>(async (resolve, reject) => {
+            try {
+                Logger.info('Create customers', customer);
+                const response = await this.axiosInstance.post('/customers.json', { customer: customer });
+                resolve(response.data.customer);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * 
+     * @param custormerId Customer Id in shopify
+     * @param {ICustomer} customer add fields that need to be updated. Id field is required
+     * @returns 
+     */
+    public update = async (custormerId: number, customer: ICustomer): Promise<ICustomer> => {
+        return new Promise<ICustomer>(async (resolve, reject) => {
+            try {
+                Logger.info(`Update customers ${custormerId}`, customer);
+                const response = await this.axiosInstance.put(`/customers/${custormerId}.json`, { customer: customer });
+                resolve(response.data.customer);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * 
+     * Adds one or more tags to a customer. It does add them toghether with the existing ones.
+     * 
+     * @param {number} customerId customer id number
+     * @param {tags: string; id: number;} customer customer to apply change to.  Just tags and id fields
+     * @param {string[]} tags tags to add
+     * @returns Promise
+    */
+    public addTags = async (customerId: number, customer: { tags: string; id: number; }, tags: string[]): Promise<ICustomer> => {
+        return new Promise<ICustomer>(async (resolve, reject) => {
+            try {
+                if(customerId !== customer.id) {
+                    throw new Error(`Trying to add tags to the wrong customer - ${customerId} vs ${customer.id}`);
+                }
+                Logger.info(`Added tags of (${tags.join(',')}) to customer with id of ${customerId}`);
+                customer.tags = [...new Set([...customer.tags.split(','), ...tags])].join();
+                const responsedCustomer: ICustomer = await this.update(customerId, customer as any);
+                resolve(responsedCustomer);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * 
+     * Removes one or more tags to a customer
+     * 
+     * @param {number} customerId customer id number
+     * @param {tags: string; id: number;} customer customer to apply change to. Just tags and id fields
+     * @param {string[]} tags tags to remove
+     * @returns Promise
+    */
+    public removeTags = async (customerId: number, customer: { tags: string; id: number; }, tags: string[]): Promise<ICustomer> => {
+        return new Promise<ICustomer>(async (resolve, reject) => {
+            try {
+                if(customerId !== customer.id) {
+                    throw new Error(`Trying to remove tags to the wrong customer - ${customerId} vs ${customer.id}`);
+                }
+                Logger.info(`Removing tags of (${tags.join(',')}) to customer with id of ${customerId}`);
+                customer.tags = (customer.tags).split(',').filter(function (x) {
+                    return tags.indexOf(x.trim()) < 0;
+                }).join(',');
+                const responsedCustomer: ICustomer = await this.update(customerId, customer as any);
+                resolve(responsedCustomer);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getInBatch = async (sinceId: number): Promise<ICustomerBatch> => {
+        return new Promise<ICustomerBatch>(async (resolve, reject) => {
+            try {
+                Logger.info(`Getting customer since id ${sinceId}`);
+                const response = await this.axiosInstance.get('/customers/count.json');
+                const count = response.data.count;
+                const batches = parseInt(((count / 250) + 1).toString());
+                const customerBatch: ICustomerBatch = { batches: batches, customers: [], nextSinceId: 0 };
+                const customersGetURL = `/customers.json?limit=250&since_id=${sinceId}`;
+                const customersRetrieved = await this.axiosInstance.get(customersGetURL);
+                customerBatch.customers = customersRetrieved.data.customers;
+                if (customerBatch.customers && customerBatch.customers.length > 249) {
+                    customerBatch.nextSinceId = customerBatch.customers[customerBatch.customers.length - 1].id;
+                } else {
+                    customerBatch.nextSinceId = null;
+                }
+                resolve(customerBatch);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getCustomerEmails = async (ids: number[]): Promise<{ email: string; id: number; }[]> => {
+        return new Promise<{ email: string; id: number; }[]>(async (resolve, reject) => {
+            try {
+                let emails: { email: string; id: number; }[] = [];
+                const idsChunks: number[][] = this.sliceIntoChunks(ids, 250);
+
+                Logger.info(`Getting customer  emails in ${idsChunks.length} chunks of 250`);
+                
+                for (const idsChunk of idsChunks) {
+                    const customersGetURL = `/customers.json?ids=${idsChunk.join(',')}&limit=250&fields=id, email`;
+                    Logger.info(`idsChunk ... ${customersGetURL}`);
+                    const customersRetrieved = await this.axiosInstance.get(customersGetURL);
+                    if(customersRetrieved.data?.customers && customersRetrieved.data.customers.length > 0) {
+                        Logger.info(`idsChunk - customersRetrieved ... ${JSON.stringify(customersRetrieved.data)}`);
+                        emails = emails.concat(customersRetrieved.data.customers);
+                    }
+                }
+                resolve(emails);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * 
+     * @param  {number} num? Optional if you want to get a certain amount of products. Leave blank to get all.
+     * @returns Promise
+     */
+    public getAll = async (num?: number): Promise<ICustomer[]> => {
+        return new Promise<ICustomer[]>(async (resolve, reject) => {
+            try {
+                Logger.info('getting customers');
+                let customers: ICustomer[] = [];
+                const response = await this.axiosInstance.get('/customers/count.json');
+                const count = response.data.count > num && num !== undefined ? num : response.data.count;
+                while (customers.length < count) {
+                    let customerGetURL = '/customers.json?limit=100&since_id=';
+                    if (customers.length > 1) {
+                        customerGetURL += customers[customers.length - 1].id;
+                    } else {
+                        customerGetURL += '0';
+                    }
+                    const customersRetrieved = await this.axiosInstance.get(customerGetURL);
+                    customers = customers.concat(customersRetrieved.data.customers);
+                    if (!customersRetrieved.data.customers || customersRetrieved.data.customers.length < 100) {
+                        break;
+                    }
+                }
+                resolve(customers.slice(0, count));
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Adds an address to a customer.
+     * 
+     * @param  {number} customerId - Customer Id
+     * @param  {IAddress} address
+     * @returns Promise
+     */
+    public addAddress = async (customerId: number, address: IAddress): Promise<IAddress> => {
+        return new Promise<IAddress>(async (resolve, reject) => {
+            try {
+                Logger.info(`Adding a address to customer ${customerId}`, address);
+                const response = await this.axiosInstance.post(`/customers/${customerId}/addresses.json`, { address: address });
+                resolve(response.data.customer_address);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Adds an address to a customer as its default.
+     * 
+     * @param  {number} customerId - Cusotmer Id
+     * @param  {IAddress} address
+     * @returns Promise
+     */
+    public addAddressAsDefault = async (customerId: number, address: IAddress): Promise<IAddress> => {
+        return new Promise<IAddress>(async (resolve, reject) => {
+            try {
+                let addressCreated = await this.addAddress(customerId, address);
+                addressCreated = await this.addressAsDefault(customerId, addressCreated.id);
+                resolve(addressCreated);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Replaces the default address of a customer for the address provided.
+     * 
+     * @param  {number} customerId - Customer Id
+     * @param  {IAddress} address
+     * @returns Promise
+     */
+    public replacesAddressAsDefault = async (customerId: number, address: IAddress): Promise<IAddress> => {
+        return new Promise<IAddress>(async (resolve, reject) => {
+            try {
+                const customer = await this.getById(customerId);
+                const defaultAddressId = customer.default_address ? customer.default_address.id : null;
+                let addressCreated = await this.addAddress(customerId, address);
+                addressCreated = await this.addressAsDefault(customerId, addressCreated.id);
+                if (defaultAddressId) {
+                    await this.removeAddress(customerId, defaultAddressId);
+                } else {
+                    Logger.info('There wasn\'t a default address');
+                }
+                resolve(addressCreated);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Converts an address of a customer to its default.
+     * 
+     * @param  {number} customerId - Customer Id
+     * @param  {IAddress} addressId
+     * @returns Promise
+     */
+    public addressAsDefault = async (customerId: number, addressId: number): Promise<IAddress> => {
+        return new Promise<IAddress>(async (resolve, reject) => {
+            try {
+                Logger.info(`Address ${addressId} of customer ${customerId} as default`);
+                const response = await this.axiosInstance.put(`/customers/${customerId}/addresses/${addressId}/default.json`, {});
+                resolve(response.data.customer_address);
+            } catch (error) { Logger.error('Error setting address as default', error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Updates an address to a customer.
+     * 
+     * @param  {number} id - Cusotmer Id
+     * @param  {IAddress} address with id field in
+     * @returns Promise
+     */
+    public updateAddress = async (id: number, address: IAddress): Promise<IAddress> => {
+        return new Promise<IAddress>(async (resolve, reject) => {
+            try {
+                Logger.info(`Updating address ${address.id} to customer ${id}`, address);
+                const response = await this.axiosInstance.put(`/customers/${id}/addresses/${address.id}.json`, { address: address });
+                resolve(response.data.customer_address);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Removes an address to a customer.
+     * 
+     * @param  {number} customerId - Customer Id
+     * @param  {number} addressId
+     * @returns Promise
+     */
+    public removeAddress = async (customerId: number, addressId: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Removing address ${addressId} for customer ${customerId}`);
+                await this.axiosInstance.delete(`/customers/${customerId}/addresses/${addressId}.json`);
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Gets all metafields for a customer or empty array.
+     * 
+     * @param  {number} id - Cusotmer Id
+     * @returns Promise
+     */
+    public getMetafields = async (id: number): Promise<IMetafield[]> => {
+        return new Promise<IMetafield[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`Getting metafields for customer id ->  ${id}`);
+                const response = await this.axiosInstance.get(`/customers/${id}/metafields.json`);
+                resolve(response.data.metafields);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Count customers.
+     * 
+     * @param  {number} daysAgo - All customers created since that date.
+     * @returns Promise
+     */
+    public count = async (daysAgo: number): Promise<number> => {
+        return new Promise<number>(async (resolve, reject) => {
+            try {
+                Logger.info(`Count customers created after ${daysAgo} days ago`);
+                const response = await this.axiosInstance.get(`/customers/count.json?created_at_min=${moment().subtract(daysAgo, 'days').format()}`);
+                resolve(response.data.count);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Gets one concrete metafield for a customer or null if it does not exists.
+     * 
+     * @param  {number} id - Cusotmer Id
+     * @param  {string} namespace
+     * @param  {string} key
+     * @returns Promise
+     */
+    public getMetafield = async (id: number, namespace: string, key: string): Promise<IMetafield> => {
+        return new Promise<IMetafield>(async (resolve, reject) => {
+            try {
+                Logger.info(`Getting metafield for customer id ->  ${id} and namespace ${namespace} and key ${key}`);
+                const metafields = await this.getMetafields(id);
+                let foundMetafield: IMetafield = null;
+                if (metafields && metafields.length > 0) {
+                    foundMetafield = metafields.find(m => m.namespace === namespace && m.key === key);
+                }
+                resolve(foundMetafield);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Sends invite to a customer.
+     * 
+     * @param  {number} customerId
+     * @returns Promise
+     */
+    public sendInvite = async (customerId: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Send invite to customer ->  ${customerId}`);
+                await this.axiosInstance.post(`/customers/${customerId}/send_invite.json`);
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Creates a metafield for a customer and return the created metafield.
+     * 
+     * @param  {number} id
+     * @param  {IMetafield} metafield
+     * @returns Promise
+     */
+    public postMetafield = async (id: number, metafield: IMetafield): Promise<IMetafield> => {
+        return new Promise<IMetafield>(async (resolve, reject) => {
+            try {
+                Logger.info(`Posting metafield for customer id ->  ${id}`);
+                const response = await this.axiosInstance.post(`/customers/${id}/metafields.json`, { metafield: metafield });
+                resolve(response.data.metafield);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Updates a metafield for a customer and return the updated metafield. <br>
+     * The functionality first retrieves the customer metafield to get the ID and then updates it.
+     * 
+     * @param  {number} customerId
+     * @param  {IMetafield} metafield.
+     * @returns Promise
+     */
+    public putMetafield = async (customerId: number, metafield: IMetafield): Promise<IMetafield> => {
+        return new Promise<IMetafield>(async (resolve, reject) => {
+            try {
+                Logger.info(`Updating a metafield for customer id ->  ${customerId}`);
+                const metafieldSaved = await this.getMetafield(customerId, metafield.namespace, metafield.key);
+                if (metafieldSaved && metafieldSaved.id) {
+                    Logger.info(`Existing Metafield. Updating a metafield for customer id ->  ${customerId}`);
+                    const response = await this.axiosInstance.put(`/customers/${customerId}/metafields/${metafieldSaved.id}.json`, { metafield: { id: metafieldSaved.id, value: metafield.value } });
+                    resolve(response.data.metafield);
+                } else {
+                    Logger.info(`Metafield not found. Updating the metafield for customer id ->  ${customerId}`);
+                    const createdMetafield = await this.postMetafield(customerId, metafield);
+                    resolve(createdMetafield);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Deletes a metafield for a customer.
+     * 
+     * @param  {number} id - Customer Id
+     * @param  {number} metafieldId 
+     * @returns Promise
+     */
+    public deleteMetafield = async (id: number, metafieldId: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`Posting metafield for customer id ->  ${id}`);
+                await this.axiosInstance.delete(`/customers/${id}/metafields/${metafieldId}.json`);
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+}