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

graphql/authorizations.ts

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

graphql/course/fields.ts

@@ -71,4 +71,41 @@ export class ExtendedFieldsCourseResolver {
         const student = await getSessionStudent(context, studentId);
         return (await prisma.course_instructors_student.count({ where: { courseId: course.id, studentId: student.id } })) > 0;
     }
+
+    @Query((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: {
+                AND: [
+                    courseSearchFilters,
+                    {
+                        OR: [
+                            {
+                                course_instructors_student: {
+                                    some: {
+                                        studentId: studentId,
+                                    },
+                                },
+                            },
+                            {
+                                shared: true,
+                            },
+                        ],
+                    },
+                ],
+            },
+            take,
+            skip,
+        });
+
+        return courses;
+    }
 }

graphql/course/mutations.ts

@@ -85,6 +85,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

@@ -73,15 +73,27 @@ class PublicLectureInput {
 @Resolver((of) => GraphQLModel.Subcourse)
 export class MutateSubcourseResolver {
     @Mutation((returns) => GraphQLModel.Subcourse)
-    @AuthorizedDeferred(Role.ADMIN, Role.OWNER)
+    @Authorized(Role.INSTRUCTOR, Role.ADMIN)
     async subcourseCreate(
         @Ctx() context: GraphQLContext,
         @Arg('courseId') courseId: number,
         @Arg('subcourse') subcourse: PublicSubcourseCreateInput,
         @Arg('studentId', { nullable: true }) studentId?: number
     ): Promise<GraphQLModel.Subcourse> {
         const course = await getCourse(courseId);
-        await hasAccess(context, 'Course', course);
+        const student = await getSessionStudent(context, studentId);
+
+        const courseInstructorAssociation = await prisma.course_instructors_student.findFirst({
+            where: {
+                courseId: courseId,
+                studentId: student.id,
+            },
+        });
+        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({
@@ -97,8 +109,6 @@ export class MutateSubcourseResolver {
                 groupChatType,
             },
         });
-
-        const student = await getSessionStudent(context, studentId);
         await prisma.subcourse_instructors_student.create({ data: { subcourseId: result.id, studentId: student.id } });
 
         await Notification.actionTaken(userForStudent(student), 'instructor_course_created', {

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';
 
@@ -113,21 +114,23 @@ export const subcourseOne = test('Create Subcourse', async () => {
 
     const { client, instructor } = await screenedInstructorOne;
     const { courseId } = await courseOne;
+    const { student } = await studentOne;
 
     const {
         subcourseCreate: { id: subcourseId },
     } = await client.request(`
         mutation CreateSubcourse {
-            subcourseCreate(courseId: ${courseId} subcourse: {
+            subcourseCreate(courseId: ${courseId}, subcourse: {
                 minGrade: 5
                 maxGrade: 10
                 maxParticipants: 1
                 joinAfterStart: true
                 allowChatContactProspects: true
                 allowChatContactParticipants: true
                 groupChatType: ${ChatType.NORMAL}
-            }) { id }
-        }
+            })
+  		{id}
+  }
     `);
 
     const { subcoursesPublic } = await client.request(`
@@ -390,3 +393,63 @@ void test('Add / Remove another instructor', async () => {
         subcourseDeleteInstructor(subcourseId: ${subcourseId} studentId: ${instructor2.student.id})
     }`);
 });
+
+void test('Find shared course', async () => {
+    const { instructor: instructor2, client: instructor2client } = await screenedInstructorTwo;
+    const { courseId, client, instructor: subcourseInstructor } = await subcourseOne;
+
+    await client.request(`
+        mutation MarkCourseShared {
+            courseMarkShared(courseId: ${courseId}, shared: true){id}
+        }
+    `);
+
+    const { templateCourses: templateCoursesEmptySearch } = await instructor2client.request(`
+        query FindSharedCourses {
+            templateCourses(search: "", take: 1) {
+              id
+            }
+        }
+    `);
+    // Instructor from subcourseOne creates subcourse, Different instructor (instructor2) must find it.
+    assert.ok(templateCoursesEmptySearch.some((it) => it.id === courseId));
+
+    const course = await prisma.course.findUnique({
+        where: { id: courseId },
+    });
+
+    const { templateCourses: templateCoursesNonEmptySearch } = await instructor2client.request(`
+    query FindSharedCourses {
+        templateCourses(search: "${course.name}", take: 1) {
+          id
+        }
+    }
+`);
+    // Instructor 2 must be able to find shared course by name
+    assert.ok(templateCoursesNonEmptySearch.some((it) => it.id === courseId));
+
+    await client.request(`
+    mutation MarkCourseShared {
+        courseMarkShared(courseId: ${courseId}, shared: false){id}
+    }
+`);
+
+    const { templateCourses: courseSearch } = await adminClient.request(`
+    query FindSharedCourses {
+        templateCourses(studentId: ${instructor2.student.id}, search: "", take: 10) { id }
+    }
+    `);
+
+    //Subcourse is not shared anymore. Instructor 2 must not find the course since it was created
+    //by the subcourseInstructor
+    assert.ok(courseSearch.every((it) => it.id != courseId));
+
+    const { templateCourses: courseSearch2 } = await adminClient.request(`
+    query FindSharedCourses {
+        templateCourses(studentId: ${subcourseInstructor.student.id}, search: "", take: 10) { id }
+    }
+`);
+
+    //SubcourseOneInstructor must be able to find his own subcourse, even if it is not shared
+    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

@@ -181,6 +181,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