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

fix: lint + format

Browse source
This commit is contained in:
Gabriellvl 2025-02-28 17:21:03 +01:00
parent ac778981e2
commit acfffda82d
8 changed files with 162 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

5
backend/src/app.ts
View file

@ -1,9 +1,8 @@
import express, { Express, Response } from 'express';
import initORM from './orm.js';
import themeRoutes from './routes/themes.js';
import learningPathRoutes from './routes/learningPaths.js'
import learningObjectRoutes from './routes/learningObjects.js'
import learningPathRoutes from './routes/learningPaths.js';
import learningObjectRoutes from './routes/learningObjects.js';
const app: Express = express();
const port: string | number = process.env.PORT || 3000;

7
backend/src/config/config.ts
View file

@ -1,9 +1,8 @@
// Can be placed in dotenv but found it redundant
// import dotenv from "dotenv";
// Import dotenv from "dotenv";
// Load .env file
// dotenv.config();
export const DWENGO_API_BASE = "https://dwengo.org/backend/api";
// Dotenv.config();
export const DWENGO_API_BASE = 'https://dwengo.org/backend/api';

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

@ -1,20 +1,28 @@
import { Request, Response } from "express";
import { getLearningObjectsFromPath } from "../services/learningObjects.js";
import { Request, Response } from 'express';
import { getLearningObjectsFromPath } from '../services/learningObjects.js';
export async function getAllLearningObjects(req: Request, res: Response): Promise<void> {
export async function getAllLearningObjects(
req: Request,
res: Response
): Promise<void> {
try {
const { hruid } = req.params;
const language = req.query.language as string || "nl"; // Default to Dutch;
const language = (req.query.language as string) || 'nl'; // Default to Dutch;
if (!language) {
res.status(400).json({ error: "Language query parameter is required." });
res.status(400).json({
error: 'Language query parameter is required.',
});
return;
}
const learningObjects = await getLearningObjectsFromPath(hruid, language);
const learningObjects = await getLearningObjectsFromPath(
hruid,
language
);
res.json(learningObjects);
} catch (error) {
console.error("Error fetching learning objects:", error);
res.status(500).json({ error: "Internal server error" });
console.error('Error fetching learning objects:', error);
res.status(500).json({ error: 'Internal server error' });
}
}

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

@ -1,19 +1,24 @@
import { Request, Response } from "express";
import axios from "axios";
import { themes } from "../data/themes.js";
import { DWENGO_API_BASE } from "../config/config.js";
import { Request, Response } from 'express';
import axios from 'axios';
import { themes } from '../data/themes.js';
import { DWENGO_API_BASE } from '../config/config.js';
/**
* Fetch learning paths for a given list of HRUIDs.
* This function sends a request to the Dwengo API with the provided HRUIDs.
*/
export async function getLearningPathsFromIds(req: Request, res: Response): Promise<void> {
export async function getLearningPathsFromIds(
req: Request,
res: Response
): Promise<void> {
try {
const { hruids } = req.query;
const language = (req.query.language as string) || "nl"; // Default to Dutch
const language = (req.query.language as string) || 'nl'; // Default to Dutch
if (!hruids) {
res.status(400).json({ error: "Missing required parameter: hruids" });
res.status(400).json({
error: 'Missing required parameter: hruids',
});
return;
}
@ -21,17 +26,20 @@ export async function getLearningPathsFromIds(req: Request, res: Response): Prom
const hruidList = Array.isArray(hruids) ? hruids : [hruids];
// Request learning paths from Dwengo API
const response = await axios.get(`${DWENGO_API_BASE}/learningPath/getPathsFromIdList`, {
params: {
pathIdList: JSON.stringify({ hruids: hruidList }),
language
const response = await axios.get(
`${DWENGO_API_BASE}/learningPath/getPathsFromIdList`,
{
params: {
pathIdList: JSON.stringify({ hruids: hruidList }),
language,
},
}
});
);
res.json(response.data);
} catch (error) {
console.error("Error fetching learning paths:", error);
res.status(500).json({ error: "Internal server error" });
console.error('Error fetching learning paths:', error);
res.status(500).json({ error: 'Internal server error' });
}
}
@ -40,16 +48,21 @@ export async function getLearningPathsFromIds(req: Request, res: Response): Prom
* First retrieves the HRUIDs associated with the theme,
* then fetches the corresponding learning paths from the Dwengo API.
*/
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) || "nl"; // Default to Dutch
const language = (req.query.language as string) || 'nl'; // Default to Dutch
// Find the theme by its title
const theme = themes.find((t) => t.title === themeKey);
const theme = themes.find((t) => {
return t.title === themeKey;
});
if (!theme) {
res.status(404).json({ error: "Theme not found" });
res.status(404).json({ error: 'Theme not found' });
return;
}
@ -57,69 +70,85 @@ export async function getLearningPathsByTheme(req: Request, res: Response): Prom
const hruidList = theme.hruids;
// Request learning paths from Dwengo API using the extracted HRUIDs
const response = await axios.get(`${DWENGO_API_BASE}/learningPath/getPathsFromIdList`, {
params: {
pathIdList: JSON.stringify({ hruids: hruidList }),
language
const response = await axios.get(
`${DWENGO_API_BASE}/learningPath/getPathsFromIdList`,
{
params: {
pathIdList: JSON.stringify({ hruids: hruidList }),
language,
},
}
});
);
res.json({
theme: themeKey,
hruids: hruidList,
learningPaths: response.data
learningPaths: response.data,
});
} catch (error) {
console.error("Error fetching learning paths for theme:", error);
res.status(500).json({ error: "Internal server error" });
console.error('Error fetching learning paths for theme:', error);
res.status(500).json({ error: 'Internal server error' });
}
}
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) || "nl";
const language = (req.query.language as string) || 'nl';
if (!query) {
res.status(400).json({ error: "Missing search query" });
res.status(400).json({ error: 'Missing search query' });
return;
}
const response = await axios.get(`${DWENGO_API_BASE}/learningPath/search`, {
params: { all: query, language }
});
const response = await axios.get(
`${DWENGO_API_BASE}/learningPath/search`,
{
params: { all: query, language },
}
);
res.json(response.data);
} catch (error) {
console.error("Error searching learning paths:", error);
res.status(500).json({ error: "Internal server error" });
console.error('Error searching learning paths:', error);
res.status(500).json({ error: 'Internal server error' });
}
}
export async function getAllLearningPaths(req: Request, res: Response): Promise<void> {
export async function getAllLearningPaths(
req: Request,
res: Response
): Promise<void> {
try {
const language = (req.query.language as string) || "nl"; // Default to Dutch
const language = (req.query.language as string) || 'nl'; // Default to Dutch
// Collect all HRUIDs from all themes
const allHruids: string[] = themes.flatMap(theme => theme.hruids);
const allHruids: string[] = themes.flatMap((theme) => {
return theme.hruids;
});
if (allHruids.length === 0) {
res.status(404).json({ error: "No HRUIDs found in themes" });
res.status(404).json({ error: 'No HRUIDs found in themes' });
return;
}
// Call the Dwengo API with all HRUIDs combined
const response = await axios.get(`${DWENGO_API_BASE}/learningPath/getPathsFromIdList`, {
params: {
pathIdList: JSON.stringify({ hruids: allHruids }),
language
const response = await axios.get(
`${DWENGO_API_BASE}/learningPath/getPathsFromIdList`,
{
params: {
pathIdList: JSON.stringify({ hruids: allHruids }),
language,
},
}
});
);
res.json(response.data);
} catch (error) {
console.error("Error fetching all learning paths:", error);
res.status(500).json({ error: "Internal server error" });
console.error('Error fetching all learning paths:', error);
res.status(500).json({ error: 'Internal server error' });
}
}

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

@ -1,11 +1,11 @@
import express from "express";
import { getAllLearningObjects } from "../controllers/learningObjects.js";
import express from 'express';
import { getAllLearningObjects } from '../controllers/learningObjects.js';
const router = express.Router();
// arg: hruid learningPath
// query: language
// Arg: hruid learningPath
// Query: language
// Route to fetch list of learning objects based on hruid of learning path
router.get("/:hruid", getAllLearningObjects);
router.get('/:hruid', getAllLearningObjects);
export default router;

27
backend/src/routes/learningPaths.ts
View file

@ -1,23 +1,28 @@
import express from "express";
import { getLearningPathsFromIds, getLearningPathsByTheme, getAllLearningPaths, searchLearningPaths } from "../controllers/learningPaths.js";
import express from 'express';
import {
getLearningPathsFromIds,
getLearningPathsByTheme,
getAllLearningPaths,
searchLearningPaths,
} from '../controllers/learningPaths.js';
const router = express.Router();
// query: language
// Query: language
// Route to fetch learning paths based on a list of HRUIDs
router.get("/", getLearningPathsFromIds);
router.get('/', getLearningPathsFromIds);
// query: language
// Query: language
// Route to fetch all possible learning paths
router.get("/all", getAllLearningPaths);
router.get('/all', getAllLearningPaths);
// query: language
// Query: language
// Route to fetch learning paths based on a searchterm
router.get("/search", searchLearningPaths);
router.get('/search', searchLearningPaths);
// arg: theme id
// query: language
// Arg: theme id
// Query: language
// Route to fetch learning paths based on a theme
router.get("/theme/:theme", getLearningPathsByTheme);
router.get('/theme/:theme', getLearningPathsByTheme);
export default router;

4
backend/src/routes/themes.ts
View file

@ -3,11 +3,11 @@ import { getThemes, getThemeByTitle } from '../controllers/themes.js';
const router = express.Router();
// query: language
// Query: language
// Route to fetch list of {key, title, description, image} themes in their respective language
router.get('/', getThemes);
// arg: theme (key)
// Arg: theme (key)
// Route to fetch list of hruids based on theme
router.get('/:theme', getThemeByTitle);

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

@ -1,5 +1,5 @@
import axios from "axios";
import { DWENGO_API_BASE } from "../config/config.js";
import axios from 'axios';
import { DWENGO_API_BASE } from '../config/config.js';
interface LearningObjectNode {
_id: string;
@ -8,15 +8,47 @@ interface LearningObjectNode {
language: string;
}
function filterLearningObjectMetadata(data: any, htmlUrl: string) {
return {
key: data.hruid,
// Hruid learningObject (not path)
_id: data._id,
uuid: data.uuid,
version: data.version,
export async function getLearningObjectsFromPath(hruid: string, language: string) {
title: data.title,
html_url: htmlUrl,
// Html content object
language: data.language,
difficulty: data.difficulty,
estimated_time: data.estimated_time,
available: data.available,
teacher_exclusive: data.teacher_exclusive,
educational_goals: data.educational_goals,
// List with learningObjects
keywords: data.keywords,
// For search
description: data.description,
// For search (not an actual description)
target_ages: data.target_ages,
// Skos concepts needed ??
// Content type needed ??
// Content location ??
};
}
export async function getLearningObjectsFromPath(
hruid: string,
language: string
) {
try {
const learningPathUrl = `${DWENGO_API_BASE}/learningPath/${hruid}/${language}`;
const learningPathResponse = await axios.get(learningPathUrl);
const nodes = learningPathResponse.data.nodes;
if (!nodes || nodes.length === 0) {
throw new Error("No learning objects found in this learning path.");
throw new Error('No learning objects found in this learning path.');
}
return await Promise.all(
@ -24,44 +56,16 @@ export async function getLearningObjectsFromPath(hruid: string, language: string
const metadataUrl = `${DWENGO_API_BASE}/learningObject/getMetadata?hruid=${node.learningobject_hruid}&version=${node.version}&language=${language}`;
const metadataResponse = await axios.get(metadataUrl);
const html_url = `${DWENGO_API_BASE}/learningObject/getRaw?hruid=${node.learningobject_hruid}&version=${node.version}&language=${language}`;
const htmlUrl = `${DWENGO_API_BASE}/learningObject/getRaw?hruid=${node.learningobject_hruid}&version=${node.version}&language=${language}`;
return filterLearningObjectMetadata(metadataResponse.data, html_url);
return filterLearningObjectMetadata(
metadataResponse.data,
htmlUrl
);
})
);
} catch (error) {
console.error("Error fetching learning objects:", error);
throw new Error("Failed to fetch learning objects.");
console.error('Error fetching learning objects:', error);
throw new Error('Failed to fetch learning objects.');
}
}
function filterLearningObjectMetadata(data: any, html_url: String) {
return {
key: data.hruid,
// hruid learningObject (not path)
_id: data._id,
uuid: data.uuid,
version: data.version,
title: data.title,
html_url,
// html content object
language: data.language,
difficulty: data.difficulty,
estimated_time: data.estimated_time,
available: data.available,
teacher_exclusive: data.teacher_exclusive,
educational_goals: data.educational_goals,
// list with learningObjects
keywords: data.keywords,
// for search
description: data.description,
// for search (not an actual description)
target_ages: data.target_ages,
// skos concepts needed ??
// content type needed ??
// content location ??
};
}