@stackfactor/client-api 1.1.228 → 1.1.231

package/dist/esm/src/lib/learningContent.js

@@ -0,0 +1,690 @@
+import { getBaseUrl } from "./utils.js";
+import { client } from "./axiosClient.js";
+import { io } from "socket.io-client";
+/**
+ * Create learning content and set information
+ * @param {Object} data Learning content data
+ * @param {String} token Authorization token
+ * @returns {Promise<object>} The created learning content
+ */
+export const createLearningContent = (data, token) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            data: data,
+        };
+        const confirmationRequest = client.put("/api/v1/learningcontent", requestData, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Delete learning content
+ * @param {String} id The id of the learning content to be deleted
+ * @param {String} comments The comments included with the deletion
+ * @param {String} token Authorization token
+ * @returns {Promise<object>} The response from the server
+ */
+export const deleteLearningContent = (id, comments, token) => {
+    const data = {
+        id: id,
+    };
+    if (comments)
+        data.comments = comments;
+    return new Promise((resolve, reject) => {
+        const request = client.delete(`/api/v1/learningcontent/`, {
+            headers: { authorization: token },
+            data: data,
+        });
+        request
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Delete media for a specific micro skill learning content activity
+ * @param {String} id
+ * @param {String} microskillid
+ * @param {String} activityId
+ * @param {String} mediaId
+ * @param {String} token
+ * @returns {Promise<object>} The response from the server
+ * */
+export const deleteLearningContentMicroSkillLearningContentActivityMedia = (id, microskillid, activityId, mediaId, token) => {
+    return new Promise((resolve, reject) => {
+        const confirmationRequest = client.delete(`/api/v1/learningcontent/media/${id}/${microskillid}/${activityId}/${mediaId}`, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Discard the learning content draft changes
+ * @param {String} id The id of the learning content to be deleted
+ * @param {String} token Authorization token
+ * @returns {Promise<object>} The response from the server
+ */
+export const discardLearningContentChanges = (id, token) => {
+    return new Promise((resolve, reject) => {
+        const data = {};
+        const request = client.get(`/api/v1/learningcontent/discard/${id}`, {
+            headers: { authorization: token },
+            data: data,
+        });
+        request
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Generate the learning activity content
+ * @param {String} learningObjectives
+ * @param {String} skillId
+ * @param {String} microSkillId
+ * @param {Object} learningActivity
+ * @param {List<String>} otherLearningActivities
+ * @param {String} integrationId
+ * @param {String} contentType
+ * @param {String} token
+ */
+export const generateLearningActivityContent = (learningObjectives, skillId, microSkillId, learningActivity, otherLearningActivities, integrationId, contentType, token, onProgressStatus) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            learningObjectives: learningObjectives,
+            learningActivity: learningActivity,
+            microSkillId: microSkillId,
+            integrationId: integrationId,
+            contentType: contentType,
+            skillId: skillId,
+        };
+        if (otherLearningActivities) {
+            requestData.otherLearningActivities = otherLearningActivities;
+        }
+        // Use socket.io for real-time progress updates
+        const socket = io(getBaseUrl(), {
+            auth: {
+                token: token,
+            },
+            path: `/api/v1/realtime`,
+            transports: ["websocket"],
+            withCredentials: true,
+            reconnection: false,
+        });
+        // Socket event handlers
+        socket.on("connect", () => {
+            socket.emit("generatelearningactivitycontent", requestData);
+        });
+        socket.on("progress", (data) => {
+            if (onProgressStatus) {
+                onProgressStatus(data);
+            }
+        });
+        socket.on("complete", (data) => {
+            socket.disconnect();
+            resolve(data);
+        });
+        socket.on("error", (err) => {
+            socket.disconnect();
+            reject(err);
+        });
+        socket.on("disconnect", (reason) => {
+            if (reason !== "io client disconnect") {
+                reject(new Error(`Socket disconnected: ${reason}`));
+            }
+        });
+    });
+};
+/**
+ * Generate micro skill test knowledge
+ * @param {String} microSkill
+ * @param {String} token
+ * @param {Function} onProgressStatus Optional callback for progress updates
+ * @returns {Promise<object>}
+ */
+export const generateMicroSkillTestKnowledge = (microSkill, token, onProgressStatus) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            microSkill: microSkill,
+        };
+        // Use socket.io for real-time progress updates
+        const socket = io(getBaseUrl(), {
+            auth: {
+                token: token,
+            },
+            path: `/api/v1/realtime`,
+            transports: ["websocket"],
+            withCredentials: true,
+            reconnection: false,
+        });
+        // Socket event handlers
+        socket.on("connect", () => {
+            socket.emit("generatemicroskilltestknowledge", requestData);
+        });
+        socket.on("progress", (data) => {
+            if (onProgressStatus) {
+                onProgressStatus(data);
+            }
+        });
+        socket.on("complete", (data) => {
+            socket.disconnect();
+            resolve(data);
+        });
+        socket.on("error", (err) => {
+            socket.disconnect();
+            reject(err);
+        });
+        socket.on("disconnect", (reason) => {
+            if (reason !== "io client disconnect") {
+                reject(new Error(`Socket disconnected: ${reason}`));
+            }
+        });
+    });
+};
+/**
+ * Get the learning content information by id
+ * @param {String} id The id of the learning content
+ * @param {String} version The version of the learning content
+ * @param {String} token Authorization token
+ * @returns {Promise<object>} The response from the server
+ */
+export const getLearningContentInformationById = (id, version, token) => {
+    return new Promise((resolve, reject) => {
+        const confirmationRequest = client.get(`/api/v1/learningcontent/${id}/${version}`, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Get the list of available content types
+ * @param {Array<String>} filter The filter used to select the learning content
+ * @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 getLearningContentList = (filter, version, includeDeleted, token) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            version: version,
+            includeDeleted: includeDeleted,
+        };
+        if (filter)
+            requestData.filter = filter;
+        const confirmationRequest = client.post(`/api/v1/learningcontent`, requestData, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Get learning content scene audio
+ * @param {String} id
+ * @param {String} microSkillId
+ * @param {String} learningActivityId
+ * @param {String} sceneId
+ * @param {String} token
+ * @param {String} version
+ */
+export const getLearningContentMicroSkillLearningContentActivitySceneAudio = (contentId, microSkillId, learningActivityId, sceneId, token, version) => {
+    return new Promise((resolve, reject) => {
+        const confirmationRequest = client.get(`/api/v1/learningcontent/audio/${contentId}/${microSkillId}/${learningActivityId}/${sceneId}/${version}`, {
+            headers: {
+                authorization: token,
+            },
+            responseType: "blob",
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Upload media for a specific micro skill learning content activity
+ * @param {String} id
+ * @param {String} microskillid
+ * @param {String} activityId
+ * @param {String} mediaId
+ * @param {String} token
+ * @returns {Promise<object>} The response from the server
+ */
+export const getLearningContentMicroSkillLearningContentActivityMedia = (id, microskillid, activityId, mediaId, token) => {
+    return new Promise((resolve, reject) => {
+        const confirmationRequest = client.get(`/api/v1/learningcontent/media/${id}/${microskillid}/${activityId}/${mediaId}`, {
+            headers: {
+                authorization: token,
+            },
+            responseType: "blob",
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * 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
+ */
+export const migrateLearningContentStorageType = (id, token) => {
+    return new Promise((resolve, reject) => {
+        const data = {};
+        const 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
+ * @param {String} comments The comments to be include with the request
+ * @param {String} token Authorization token
+ * @returns {Promise<object>} The response from the server
+ */
+export const publishLearningContent = (id, comments, token) => {
+    return new Promise((resolve, reject) => {
+        const data = {};
+        if (comments)
+            data.comments = comments;
+        const confirmationRequest = client.post(`/api/v1/learningcontent/publish/${id}`, data, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Set learning content information
+ * @param {String} id The id of the learning content to be updated
+ * @param {Object} data Data used to update the learning content
+ * @param {String} token Authorization token
+ * @returns {Promise<object>} The updated learning content
+ */
+export const setLearningContentInformation = (id, data, token) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            data: data,
+            id: id,
+        };
+        const confirmationRequest = client.post(`/api/v1/learningcontent/update`, requestData, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Set partial content information
+ * @param {String} id
+ * @param {Object} data
+ * @param {String} token
+ * @returns {Promise<object>}
+ */
+export const setLearningContentPartialContentInformation = (id, data, token) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            data: data,
+            id: id,
+        };
+        const 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} learningcontentid
+ * @param {String} microSkillId
+ * @param {Object} data
+ * @param {String} token
+ * @returns {Promise<String>} OK word if the operation was successful
+ */
+export const setLearningContentLearningContentInformation = (id, learningcontentid, microSkillId, data, token) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            data: data,
+            id: id,
+            learningcontentid: learningcontentid,
+            microSkillId: microSkillId,
+        };
+        const confirmationRequest = client.post(`/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
+ */
+export const setLearningContentLearningMicroSkillContentInformation = (id, microskillid, data, token) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            data: data,
+        };
+        const confirmationRequest = client.post(`/api/v1/learningcontent/updatemicroskilllearningcontent/${id}/${microskillid}`, requestData, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Update the learning content tags
+ * @param {String} id The id of the learning to be updated
+ * @param {Object} tags Updated learning content tags
+ * @param {String} token Authorization token
+ */
+export const setLearningContentTags = (id, tags, token) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            tags: tags,
+            id: id,
+        };
+        const confirmationRequest = client.post(`/api/v1/learningcontent/updatetags/`, requestData, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Upload media for a specific micro skill learning content activity
+ * @param {String} id
+ * @param {String} microskillid
+ * @param {String} activityId
+ * @param {String} mediaId
+ * @param {Blob} blob
+ * @param {String} token
+ * @returns {Promise<object>} The response from the server
+ */
+export const uploadLearningContentMicroSkillLearningContentActivityMedia = (id, microskillid, activityId, mediaId, blob, token) => {
+    const formData = new FormData();
+    formData.append("file", blob, "media.bin");
+    return new Promise((resolve, reject) => {
+        const confirmationRequest = client.post(`/api/v1/learningcontent/media/${id}/${microskillid}/${activityId}/${mediaId}`, formData, {
+            headers: {
+                authorization: token,
+                "Content-Type": "multipart/form-data",
+            },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Generate lab configuration content
+ * @param {String} skillId The id of the skill
+ * @param {String} proficiencyLevel The proficiency level
+ * @param {Number} labType The lab type
+ * @param {Object} labConfiguration The lab configuration
+ * @param {String} token Authorization token
+ * @param {String} integrationId Optional integration id
+ * @param {Function} onProgressStatus Optional callback for progress updates
+ * @returns {Promise<object>} The generated content
+ */
+export const generateLabConfigurationContent = (skillId, proficiencyLevel, labType, labConfiguration, token, integrationId, onProgressStatus) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            skillId: skillId,
+            proficiencyLevel: proficiencyLevel,
+            labType: labType,
+            labConfiguration: labConfiguration,
+        };
+        if (integrationId) {
+            requestData.integrationId = integrationId;
+        }
+        // Use socket.io for real-time progress updates
+        const socket = io(getBaseUrl(), {
+            auth: {
+                token: token,
+            },
+            path: `/api/v1/realtime`,
+            transports: ["websocket"],
+            withCredentials: true,
+            reconnection: false,
+        });
+        // Socket event handlers
+        socket.on("connect", () => {
+            socket.emit("generatelabconfigurationcontent", requestData);
+        });
+        socket.on("progress", (data) => {
+            if (onProgressStatus) {
+                onProgressStatus(data);
+            }
+        });
+        socket.on("complete", (data) => {
+            socket.disconnect();
+            resolve(data);
+        });
+        socket.on("error", (err) => {
+            socket.disconnect();
+            reject(err);
+        });
+        socket.on("disconnect", (reason) => {
+            if (reason !== "io client disconnect") {
+                reject(new Error(`Socket disconnected: ${reason}`));
+            }
+        });
+    });
+};
+/**
+ * Get media for a specific lab configuration
+ * @param {String} id The id of the learning content
+ * @param {String} labConfigurationId The id of the lab configuration
+ * @param {String} mediaId The id of the media
+ * @param {String} token Authorization token
+ * @returns {Promise<object>} The response from the server
+ */
+export const getLearningContentLabConfigurationMedia = (id, labConfigurationId, mediaId, token) => {
+    return new Promise((resolve, reject) => {
+        const confirmationRequest = client.get(`/api/v1/learningcontent/media/lab/${id}/${labConfigurationId}/${mediaId}`, {
+            headers: {
+                authorization: token,
+            },
+            responseType: "blob",
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Upload media for a specific lab configuration
+ * @param {String} id The id of the learning content
+ * @param {String} labConfigurationId The id of the lab configuration
+ * @param {String} mediaId The id of the media
+ * @param {Blob} blob The media file to upload
+ * @param {String} token Authorization token
+ * @returns {Promise<object>} The response from the server
+ */
+export const uploadLearningContentLabConfigurationMedia = (id, labConfigurationId, mediaId, blob, token) => {
+    const formData = new FormData();
+    formData.append("file", blob, "media.bin");
+    return new Promise((resolve, reject) => {
+        const confirmationRequest = client.post(`/api/v1/learningcontent/media/lab/${id}/${labConfigurationId}/${mediaId}`, formData, {
+            headers: {
+                authorization: token,
+                "Content-Type": "multipart/form-data",
+            },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Update a single lab configuration for a specific learning content
+ * @param {String} id The id of the learning content
+ * @param {String} labConfigurationId The id of the lab configuration
+ * @param {Object} data The lab configuration data
+ * @param {String} token Authorization token
+ * @returns {Promise<object>} The response from the server
+ */
+export const updateLearningContentLabConfiguration = (id, labConfigurationId, data, token) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            id: id,
+            labConfigurationId: labConfigurationId,
+            data: data,
+        };
+        const confirmationRequest = client.post(`/api/v1/learningcontent/updatelabconfiguration`, requestData, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Update lab configurations for a specific learning content
+ * @param {String} id The id of the learning content
+ * @param {Array<Object>} data The lab configurations data
+ * @param {String} token Authorization token
+ * @returns {Promise<object>} The response from the server
+ */
+export const updateLearningContentLabConfigurations = (id, data, token) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            data: data,
+        };
+        const confirmationRequest = client.post(`/api/v1/learningcontent/updatelabconfigurations/${id}`, requestData, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+/**
+ * Watch learning content
+ * @param {String} id The id of the learning content to be updated
+ * @param {Boolean} watch Set to true or false
+ * @param {String} token Authorization token
+ */
+export const watchLearningContent = (id, watch, token) => {
+    return new Promise((resolve, reject) => {
+        const requestData = {
+            id: id,
+            watch: watch,
+        };
+        const confirmationRequest = client.post(`/api/v1/learningcontent/watch`, requestData, {
+            headers: { authorization: token },
+        });
+        confirmationRequest
+            .then((response) => {
+            resolve(response.data);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    });
+};
+//# sourceMappingURL=learningContent.js.map