refactor(backend): Changed folder structure for learning content services.

backend/src/services/learning-objects/dwengo-api-learning-object-provider.ts

@@ -0,0 +1,158 @@
+import { DWENGO_API_BASE } from '../../config.js';
+import { fetchWithLogging } from '../../util/apiHelper.js';
+import {
+    FilteredLearningObject, LearningObjectIdentifier,
+    LearningObjectMetadata,
+    LearningObjectNode, LearningPathIdentifier,
+    LearningPathResponse,
+} from '../../interfaces/learning-content.js';
+import dwengoApiLearningPathProvider from '../learning-paths/dwengo-api-learning-path-provider.js';
+import {LearningObjectProvider} from "./learning-object-provider";
+
+/**
+ * Helper function to convert the learning object metadata retrieved from the API to a FilteredLearningObject which
+ * our API should return.
+ * @param data
+ */
+function filterData(
+    data: LearningObjectMetadata
+): FilteredLearningObject {
+    return {
+        key: data.hruid, // Hruid learningObject (not path)
+        _id: data._id,
+        uuid: data.uuid,
+        version: data.version,
+        title: data.title,
+        htmlUrl: `/learningObject/${data.hruid}/html?language=${data.language}&version=${data.version}`, // Url to fetch html content
+        language: data.language,
+        difficulty: data.difficulty,
+        estimatedTime: data.estimated_time,
+        available: data.available,
+        teacherExclusive: data.teacher_exclusive,
+        educationalGoals: data.educational_goals, // List with learningObjects
+        keywords: data.keywords, // For search
+        description: data.description, // For search (not an actual description)
+        targetAges: data.target_ages,
+        contentType: data.content_type, // Markdown, image, audio, etc.
+        contentLocation: data.content_location, // If content type extern
+        skosConcepts: data.skos_concepts,
+        returnValue: data.return_value, // Callback response information
+    };
+}
+
+/**
+ * Generic helper function to fetch all learning objects from a given path (full data or just HRUIDs)
+ */
+async function fetchLearningObjects(
+    learningPathId: LearningPathIdentifier,
+    full: boolean
+): Promise<FilteredLearningObject[] | string[]> {
+    try {
+        const learningPathResponse: LearningPathResponse =
+            await dwengoApiLearningPathProvider.fetchLearningPaths(
+                [learningPathId.hruid],
+                learningPathId.language,
+                `Learning path for HRUID "${learningPathId.hruid}"`
+            );
+
+        if (
+            !learningPathResponse.success ||
+            !learningPathResponse.data?.length
+        ) {
+            console.error(
+                `⚠️ WARNING: Learning path "${learningPathId.hruid}" exists but contains no learning objects.`
+            );
+            return [];
+        }
+
+        const nodes: LearningObjectNode[] = learningPathResponse.data[0].nodes;
+
+        if (!full) {
+            return nodes.map((node) => {
+                return node.learningobject_hruid;
+            });
+        }
+
+        return await Promise.all(
+            nodes.map(async (node) => {
+                return dwengoApiLearningObjectProvider.getLearningObjectById({
+                    hruid: node.learningobject_hruid,
+                    language: learningPathId.language
+                });
+            })
+        ).then((objects) => {
+            return objects.filter((obj): obj is FilteredLearningObject => {
+                return obj !== null;
+            });
+        });
+    } catch (error) {
+        console.error('❌ Error fetching learning objects:', error);
+        return [];
+    }
+}
+
+const dwengoApiLearningObjectProvider: LearningObjectProvider = {
+    /**
+     * Fetches a single learning object by its HRUID
+     */
+    async getLearningObjectById(
+        id: LearningObjectIdentifier
+    ): Promise<FilteredLearningObject | null> {
+        let metadataUrl = `${DWENGO_API_BASE}/learningObject/getMetadata`;
+        const metadata = await fetchWithLogging<LearningObjectMetadata>(
+            metadataUrl,
+            `Metadata for Learning Object HRUID "${id.hruid}" (language ${id.language})`,
+            {
+                params: id
+            }
+        );
+
+        if (!metadata) {
+            console.error(`⚠️ WARNING: Learning object "${id.hruid}" not found.`);
+            return null;
+        }
+
+        return filterData(metadata);
+    },
+
+    /**
+     * Fetch full learning object data (metadata)
+     */
+    async getLearningObjectsFromPath(id: LearningPathIdentifier): Promise<FilteredLearningObject[]> {
+        return (await fetchLearningObjects(
+            id,
+            true,
+        )) as FilteredLearningObject[];
+    },
+
+    /**
+     * Fetch only learning object HRUIDs
+     */
+    async getLearningObjectIdsFromPath(id: LearningPathIdentifier): Promise<string[]> {
+        return (await fetchLearningObjects(id, false)) as string[];
+    },
+
+    /**
+     * Obtain a HTML-rendering of the learning object with the given identifier (as a string). For learning objects
+     * from the Dwengo API, this means passing through the HTML rendering from there.
+     */
+    async getLearningObjectHTML(id: LearningObjectIdentifier): Promise<string | null> {
+        const htmlUrl = `${DWENGO_API_BASE}/learningObject/getRaw`;
+        const html = await fetchWithLogging<string>(
+            htmlUrl,
+            `Metadata for Learning Object HRUID "${id.hruid}" (language ${id.language})`,
+            {
+                params: id
+            }
+        );
+
+        if (!html) {
+            console.error(`⚠️ WARNING: Learning object "${id.hruid}" not found.`);
+            return null;
+        }
+
+        return html;
+    }
+};
+
+export default dwengoApiLearningObjectProvider;