feat(backend): DatabaseLearningObjectProvider geïmplementeerd.

backend/src/services/learning-objects/database-learning-object-provider.ts

@@ -4,6 +4,51 @@ import {
     LearningObjectIdentifier,
     LearningPathIdentifier
 } from "../../interfaces/learning-content";
+import {getLearningObjectRepository, getLearningPathRepository} from "../../data/repositories";
+import {Language} from "../../entities/content/language";
+import {LearningObject} from "../../entities/content/learning-object.entity";
+import {getUrlStringForLearningObject} from "../../util/links";
+import processingService from "./processing/processing-service";
+import {NotFoundError} from "@mikro-orm/core";
+
+const learningObjectRepo = getLearningObjectRepository();
+const learningPathRepo = getLearningPathRepository();
+
+function filter(learningObject: LearningObject | null): FilteredLearningObject | null {
+    if (!learningObject) {
+        return null;
+    }
+    return {
+        key: learningObject.hruid,
+        _id: learningObject.uuid, // For backwards compatibility with the original Dwengo API, we also populate the _id field.
+        uuid: learningObject.uuid,
+        language: learningObject.language,
+        version: learningObject.version,
+        title: learningObject.title,
+        description: learningObject.description,
+        htmlUrl: getUrlStringForLearningObject(learningObject),
+        available: learningObject.available,
+        contentType: learningObject.contentType,
+        contentLocation: learningObject.contentLocation,
+        difficulty: learningObject.difficulty || 1,
+        estimatedTime: learningObject.estimatedTime,
+        keywords: learningObject.keywords,
+        educationalGoals: learningObject.educationalGoals,
+        returnValue: {
+            callback_url: learningObject.returnValue.callbackUrl,
+            callback_schema: JSON.parse(learningObject.returnValue.callbackSchema)
+        },
+        skosConcepts: learningObject.skosConcepts,
+        targetAges: learningObject.targetAges || [],
+        teacherExclusive: learningObject.teacherExclusive
+    }
+}
+
+function findLearningObjectEntityById(id: LearningObjectIdentifier): Promise<LearningObject | null> {
+    return learningObjectRepo.findLatestByHruidAndLanguage(
+        id.hruid, id.language as Language
+    );
+}
 
 /**
  * Service providing access to data about learning objects from the database
@@ -12,31 +57,61 @@ const databaseLearningObjectProvider: LearningObjectProvider = {
     /**
      * Fetches a single learning object by its HRUID
      */
-    getLearningObjectById(id: LearningObjectIdentifier): Promise<FilteredLearningObject | null> {
-        return Promise.resolve(null); // TODO
-    },
-
-    /**
-     * Fetch full learning object data (metadata)
-     */
-    getLearningObjectHTML(id: LearningObjectIdentifier): Promise<string | null> {
-        return Promise.resolve(null); // TODO
-    },
-
-    /**
-     * Fetch only learning object HRUIDs
-     */
-    getLearningObjectIdsFromPath(id: LearningPathIdentifier): Promise<string[]> {
-        return Promise.resolve([]);// TODO
+    async getLearningObjectById(id: LearningObjectIdentifier): Promise<FilteredLearningObject | null> {
+        const learningObject = await findLearningObjectEntityById(id);
+        return filter(learningObject);
     },
 
     /**
      * Obtain a HTML-rendering of the learning object with the given identifier (as a string).
      */
-    getLearningObjectsFromPath(id: LearningPathIdentifier): Promise<FilteredLearningObject[]> {
-        return Promise.resolve([]); // TODO
-    }
+    async getLearningObjectHTML(id: LearningObjectIdentifier): Promise<string | null> {
+        const learningObject  = await learningObjectRepo.findLatestByHruidAndLanguage(
+            id.hruid, id.language as Language
+        );
+        if (!learningObject) {
+            return null;
+        }
+        return await processingService.render(
+            learningObject,
+            (id) => findLearningObjectEntityById(id)
+        );
+    },
 
+    /**
+     * Fetch the HRUIDs of all learning objects on this path.
+     */
+    async getLearningObjectIdsFromPath(id: LearningPathIdentifier): Promise<string[]> {
+        const learningPath = await learningPathRepo.findByHruidAndLanguage(id.hruid, id.language);
+        if (!learningPath) {
+            throw new NotFoundError("The learning path with the given ID could not be found.");
+        }
+        return learningPath.nodes.map(it => it.learningObjectHruid); // TODO: Determine this based on the submissions of the user.
+    },
+
+    /**
+     * Fetch the full metadata of all learning objects on this path.
+     */
+    async getLearningObjectsFromPath(id: LearningPathIdentifier): Promise<FilteredLearningObject[]> {
+        const learningPath = await learningPathRepo.findByHruidAndLanguage(id.hruid, id.language);
+        if (!learningPath) {
+            throw new NotFoundError("The learning path with the given ID could not be found.");
+        }
+        const learningObjects = await Promise.all(
+            learningPath.nodes.map(it => {
+                const learningObject = this.getLearningObjectById({
+                    hruid: it.learningObjectHruid,
+                    language: it.language,
+                    version: it.version
+                })
+                if (learningObject === null) {
+                    console.log(`WARN: Learning object corresponding with node ${it} not found!`);
+                }
+                return learningObject;
+            })
+        );
+        return learningObjects.filter(it => it !== null);
+    }
 }
 
 export default databaseLearningObjectProvider;