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

fix: format + lint

Browse source
This commit is contained in:
Gabriellvl 2025-03-02 12:18:08 +01:00
parent 308661d72b
commit e762621287
5 changed files with 87 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -2,17 +2,17 @@ import { Request, Response } from 'express';
import {
getLearningObjectById,
getLearningObjectIdsFromPath,
getLearningObjectsFromPath
getLearningObjectsFromPath,
} from '../services/learningObjects.js';
import { FALLBACK_LANG } from '../config.js';
import {FilteredLearningObject} from "../interfaces/learningPath";
import { FilteredLearningObject } from '../interfaces/learningPath';
export async function getAllLearningObjects(
req: Request,
res: Response
): Promise<void> {
try {
const hruid = (req.query.hruid as string);
const hruid = req.query.hruid as string;
const full = req.query.full === 'true';
const language = (req.query.language as string) || FALLBACK_LANG;
@ -22,10 +22,14 @@ export async function getAllLearningObjects(
}
let learningObjects: FilteredLearningObject[] | string[];
if (full)
learningObjects = await getLearningObjectsFromPath(hruid,language);
else
learningObjects = await getLearningObjectIdsFromPath(hruid, language)
if (full) {
learningObjects = await getLearningObjectsFromPath(hruid, language);
} else {
learningObjects = await getLearningObjectIdsFromPath(
hruid,
language
);
}
res.json(learningObjects);
} catch (error) {
@ -34,7 +38,6 @@ export async function getAllLearningObjects(
}
}
export async function getLearningObject(
req: Request,
res: Response
@ -50,7 +53,7 @@ export async function getLearningObject(
const learningObject = await getLearningObjectById(hruid, language);
res.json(learningObject);
} catch (error){
} catch (error) {
console.error('Error fetching learning object:', error);
res.status(500).json({ error: 'Internal server error' });
}

40
backend/src/controllers/learningPaths.ts
View file

@ -1,41 +1,59 @@
import { Request, Response } from 'express';
import { themes } from '../data/themes.js';
import { FALLBACK_LANG } from '../config.js';
import { fetchLearningPaths, searchLearningPaths } from '../services/learningPaths.js';
import {
fetchLearningPaths,
searchLearningPaths,
} from '../services/learningPaths.js';
/**
* Fetch learning paths based on query parameters.
*/
export async function getLearningPaths(
req: Request,
res: Response
): Promise<void> {
): Promise<void> {
try {
const hruids = req.query.hruid;
const themeKey = (req.query.theme as string);
const searchQuery = (req.query.search as string);
const themeKey = req.query.theme as string;
const searchQuery = req.query.search as string;
const language = (req.query.language as string) || FALLBACK_LANG;
let hruidList = [];
let hruidList;
if (hruids) {
hruidList = Array.isArray(hruids) ? hruids.map(String) : [String(hruids)];
hruidList = Array.isArray(hruids)
? hruids.map(String)
: [String(hruids)];
} else if (themeKey) {
const theme = themes.find((t) => t.title === themeKey);
const theme = themes.find((t) => {
return t.title === themeKey;
});
if (theme) {
hruidList = theme.hruids;
} else {
res.status(404).json({ error: `Theme "${themeKey}" not found.` });
res.status(404).json({
error: `Theme "${themeKey}" not found.`,
});
return;
}
} else if (searchQuery) {
const searchResults = await searchLearningPaths(searchQuery, language);
const searchResults = await searchLearningPaths(
searchQuery,
language
);
res.json(searchResults);
return;
} else {
hruidList = themes.flatMap((theme) => theme.hruids);
hruidList = themes.flatMap((theme) => {
return theme.hruids;
});
}
const learningPaths = await fetchLearningPaths(hruidList, language, `HRUIDs: ${hruidList.join(', ')}`);
const learningPaths = await fetchLearningPaths(
hruidList,
language,
`HRUIDs: ${hruidList.join(', ')}`
);
res.json(learningPaths.data);
} catch (error) {
console.error('❌ Unexpected error fetching learning paths:', error);

6
backend/src/routes/learningObjects.ts
View file

@ -1,5 +1,8 @@
import express from 'express';
import {getAllLearningObjects, getLearningObject} from '../controllers/learningObjects.js';
import {
getAllLearningObjects,
getLearningObject,
} from '../controllers/learningObjects.js';
const router = express.Router();
@ -15,7 +18,6 @@ const router = express.Router();
// Example 2: http://localhost:3000/learningObject?full=true&hruid=un_artificiele_intelligentie
router.get('/', getAllLearningObjects);
// Parameter: hruid of learning object
// Query: language
// Route to fetch data of one learning object based on its hruid

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

@ -3,7 +3,8 @@ import { fetchWithLogging } from '../util/apiHelper.js';
import {
FilteredLearningObject,
LearningObjectMetadata,
LearningObjectNode, LearningPathResponse,
LearningObjectNode,
LearningPathResponse,
} from '../interfaces/learningPath.js';
import { fetchLearningPaths } from './learningPaths.js';
@ -40,7 +41,7 @@ function filterData(
export async function getLearningObjectById(
hruid: string,
language: string
): Promise<FilteredLearningObject | null> {
): Promise<FilteredLearningObject | null> {
const metadataUrl = `${DWENGO_API_BASE}/learningObject/getMetadata?hruid=${hruid}&language=${language}`;
const metadata = await fetchWithLogging<LearningObjectMetadata>(
metadataUrl,
@ -65,26 +66,43 @@ async function fetchLearningObjects(
language: string
): Promise<FilteredLearningObject[] | string[]> {
try {
const learningPathResponse: LearningPathResponse = await fetchLearningPaths(
[hruid],
language,
`Learning path for HRUID "${hruid}"`
);
const learningPathResponse: LearningPathResponse =
await fetchLearningPaths(
[hruid],
language,
`Learning path for HRUID "${hruid}"`
);
if (!learningPathResponse.success || !learningPathResponse.data?.length) {
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 nodes.map((node) => {
return node.learningobject_hruid;
});
}
return await Promise.all(
nodes.map(async (node) => getLearningObjectById(node.learningobject_hruid, language))
).then((objects) => objects.filter((obj): obj is FilteredLearningObject => obj !== null));
nodes.map(async (node) => {
return getLearningObjectById(
node.learningobject_hruid,
language
);
})
).then((objects) => {
return objects.filter((obj): obj is FilteredLearningObject => {
return obj !== null;
});
});
} catch (error) {
console.error('❌ Error fetching learning objects:', error);
return [];
@ -98,7 +116,11 @@ export async function getLearningObjectsFromPath(
hruid: string,
language: string
): Promise<FilteredLearningObject[]> {
return await fetchLearningObjects(hruid, true, language) as FilteredLearningObject[];
return (await fetchLearningObjects(
hruid,
true,
language
)) as FilteredLearningObject[];
}
/**
@ -108,5 +130,5 @@ export async function getLearningObjectIdsFromPath(
hruid: string,
language: string
): Promise<string[]> {
return await fetchLearningObjects(hruid, false, language) as string[];
return (await fetchLearningObjects(hruid, false, language)) as string[];
}

9
backend/src/services/learningPaths.ts
View file

@ -45,14 +45,17 @@ export async function fetchLearningPaths(
};
}
export async function searchLearningPaths(
query: string,
language: string
): Promise<LearningPath[]> {
): Promise<LearningPath[]> {
const apiUrl = `${DWENGO_API_BASE}/learningPath/search`;
const params = { all: query, language };
const searchResults = await fetchWithLogging<LearningPath[]>(apiUrl, `Search learning paths with query "${query}"`, params);
const searchResults = await fetchWithLogging<LearningPath[]>(
apiUrl,
`Search learning paths with query "${query}"`,
params
);
return searchResults ?? [];
}