@stackfactor/client-api 1.0.0

package/lib/integrationConfiguration.js

@@ -0,0 +1,94 @@
+import axios from "./axios";
+
+export default {
+  axios: axios,
+
+  /**
+   * Get the integration configuration
+   * @param {[String]} ids
+   * @param {Number} type
+   * @param {String} token Authorization token
+   */
+  getIntegrationsConfiguration(ids, type, token) {
+    return new Promise(function (resolve, reject) {
+      let requestData = { type: type };
+      if (ids) requestData.ids = ids;
+      let confirmationRequest = axios.post(
+        "api/v1/integrationsconfiguration",
+        requestData,
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Save integration configuration
+   * @param {String} id The id of the integration configurationto be updated
+   * @param {Number} type The type of configuration
+   * @param {Object} configuration Data used to update the integration configuration
+   * @param {String} token Authorization token
+   */
+  saveIntegrationConfiguration(id, type, configuration, token) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        id: id,
+        configuration: configuration,
+        type: type,
+      };
+      let confirmationRequest = axios.put(
+        `api/v1/integrationsconfiguration`,
+        requestData,
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Test integration configuration
+   * @param {String} id The id of the integration to be updated
+   * @param {String} type The type of configuration
+   * @param {Object} configuration Configuration to be tested
+   * @param {String} token Authorization token
+   */
+  testIntegrationConfiguration(id, type, configuration, token) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        id: id,
+        configuration: configuration,
+        type: type,
+      };
+      let confirmationRequest = axios.post(
+        `api/v1/integrationsconfiguration/testConfiguration`,
+        requestData,
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+};

package/lib/integrations/contentgenerator.js

@@ -0,0 +1,79 @@
+/* eslint-disable no-undef */
+import axios from "../axios";
+
+export default {
+  axios: axios,
+  /**
+   * Generate content
+   * @param {Array<String>} data
+   * @param {String} contentType
+   * @param {String} integrationId
+   * @param {String} token
+   * @returns {Object}
+   */
+  generateContent(data, contentType, integrationId, token) {
+    return new Promise(function (resolve, reject) {
+      let data_ = {
+        data: data,
+        contentType: contentType,
+      };
+      if (integrationId) data.integrationId = integrationId;
+      const request = axios.post(`api/v1/contentgenerators/generate`, data_, {
+        headers: { authorization: token },
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Generate content aync
+   * @param {String} id
+   * @param {Object} data
+   * @param {String} contentType
+   * @param {String} elementType
+   * @param {String} integrationId
+   * @param {String} comments
+   * @param {String} token
+   * @returns {Object}
+   */
+  generateContentAsync(
+    id,
+    data,
+    contentType,
+    elementType,
+    integrationId,
+    comments,
+    token
+  ) {
+    return new Promise(function (resolve, reject) {
+      let data_ = {
+        data: data,
+        comments: comments,
+        contentType: contentType,
+        elementType: elementType,
+        id: id,
+      };
+      if (integrationId) data_.integrationId = integrationId;
+      const request = axios.post(
+        `api/v1/contentgenerators/generateasync`,
+        data_,
+        {
+          headers: { authorization: token },
+        }
+      );
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+};

package/lib/logger.js

@@ -0,0 +1,61 @@
+import axios from "./axios";
+
+export default {
+  axios: axios,
+
+  /**
+   * Create a comment for a specified element id
+   * @param {String} elementId
+   * @param {String} elementType
+   * @param {Object} data
+   * @param {String} token Authorization token
+   */
+  comment(elementId, elementType, data, token) {
+    return new Promise(function (resolve, reject) {
+      let confirmationRequest = axios.post(
+        "api/v1/logger/comment/",
+        {
+          data: data,
+          elementId: elementId,
+          elementType: elementType,
+        },
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Get the list of logger entries for selected element
+   * @param {String} elementId
+   * @param {number} page The results page
+   * @param {number} elementsPerPage The number of elements per page
+   * @param {String} token
+   * @returns
+   */
+  getListByElementId(elementId, page, elementsPerPage, token) {
+    return new Promise(function (resolve, reject) {
+      let data = {};
+      if (elementsPerPage !== null) data.elementsPerPage = elementsPerPage;
+      if (page !== null) data.page = page;
+      const getTokensRequest = axios.post(`api/v1/logger/${elementId}`, data, {
+        headers: { authorization: token },
+      });
+      getTokensRequest
+        .then((result) => {
+          resolve(result.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+};

package/lib/role.js

@@ -0,0 +1,266 @@
+import axios from "./axios";
+
+// eslint-disable-next-line no-undef
+export default {
+  axios: axios,
+
+  /**
+   * Create role and set information
+   * @param {Object} data
+   * @param {String} token Authorization token
+   */
+  createRole(data, token) {
+    return new Promise(function (resolve, reject) {
+      let confirmationRequest = axios.put(
+        "api/v1/roles",
+        { data: data },
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Create from from template
+   * @param {String} templateId
+   * @param {Object} data
+   * @param {String} token Authorization token
+   */
+  createRoleFromTemplate(templateId, data, token) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        templateId: templateId,
+        data: data,
+      };
+      let confirmationRequest = axios.put(
+        "api/v1/roles/createfromtemplate/",
+        requestData,
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Delete role
+   * @param {String} id The id of the role to be deleted
+   * @param {String} comment The comment included with the deletion
+   * @param {String} token Authorization token
+   */
+  deleteRole(id, comment, token) {
+    return new Promise(function (resolve, reject) {
+      const data = {
+        id: id,
+      };
+      if (comment) data.comment = comment;
+      const request = axios.delete(`api/v1/roles/`, {
+        headers: { authorization: token },
+        data: data,
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Discard the role draft changes
+   * @param {String} id The id of the role to be deleted
+   * @param {String} token Authorization token
+   */
+  discardRoleChanges(id, token) {
+    return new Promise(function (resolve, reject) {
+      const data = {};
+      const request = axios.get(`api/v1/roles/discard/${id}`, {
+        headers: { authorization: token },
+        data: data,
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Get role information
+   * @param {number} id The id of the role
+   * @param {String} token Authorization token
+   */
+  getRoleInformationById(id, version, token) {
+    return new Promise(function (resolve, reject) {
+      let confirmationRequest = axios.get(
+        `api/v1/roles/role/${id}/${version}`,
+        {
+          headers: { authorization: token },
+        }
+      );
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Get roles list
+   * @param {Object} filter The filter used to select the roles
+   * @param {String} version The version to be retrieved
+   * @param {Boolean} includeDeleted If true it will return deleted records as well
+   * @param {boolean} includeDetailedInformation If true it will return detailed information
+   * @param {Boolean} returnDefaultIfVersionNotAvailable Return the default version if published not available
+   * @param {String} token Authorization token
+   */
+  getRolesList(
+    filter,
+    version,
+    includeDeleted,
+    includeDetailedInformation,
+    returnDefaultIfVersionNotAvailable,
+    token
+  ) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        version: version,
+        includeDeleted: includeDeleted,
+        includeDetailedInformation: includeDetailedInformation,
+        returnDefaultIfVersionNotAvailable: returnDefaultIfVersionNotAvailable,
+      };
+      if (filter) requestData.filter = filter;
+      let confirmationRequest = axios.post(`api/v1/roles`, requestData, {
+        headers: { authorization: token },
+      });
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Publish role
+   * @param {number} id The id of the role to be published
+   * @param {String} comment The comment to be include with the request
+   * @param {String} token Authorization token
+   */
+  publishRole(id, comment, token) {
+    return new Promise(function (resolve, reject) {
+      let data = {};
+      if (comment) data.comment = comment;
+      let confirmationRequest = axios.post(`api/v1/roles/publish/${id}`, data, {
+        headers: { authorization: token },
+      });
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Set role profile information
+   * @param {String} id The id of the role to be updated
+   * @param {Object} data Data used to update the role
+   * @param {String} token Authorization token
+   */
+  setRoleInformation(id, data, token) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        data: data,
+        id: id,
+      };
+      let confirmationRequest = axios.post(`api/v1/roles/update`, requestData, {
+        headers: { authorization: token },
+      });
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+
+  /**
+   * Set user roles
+   * @param {String} id
+   * @param {Array<Object>} roles
+   * @param {String} token
+   */
+  setUserRoles(id, roles, roleDescription, token) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        roles: roles,
+        roleDescription: roleDescription,
+      };
+      if (id) requestData.userid = id;
+      let request = axios.post(`api/v1/roles/settouser/`, requestData, {
+        headers: { authorization: token },
+      });
+      request
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+  /**
+   * Watch role
+   * @param {String} id The id of the skill to be updated
+   * @param {Boolean} watch Set to true or false
+   * @param {String} token Authorization token
+   */
+  watchRole(id, watch, token) {
+    return new Promise(function (resolve, reject) {
+      const requestData = {
+        id: id,
+        watch: watch,
+      };
+      let confirmationRequest = axios.post(`api/v1/roles/watch`, requestData, {
+        headers: { authorization: token },
+      });
+      confirmationRequest
+        .then((response) => {
+          resolve(response.data);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
+};