@stackfactor/client-api 1.1.10 → 1.1.12-9.1

package/lib/{learningContent.js → learningContent.ts}

@@ -1,14 +1,35 @@
 import { client } from "./axiosClient.js";
 
+interface LearningContentData {
+  data?: object;
+  id?: string;
+  comments?: string;
+  learningcontentid?: string;
+  microSkillId?: string;
+  tags?: object;
+  watch?: boolean;
+}
+
+interface GenerateLearningActivityContentData {
+  learningObjectives: string;
+  learningActivity: object;
+  microSkillId: string;
+  sections: string[];
+  otherLearningActivities?: string[];
+}
+
 /**
  * Create learning content and set information
  * @param {Object} data Learning content data
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The created learning content
  */
-const createLearningContent = (data, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const createLearningContent = (
+  data: object,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       data: data,
     };
     let confirmationRequest = client.put(
@@ -35,12 +56,16 @@ const createLearningContent = (data, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The response from the server
  */
-export const deleteLearningContent = (id, comments, token) => {
-  const data = {
+const deleteLearningContent = (
+  id: string,
+  comments: string,
+  token: string
+): Promise<object> => {
+  const data: LearningContentData = {
     id: id,
   };
   if (comments) data.comments = comments;
-  return new Promise(function (resolve, reject) {
+  return new Promise((resolve, reject) => {
     const request = client.delete(`api/v1/learningcontent/`, {
       headers: { authorization: token },
       data: data,
@@ -61,8 +86,11 @@ export const deleteLearningContent = (id, comments, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The response from the server
  */
-export const discardLearningContentChanges = (id, token) => {
-  return new Promise(function (resolve, reject) {
+const discardLearningContentChanges = (
+  id: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     const data = {};
     const request = client.get(`api/v1/learningcontent/discard/${id}`, {
       headers: { authorization: token },
@@ -80,25 +108,33 @@ export const discardLearningContentChanges = (id, token) => {
 
 /**
  * Generate the learning activity content
+ * @param {String} learningObjectives
  * @param {String} skillId
  * @param {String} microSkillId
  * @param {Object} learningActivity
+ * @param {List<String>} otherLearningActivities
  * @param {List<String>} sections
  * @param {String} token
  */
-export const generateLearningActivityContent = (
-  skillId,
-  microSkillId,
-  learningActivity,
-  sections,
-  token
-) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const generateLearningActivityContent = (
+  learningObjectives: string,
+  skillId: string,
+  microSkillId: string,
+  learningActivity: object,
+  otherLearningActivities: string[],
+  sections: string[],
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: GenerateLearningActivityContentData = {
+      learningObjectives: learningObjectives,
       learningActivity: learningActivity,
       microSkillId: microSkillId,
       sections: sections,
     };
+    if (otherLearningActivities) {
+      requestData.otherLearningActivities = otherLearningActivities;
+    }
     const request = client.post(
       `api/v1/learningcontent/generatelearningactivitycontent/${skillId}`,
       requestData,
@@ -116,6 +152,37 @@ export const generateLearningActivityContent = (
   });
 };
 
+/**
+ * Generate micro skill test knowledge
+ * @param {String} microSkill
+ * @param {String} token
+ * @returns {Promise<Object>}
+ */
+const generateMicroSkillTestKnowledge = (
+  microSkill: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    let data = {
+      microSkill: microSkill,
+    };
+    let confirmationRequest = client.post(
+      `api/v1/learningcontent/generatemicroskilltestknowledge`,
+      data,
+      {
+        headers: { authorization: token },
+      }
+    );
+    confirmationRequest
+      .then((response) => {
+        resolve(response.data);
+      })
+      .catch((error) => {
+        reject(error);
+      });
+  });
+};
+
 /**
  * Get the learning content information by id
  * @param {String} id The id of the learning content
@@ -123,8 +190,12 @@ export const generateLearningActivityContent = (
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The response from the server
  */
-export const getLearningContentInformationById = (id, version, token) => {
-  return new Promise(function (resolve, reject) {
+const getLearningContentInformationById = (
+  id: string,
+  version: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.get(
       `api/v1/learningcontent/${id}/${version}`,
       {
@@ -149,14 +220,14 @@ export const getLearningContentInformationById = (id, version, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Array<Object>>} The list of available content
  */
-export const getLearningContentList = (
-  filter,
-  version,
-  includeDeleted,
-  token
-) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const getLearningContentList = (
+  filter: string[],
+  version: string,
+  includeDeleted: boolean,
+  token: string
+): Promise<object[]> => {
+  return new Promise((resolve, reject) => {
+    const requestData: { version: string; includeDeleted: boolean; filter?: string[] } = {
       version: version,
       includeDeleted: includeDeleted,
     };
@@ -178,6 +249,35 @@ export const getLearningContentList = (
   });
 };
 
+/**
+ * Migrate learning content storage
+ * @param {String} id The id of the content to be migrated
+ * @param {String} token Authorization token
+ * @returns {Promise<Object>} The response from the server
+ */
+const migrateLearningContentStorageType = (
+  id: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    let data = {};
+    let confirmationRequest = client.post(
+      `api/v1/learningcontent/migratestorage/${id}`,
+      data,
+      {
+        headers: { authorization: token },
+      }
+    );
+    confirmationRequest
+      .then((response) => {
+        resolve(response.data);
+      })
+      .catch((error) => {
+        reject(error);
+      });
+  });
+};
+
 /**
  * Publish learning content
  * @param {String} id The id of the content to be published
@@ -185,9 +285,13 @@ export const getLearningContentList = (
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The response from the server
  */
-export const publishLearningContent = (id, comments, token) => {
-  return new Promise(function (resolve, reject) {
-    let data = {};
+const publishLearningContent = (
+  id: string,
+  comments: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    let data: LearningContentData = {};
     if (comments) data.comments = comments;
 
     let confirmationRequest = client.post(
@@ -214,9 +318,13 @@ export const publishLearningContent = (id, comments, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The updated learning content
  */
-export const setLearningContentInformation = (id, data, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const setLearningContentInformation = (
+  id: string,
+  data: object,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       data: data,
       id: id,
     };
@@ -237,29 +345,100 @@ export const setLearningContentInformation = (id, data, token) => {
   });
 };
 
+/**
+ * Set partial content information
+ * @param {String} id
+ * @param {Object} data
+ * @param {String} token
+ * @returns {Promise<Object>}
+ */
+const setLearningContentPartialContentInformation = (
+  id: string,
+  data: object,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
+      data: data,
+      id: id,
+    };
+    let confirmationRequest = client.post(
+      `api/v1/learningcontent/updatepartialcontent/${id}`,
+      requestData,
+      {
+        headers: { authorization: token },
+      }
+    );
+    confirmationRequest
+      .then((response) => {
+        resolve(response.data);
+      })
+      .catch((error) => {
+        reject(error);
+      });
+  });
+};
+
 /**
  * Set the content for a specific learning activity
  * @param {String} id
- * @param {String} learningActivityId
- * @param {String} operation
+ * @param {String} learningcontentid
+ * @param {String} microSkillId
  * @param {Object} data
  * @param {String} token
- * @returns {Promise<String>} OK word if the operation was succesful
+ * @returns {Promise<String>} OK word if the operation was successful
  */
-export const setLearningActivityInformation = (
-  id,
-  learningActivityId,
-  operation,
-  data,
-  token
-) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const setLearningContentLearningContentInformation = (
+  id: string,
+  learningcontentid: string,
+  microSkillId: string,
+  data: object,
+  token: string
+): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       data: data,
-      operation: operation,
+      id: id,
+      learningcontentid: learningcontentid,
+      microSkillId: microSkillId,
     };
     let confirmationRequest = client.post(
-      `api/v1/learningcontent/updateactivity/${id}/${learningActivityId}`,
+      `api/v1/learningcontent/updatelearningcontent/`,
+      requestData,
+      {
+        headers: { authorization: token },
+      }
+    );
+    confirmationRequest
+      .then((response) => {
+        resolve(response.data);
+      })
+      .catch((error) => {
+        reject(error);
+      });
+  });
+};
+
+/**
+ * Set all the learning content for a specific micro skill
+ * @param {String} id
+ * @param {String} microskillid
+ * @param {Object} data
+ * @param {String} token
+ * @returns {Promise<String>} OK word if the operation was successful
+ */
+const setLearningContentLearningMicroSkillContentInformation = (
+  id: string,
+  microskillid: string,
+  data: object,
+  token: string
+): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
+      data: data,
+    };
+    let confirmationRequest = client.post(
+      `api/v1/learningcontent/updatemicroskilllearningcontent/${id}/${microskillid}`,
       requestData,
       {
         headers: { authorization: token },
@@ -281,9 +460,13 @@ export const setLearningActivityInformation = (
  * @param {Object} tags Updated learning content tags
  * @param {String} token Authorization token
  */
-export const setLearningContentTags = (id, tags, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const setLearningContentTags = (
+  id: string,
+  tags: object,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       tags: tags,
       id: id,
     };
@@ -310,9 +493,13 @@ export const setLearningContentTags = (id, tags, token) => {
  * @param {Boolean} watch Set to true or false
  * @param {String} token Authorization token
  */
-export const watchLearningContent = (id, watch, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const watchLearningContent = (
+  id: string,
+  watch: boolean,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       id: id,
       watch: watch,
     };
@@ -333,18 +520,20 @@ export const watchLearningContent = (id, watch, token) => {
   });
 };
 
-const learningContent = {
+export default {
   createLearningContent,
   deleteLearningContent,
   discardLearningContentChanges,
   getLearningContentInformationById,
   generateLearningActivityContent,
+  generateMicroSkillTestKnowledge,
   getLearningContentList,
+  migrateLearningContentStorageType,
   publishLearningContent,
-  setLearningActivityInformation,
+  setLearningContentPartialContentInformation,
+  setLearningContentLearningContentInformation,
+  setLearningContentLearningMicroSkillContentInformation,
   setLearningContentInformation,
   setLearningContentTags,
   watchLearningContent,
 };
-
-export default learningContent;

package/lib/{learningPath.js → learningPath.ts}

@@ -1,12 +1,23 @@
 import { client } from "./axiosClient.js";
 
+interface LearningPathData {
+  data?: object;
+  id?: string;
+  comments?: string;
+  tags?: object;
+  list?: string[];
+  version?: string;
+  includeDeleted?: boolean;
+}
+
 /**
  * Create learning path and set information
  * @param {Object} data
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-export const createLearningPath = (data, token) => {
-  return new Promise(function (resolve, reject) {
+const createLearningPath = (data: object, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.put(
       "api/v1/learningpaths",
       { data: data },
@@ -29,10 +40,11 @@ export const createLearningPath = (data, token) => {
  * @param {String} id The id of the template to be deleted
  * @param {String} comments The comments for approver
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-export const deleteLearningPath = (id, comments, token) => {
-  return new Promise(function (resolve, reject) {
-    const data = {
+const deleteLearningPath = (id: string, comments: string, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const data: LearningPathData = {
       id: id,
     };
     if (comments) data.comments = comments;
@@ -54,9 +66,10 @@ export const deleteLearningPath = (id, comments, token) => {
  * Discard the training plan draft changes
  * @param {String} id The id of the training plan to be deleted
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-export const discardLearningPathChanges = (id, token) => {
-  return new Promise(function (resolve, reject) {
+const discardLearningPathChanges = (id: string, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
     const data = {};
     const request = client.get(`api/v1/learningpaths/discard/${id}`, {
       headers: { authorization: token },
@@ -73,12 +86,14 @@ export const discardLearningPathChanges = (id, token) => {
 };
 
 /**
- * Get traing plan template information
+ * Get training plan template information
  * @param {String} id The id of the template
+ * @param {String} version The version of the template
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-export const getLearningPathInformationById = (id, version, token) => {
-  return new Promise(function (resolve, reject) {
+const getLearningPathInformationById = (id: string, version: string, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.get(
       `api/v1/learningpaths/${id}/${version}`,
       {
@@ -99,18 +114,29 @@ export const getLearningPathInformationById = (id, version, token) => {
  * Get learning path list
  * @param {Array<String>} list The filter used to select the skill
  * @param {String} version The version to be retrieved
+ * @param {boolean} includeDeleted When true it will return the deleted records as well
  * @param {String} token Authorization token
+ * @returns {Promise<Array<Object>>} The list of available content
  */
-export const getLearningPathsList = (list, version, includeDeleted, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const getLearningPathsList = (
+  list: string[],
+  version: string,
+  includeDeleted: boolean,
+  token: string
+): Promise<object[]> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningPathData = {
       version: version,
       includeDeleted: includeDeleted,
     };
     if (list) requestData.list = list;
-    let confirmationRequest = client.post(`api/v1/learningpaths`, requestData, {
-      headers: { authorization: token },
-    });
+    let confirmationRequest = client.post(
+      `api/v1/learningpaths`,
+      requestData,
+      {
+        headers: { authorization: token },
+      }
+    );
     confirmationRequest
       .then((response) => {
         resolve(response.data);
@@ -122,14 +148,15 @@ export const getLearningPathsList = (list, version, includeDeleted, token) => {
 };
 
 /**
- * Publish training pplan template
+ * Publish training plan template
  * @param {String} id The id of the template to be published
  * @param {String} comments The comments to be include with the request
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-export const publishLearningPath = (id, comments, token) => {
-  return new Promise(function (resolve, reject) {
-    let data = {};
+const publishLearningPath = (id: string, comments: string, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    let data: LearningPathData = {};
     if (comments) data.comments = comments;
     let confirmationRequest = client.post(
       `api/v1/learningpaths/publish/${id}`,
@@ -153,10 +180,11 @@ export const publishLearningPath = (id, comments, token) => {
  * @param {String} id The id of the template to be updated
  * @param {Object} data Data used to update the template
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-export const setLearningPathInformation = (id, data, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const setLearningPathInformation = (id: string, data: object, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningPathData = {
       data: data,
       id: id,
     };
@@ -182,10 +210,11 @@ export const setLearningPathInformation = (id, data, token) => {
  * @param {String} id The id of the template to be updated
  * @param {Object} tags The updated tags
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-export const setLearningPathTags = (id, tags, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const setLearningPathTags = (id: string, tags: object, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningPathData = {
       tags: tags,
       id: id,
     };
@@ -206,7 +235,7 @@ export const setLearningPathTags = (id, tags, token) => {
   });
 };
 
-const learningPath = {
+export default {
   createLearningPath,
   deleteLearningPath,
   discardLearningPathChanges,
@@ -215,6 +244,4 @@ const learningPath = {
   publishLearningPath,
   setLearningPathInformation,
   setLearningPathTags,
-};
-
-export default learningPath;
+};

package/lib/{logger.js → logger.ts}

@@ -6,9 +6,15 @@ import { client } from "./axiosClient.js";
  * @param {String} elementType
  * @param {Object} data
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-export const comments = (elementId, elementType, data, token) => {
-  return new Promise(function (resolve, reject) {
+const comments = (
+  elementId: string,
+  elementType: string,
+  data: object,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.post(
       "api/v1/logger/comments/",
       {
@@ -36,10 +42,16 @@ export const comments = (elementId, elementType, data, token) => {
  * @param {Number} page The results page
  * @param {Number} elementsPerPage The number of elements per page
  * @param {String} token
+ * @returns {Promise<Object>}
  */
-export const getListByElementId = (elementId, page, elementsPerPage, token) => {
-  return new Promise(function (resolve, reject) {
-    let data = {};
+const getListByElementId = (
+  elementId: string,
+  page: number | null,
+  elementsPerPage: number | null,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    let data: { elementsPerPage?: number, page?: number } = {};
     if (elementsPerPage !== null) data.elementsPerPage = elementsPerPage;
     if (page !== null) data.page = page;
     const getTokensRequest = client.post(`api/v1/logger/${elementId}`, data, {
@@ -55,6 +67,4 @@ export const getListByElementId = (elementId, page, elementsPerPage, token) => {
   });
 };
 
-const logger = { comments, getListByElementId };
-
-export default logger;
+export default { comments, getListByElementId };