Merge branch 'main' of github.com:Citizen-Knowledge-Graph/foerderfunke-react-app

Author: wbglaeser

package.json

@@ -8,7 +8,7 @@
     "@babel/plugin-transform-private-property-in-object": "^7.24.7",
     "@emotion/react": "^11.11.4",
     "@emotion/styled": "^11.11.5",
-    "@foerderfunke/matching-engine": "^1.3.0",
+    "@foerderfunke/matching-engine": "^1.3.3",
     "@mui/icons-material": "^5.15.19",
     "@mui/material": "^5.15.19",
     "@mui/x-charts": "^7.6.2",

src/core/managers/matchingEngineManager.js

@@ -57,43 +57,28 @@ const matchingEngineManager = {
         return engine.metadata || {};
     },
 
-    async fetchValidationReport(userId, language = "en") {
+    // fetchValidationReport and fetchQuizReport could probably be unified further to only expose fetchMatchingReport() TODO
+    async fetchMatchingReport(userId, rps, lang = "en") {
         if (!this.matchingEngineInstance) {
-            await this.initMatchingEngine(language);
+            await this.initMatchingEngine(lang);
         }
-
-        const validationConfig = await resourceService.fetchResourceWithCache(
-            "assets/data/requirement-profiles/requirement-profiles.json"
-        );
-
         const userProfile = userManager.retrieveUserData(userId);
         const userProfileTurtle = await convertUserProfileToTurtle(userProfile);
+        return this.matchingEngineInstance.matching(userProfileTurtle, rps, FORMAT.JSON_LD);
+    },
+
+    async fetchValidationReport(userId, language = "en") {
+        const validationConfig = await resourceService.fetchResourceWithCache("assets/data/requirement-profiles/requirement-profiles.json");
         const requirementProfiles = [];
         for (const { rpUri, behindFeatureFlag } of validationConfig["queries"]) {
             if (behindFeatureFlag && !featureFlags[behindFeatureFlag]) continue;
             requirementProfiles.push(rpUri);
         }
-
-        const report = await this.matchingEngineInstance.matching(
-            userProfileTurtle,
-            requirementProfiles,
-            FORMAT.JSON_LD
-        );
-
-        return report;
+        return await this.fetchMatchingReport(userId, requirementProfiles, language);
     },
 
     async fetchQuizReport(userId, requirementProfiles, language = "en") {
-        if (!this.matchingEngineInstance) {
-            await this.initMatchingEngine(language);
-        }
-        const userProfile = userManager.retrieveUserData(userId);
-        const userProfileTurtle = await convertUserProfileToTurtle(userProfile);
-        return this.matchingEngineInstance.matching(
-            userProfileTurtle,
-            requirementProfiles.map(rp => expand(rp)),
-            FORMAT.JSON_LD
-        );
+        return await this.fetchMatchingReport(userId, requirementProfiles.map(rp => expand(rp)), language);
     },
 
     async fetchEvaluationGraph(userId, requirementProfile, language = "en") {

src/core/managers/profileManager.js

@@ -0,0 +1,54 @@
+import { ProfileManager } from "@foerderfunke/matching-engine/src/ProfileManager";
+import resourceService from "@/core/services/resourceService";
+
+const profileManager = {
+    profileManagerInstance: null,
+    constructionPromise: null,
+
+    async constructProfileManagerOnce() {
+        if (this.profileManagerInstance) return this.profileManagerInstance;
+        if (this.constructionPromise) return this.constructionPromise;
+
+        console.log("Constructing Profile Manager...");
+        this.constructionPromise = (async () => {
+            const validationConfig = await resourceService.fetchResourceWithCache(
+                "assets/data/requirement-profiles/requirement-profiles.json"
+            );
+
+            const datafieldsString = await resourceService.fetchResourceWithCache(validationConfig["datafields"]);
+            const datafieldsBielefeldString = await resourceService.fetchResourceWithCache(validationConfig["datafields-bielefeld"]);
+            const definitionsString = await resourceService.fetchResourceWithCache(validationConfig["definitions"]);
+            const materializationString = await resourceService.fetchResourceWithCache(validationConfig["materialization"]);
+            const consistencyString = await resourceService.fetchResourceWithCache(validationConfig["consistency"]);
+
+            const profileManager = new ProfileManager();
+            profileManager.addDatafieldsTurtle(datafieldsString)
+            profileManager.addDatafieldsTurtle(datafieldsBielefeldString)
+            profileManager.addDefinitionsTurtle(definitionsString);
+            profileManager.addMaterializationTurtle(materializationString);
+            profileManager.addConsistencyTurtle(consistencyString);
+
+            this.profileManagerInstance = profileManager;
+            console.log("Profile Manager constructed.");
+            return profileManager;
+        })();
+
+        return this.constructionPromise;
+    },
+
+    async initProfileManager(defaultProfileId) {
+        const profileManager = await this.constructProfileManagerOnce();
+        await profileManager.init();
+        // let profileIds = JSON.parse(localStorage.getItem('userIds')) || []
+        let existingProfileTurtle = localStorage.getItem(defaultProfileId);
+        if (existingProfileTurtle) {
+            profileManager.importProfileTurtle(defaultProfileId, existingProfileTurtle);
+        } else {
+            let profile = profileManager.getProfile(profileManager.newProfile(defaultProfileId));
+            localStorage.setItem(defaultProfileId, await profile.toTurtle());
+        }
+        return profileManager;
+    },
+};
+
+export default profileManager;

src/ui/shared-hooks/useInitialiseApplication.js

@@ -4,6 +4,7 @@ import { useLanguageStore } from "@/ui/storage/useLanguageStore";
 import { useApplicationLoadingState, useInitialisationState } from '@/ui/storage/updates';
 import matchingEngineManager from "@/core/managers/matchingEngineManager";
 import userManager from "@/core/managers/userManager";
+import profileManager from "@/core/managers/profileManager";
 
 export const useInitialiseApplication = () => {
     const setInitialisationState = useInitialisationState((state) => state.setInitialisationState);
@@ -20,7 +21,7 @@ export const useInitialiseApplication = () => {
     const validationReportStore = useValidationReportStore();
     const language = useLanguageStore((state) => state.language);
 
-    const fixedUserId = "ff:quick-check-user";
+    const fixedUserId = "ff:quick-check-user"; // change to ff:citizen1 when switching to ProfileManager TODO
 
     useEffect(() => {
         const initializeAppState = async () => {
@@ -39,17 +40,23 @@ export const useInitialiseApplication = () => {
                 if (!userProfile) userManager.initialiseNewUser(fixedUserId);
                 updateUserId(fixedUserId);
 
+                // Construct and init profile manager
+                await profileManager.constructProfileManagerOnce()
+                // await profileManager.initProfileManager(fixedUserId)
+                // updateUserId(fixedUserId);
+
                 // Construct engine once (does not call .init)
                 await matchingEngineManager.constructMatchingEngineOnce();
 
                 // Call init(language) once after construction
-                lastInitializedLang.current = language; // ✅ prevent duplicate init
+                lastInitializedLang.current = language; // prevent duplicate init
                 await matchingEngineManager.initMatchingEngine(language);
 
                 // Fetch metadata and report
                 const metadata = await matchingEngineManager.fetchMetadata(language);
                 metadataStore.updateMetadata(metadata || "empty");
 
+                // It this necessary initially or only later? TODO
                 const report = await matchingEngineManager.fetchValidationReport(fixedUserId, language);
                 validationReportStore.updateValidationReport(report || "empty");