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

fix: format

Browse source
This commit is contained in:
Gabriellvl 2025-03-01 18:42:45 +01:00
parent 5da0720a08
commit 887787de05
8 changed files with 107 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

2
backend/src/config.ts
View file

@ -7,4 +7,4 @@
export const DWENGO_API_BASE = 'https://dwengo.org/backend/api';
export const FALLBACK_LANG = "nl";
export const FALLBACK_LANG = 'nl';

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

@ -1,6 +1,6 @@
import { Request, Response } from 'express';
import { getLearningObjectsFromPath } from '../services/learningObjects.js';
import {FALLBACK_LANG} from "../config";
import { FALLBACK_LANG } from '../config';
export async function getAllLearningObjects(
req: Request,

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

@ -1,16 +1,19 @@
import { Request, Response } from 'express';
import { themes } from '../data/themes.js';
import {DWENGO_API_BASE, FALLBACK_LANG} from '../config.js';
import { fetchWithLogging } from "../util/apiHelper.js";
import { fetchLearningPaths } from "../services/learningPaths.js";
import {LearningPath} from "../interfaces/learningPath";
import { DWENGO_API_BASE, FALLBACK_LANG } from '../config.js';
import { fetchWithLogging } from '../util/apiHelper.js';
import { fetchLearningPaths } from '../services/learningPaths.js';
import { LearningPath } from '../interfaces/learningPath';
/**
* Fetch learning paths based on HRUIDs or return all if no HRUIDs are provided.
* - If `hruids` are given -> fetch specific learning paths.
* - If `hruids` is missing -> return all available learning paths.
*/
export async function getLearningPaths(req: Request, res: Response): Promise<void> {
export async function getLearningPaths(
req: Request,
res: Response
): Promise<void> {
try {
const hruids = req.query.hruids; // Can be string or array
const language = (req.query.language as string) || FALLBACK_LANG;
@ -18,13 +21,21 @@ export async function getLearningPaths(req: Request, res: Response): Promise<voi
let hruidList: string[];
if (hruids) {
hruidList = Array.isArray(hruids) ? hruids.map(String) : [String(hruids)];
hruidList = Array.isArray(hruids)
? hruids.map(String)
: [String(hruids)];
} else {
// If no hruids are provided, fetch ALL learning paths
hruidList = themes.flatMap((theme) => {return 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);
} catch (error) {
@ -33,37 +44,51 @@ export async function getLearningPaths(req: Request, res: Response): Promise<voi
}
}
/**
* Fetch all learning paths for a specific theme.
*/
export async function getLearningPathsByTheme(req: Request, res: Response): Promise<void> {
export async function getLearningPathsByTheme(
req: Request,
res: Response
): Promise<void> {
try {
const themeKey = req.params.theme;
const language = (req.query.language as string) || FALLBACK_LANG;
const theme = themes.find((t) => {return t.title === themeKey});
const theme = themes.find((t) => {
return t.title === themeKey;
});
if (!theme) {
console.error(`⚠️ WARNING: Theme "${themeKey}" not found.`);
res.status(404).json({ error: 'Theme not found' });
return;
}
const response = await fetchLearningPaths(theme.hruids, language, `theme "${themeKey}"`);
const response = await fetchLearningPaths(
theme.hruids,
language,
`theme "${themeKey}"`
);
res.json({
theme: themeKey,
hruids: theme.hruids,
...response,
});
} catch (error) {
console.error('❌ Unexpected error fetching learning paths by theme:', error);
console.error(
'❌ Unexpected error fetching learning paths by theme:',
error
);
}
}
/**
* Search learning paths by query.
*/
export async function searchLearningPaths(req: Request, res: Response): Promise<void> {
export async function searchLearningPaths(
req: Request,
res: Response
): Promise<void> {
try {
const query = req.query.query as string;
const language = (req.query.language as string) || FALLBACK_LANG;
@ -76,7 +101,11 @@ export async function searchLearningPaths(req: Request, res: Response): Promise<
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
);
res.json(searchResults ?? []);
} catch (error) {
console.error('❌ Unexpected error searching learning paths:', error);

5
backend/src/controllers/themes.ts
View file

@ -3,7 +3,7 @@ import path from 'path';
import yaml from 'js-yaml';
import { Request, Response } from 'express';
import { themes } from '../data/themes.js';
import {FALLBACK_LANG} from "../config";
import { FALLBACK_LANG } from '../config';
interface Translations {
curricula_page: {
@ -27,7 +27,8 @@ function loadTranslations(language: string): Translations {
}
export function getThemes(req: Request, res: Response) {
const language = (req.query.language as string)?.toLowerCase() || FALLBACK_LANG;
const language =
(req.query.language as string)?.toLowerCase() || FALLBACK_LANG;
const translations = loadTranslations(language);
const themeList = themes.map((theme) => {

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

@ -8,7 +8,7 @@ const router = express.Router();
// Arg: hruid learningPath
// Query: language
// Route to fetch list of learning objects based on hruid of learning path
// example: http://localhost:3000/learningObject/un_artificiele_intelligentie
// Example: http://localhost:3000/learningObject/un_artificiele_intelligentie
router.get('/:hruid', getAllLearningObjects);
export default router;

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

@ -1,10 +1,16 @@
import { DWENGO_API_BASE } from '../config.js';
import { fetchWithLogging } from "../util/apiHelper.js";
import {FilteredLearningObject, LearningObjectMetadata, LearningObjectNode} from "../interfaces/learningPath.js";
import {fetchLearningPaths} from "./learningPaths.js";
import { fetchWithLogging } from '../util/apiHelper.js';
import {
FilteredLearningObject,
LearningObjectMetadata,
LearningObjectNode,
} from '../interfaces/learningPath.js';
import { fetchLearningPaths } from './learningPaths.js';
function filterLearningObjectMetadata(data: LearningObjectMetadata, htmlUrl: string) : FilteredLearningObject {
function filterLearningObjectMetadata(
data: LearningObjectMetadata,
htmlUrl: string
): FilteredLearningObject {
return {
key: data.hruid, // Hruid learningObject (not path)
_id: data._id,
@ -31,12 +37,22 @@ function filterLearningObjectMetadata(data: LearningObjectMetadata, htmlUrl: str
export async function getLearningObjectsFromPath(
hruid: string,
language: string
): Promise<FilteredLearningObject[]> {
): Promise<FilteredLearningObject[]> {
try {
const learningPathResponse = await fetchLearningPaths([hruid], language, `Learning path for HRUID "${hruid}"`);
const 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 ||
learningPathResponse.data.length === 0
) {
console.error(
`⚠️ WARNING: Learning path "${hruid}" exists but contains no learning objects.`
);
return [];
}
@ -50,12 +66,18 @@ export async function getLearningObjectsFromPath(
`Metadata for Learning Object HRUID "${node.learningobject_hruid}" (version ${node.version}, language ${language})`
);
if (!metadata) {return null;}
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})});
).then((objects) => {
return objects.filter((obj): obj is FilteredLearningObject => {
return obj !== null;
});
});
} catch (error) {
console.error('Error fetching learning objects:', error);
return [];

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

@ -1,6 +1,9 @@
import { fetchWithLogging } from "../util/apiHelper.js";
import { DWENGO_API_BASE } from "../config.js";
import {LearningPath, LearningPathResponse} from "../interfaces/learningPath.js";
import { fetchWithLogging } from '../util/apiHelper.js';
import { DWENGO_API_BASE } from '../config.js';
import {
LearningPath,
LearningPathResponse,
} from '../interfaces/learningPath.js';
export async function fetchLearningPaths(
hruids: string[],
@ -19,7 +22,11 @@ export async function fetchLearningPaths(
const apiUrl = `${DWENGO_API_BASE}/learningPath/getPathsFromIdList`;
const params = { pathIdList: JSON.stringify({ hruids }), language };
const learningPaths = await fetchWithLogging<LearningPath[]>(apiUrl, `Learning paths for ${source}`, params);
const learningPaths = await fetchWithLogging<LearningPath[]>(
apiUrl,
`Learning paths for ${source}`,
params
);
if (!learningPaths || learningPaths.length === 0) {
console.error(`⚠️ WARNING: No learning paths found for ${source}.`);

19
backend/src/util/apiHelper.ts
View file

@ -1,4 +1,4 @@
import axios, {AxiosRequestConfig} from 'axios';
import axios, { AxiosRequestConfig } from 'axios';
// !!!! when logger is done -> change
@ -14,8 +14,8 @@ import axios, {AxiosRequestConfig} from 'axios';
export async function fetchWithLogging<T>(
url: string,
description: string,
params?: Record<string,any>
): Promise<T | null> {
params?: Record<string, any>
): Promise<T | null> {
try {
const config: AxiosRequestConfig = params ? { params } : {};
@ -24,12 +24,19 @@ export async function fetchWithLogging<T>(
} catch (error: any) {
if (error.response) {
if (error.response.status === 404) {
console.error(`❌ ERROR: ${description} not found (404) at "${url}".`);
console.error(
`❌ ERROR: ${description} not found (404) at "${url}".`
);
} else {
console.error(`❌ ERROR: Failed to fetch ${description}. Status: ${error.response.status} - ${error.response.statusText} (URL: "${url}")`);
console.error(
`❌ ERROR: Failed to fetch ${description}. Status: ${error.response.status} - ${error.response.statusText} (URL: "${url}")`
);
}
} else {
console.error(`❌ ERROR: Network or unexpected error when fetching ${description}:`, error.message);
console.error(
`❌ ERROR: Network or unexpected error when fetching ${description}:`,
error.message
);
}
return null;
}