feat: tutor notes + mentorship + moderation + escalation

src/app/api/models/project.ts

@@ -43,7 +43,8 @@ export class Project extends Entity {
 
   public hasPortfolio: boolean;
   public portfolioStatus: number;
-  public portfolioFiles: { kind: string; name: string; idx: number }[];
+  public portfolioFiles: {kind: string; name: string; idx: number}[];
+  public escalationAttemptsRemaining: number;
 
   public taskStats: {
     key: TaskStatusEnum;

src/app/api/models/task.ts

@@ -18,6 +18,8 @@ import {
   TestAttempt,
   TestAttemptService,
   ScormComment,
+  UnitRoleService,
+  UnitRole,
 } from './doubtfire-model';
 import {Grade} from './grade';
 import {LOCALE_ID} from '@angular/core';
@@ -27,6 +29,18 @@ import {gradeTaskModal, uploadSubmissionModal} from 'src/app/ajs-upgraded-provid
 import {AlertService} from 'src/app/common/services/alert.service';
 import {MappingFunctions} from '../services/mapping-fn';
 
+export const FeedbackModerationAction = {
+  ShowMore: 'show_more',
+  ShowLess: 'show_less',
+  DismissOk: 'dismiss_ok',
+  DismissGood: 'dismiss_good',
+  Upheld: 'upheld',
+  Overturn: 'overturn',
+} as const;
+
+export type FeedbackModerationActionType =
+  (typeof FeedbackModerationAction)[keyof typeof FeedbackModerationAction];
+
 export class Task extends Entity {
   id: number;
 
@@ -44,6 +58,8 @@ export class Task extends Entity {
   numNewComments: number = 0;
   hasExtensions: boolean;
 
+  moderationType: 'random_sample' | 'escalation' | 'first_feedback';
+
   project: Project;
   definition: TaskDefinition;
 
@@ -93,6 +109,16 @@ export class Task extends Entity {
     return this.commentCache.currentValues;
   }
 
+  public get tutor(): UnitRole {
+    const enrolments = this.project.tutorialEnrolmentsCache.currentValues.filter(
+      (t) => t.tutorialStream.name === this.definition.tutorialStream.name,
+    );
+    if (enrolments.length === 1) {
+      const user = enrolments[0].tutor;
+      return this.unit.staff.find((ur) => ur.user.id === user.id);
+    }
+  }
+
   public addComment(textString): void {
     AppInjector.get(TaskCommentService)
       .addComment(this, textString, 'text')
@@ -982,4 +1008,39 @@ export class Task extends Entity {
 
     return false;
   }
+
+  public moderateFeedback(
+    action: FeedbackModerationActionType,
+    applyToAll: boolean = false,
+  ): Observable<boolean> {
+    const unitRoleService: UnitRoleService = AppInjector.get(UnitRoleService);
+
+    const tutor = this.tutor;
+    if (!tutor) {
+      return;
+    }
+
+    return unitRoleService.post(
+      {
+        id: tutor.id,
+        taskId: this.id,
+      },
+      {
+        endpointFormat: '/unit_roles/:id:/moderation/:taskId:',
+        body: {
+          action,
+          apply_to_all: applyToAll,
+        },
+      },
+    );
+  }
+
+  public requestFeedbackReview(): Observable<boolean> {
+    const httpClient: HttpClient = AppInjector.get(HttpClient);
+    const url = `${AppInjector.get(DoubtfireConstants).API_URL}/projects/${
+      this.project.id
+    }/task_def_id/${this.definition.id}/feedback_review`;
+
+    return httpClient.post<boolean>(url, {});
+  }
 }

src/app/api/models/tutor-note.ts

@@ -0,0 +1,55 @@
+import {Entity} from 'ngx-entity-service';
+import {AppInjector} from 'src/app/app-injector';
+import {AlertService} from 'src/app/common/services/alert.service';
+import {TutorNoteService} from '../services/tutor-note.service';
+import {Project, Task, TaskDefinition, UnitRole, User, UserService} from './doubtfire-model';
+
+export class TutorNote extends Entity {
+  id: number;
+
+  unitRole: UnitRole;
+  task?: Task;
+  taskDefinition?: TaskDefinition;
+  project?: Project;
+  user: User;
+  note: string;
+  replyTo?: TutorNote;
+  replyToId: number;
+  readByUnitRole: boolean;
+
+  createdAt: Date;
+  updatedAt: Date;
+
+  constructor(data?: UnitRole) {
+    super();
+    if (data) {
+      this.unitRole = data;
+    } else {
+      console.error('Failed to get unit role');
+    }
+  }
+
+  public get noteIsForMe(): boolean {
+    const userService: UserService = AppInjector.get(UserService);
+    return this.unitRole.user.id === userService.currentUser.id;
+  }
+
+  public get authorIsMe(): boolean {
+    const userService: UserService = AppInjector.get(UserService);
+    return this.user.id === userService.currentUser.id;
+  }
+
+  public delete() {
+    const tutorNoteService: TutorNoteService = AppInjector.get(TutorNoteService);
+    tutorNoteService
+      .delete({unitRoleId: this.unitRole.id, id: this.id}, {cache: this.unitRole.tutorNotesCache})
+      .subscribe({
+        next: () => {
+          AppInjector.get(AlertService).error('Successfully deleted tutor note', 4000);
+        },
+        error: (error) => {
+          AppInjector.get(AlertService).error(error?.message || error || 'Unknown error', 2000);
+        },
+      });
+  }
+}

src/app/api/models/unit-role.ts

@@ -1,17 +1,25 @@
-import { Entity, EntityMapping } from 'ngx-entity-service';
-import { User, Unit } from './doubtfire-model';
+import {Entity, EntityCache, EntityMapping} from 'ngx-entity-service';
+import {User, Unit} from './doubtfire-model';
+import {TutorNote} from './tutor-note';
 
 /**
  * A unit role represents a academic teaching role within a unit. Linking a user
  * to their role within the unit.
  */
 export class UnitRole extends Entity {
-
   id: number;
   role: string;
   user: User;
   unit: Unit;
   observerOnly: boolean;
+  mentorId: number;
+  tutorNoteCount: number;
+
+  public get mentor(): UnitRole {
+    return this.unit?.staff.find((ur) => ur.id === this.mentorId);
+  }
+
+  public readonly tutorNotesCache: EntityCache<TutorNote> = new EntityCache<TutorNote>();
 
   /**
    * The id for updated roles - but we need to move away from this to the role string...
@@ -29,10 +37,12 @@ export class UnitRole extends Entity {
     return this.user.matches(text) || this.unit.matches(text);
   }
 
-  public override toJson<T extends Entity>(mappingData: EntityMapping<T>, ignoreKeys?: string[]): object {
+  public override toJson<T extends Entity>(
+    mappingData: EntityMapping<T>,
+    ignoreKeys?: string[],
+  ): object {
     return {
       unit_role: super.toJson(mappingData, ignoreKeys),
-    }
+    };
   }
-
 }

src/app/api/services/project.service.ts

@@ -207,6 +207,7 @@ export class ProjectService extends CachedEntityService<Project> {
           });
         },
       },
+      'escalationAttemptsRemaining',
     );
 
     this.mapping.addJsonKey(

src/app/api/services/task.service.ts

@@ -22,6 +22,7 @@ export class TaskService extends CachedEntityService<Task> {
 
   private readonly taskInboxEndpoint = '/units/:id:/tasks/inbox';
   private readonly taskExplorerEndpoint = '/units/:id:/task_definitions/:task_def_id:/tasks';
+  private readonly taskModerationEndpoint = '/units/:id:/tasks/moderation';
   private readonly refreshTaskEndpoint = 'projects/:projectId:/refresh_tasks/:taskDefinitionId:';
 
   constructor(httpClient: HttpClient) {
@@ -97,6 +98,7 @@ export class TaskService extends CachedEntityService<Task> {
           });
         },
       },
+      'moderationType',
     );
 
     this.mapping.addJsonKey('qualityPts', 'grade', 'includeInPortfolio', 'trigger');
@@ -155,6 +157,24 @@ export class TaskService extends CachedEntityService<Task> {
     );
   }
 
+  public queryTasksForMentorModeration(unit: Unit): Observable<Task[]> {
+    const cache: EntityCache<Task> = new EntityCache<Task>();
+    return this.query(
+      {
+        id: unit.id,
+      },
+      {
+        endpointFormat: this.taskModerationEndpoint,
+        cache: cache,
+        constructorParams: unit,
+      },
+    ).pipe(
+      tap((tasks: Task[]) => {
+        unit.incorporateTasks(tasks);
+      }),
+    );
+  }
+
   public refreshExtensionDetails(task: Task): void {
     const pathIds = {
       projectId: task.project.id,