feat: add shared attribute, add markshared mutation, add templateCour…

graphql/authorizations.ts

@@ -576,6 +576,7 @@ export const authorizationModelEnhanceMap: ModelsEnhanceMap = {
             | 'description'
             | 'createdAt'
             | 'updatedAt'
+            | 'shared'
         >({
             screeningComment: adminOrOwner,
             correspondentId: adminOrOwner,

graphql/course/fields.ts

@@ -71,4 +71,40 @@ export class ExtendedFieldsCourseResolver {
         const student = await getSessionStudent(context, studentId);
         return (await prisma.course_instructors_student.count({ where: { courseId: course.id, studentId: student.id } })) > 0;
     }
+
+    @FieldResolver((returns) => [Course])
+    @Authorized(Role.ADMIN, Role.OWNER, Role.INSTRUCTOR)
+    async templateCourses(
+        @Arg('studentId', { nullable: true }) studentId: number,
+        @Arg('search') search: string,
+        @Arg('take', () => GraphQLInt) take,
+        @Arg('skip', () => GraphQLInt, { nullable: true }) skip: number = 0
+    ) {
+        const courseSearchFilters = await courseSearch(search);
+        const courses = await prisma.course.findMany({
+            where: {
+                OR: [
+                    {
+                        AND: [
+                            {
+                                course_instructors_student: {
+                                    some: {
+                                        studentId: studentId,
+                                    },
+                                },
+                            },
+                            courseSearchFilters,
+                        ],
+                    },
+                    {
+                        shared: true,
+                    },
+                ],
+            },
+            take,
+            skip,
+        });
+
+        return courses;
+    }
 }

graphql/course/mutations.ts

@@ -12,7 +12,7 @@ import * as GraphQLModel from '../generated/models';
 import { getCourse, getStudent, getSubcoursesForCourse } from '../util';
 import { putFile, DEFAULT_BUCKET } from '../../common/file-bucket';
 
-import { course_schooltype_enum as CourseSchooltype, course_subject_enum as CourseSubject, course_coursestate_enum as CourseState } from '../generated';
+import { course_schooltype_enum as CourseSchooltype, course_subject_enum as CourseSubject, course_coursestate_enum as CourseState, Course } from '../generated';
 import { ForbiddenError } from '../error';
 import { addCourseInstructor, allowCourse, denyCourse, subcourseOver } from '../../common/courses/states';
 import { getCourseImageKey } from '../../common/courses/util';
@@ -82,6 +82,20 @@ export class MutateCourseResolver {
         return result;
     }
 
+    @Mutation((returns) => GraphQLModel.Course)
+    @AuthorizedDeferred(Role.ADMIN, Role.OWNER)
+    async courseMarkShared(@Ctx() context: GraphQLContext, @Arg('courseId') courseId: number, @Arg('shared') shared: boolean): Promise<GraphQLModel.Course> {
+        const course = await getCourse(courseId);
+        await hasAccess(context, 'Course', course);
+
+        const updatedCourse = await prisma.course.update({
+            where: { id: course.id },
+            data: { shared: shared },
+        });
+        logger.info(`Course(${course.id} was ${shared ? 'shared' : 'unshared'} by User(${context.user.userID})`);
+        return updatedCourse;
+    }
+
     @Mutation((returns) => GraphQLModel.Course)
     @AuthorizedDeferred(Role.ADMIN, Role.OWNER)
     async courseEdit(

graphql/subcourse/mutations.ts

@@ -71,7 +71,7 @@ class PublicLectureInput {
 @Resolver((of) => GraphQLModel.Subcourse)
 export class MutateSubcourseResolver {
     @Mutation((returns) => GraphQLModel.Subcourse)
-    @AuthorizedDeferred(Role.ADMIN, Role.OWNER)
+    @Authorized(Role.INSTRUCTOR)
     async subcourseCreate(
         @Ctx() context: GraphQLContext,
         @Arg('courseId') courseId: number,
@@ -80,6 +80,17 @@ export class MutateSubcourseResolver {
     ): Promise<GraphQLModel.Subcourse> {
         const course = await getCourse(courseId);
         await hasAccess(context, 'Course', course);
+        const courseInstructorAssociation = await prisma.course_instructors_student.findFirst({
+            where: {
+                courseId: courseId,
+                studentId: studentId,
+            },
+        });
+        const isCourseSharedOrOwned = !!courseInstructorAssociation || course.shared;
+        if (!isCourseSharedOrOwned) {
+            logger.error(`Course(${courseId}) is not shared or Student(${studentId}) is not an instructor of this course`);
+            throw new PrerequisiteError('This course is not shared or you are not the instructor of this course!');
+        }
 
         const { joinAfterStart, minGrade, maxGrade, maxParticipants, allowChatContactParticipants, allowChatContactProspects, groupChatType } = subcourse;
         const result = await prisma.subcourse.create({
@@ -95,7 +106,6 @@ export class MutateSubcourseResolver {
                 groupChatType,
             },
         });
-
         const student = await getSessionStudent(context, studentId);
         await prisma.subcourse_instructors_student.create({ data: { subcourseId: result.id, studentId: student.id } });
 

integration-tests/07_course.ts

@@ -1,11 +1,12 @@
 import { test } from './base';
 import { adminClient } from './base/clients';
-import { pupilOne } from './01_user';
+import { pupilOne, studentOne } from './01_user';
 import * as assert from 'assert';
 import { screenedInstructorOne, screenedInstructorTwo } from './02_screening';
 import { ChatType } from '../common/chat/types';
 import { expectFetch } from './base/mock';
 import { course_coursestate_enum as CourseState } from '@prisma/client';
+import { prisma } from '../common/prisma';
 
 const appointmentTitle = 'Group Appointment 1';
 
@@ -21,6 +22,7 @@ const courseOne = test('Create Course One', async () => {
             description: "Why should I test if my users can do that for me in production?"
             category: club
             allowContact: true
+            shared: true
             subject: Informatik
             schooltype: gymnasium
         }) {
@@ -113,6 +115,7 @@ export const subcourseOne = test('Create Subcourse', async () => {
 
     const { client, instructor } = await screenedInstructorOne;
     const { courseId } = await courseOne;
+    const { student } = await studentOne;
 
     const {
         subcourseCreate: { id: subcourseId },
@@ -126,7 +129,7 @@ export const subcourseOne = test('Create Subcourse', async () => {
                 allowChatContactProspects: true
                 allowChatContactParticipants: true
                 groupChatType: ${ChatType.NORMAL}
-            }) { id }
+            } studentId: ${student.userID}) { id }
         }
     `);
 
@@ -390,3 +393,38 @@ void test('Add / Remove another instructor', async () => {
         subcourseDeleteInstructor(subcourseId: ${subcourseId} studentId: ${instructor2.student.id})
     }`);
 });
+
+void test('Find shared course', async () => {
+    const { instructor: instructor1 } = await screenedInstructorTwo;
+    const { instructor, courseId } = await subcourseOne;
+
+    const { courseSearch: courseSearch } = await adminClient.request(`
+    query FindSharedCourses {
+        templateCourses(studentId: ${instructor1.student.id}) { id }
+    }
+`);
+
+    assert.ok(courseSearch.some((it) => it.id === courseId));
+});
+
+void test('Test template course search', async () => {
+    const { instructor: instructor1 } = await screenedInstructorTwo;
+    const { instructor, courseId } = await subcourseOne;
+
+    await prisma.course.update({ where: { id: courseId }, data: { shared: false } });
+
+    const { courseSearch: courseSearch } = await adminClient.request(`
+    query FindSharedCourses {
+        templateCourses(studentId: ${instructor1.student.id}) { id }
+    }
+`);
+
+    assert.ok(courseSearch.every((it) => it.id != courseId));
+
+    const { courseSearch: courseSearch2 } = await adminClient.request(`
+    query FindSharedCourses {
+        templateCourses(studentId: ${instructor.student.id}) { id }
+    }
+`);
+    assert.ok(courseSearch2.some((it) => it.id === courseId));
+});

prisma/migrations/20231129181612_add_shared_attribute_to_course/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "course" ADD COLUMN     "shared" BOOLEAN NOT NULL DEFAULT false;

prisma/schema.prisma

@@ -179,6 +179,8 @@ model course {
   course_instructors_student course_instructors_student[]
   course_tags_course_tag     course_tags_course_tag[]
   subcourse                  subcourse[]
+  shared                     Boolean                      @default(false)
+
 }
 
 // DEPRECATED: This was filled from BBB Meetings, replaced with the zoomMeetingReports field of lectures