groupcore-utils 1.2.3 → 1.3.3

package/README.md

@@ -0,0 +1,92 @@
+## Group Core Util Package
+### Description
+This package provides methods to work with parts of your Core account to enable you build solutions around the Core features.
+
+### Installation
+```
+npm install groupcore-utils
+```
+
+### Basic Usage
+```
+import CoreUtils from 'groupcore-utils'
+
+...
+const projectId = 'your Core project ID'
+const apiToken = 'your Core project API token'
+const apiUrl = 'your Core API URL'
+
+const coreUtil = new CoreUtils({ projectId, apiToken, apiUrl })
+
+// now you can call any of the available methods
+// for example, to get the inventory items of a particular inveentory group with ID of 1
+coreUtil.getGroupInventory({groupId: 1}).then((response)=>{
+    ....
+})
+
+```
+
+### Available Methods
+These are the methods you can call with this package. This list will continually be updated as needs arise.
+
+#### submitForm()
+```
+  /**
+   * Submit a form to the Core Lead Management module
+   * @param {object} formData - Key-value pair of all form fields to be submitted
+   * @param {number} formId - The ID of the Core form for the submission
+   * @param {string} email - The email address of the submitter
+   * @param {number} [leadId=null] - The lead ID, if the addLead method is called before submission
+   * @returns {Promise}
+   */
+```
+
+
+#### sendMail()
+```
+  /**
+   * Send an email message from your Core account.
+   * @param {string} recipientEmail - Email address of recipient
+   * @param {string} subject - Subject of the email
+   * @param {string} htmlBody - HTML body of the email message
+   * @param {boolean} [hasAttachment] - Specify if an attachment will be sent with the email
+   * @param {string} [attachmentFilename] - Choose the filename of the attachment. Optional if hasAttachment is false
+   * @param {string} [attachmentUrl] - The location of the attachment. Optional if hasAttachment is false
+   * @returns {Promise}
+   */
+```
+
+#### addLead()
+```
+  /**
+   * Add a lead to the Core Lead Management module
+   * @param {string} firstname - The first name of the lead
+   * @param {string} lastname - The last name of the lead
+   * @param {string} phone - The phone number of the lead
+   * @param {string} email - The email address of the lead
+   * @returns {Promise}
+   */
+```
+
+#### getGroupInventory()
+```
+  /**
+   * get inventory by group
+   * @param {number} groupId - The ID of the Core inventory group
+   * @returns {Promise}
+   */
+```
+
+#### getSectionContent()
+```
+  /**
+   * Get content from the Core content management system, by section
+   * @param {number} groupId - The ID of the Core inventory group
+   * @returns {Promise}
+   */
+```
+
+### Testing
+```
+npm run test
+```

package/Utils.js

