allow cancel/edit a subcourse always when user is an admin

common/courses/states.ts

@@ -21,6 +21,8 @@ import { cancelAppointment } from '../appointment/cancel';
 import { User, userForStudent } from '../user';
 import { addGroupAppointmentsOrganizer } from '../appointment/participants';
 import { sendPupilCoursePromotion, sendSubcourseCancelNotifications } from './notifications';
+import { isElevated } from '../../graphql/authentication';
+import { GraphQLContext } from '../../graphql/context';
 
 const logger = getLogger('Course States');
 
@@ -122,7 +124,7 @@ export async function publishSubcourse(subcourse: Subcourse) {
 
 /* ---------------- Subcourse Cancel ------------ */
 
-export async function canCancel(subcourse: Subcourse): Promise<Decision> {
+export async function canCancel(subcourse: Subcourse, isAdmin: boolean): Promise<Decision> {
     if (!subcourse.published) {
         return { allowed: false, reason: 'not-published' };
     }
@@ -131,15 +133,19 @@ export async function canCancel(subcourse: Subcourse): Promise<Decision> {
         return { allowed: false, reason: 'already-cancelled' };
     }
 
+    if (isAdmin) {
+        return { allowed: true, reason: 'user-is-admin' };
+    }
+
     if (await subcourseOver(subcourse)) {
         return { allowed: false, reason: 'subcourse-ended' };
     }
 
     return { allowed: true };
 }
 
-export async function cancelSubcourse(user: User, subcourse: Subcourse) {
-    const can = await canCancel(subcourse);
+export async function cancelSubcourse(user: User, subcourse: Subcourse, isAdmin: boolean) {
+    const can = await canCancel(subcourse, isAdmin);
     if (!can.allowed) {
         throw new Error(`Cannot cancel Subcourse(${subcourse.id}), reason: ${can.reason}`);
     }
@@ -156,16 +162,19 @@ export async function cancelSubcourse(user: User, subcourse: Subcourse) {
 
 /* --------------- Modify Subcourse ------------------- */
 
-export async function canEditSubcourse(subcourse: Subcourse): Promise<Decision> {
+export async function canEditSubcourse(subcourse: Subcourse, isAdmin: boolean): Promise<Decision> {
+    if (isAdmin) {
+        return { allowed: true, reason: 'user-is-admin' };
+    }
     if (subcourse.published && (await subcourseOver(subcourse))) {
         return { allowed: false, reason: 'course-ended' };
     }
 
     return { allowed: true };
 }
 
-export async function editSubcourse(subcourse: Subcourse, update: Partial<Subcourse>) {
-    const can = await canEditSubcourse(subcourse);
+export async function editSubcourse(subcourse: Subcourse, update: Partial<Subcourse>, isAdmin: boolean) {
+    const can = await canEditSubcourse(subcourse, isAdmin);
     if (!can.allowed) {
         throw new Error(`Cannot edit Subcourse(${subcourse.id}) reason: ${can.reason}`);
     }

graphql/subcourse/fields.ts

@@ -3,7 +3,7 @@ import { canCancel, canEditSubcourse, canPublish } from '../../common/courses/st
 import { Arg, Authorized, Ctx, Field, FieldResolver, Int, ObjectType, Query, Resolver, Root } from 'type-graphql';
 import { canJoinSubcourse, couldJoinSubcourse, isParticipant } from '../../common/courses/participants';
 import { prisma } from '../../common/prisma';
-import { getSessionPupil, getSessionStudent, isElevated, isSessionPupil, isSessionStudent } from '../authentication';
+import { getSessionPupil, getSessionStudent, isElevated, isSessionPupil, isSessionStudent, isAdmin } from '../authentication';
 import { Role } from '../authorizations';
 import { PublicCache } from '../cache';
 import { LimitedQuery, LimitEstimated } from '../complexity';
@@ -459,14 +459,16 @@ export class ExtendedFieldsSubcourseResolver {
 
     @FieldResolver((returns) => Decision)
     @Authorized(Role.ADMIN, Role.OWNER)
-    async canCancel(@Root() subcourse: Required<Subcourse>) {
-        return await canCancel(subcourse);
+    async canCancel(@Ctx() context: GraphQLContext, @Root() subcourse: Required<Subcourse>) {
+        const isanAdmin = await isAdmin(context);
+        return await canCancel(subcourse, isanAdmin);
     }
 
     @FieldResolver((returns) => Decision)
     @Authorized(Role.ADMIN, Role.OWNER)
-    async canEdit(@Root() subcourse: Required<Subcourse>) {
-        return await canEditSubcourse(subcourse);
+    async canEdit(@Ctx() context: GraphQLContext, @Root() subcourse: Required<Subcourse>) {
+        const isanAdmin = await isAdmin(context);
+        return await canEditSubcourse(subcourse, isanAdmin);
     }
 
     @FieldResolver((returns) => Decision)

graphql/subcourse/mutations.ts

@@ -8,7 +8,7 @@ import { getLogger } from '../../common/logger/logger';
 import { prisma } from '../../common/prisma';
 import { userForPupil, userForStudent } from '../../common/user';
 import { PrerequisiteError } from '../../common/util/error';
-import { getSessionPupil, getSessionStudent } from '../authentication';
+import { getSessionPupil, getSessionStudent, isAdmin } from '../authentication';
 import { AuthorizedDeferred, hasAccess, Role } from '../authorizations';
 import { GraphQLContext } from '../context';
 import { getFile, removeFile } from '../files';
@@ -169,20 +169,21 @@ export class MutateSubcourseResolver {
         @Arg('subcourse') data: PublicSubcourseEditInput
     ): Promise<GraphQLModel.Subcourse> {
         const subcourse = await getSubcourse(subcourseId, true);
+        const isanAdmin = await isAdmin(context);
         await hasAccess(context, 'Subcourse', subcourse);
 
         logger.info(`Subcourse(${subcourseId}) was edited by User(${context.user.userID})`);
-        return await editSubcourse(subcourse, data);
+        return await editSubcourse(subcourse, data, isanAdmin);
     }
 
     @Mutation((returns) => Boolean)
     @AuthorizedDeferred(Role.ADMIN, Role.OWNER)
     async subcourseCancel(@Ctx() context: GraphQLContext, @Arg('subcourseId') subcourseId: number): Promise<boolean> {
         const { user } = context;
         const subcourse = await getSubcourse(subcourseId);
+        const isanAdmin = await isAdmin(context);
         await hasAccess(context, 'Subcourse', subcourse);
-
-        await cancelSubcourse(user, subcourse);
+        await cancelSubcourse(user, subcourse, isanAdmin);
         if (subcourse.conversationId) {
             await markConversationAsReadOnly(subcourse.conversationId);
         }