tdpeuter/2025SELab2-project-Dwengo
tdpeuter/2025SELab2-project-Dwengo
1
Fork 0
Code Issues Releases 4 Packages 2 Wiki Activity

fix: afsplitsing functies objects

Browse source
This commit is contained in:
Gabriellvl 2025-03-02 11:05:06 +01:00
parent 484120ab50
commit 3b689d8e09
2 changed files with 100 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

52
backend/src/controllers/learningObjects.ts
View file

@ -1,29 +1,57 @@
import { Request, Response } from 'express';
import { getLearningObjectsFromPath } from '../services/learningObjects.js';
import {
getLearningObjectById,
getLearningObjectIdsFromPath,
getLearningObjectsFromPath
} from '../services/learningObjects.js';
import { FALLBACK_LANG } from '../config.js';
import {FilteredLearningObject} from "../interfaces/learningPath";
export async function getAllLearningObjects(
req: Request,
res: Response
): Promise<void> {
try {
const hruid = (req.query.hruid as string);
const full = req.query.full === 'true';
const language = (req.query.language as string) || FALLBACK_LANG;
if (!hruid) {
res.status(400).json({ error: 'HRUID query is required.' });
return;
}
let learningObjects: FilteredLearningObject[] | string[];
if (full)
learningObjects = await getLearningObjectsFromPath(hruid,language);
else
learningObjects = await getLearningObjectIdsFromPath(hruid, language)
res.json(learningObjects);
} catch (error) {
console.error('Error fetching learning objects:', error);
res.status(500).json({ error: 'Internal server error' });
}
}
export async function getLearningObject(
req: Request,
res: Response
): Promise<void> {
try {
const { hruid } = req.params;
const language = (req.query.language as string) || FALLBACK_LANG;
if (!language) {
res.status(400).json({
error: 'Language query parameter is required.',
});
if (!hruid) {
res.status(400).json({ error: 'HRUID parameter is required.' });
return;
}
const learningObjects = await getLearningObjectsFromPath(
hruid,
language
);
res.json(learningObjects);
} catch (error) {
console.error('Error fetching learning objects:', error);
const learningObject = await getLearningObjectById(hruid, language);
res.json(learningObject);
} catch (error){
console.error('Error fetching learning object:', error);
res.status(500).json({ error: 'Internal server error' });
}
}

93
backend/src/services/learningObjects.ts
View file

@ -3,11 +3,11 @@ import { fetchWithLogging } from '../util/apiHelper.js';
import {
FilteredLearningObject,
LearningObjectMetadata,
LearningObjectNode,
LearningObjectNode, LearningPathResponse,
} from '../interfaces/learningPath.js';
import { fetchLearningPaths } from './learningPaths.js';
function filterLearningObjectMetadata(
function filterData(
data: LearningObjectMetadata,
htmlUrl: string
): FilteredLearningObject {
@ -34,52 +34,79 @@ function filterLearningObjectMetadata(
};
}
export async function getLearningObjectsFromPath(
/**
* Fetches a single learning object by its HRUID
*/
export async function getLearningObjectById(
hruid: string,
language: string
): Promise<FilteredLearningObject[]> {
): Promise<FilteredLearningObject | null> {
const metadataUrl = `${DWENGO_API_BASE}/learningObject/getMetadata?hruid=${hruid}&language=${language}`;
const metadata = await fetchWithLogging<LearningObjectMetadata>(
metadataUrl,
`Metadata for Learning Object HRUID "${hruid}" (language ${language})`
);
if (!metadata) {
console.error(`⚠️ WARNING: Learning object "${hruid}" not found.`);
return null;
}
const htmlUrl = `${DWENGO_API_BASE}/learningObject/getRaw?hruid=${hruid}&language=${language}`;
return filterData(metadata, htmlUrl);
}
/**
* Generic function to fetch learning objects (full data or just HRUIDs)
*/
async function fetchLearningObjects(
hruid: string,
full: boolean,
language: string
): Promise<FilteredLearningObject[] | string[]> {
try {
const learningPathResponse = await fetchLearningPaths(
const learningPathResponse: LearningPathResponse = await fetchLearningPaths(
[hruid],
language,
`Learning path for HRUID "${hruid}"`
);
if (
!learningPathResponse.success ||
!learningPathResponse.data ||
learningPathResponse.data.length === 0
) {
console.error(
`⚠️ WARNING: Learning path "${hruid}" exists but contains no learning objects.`
);
if (!learningPathResponse.success || !learningPathResponse.data?.length) {
console.error(`⚠️ WARNING: Learning path "${hruid}" exists but contains no learning objects.`);
return [];
}
const nodes: LearningObjectNode[] = learningPathResponse.data[0].nodes;
if (!full) {
return nodes.map(node => node.learningobject_hruid);
}
return await Promise.all(
nodes.map(async (node) => {
const metadataUrl = `${DWENGO_API_BASE}/learningObject/getMetadata?hruid=${node.learningobject_hruid}&version=${node.version}&language=${language}`;
const metadata = await fetchWithLogging<LearningObjectMetadata>(
metadataUrl,
`Metadata for Learning Object HRUID "${node.learningobject_hruid}" (version ${node.version}, language ${language})`
);
if (!metadata) {
return null;
}
const htmlUrl = `${DWENGO_API_BASE}/learningObject/getRaw?hruid=${node.learningobject_hruid}&version=${node.version}&language=${language}`;
return filterLearningObjectMetadata(metadata, htmlUrl);
})
).then((objects) => {
return objects.filter((obj): obj is FilteredLearningObject => {
return obj !== null;
});
});
nodes.map(async (node) => getLearningObjectById(node.learningobject_hruid, language))
).then((objects) => objects.filter((obj): obj is FilteredLearningObject => obj !== null));
} catch (error) {
console.error('Error fetching learning objects:', error);
console.error('❌ Error fetching learning objects:', error);
return [];
}
}
/**
* Fetch full learning object data (metadata)
*/
export async function getLearningObjectsFromPath(
hruid: string,
language: string
): Promise<FilteredLearningObject[]> {
return await fetchLearningObjects(hruid, true, language) as FilteredLearningObject[];
}
/**
* Fetch only learning object HRUIDs
*/
export async function getLearningObjectIdsFromPath(
hruid: string,
language: string
): Promise<string[]> {
return await fetchLearningObjects(hruid, false, language) as string[];
}