create course without request

src/Router.ts

@@ -84,6 +84,7 @@ router.use(
             routerGroup((r: Router) => {
                 r.get("/training-request", UserTrainingController.getRequests);
                 r.get("/training-request/:course_uuid", UserTrainingController.getRequestsByUUID);
+                r.get("/training-request/:course_uuid/active", UserTrainingController.getActiveRequestsByUUID);
 
                 r.get("/mentor-group", UserMentorGroupController.getMentorGroups);
                 r.get("/mentor-group/cm", UserMentorGroupController.getCourseManagerMentorGroups);
@@ -164,7 +165,7 @@ router.use(
                 r.get("/log-template/:uuid", TrainingSessionAdminController.getLogTemplate);
                 r.get("/participants/:uuid", TrainingSessionAdminController.getParticipants);
 
-                r.post("/log/:uuid", TrainingSessionAdminController.createTrainingLogs);
+                r.put("/log/:uuid", TrainingSessionAdminController.createTrainingLogs);
             })
         );
 
@@ -174,6 +175,7 @@ router.use(
                 r.get("/", CourseAdministrationController.getAll);
                 r.put("/", CourseAdministrationController.create);
 
+                r.get("/mentorable", CourseAdministrationController.getMentorable);
                 r.get("/editable", CourseAdministrationController.getEditable);
 
                 r.get("/info/", CourseInformationAdministrationController.getByUUID);

src/controllers/course/CourseAdminController.ts

@@ -6,6 +6,7 @@ import { MentorGroupsBelongsToCourses } from "../../models/through/MentorGroupsB
 import CourseAdminValidator from "../_validators/CourseAdminValidator";
 import { ValidatorType } from "../_validators/ValidatorType";
 import { HttpStatusCode } from "axios";
+import { TrainingType } from "../../models/TrainingType";
 
 /**
  * Gets all courses
@@ -116,8 +117,49 @@ async function create(request: Request, response: Response) {
     response.send(course);
 }
 
+async function getMentorable(request: Request, response: Response) {
+    const user: User = request.body.user;
+
+    const userWithCourses = await User.findOne({
+        where: {
+            id: user.id
+        },
+        include: [{
+            association: User.associations.mentor_groups,
+            through: {attributes: []},
+            include: [{
+                association: MentorGroup.associations.courses,
+                through: {attributes: []},
+                include: [{
+                    association: Course.associations.training_types,
+                    through: {attributes: []},
+                    include: [{
+                        association: TrainingType.associations.training_stations,
+                        through: {attributes: []}
+                    }]
+                }]
+            }]
+        }]
+    });
+
+    if (userWithCourses == null || userWithCourses.mentor_groups == null) {
+        response.sendStatus(HttpStatusCode.InternalServerError);
+        return;
+    }
+
+    let courses: Course[] = [];
+    for (const mentorGroup of userWithCourses.mentor_groups) {
+        for (const course of mentorGroup.courses ?? []) {
+            courses.push(course);
+        }
+    }
+
+    response.send(courses);
+}
+
 export default {
     create,
     getAll,
     getEditable,
+    getMentorable
 };

src/controllers/training-session/TrainingSessionAdminController.ts

@@ -82,6 +82,7 @@ async function createTrainingSession(request: Request, response: Response) {
                 user_id: userID,
                 course_id: course.id,
                 training_type_id: data.training_type_id,
+                status: "requested"
             },
         });
 
@@ -365,6 +366,15 @@ async function createTrainingLogs(request: Request, response: Response) {
                 },
             }
         );
+
+        await TrainingRequest.update({
+            status: "completed"
+        }, {
+            where: {
+                user_id: user_id,
+                training_session_id: session.id
+            }
+        });
     }
 
     await session.update({

src/controllers/user/UserTrainingController.ts

@@ -2,6 +2,8 @@ import { Request, Response } from "express";
 import { User } from "../../models/User";
 import { TrainingRequest } from "../../models/TrainingRequest";
 import { Course } from "../../models/Course";
+import { HttpStatusCode } from "axios";
+import { Op } from "sequelize";
 
 /**
  * Get a list of all training-requests made by this user
@@ -46,7 +48,36 @@ async function getRequestsByUUID(request: Request, response: Response) {
     response.send(trainingRequests);
 }
 
+async function getActiveRequestsByUUID(request: Request, response: Response) {
+    const user: User = request.body.user;
+    const params = request.params as {course_uuid: string};
+
+    const course = await Course.findOne({
+        where: {
+            uuid: params.course_uuid
+        }
+    });
+
+    if (course == null) {
+        response.sendStatus(HttpStatusCode.BadRequest);
+        return;
+    }
+
+    const trainingRequests = await TrainingRequest.findAll({
+        where: {
+            user_id: user.id,
+            course_id: course.id,
+        },
+        include: [TrainingRequest.associations.training_type, TrainingRequest.associations.training_station],
+    });
+
+    response.send(trainingRequests.filter((t) => {
+        return t.status == "requested" || t.status == "planned"
+    }));
+}
+
 export default {
     getRequests,
     getRequestsByUUID,
+    getActiveRequestsByUUID
 };

src/models/Course.ts

@@ -43,6 +43,7 @@ export class Course extends Model<InferAttributes<Course>, InferCreationAttribut
 
     declare static associations: {
         training_type: Association<Course, TrainingType>;
+        training_types: Association<Course, TrainingType>;
         action_requirements: Association<Course, ActionRequirement>;
         mentor_groups: Association<Course, MentorGroup>;
         skill_template: Association<Course, CourseSkillTemplate>;