@@ -21,25 +21,34 @@ class Utils {
    * @param {number} formId - The ID of the Core form for the submission
    * @param {string} email - The email address of the submitter
    * @param {number} [leadId=null] - The lead ID, if the addLead method is called before submission
-   * @returns {Object.<{error: string}>|Promise.<Object.<{insertId: number}>>} - Returns an error or a promise that resolves to an object
+   * @returns {Promise}
    */
   submitForm({ formData, formId, email, leadId = 0 }) {
-    if (_isEmpty(formData) || _isEmpty(String(formId)) || _isEmpty(email)) {
-      return { error: 'Missing some required params' };
-    }
+    return new Promise((resolve, reject) => {
+      if (_isEmpty(formData) || _isEmpty(String(formId)) || _isEmpty(email)) {
+        reject({ error: 'Missing some required params' });
+        return;
+      }
 
-    return axios({
-      method: 'POST',
-      url: `${this.apiUrl}/com/submissions`,
-      data: {
-        formData,
-        formId,
-        email,
-        leadId,
-      },
-      headers: {
-        token: this.token,
-      },
+      axios({
+        method: 'POST',
+        url: `${this.apiUrl}/com/submissions`,
+        data: {
+          formData,
+          formId,
+          email,
+          leadId,
+        },
+        headers: {
+          token: this.token,
+        },
+      })
+        .then((response) => {
+          resolve(response);
+        })
+        .catch(() => {
+          reject({ error: 'API error' });
+        });
     });
   }
 
@@ -51,36 +60,47 @@ class Utils {
    * @param {boolean} [hasAttachment] - Specify if an attachment will be sent with the email
    * @param {string} [attachmentFilename] - Choose the filename of the attachment. Optional if hasAttachment is false
    * @param {string} [attachmentUrl] - The location of the attachment. Optional if hasAttachment is false
-   * @returns {Object.<{error: string}>|Promise.<Object.<{insertId: number}>>} - Returns an error or a promise that resolves to an object
+   * @returns {Promise}
    */
   sendMail({ recipientEmail, subject, htmlBody, hasAttachment = false, attachmentFilename, attachmentUrl }) {
-    if (hasAttachment) {
-      if (_isEmpty(attachmentFilename) || _isEmpty(attachmentUrl)) {
-        return { error: 'Some missing params. If hasAttachment is true, both attachmentFilename and attachmentUrl are required' };
+    return new Promise((resolve, reject) => {
+      if (hasAttachment) {
+        if (_isEmpty(attachmentFilename) || _isEmpty(attachmentUrl)) {
+          reject({ error: 'Some missing params. If hasAttachment is true, both attachmentFilename and attachmentUrl are required' });
+          return;
+        }
       }
-    }
 
-    if (!hasAttachment && (attachmentFilename || attachmentUrl)) {
-      return { error: 'If hasAttachment is false, both attachmentFilename and attachmentUrl cannot be accepted' };
-    }
+      if (!hasAttachment && (attachmentFilename || attachmentUrl)) {
+        reject({ error: 'If hasAttachment is false, both attachmentFilename and attachmentUrl cannot be accepted' });
+        return;
+      }
 
-    if (_isEmpty(recipientEmail) || _isEmpty(subject) || _isEmpty(htmlBody)) {
-      return { error: 'Missing some required params' };
-    }
+      if (_isEmpty(recipientEmail) || _isEmpty(subject) || _isEmpty(htmlBody)) {
+        reject({ error: 'Missing some required params' });
+        return;
+      }
 
-    return axios({
-      method: 'POST',
-      url: `${this.apiUrl}/com/mail`,
-      data: {
-        project: this.project,
-        email: recipientEmail,
-        message: htmlBody,
-        subject,
-        attachments: hasAttachment ? [{ filename: attachmentFilename, path: attachmentUrl }] : null,
-      },
-      headers: {
-        token: this.token,
-      },
+      axios({
+        method: 'POST',
+        url: `${this.apiUrl}/com/mail`,
+        data: {
+          project: this.project,
+          email: recipientEmail,
+          message: htmlBody,
+          subject,
+          attachments: hasAttachment ? [{ filename: attachmentFilename, path: attachmentUrl }] : null,
+        },
+        headers: {
+          token: this.token,
+        },
+      })
+        .then((response) => {
+          resolve(response);
+        })
+        .catch(() => {
+          reject({ error: 'API error' });
+        });
     });
   }
 
@@ -90,52 +110,92 @@ class Utils {
    * @param {string} lastname - The last name of the lead
    * @param {string} phone - The phone number of the lead
    * @param {string} email - The email address of the lead
-   * @returns {Object.<{error: string}>|Promise.<Object.<{insertId: number}>>} - Returns an error or a promise that resolves to an object
+   * @returns {Promise}
    */
   addLead({ firstname, lastname, phone = null, email }) {
-    if (_isEmpty(firstname) || _isEmpty(lastname) || _isEmpty(email)) {
-      return { error: 'Missing some required params' };
-    }
+    return new Promise((resolve, reject) => {
+      if (_isEmpty(firstname) || _isEmpty(lastname) || _isEmpty(email)) {
+        reject({ error: 'Missing some required params' });
+        return;
+      }
 
-    return axios({
-      method: 'POST',
-      url: `${this.apiUrl}/com/leads`,
-      data: {
-        project: this.project,
-        firstname,
-        lastname,
-        email,
-        phone,
-      },
-      headers: {
-        token: this.token,
-      },
+      axios({
+        method: 'POST',
+        url: `${this.apiUrl}/com/leads`,
+        data: {
+          project: this.project,
+          firstname,
+          lastname,
+          email,
+          phone,
+        },
+        headers: {
+          token: this.token,
+        },
+      })
+        .then((response) => {
+          resolve(response);
+        })
+        .catch(() => {
+          reject({ error: 'API error' });
+        });
     });
   }
 
   /**
    * get inventory by group
    * @param {number} groupId - The ID of the Core inventory group
-   * @returns {Object.<{error: string}>|Promise.<Object>} - Returns an error or a promise that resolves to an object
+   * @returns {Promise}
    */
   async getGroupInventory({ groupId }) {
-    if (_isUndefined(groupId)) {
-      return { error: 'Missing some required params' };
-    }
+    return new Promise((resolve, reject) => {
+      if (_isUndefined(groupId)) {
+        reject({ error: 'Missing some required params' });
+        return;
+      }
 
-    try {
-      const response = await axios({
+      axios({
         method: 'GET',
         url: `${this.apiUrl}/inv/groups?id=${groupId}`,
         headers: {
           token: this.token,
         },
-      });
+      })
+        .then((response) => {
+          resolve(response.data[0]);
+        })
+        .catch(() => {
+          reject({ error: 'API error' });
+        });
+    });
+  }
+
+  /**
+   * Get content from the Core content management system, by section
+   * @param {number} groupId - The ID of the Core inventory group
+   * @returns {Promise}
+   */
+  async getSectionContent({ groupId }) {
+    return new Promise((resolve, reject) => {
+      if (_isUndefined(groupId)) {
+        reject({ error: 'Missing some required params' });
+        return;
+      }
 
-      return response.data[0];
-    } catch (e) {
-      return { error: 'API error' };
-    }
+      axios({
+        method: 'GET',
+        url: `${this.apiUrl}/cms/sections?group=${groupId}`,
+        headers: {
+          token: this.token,
+        },
+      })
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch(() => {
+          reject({ error: 'API error' });
+        });
+    });
   }
 }
 

package/Utils.spec.js

@@ -5,119 +5,202 @@ const axios = require('axios');
 jest.mock('axios');
 
 describe('Testing Utils.submitForm()', () => {
-  test('It should get a status 204 as response', async () => {
+  it('Should get a status 204 as response', async () => {
     axios.mockResolvedValue({ status: 200 });
-    const response = await util.submitForm({ formData: { name: 'test' }, formId: 300, email: 'test@email.com' });
+    const response = await util.submitForm({ formData: { name: 'abcd' }, formId: 300, email: '1234' });
     expect(response.status).toEqual(200);
   });
 
-  test('It should return error if missing params', async () => {
-    const response = await util.submitForm({ formId: 10, email: 'test@email.com', leadId: 10 });
-    const error = { error: 'Missing some required params' };
-    expect(response).toEqual(error);
+  it('Should return error if missing params', async () => {
+    try {
+      await util.submitForm({ formId: 1234, email: '1234', leadId: 1234 });
+    } catch (error) {
+      expect(error).toEqual({ error: 'Missing some required params' });
+    }
+  });
+
+  it('Should catch any errors during API call', async () => {
+    axios.mockRejectedValue();
+
+    try {
+      await util.submitForm({ formData: { name: 'abcd' }, formId: 1234, email: '1234' });
+    } catch (error) {
+      expect(error).toEqual({ error: 'API error' });
+    }
   });
 });
 
 describe('Testing Utils.sendMail()', () => {
-  test('It should return right response', async () => {
+  it('It should return right response', async () => {
     axios.mockResolvedValue({ status: 204 });
     const response = await util.sendMail({
-      recipientEmail: 'test@email.com',
-      subject: 'Test subject',
-      htmlBody: '<p>Html body</p>',
+      recipientEmail: '1234',
+      subject: 'abcd',
+      htmlBody: '<p>abcd</p>',
     });
     expect(response.status).toEqual(204);
   });
 
-  test('It should return right response with attachment', async () => {
+  it('It should return right response with attachment', async () => {
     axios.mockResolvedValue({ status: 204 });
     const response = await util.sendMail({
-      recipientEmail: 'test@email.com',
-      subject: 'Test subject',
-      htmlBody: '<p>Html body</p>',
+      recipientEmail: 'abcd',
+      subject: 'abcd',
+      htmlBody: '<p>abcd</p>',
       hasAttachment: true,
-      attachmentFilename: 'file',
-      attachmentUrl: 'url',
+      attachmentFilename: 'abcd',
+      attachmentUrl: 'abcd',
     });
     expect(response.status).toEqual(204);
   });
 
-  test('Should require attachmentFilename and attachmentUrl if hasAttachment is true', async () => {
-    const response = await util.sendMail({
-      recipientEmail: 'test@email.com',
-      subject: 'Test subject',
-      htmlBody: '<p>Html body</p>',
-      hasAttachment: true,
-      attachmentFilename: 'testfilename',
-    });
-    const error = { error: 'Some missing params. If hasAttachment is true, both attachmentFilename and attachmentUrl are required' };
-    expect(response).toEqual(error);
+  it('Should require attachmentFilename and attachmentUrl if hasAttachment is true', async () => {
+    try {
+      await util.sendMail({
+        recipientEmail: 'abcd',
+        subject: 'abcd',
+        htmlBody: '<p>abcd</p>',
+        hasAttachment: true,
+        attachmentFilename: 'abcd',
+      });
+    } catch (error) {
+      expect(error).toEqual({ error: 'Some missing params. If hasAttachment is true, both attachmentFilename and attachmentUrl are required' });
+    }
   });
 
-  test('Should return error if hasAttachment is false or undefined but attachmentUrl or attachmentFilename are not empty', async () => {
-    const response = await util.sendMail({
-      recipientEmail: 'test@email.com',
-      subject: 'Test subject',
-      htmlBody: '<p>Html body</p>',
-      attachmentFilename: 'testfilename',
-    });
-    const error = { error: 'If hasAttachment is false, both attachmentFilename and attachmentUrl cannot be accepted' };
-    expect(response).toEqual(error);
+  it('Should return error if hasAttachment is false or undefined but attachmentUrl or attachmentFilename are not empty', async () => {
+    try {
+      await util.sendMail({
+        recipientEmail: 'abcd',
+        subject: 'abcd',
+        htmlBody: '<p>abcd</p>',
+        attachmentFilename: 'abcd',
+      });
+    } catch (error) {
+      expect(error).toEqual({ error: 'If hasAttachment is false, both attachmentFilename and attachmentUrl cannot be accepted' });
+    }
   });
 
-  test('Should return error if missing required params', async () => {
-    const response = await util.sendMail({
-      recipientEmail: 'test@email.com',
-    });
-    const error = { error: 'Missing some required params' };
-    expect(response).toEqual(error);
+  it('Should return error if missing required params', async () => {
+    try {
+      await util.sendMail({
+        recipientEmail: '1234',
+      });
+    } catch (error) {
+      expect(error).toEqual({ error: 'Missing some required params' });
+    }
+  });
+
+  it('Should catch any errors during API call', async () => {
+    axios.mockRejectedValue();
+
+    try {
+      await util.sendMail({
+        recipientEmail: '1234',
+        subject: 'abcd',
+        htmlBody: '<p>abcd</p>',
+      });
+    } catch (error) {
+      expect(error).toEqual({ error: 'API error' });
+    }
   });
 });
 
 describe('Testing Utils.addLead()', () => {
-  test('It should return right response', async () => {
+  it('It should return right response', async () => {
     axios.mockResolvedValue({ data: { insertId: 3 } });
-    const response = await util.addLead({ firstname: 'test', lastname: 'test', email: 'test@email.com', phone: '123456' });
+    const response = await util.addLead({ firstname: 'test', lastname: 'test', email: 'abcd', phone: '123456' });
     expect(response.data.insertId).toEqual(3);
   });
 
-  test('Should return error if missing required params', async () => {
-    const response = await util.addLead({
-      firstname: 'test@email.com',
-    });
-    const error = { error: 'Missing some required params' };
-    expect(response).toEqual(error);
+  it('Should return error if missing required params', async () => {
+    try {
+      await util.addLead({
+        firstname: '1234',
+      });
+    } catch (error) {
+      expect(error).toEqual({ error: 'Missing some required params' });
+    }
+  });
+
+  it('Should catch any errors during API call', async () => {
+    axios.mockRejectedValue();
+
+    try {
+      await util.addLead({ firstname: 'test', lastname: 'test', email: 'abcd', phone: '123456' });
+    } catch (error) {
+      expect(error).toEqual({ error: 'API error' });
+    }
   });
 });
 
-describe('Testing Utils.getGroupInventory', () => {
+describe('Testing Utils.getGroupInventory()', () => {
   it('Should return the right response', async () => {
-    axios.mockResolvedValue([
-      {
-        id: 13,
-        item: '{"item":"test","price":12.34}',
-        inventoryGroup: 6,
-        status: 0,
-        dateAdded: 0,
-        cost: 8,
-        data: {
-          test: 'test',
+    axios.mockResolvedValue({
+      data: [
+        {
+          id: 13,
+          item: '{"item":"abcd","price":12.34}',
+          inventoryGroup: 6,
+          status: 0,
+          dateAdded: 0,
+          cost: 8,
+          data: {
+            test: 'abcd',
+          },
         },
-      },
-    ]);
+      ],
+    });
 
     const response = await util.getGroupInventory({ groupId: 6 });
     expect(response.id).toEqual(13);
   });
 
   it('Should validate the group ID param', async () => {
-    const response = await util.getGroupInventory({ groups: 6 });
-    expect(response).toEqual({ error: 'Missing some required params' });
+    try {
+      await util.getGroupInventory({ groups: 6 });
+    } catch (error) {
+      expect(error).toEqual({ error: 'Missing some required params' });
+    }
   });
 
   it('Should catch any errors during API call', async () => {
     axios.mockRejectedValue();
-    const response = await util.getGroupInventory({ groupId: 6 });
-    expect(response).toEqual({ error: 'API error' });
+    try {
+      await util.getGroupInventory({ groupId: 6 });
+    } catch (error) {
+      expect(error).toEqual({ error: 'API error' });
+    }
+  });
+});
+
+describe('Testing Utils.getSectionContent()', () => {
+  it('Should return the right response', async () => {
+    axios.mockResolvedValue({
+      data: {
+        testLabel: 'this is a test label',
+      },
+    });
+
+    const response = await util.getSectionContent({ groupId: 6 });
+    expect(response.testLabel).toEqual('this is a test label');
+  });
+
+  it('Should validate the group ID param', async () => {
+    try {
+      await util.getSectionContent({ groups: 6 });
+    } catch (error) {
+      expect(error).toEqual({ error: 'Missing some required params' });
+    }
+  });
+
+  it('Should catch any errors during API call', async () => {
+    axios.mockRejectedValue();
+
+    try {
+      await util.getSectionContent({ groupId: 6 });
+    } catch (error) {
+      expect(error).toEqual({ error: 'API error' });
+    }
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groupcore-utils",
-  "version": "1.2.3",
+  "version": "1.3.3",
   "description": "Utilities for working with some Core features",
   "main": "Utils.js",
   "scripts": {