feat: submission full backend stack opgekuist

backend/src/controllers/groups.ts

@@ -8,7 +8,6 @@ export async function getGroupHandler(req: Request, res: Response): Promise<void
     const classId = req.params.classid;
     const assignmentId = parseInt(req.params.assignmentid);
     const groupId = parseInt(req.params.groupid);
-    const full = req.query.full === 'true';
     requireFields({ classId, assignmentId, groupId });
 
     if (isNaN(assignmentId)) {
@@ -19,7 +18,7 @@ export async function getGroupHandler(req: Request, res: Response): Promise<void
         throw new BadRequestException('Group id must be a number');
     }
 
-    const group = await getGroup(classId, assignmentId, groupId, full);
+    const group = await getGroup(classId, assignmentId, groupId);
 
     if (!group) {
         res.status(404).json({ error: 'Group not found' });

backend/src/interfaces/group.ts

@@ -1,11 +1,13 @@
 import { Group } from '../entities/assignments/group.entity.js';
 import { mapToAssignmentDTO } from './assignment.js';
+import { mapToClassDTO } from './class.js';
 import { mapToStudentDTO } from './student.js';
 import { GroupDTO } from '@dwengo-1/common/interfaces/group';
 
 export function mapToGroupDTO(group: Group): GroupDTO {
     return {
-        assignment: mapToAssignmentDTO(group.assignment), // ERROR: , group.assignment.within),
+        class: mapToClassDTO(group.assignment.within),
+        assignment: mapToAssignmentDTO(group.assignment),
         groupNumber: group.groupNumber!,
         members: group.members.map(mapToStudentDTO),
     };
@@ -13,6 +15,7 @@ export function mapToGroupDTO(group: Group): GroupDTO {
 
 export function mapToGroupDTOId(group: Group): GroupDTO {
     return {
+        class: group.assignment.within.classId!,
         assignment: group.assignment.id!,
         groupNumber: group.groupNumber!,
         members: group.members.map((member) => member.username),

backend/src/interfaces/submission.ts

@@ -1,6 +1,9 @@
+import { getSubmissionRepository } from '../data/repositories.js';
+import { Group } from '../entities/assignments/group.entity.js';
 import { Submission } from '../entities/assignments/submission.entity.js';
+import { Student } from '../entities/users/student.entity.js';
 import { mapToGroupDTO } from './group.js';
-import { mapToStudent, mapToStudentDTO } from './student.js';
+import { mapToStudentDTO } from './student.js';
 import { SubmissionDTO, SubmissionDTOId } from '@dwengo-1/common/interfaces/submission';
 
 export function mapToSubmissionDTO(submission: Submission): SubmissionDTO {
@@ -29,17 +32,14 @@ export function mapToSubmissionDTOId(submission: Submission): SubmissionDTOId {
     };
 }
 
-export function mapToSubmission(submissionDTO: SubmissionDTO): Submission {
+export function mapToSubmission(submissionDTO: SubmissionDTO, submitter: Student, onBehalfOf: Group | undefined): Submission {
-    const submission = new Submission();
+    return getSubmissionRepository().create({
-    submission.learningObjectHruid = submissionDTO.learningObjectIdentifier.hruid;
+        learningObjectHruid: submissionDTO.learningObjectIdentifier.hruid,
-    submission.learningObjectLanguage = submissionDTO.learningObjectIdentifier.language;
+        learningObjectLanguage: submissionDTO.learningObjectIdentifier.language,
-    submission.learningObjectVersion = submissionDTO.learningObjectIdentifier.version!;
+        learningObjectVersion: submissionDTO.learningObjectIdentifier.version || 1,
-    // Submission.submissionNumber = submissionDTO.submissionNumber;
+        submitter: submitter,
-    submission.submitter = mapToStudent(submissionDTO.submitter);
+        submissionTime: new Date(),
-    // Submission.submissionTime = submissionDTO.time;
+        content: submissionDTO.content,
-    // Submission.onBehalfOf =  submissionDTO.group!;
+        onBehalfOf: onBehalfOf,
-    // TODO fix group
+    });
-    submission.content = submissionDTO.content;
-
-    return submission;
 }

backend/src/services/classes.ts

@@ -26,7 +26,7 @@ export async function fetchClass(classid: string): Promise<Class> {
 
 export async function getAllClasses(full: boolean): Promise<ClassDTO[] | string[]> {
     const classRepository = getClassRepository();
-    const classes = await classRepository.find({}, { populate: ['students', 'teachers'] });
+    const classes = await classRepository.findAll({ populate: ['students', 'teachers'] });
 
     if (full) {
         return classes.map(mapToClassDTO);
@@ -34,13 +34,12 @@ export async function getAllClasses(full: boolean): Promise<ClassDTO[] | string[
     return classes.map((cls) => cls.classId!);
 }
 
-export async function getClass(classId: string): Promise<ClassDTO | null> {
+export async function getClass(classId: string): Promise<ClassDTO> {
     const cls = await fetchClass(classId);
-
     return mapToClassDTO(cls);
 }
 
-export async function createClass(classData: ClassDTO): Promise<ClassDTO | null> {
+export async function createClass(classData: ClassDTO): Promise<ClassDTO> {
     const teacherUsernames = classData.teachers || [];
     const teachers = (await Promise.all(teacherUsernames.map(async (id) => fetchTeacher(id) )));
 
@@ -48,7 +47,6 @@ export async function createClass(classData: ClassDTO): Promise<ClassDTO | null>
     const students = (await Promise.all(studentUsernames.map(async (id) => fetchStudent(id) )));
 
     const classRepository = getClassRepository();
-
     const newClass = classRepository.create({
         displayName: classData.displayName,
         teachers: teachers,

backend/src/services/groups.ts

@@ -14,80 +14,58 @@ import { GroupDTO } from '@dwengo-1/common/interfaces/group';
 import { SubmissionDTO, SubmissionDTOId } from '@dwengo-1/common/interfaces/submission';
 import { getLogger } from '../logging/initalize.js';
 import { fetchAssignment } from './assignments.js';
+import { NotFoundException } from '../exceptions/not-found-exception.js';
+import { fetchClass } from './classes.js';
 
-async function fetchGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<Group | null> {
+export async function fetchGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<Group> {
     const assignment = await fetchAssignment(classId, assignmentNumber);
 
-    if (!assignment) {
-        return null;
-    }
-
     const groupRepository = getGroupRepository();
     const group = await groupRepository.findByAssignmentAndGroupNumber(assignment, groupNumber);
 
+    if (!group) {
+        throw new NotFoundException('Could not find group');
+    }
+
     return group; 
 }
 
-export async function getGroup(classId: string, assignmentNumber: number, groupNumber: number, full: boolean): Promise<GroupDTO | null> {
+export async function getGroup(classId: string, assignmentNumber: number, groupNumber: number): Promise<GroupDTO> {
     const group = await fetchGroup(classId, assignmentNumber, groupNumber);
-
+    return mapToGroupDTO(group);
-    if (!group) {
-        return null;
-    }
-
-    if (full) {
-        return mapToGroupDTO(group);
-    }
-
-    return mapToGroupDTOId(group);
 }
 
-export async function createGroup(groupData: GroupDTO, classid: string, assignmentNumber: number): Promise<Group | null> {
+export async function getExistingGroupFromGroupDTO(groupData: GroupDTO) {
+    const classId = typeof(groupData.class) === 'string' ? groupData.class : groupData.class.id;
+    const assignmentNumber = typeof(groupData.assignment) === 'number' ? groupData.assignment : groupData.assignment.id;
+    const groupNumber = groupData.groupNumber;
+
+    return await fetchGroup(classId, assignmentNumber, groupNumber);
+}
+
+export async function createGroup(groupData: GroupDTO, classid: string, assignmentNumber: number): Promise<GroupDTO> {
     const studentRepository = getStudentRepository();
 
-    const memberUsernames = (groupData.members as string[]) || []; // TODO check if groupdata.members is a list
+    const memberUsernames = (groupData.members as string[]) || [];
     const members = (await Promise.all([...memberUsernames].map(async (id) => studentRepository.findByUsername(id)))).filter(
         (student) => student !== null
     );
 
-    getLogger().debug(members);
+    const assignment = await fetchAssignment(classid, assignmentNumber);
-
-    const classRepository = getClassRepository();
-    const cls = await classRepository.findById(classid);
-
-    if (!cls) {
-        return null;
-    }
-
-    const assignmentRepository = getAssignmentRepository();
-    const assignment = await assignmentRepository.findByClassAndId(cls, assignmentNumber);
-
-    if (!assignment) {
-        return null;
-    }
 
     const groupRepository = getGroupRepository();
-    try {
+    const newGroup = groupRepository.create({
-        const newGroup = groupRepository.create({
+        assignment: assignment,
-            assignment: assignment,
+        members: members,
-            members: members,
+    });
-        });
+    await groupRepository.save(newGroup);
-        await groupRepository.save(newGroup);
 
-        return newGroup;
+    return mapToGroupDTO(newGroup);
-    } catch (e) {
-        getLogger().error(e);
-        return null;
-    }
 }
 
 export async function getAllGroups(classId: string, assignmentNumber: number, full: boolean): Promise<GroupDTO[]> {
     const assignment = await fetchAssignment(classId, assignmentNumber);
 
-    if (!assignment) {
-        return [];
-    }
-
     const groupRepository = getGroupRepository();
     const groups = await groupRepository.findAllGroupsForAssignment(assignment);
 
@@ -106,10 +84,6 @@ export async function getGroupSubmissions(
 ): Promise<SubmissionDTO[] | SubmissionDTOId[]> {
     const group = await fetchGroup(classId, assignmentNumber, groupNumber);
 
-    if (!group) {
-        return [];
-    }
-
     const submissionRepository = getSubmissionRepository();
     const submissions = await submissionRepository.findAllSubmissionsForGroup(group);
 

backend/src/services/submissions.ts

@@ -4,11 +4,14 @@ import { NotFoundException } from '../exceptions/not-found-exception.js';
 import { mapToSubmission, mapToSubmissionDTO } from '../interfaces/submission.js';
 import { SubmissionDTO } from '@dwengo-1/common/interfaces/submission';
 import { Language } from '@dwengo-1/common/util/language';
+import { fetchStudent } from './students.js';
+import { fetchGroup, getExistingGroupFromGroupDTO } from './groups.js';
+import { Submission } from '../entities/assignments/submission.entity.js';
 
-export async function getSubmission(
+export async function fetchSubmission(
     loId: LearningObjectIdentifier,
-    submissionNumber: number
+    submissionNumber: number,
-): Promise<SubmissionDTO> {
+): Promise<Submission> {
     const submissionRepository = getSubmissionRepository();
     const submission = await submissionRepository.findSubmissionByLearningObjectAndSubmissionNumber(loId, submissionNumber);
 
@@ -16,6 +19,14 @@ export async function getSubmission(
         throw new NotFoundException('Could not find submission');
     }
 
+    return submission;
+}
+
+export async function getSubmission(
+    loId: LearningObjectIdentifier,
+    submissionNumber: number
+): Promise<SubmissionDTO> {
+    const submission = await fetchSubmission(loId, submissionNumber);
     return mapToSubmissionDTO(submission);
 }
 
@@ -28,30 +39,22 @@ export async function getAllSubmissions(
     return submissions.map(mapToSubmissionDTO);
 }
 
-export async function createSubmission(submissionDTO: SubmissionDTO): Promise<SubmissionDTO | null> {
+export async function createSubmission(submissionDTO: SubmissionDTO): Promise<SubmissionDTO> {
-    const submissionRepository = getSubmissionRepository();
+    const submitter = await fetchStudent(submissionDTO.submitter.username);
-    const submission = mapToSubmission(submissionDTO);
+    const group = submissionDTO.group ? await getExistingGroupFromGroupDTO(submissionDTO.group) : undefined;
 
-    try {
+    const submissionRepository = getSubmissionRepository();
-        const newSubmission = submissionRepository.create(submission);
+    const submission = mapToSubmission(submissionDTO, submitter, group);
-        await submissionRepository.save(newSubmission);
+    await submissionRepository.save(submission);
-    } catch (_) {
-        return null;
-    }
 
     return mapToSubmissionDTO(submission);
 }
 
 export async function deleteSubmission(loId: LearningObjectIdentifier, submissionNumber: number): Promise<SubmissionDTO> {
+    const submission = await fetchSubmission(loId, submissionNumber);
+    
     const submissionRepository = getSubmissionRepository();
-
-    const submission = await getSubmission(loId, submissionNumber);
-
-    if (!submission) {
-        throw new NotFoundException('Could not delete submission because it does not exist');
-    }
-
     await submissionRepository.deleteSubmissionByLearningObjectAndSubmissionNumber(loId, submissionNumber);
 
-    return submission;
+    return mapToSubmissionDTO(submission);
 }

common/src/interfaces/group.ts

@@ -1,7 +1,9 @@
 import { AssignmentDTO } from './assignment';
+import { ClassDTO } from './class';
 import { StudentDTO } from './student';
 
 export interface GroupDTO {
+    class: string | ClassDTO;
     assignment: number | AssignmentDTO;
     groupNumber: number;
     members: string[] | StudentDTO[];