@stackfactor/client-api 1.0.0

package/lib/groups.js

@@ -0,0 +1,314 @@
+//
+// Group sepcific requests
+//
+import axios from "./axios";
+
+export default {
+  axios: axios,
+
+  /**
+   * Add permissions to group
+   * @param {String} groupId The group Id
+   * @param {Array<String>} permissions The permissions to be added
+   * @param {String} authToken - Authentication token
+   */
+  addPermissionsToGroup(groupId, permissions, authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.post(
+        `api/v1/groups/permissions/add`,
+        {
+          groupId: groupId,
+          permissions: permissions,
+        },
+        { headers: { authorization: authToken } }
+      );
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Add users to group
+   * @param {String} groupId The group Id
+   * @param {Array<String>} users The users to be added
+   * @param {String} authToken - Authentication token
+   */
+  addUsersToGroup(groupId, users, authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.post(
+        `api/v1/groups/users/add`,
+        {
+          groupId: groupId,
+          users: users,
+        },
+        { headers: { authorization: authToken } }
+      );
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Create group
+   * @param {String} name The name of the group
+   * @param {String} description The description of the group
+   * @param {String} authToken The authorization token
+   */
+  createGroup(name, description, authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.post(
+        `api/v1/groups/group`,
+        {
+          name: name,
+          description: description,
+        },
+        { headers: { authorization: authToken } }
+      );
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Delete group
+   * @param {String} groupId The group to be deleted
+   * @param {String} defaultGroupId The default group all the users will be moved to
+   * @param {String} authToken The authentication token
+   */
+  deleteGroup(groupId, defaultGroupId, authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.delete(`api/v1/groups/delete`, {
+        headers: { authorization: authToken },
+        data: {
+          id: groupId,
+          defaultGroupId: defaultGroupId,
+        },
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Get all permissions
+   *
+   * @param {String} authToken The authentication token
+   */
+  getAllPermissions(authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.get(`api/v1/groups/permissions/getAllPermissions`, {
+        headers: { authorization: authToken },
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Get group by Id
+   * @param {*} groupId The group Id
+   * @param {String} authToken The authentication token
+   */
+  getGroupById(groupId, authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.get(`api/v1/groups/group/${groupId}`, {
+        headers: { authorization: authToken },
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Get groups for current tenant
+   * @param {*} authToken The authentication token
+   */
+  getGroups(authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.get(`api/v1/groups/`, {
+        headers: { authorization: authToken },
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Get current user permissions
+   * @param {*} authToken The authentication token
+   */
+  getUserPermissions(authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.get(`api/v1/groups/users/getuserpermissions`, {
+        headers: { authorization: authToken },
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Build in permissions
+   */
+  permissions: {
+    ADMIN_AUTHOR_CONTENT: "5ea3d1152839450e16e72bba",
+    ADMIN_PROMOTE_CONTENT: "5ea3d10bea252025c8ec351b",
+    ADMIN_MANAGE_CONTENT_PROVIDERS: "61970935cee185acf08111f6",
+    AUTHOR_CONTENT: "5fac210560e43de7c6b4a208",
+    MANAGE_BILLING: "5e1570cd03f676213bfdcd08",
+    MANAGE_CONTENT_PROVIDERS: "5f0fa12f16a720fde58ea820",
+    MANAGE_GROUPS: "5dd612fe59e518ac87b8cf8e",
+    MANAGE_OWN_PROFILE_INFORMATION_AUTO_APP: "5fac210e7e6539d37a897c94",
+    MANAGE_ORGANIZATION_INFORMATION: "5dd612d5338ea9a6ae6326da",
+    MANAGE_OWN_SKILL_SET_AUTO_APPROVE: "5fac21164351c6727a34cd4e",
+    MANAGE_SETTINGS: "5e1570e087d836dc77888a5f",
+    MANAGE_TEAM_INFORMATION_AUTO_APPROVE: "5fac211e6c8f874bd7137b98",
+    MANAGE_TEAMS: "5dd61314afc2455a89b1a37b",
+    MANAGE_USERS: "5dd612e40f0bc559c41a2b29",
+    PROMOTE_CONTENT: "5fac2126427ce31f8a92c0cb",
+    MANAGE_PLAN_TEMPLATES: "5dd61305a73c68b44c3f0827",
+  },
+  /**
+   * Remove permissions from group
+   * @param {String} groupId The group Id
+   * @param {Array<String>} permissions The permissions to be removed from the group
+   * @param {String} authToken The authentication token
+   */
+  removePermissionsFromGroup(groupId, permissions, authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.post(
+        `api/v1/groups/permissions/remove/`,
+        {
+          groupId: groupId,
+          permissions: permissions,
+        },
+        { headers: { authorization: authToken } }
+      );
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Remove users from group
+   * @param {String} groupId The group Id
+   * @param {Array<String>} users The users to be removed from the group
+   * @param {String} authToken The authentication token
+   */
+  removeUsersFromGroup(groupId, users, authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.post(
+        `api/v1/groups/users/remove/`,
+        {
+          groupId: groupId,
+          users: users,
+        },
+        { headers: { authorization: authToken } }
+      );
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /*
+   * Set group as defualt
+   * @param {String} groupId The group Id
+   * @param {String} authToken The authentication token
+   */
+  setDefault(groupId, authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.put(
+        `api/v1/groups/setDefault/`,
+        {
+          id: groupId,
+        },
+        { headers: { authorization: authToken } }
+      );
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Update group
+   * @param {String} groupId The group Id
+   * @param {string} name The updated name of the group
+   * @param {string} description The updated description of the group
+   * @param {String} authToken The authentication token
+   */
+  updateGroup(groupId, name, description, authToken) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.patch(
+        `api/v1/groups/group/`,
+        {
+          id: groupId,
+          name: name,
+          description: description,
+        },
+        { headers: { authorization: authToken } }
+      );
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+};

package/lib/integration.js

@@ -0,0 +1,337 @@
+/* eslint-disable no-undef */
+import axios, { errorToString } from "./axios";
+import axiosLib from "axios";
+import htmlParser from "node-html-parser";
+import htmlToText from "html2plaintext";
+
+export default {
+  axios: axios,
+
+  /**
+   * Create integration and set information
+   * @param {object} data The new integration information
+   * @param {String} token Authorization token
+   */
+  createIntegration(data, token) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        data: data,
+      };
+      let confirmationRequest = axios.put("api/v1/integrations/", requestData, {
+        headers: { authorization: token },
+      });
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Delete integration
+   * @param {String} id The id of the integration to be deleted
+   * @param {String} token Authorization token
+   */
+  deleteIntegration(id, token) {
+    return new Promise(function (resolve, reject) {
+      const request = axios.delete(`api/v1/integrations/`, {
+        headers: { authorization: token },
+        data: {
+          id: id,
+        },
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Discard the integration draft changes
+   * @param {String} id The id of the role template to be deleted
+   * @param {String} token Authorization token
+   */
+  discardIntegrationChanges(id, token) {
+    return new Promise(function (resolve, reject) {
+      const data = {};
+      const request = axios.get(`api/v1/integrations/discard/${id}`, {
+        headers: { authorization: token },
+        data: data,
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Get integration information
+   * @param {String} id The id of the integration
+   * @param {String} version The version of the integration to be received
+   * @param {String} token Authorization token
+   */
+  getIntegrationInformationById(id, version, token) {
+    return new Promise(function (resolve, reject) {
+      let confirmationRequest = axios.get(
+        `api/v1/integrations/${id}/${version}`,
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Get integrations list
+   * @param {Array<String>} filter The filter used to select the integration
+   * @param {String} type The type of the integration
+   * @param {String} version The version to be retrieved
+   * @param {Boolean} includeSupportedCapabilities If true, the supported capabilities will be included in the response
+   * @param {String} token Authorization token
+   */
+  getIntegrationsList(
+    filter,
+    type,
+    version,
+    includeSupportedCapabilities,
+    token
+  ) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        includeSupportedCapabilities: includeSupportedCapabilities,
+        version: version,
+      };
+      if (filter) requestData.filter = filter;
+      if (type) requestData.type = type;
+      let confirmationRequest = axios.post(`api/v1/integrations`, requestData, {
+        headers: { authorization: token },
+      });
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Get content information by Url
+   * @param {String} url The training url
+   * @param {String} verb The verb
+   * @param {String} token Authorization token
+   */
+  getContentInformationByUrl(url, verb, token) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        url: url,
+        verb: verb,
+      };
+      let confirmationRequest = axios.post(
+        `api/v1/contentproviders/getcontentinformationbyurl`,
+        requestData,
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  //get content information by url from the browser instead of the backend
+  getContentInformationByUrlFromBrowser(url) {
+    return new Promise(function (resolve, reject) {
+      let domain = new URL(url);
+      let instance = axiosLib.create({
+        baseURL: domain.origin,
+      });
+      let confirmationRequest = instance.get(domain.pathname, {
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Headers":
+            "Authorization, Origin, X-Requested-With, Content-Type, Accept",
+          Accept:
+            "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+          "Accept-Encoding": "gzip, deflate, br",
+          "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE",
+          "User-Agent": "Mozilla/5.0",
+        },
+      });
+      confirmationRequest
+        .then((response) => {
+          //get the reading time
+          const getReadingTime = (text) => {
+            const wpm = 225;
+            const words = text.trim().split(/\s+/).length;
+            return Math.ceil(words / wpm);
+          };
+
+          let document = htmlParser.parse(response.responseText);
+          let duration = getReadingTime(htmlToText(response.responseText));
+          let title = document.querySelector("title")?.rawText;
+          let description = "";
+          const descriptionEl = document.querySelector("meta");
+          try {
+            if (descriptionEl) {
+              const descriptionParentNode = descriptionEl.parentNode;
+              if (descriptionParentNode) {
+                const descriptionChildNodes = descriptionParentNode.childNodes;
+                if (descriptionChildNodes) {
+                  const descriptionRawAttr = descriptionChildNodes.find(
+                    (item) => item.rawAttrs.includes("description")
+                  );
+                  if (descriptionRawAttr) {
+                    const descriptionContent =
+                      descriptionRawAttr.rawAttrs.substring(
+                        descriptionRawAttr.rawAttrs.indexOf("content=") + 9
+                      );
+                    description = descriptionContent.substring(
+                      0,
+                      descriptionContent.length - 1
+                    );
+                  }
+                }
+              }
+            }
+          } finally {
+            resolve({
+              description: description,
+              duration: duration,
+              icon: `http://www.google.com/s2/favicons?sz=128&domain_url=${pathArray[2]}`,
+              title: title ? title.trim() : url,
+              type: 0,
+              internal: true,
+            });
+          }
+        })
+        .catch((error) => {
+          reject(new Error(errorToString(error)));
+        });
+    });
+  },
+
+  /**
+   * Get enabled content providers
+   * @param {String} userid
+   * @param {String} verb The verb
+   * @param {String} token Authorization token
+   */
+  getEnabledContentProviders(userId, token) {
+    return new Promise(function (resolve, reject) {
+      let confirmationRequest = axios.get(
+        `api/v1/contentproviders/getenabledcontentproviders/${userId}`,
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Publish integration
+   * @param {String} id The id of the integration to be published
+   * @param {String} token Authorization token
+   */
+  publishIntegration(id, token) {
+    return new Promise(function (resolve, reject) {
+      let confirmationRequest = axios.post(
+        `api/v1/integrations/publish/${id}`,
+        {},
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Set integration information
+   * @param {String} id The id of the integration to be updated
+   * @param {Object} data Data used to update the integration
+   * @param {String} token Authorization token
+   */
+  setIntegrationInformation(id, data, token) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        data: data,
+      };
+      let confirmationRequest = axios.post(
+        `api/v1/integrations/${id}`,
+        requestData,
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Set default integration
+   * @param {String} id The id of the integration to be set as default
+   * @param {String} token Authorization token
+   */
+  setDefaultIntegration(id, token) {
+    return new Promise(function (resolve, reject) {
+      let confirmationRequest = axios.post(
+        `api/v1/integrations/${id}/default`,
+        "",
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+};