feat(Run): Allow teachers to archive runs

src/app/app.module.ts

@@ -23,6 +23,7 @@ import { AnnouncementComponent } from './announcement/announcement.component';
 import { AnnouncementDialogComponent } from './announcement/announcement.component';
 import { TrackScrollDirective } from './track-scroll.directive';
 import { RecaptchaV3Module, RECAPTCHA_V3_SITE_KEY, RECAPTCHA_BASE_URL } from 'ng-recaptcha';
+import { ArchiveProjectService } from './services/archive-project.service';
 
 export function initialize(
   configService: ConfigService,
@@ -59,11 +60,12 @@ export function initialize(
     MatDialogModule,
     RecaptchaV3Module,
     RouterModule.forRoot([], {
-    scrollPositionRestoration: 'enabled',
-    anchorScrolling: 'enabled'
-})
+      scrollPositionRestoration: 'enabled',
+      anchorScrolling: 'enabled'
+    })
   ],
   providers: [
+    ArchiveProjectService,
     ConfigService,
     StudentService,
     TeacherService,

src/app/domain/archiveProjectResponse.ts

@@ -0,0 +1,4 @@
+export class ArchiveProjectResponse {
+  archived: boolean;
+  id: number;
+}

src/app/domain/project.ts

@@ -2,22 +2,24 @@ import { Run } from './run';
 import { User } from '../domain/user';
 
 export class Project {
-  id: number;
-  name: string;
-  metadata: any;
-  dateCreated: string;
+  archived: boolean;
   dateArchived: string;
-  lastEdited: string;
-  projectThumb: string;
-  thumbStyle: any;
+  dateCreated: string;
+  id: number;
   isHighlighted: boolean;
+  lastEdited: string;
+  license: String;
+  metadata: any;
+  name: string;
   owner: User;
-  sharedOwners: User[] = [];
-  run: Run;
   parentId: number;
-  wiseVersion: number;
+  projectThumb: string;
+  run: Run;
+  sharedOwners: User[] = [];
+  tags: string[];
+  thumbStyle: any;
   uri: String;
-  license: String;
+  wiseVersion: number;
 
   static readonly VIEW_PERMISSION: number = 1;
   static readonly EDIT_PERMISSION: number = 2;

src/app/services/archive-project.service.ts

@@ -0,0 +1,32 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Project } from '../domain/project';
+
+@Injectable()
+export class ArchiveProjectService {
+  constructor(private http: HttpClient) {}
+
+  archiveProject(project: Project): Observable<any> {
+    return this.http.put<Project>(`/api/project/${project.id}/archived`, null);
+  }
+
+  archiveProjects(projects: Project[]): Observable<any> {
+    const projectIds = projects.map((project) => project.id);
+    return this.http.put<Project[]>(`/api/projects/archived`, projectIds);
+  }
+
+  unarchiveProject(project: Project): Observable<any> {
+    return this.http.delete<Project>(`/api/project/${project.id}/archived`);
+  }
+
+  unarchiveProjects(projects: Project[]): Observable<any> {
+    let params = new HttpParams();
+    for (const project of projects) {
+      params = params.append('projectIds', project.id);
+    }
+    return this.http.delete<any>(`/api/projects/archived`, {
+      params: params
+    });
+  }
+}

src/app/teacher/run-menu/run-menu.component.html

@@ -29,5 +29,13 @@
       <mat-icon>report_problem</mat-icon>
       <span i18n>Report Problem</span>
     </a>
+    <a mat-menu-item *ngIf="!run.archived" (click)="archive()">
+      <mat-icon>folder</mat-icon>
+      <span i18n>Archive</span>
+    </a>
+    <a mat-menu-item *ngIf="run.archived" (click)="unarchive()">
+      <mat-icon>folder_off</mat-icon>
+      <span i18n>Unarchive</span>
+    </a>
   </div>
 </mat-menu>

src/app/teacher/run-menu/run-menu.component.spec.ts

@@ -1,8 +1,7 @@
 import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
 import { RunMenuComponent } from './run-menu.component';
 import { TeacherService } from '../teacher.service';
-import { Project } from '../../domain/project';
-import { BehaviorSubject, Observable } from 'rxjs';
+import { BehaviorSubject, Observable, of, throwError } from 'rxjs';
 import { MatDialog } from '@angular/material/dialog';
 import { MatMenuModule } from '@angular/material/menu';
 import { ConfigService } from '../../services/config.service';
@@ -12,6 +11,11 @@ import { TeacherRun } from '../teacher-run';
 import { NO_ERRORS_SCHEMA } from '@angular/core';
 import { Course } from '../../domain/course';
 import { RouterTestingModule } from '@angular/router/testing';
+import { MatSnackBar, MatSnackBarModule } from '@angular/material/snack-bar';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { ArchiveProjectService } from '../../services/archive-project.service';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+import { Project } from '../../domain/project';
 
 export class MockTeacherService {
   checkClassroomAuthorization(): Observable<string> {
@@ -56,44 +60,84 @@ export class MockConfigService {
   }
 }
 
-describe('RunMenuComponent', () => {
-  let component: RunMenuComponent;
-  let fixture: ComponentFixture<RunMenuComponent>;
+let archiveProjectService: ArchiveProjectService;
+let component: RunMenuComponent;
+let fixture: ComponentFixture<RunMenuComponent>;
+let snackBarSpy: jasmine.Spy;
+let teacherService: TeacherService;
 
-  beforeEach(waitForAsync(() => {
-    TestBed.configureTestingModule({
-      imports: [MatMenuModule, RouterTestingModule],
-      declarations: [RunMenuComponent],
-      providers: [
-        { provide: TeacherService, useClass: MockTeacherService },
-        { provide: UserService, useClass: MockUserService },
-        { provide: ConfigService, useClass: MockConfigService },
-        { provide: MatDialog, useValue: {} }
-      ],
-      schemas: [NO_ERRORS_SCHEMA]
-    }).compileComponents();
-  }));
+describe('RunMenuComponent', () => {
+  beforeEach(
+    waitForAsync(() => {
+      TestBed.configureTestingModule({
+        imports: [
+          BrowserAnimationsModule,
+          HttpClientTestingModule,
+          MatMenuModule,
+          MatSnackBarModule,
+          RouterTestingModule
+        ],
+        declarations: [RunMenuComponent],
+        providers: [
+          ArchiveProjectService,
+          { provide: TeacherService, useClass: MockTeacherService },
+          { provide: UserService, useClass: MockUserService },
+          { provide: ConfigService, useClass: MockConfigService },
+          { provide: MatDialog, useValue: {} }
+        ],
+        schemas: [NO_ERRORS_SCHEMA]
+      }).compileComponents();
+    })
+  );
 
   beforeEach(() => {
     fixture = TestBed.createComponent(RunMenuComponent);
     component = fixture.componentInstance;
-    const run: TeacherRun = new TeacherRun();
-    run.id = 1;
-    run.name = 'Photosynthesis';
     const owner = new User();
-    owner.id = 1;
-    run.owner = owner;
-    const project = new Project();
-    project.id = 1;
-    project.owner = owner;
-    project.sharedOwners = [];
-    run.project = project;
-    run.sharedOwners = [];
-    component.run = run;
+    component.run = new TeacherRun({
+      id: 1,
+      name: 'Photosynthesis',
+      owner: owner,
+      project: {
+        id: 1,
+        owner: owner,
+        sharedOwners: []
+      }
+    });
+    archiveProjectService = TestBed.inject(ArchiveProjectService);
+    teacherService = TestBed.inject(TeacherService);
+    snackBarSpy = spyOn(TestBed.inject(MatSnackBar), 'open');
+    spyOn(archiveProjectService, 'archiveProject').and.callFake((project: Project) => {
+      project.archived = true;
+      return of(project);
+    });
+    spyOn(archiveProjectService, 'unarchiveProject').and.callFake((project: Project) => {
+      project.archived = false;
+      return of(project);
+    });
     fixture.detectChanges();
   });
 
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
+  archive();
+  unarchive();
 });
+
+function archive() {
+  describe('archive()', () => {
+    it('should archive a run', () => {
+      component.archive();
+      expect(component.run.archived).toEqual(true);
+      expect(snackBarSpy).toHaveBeenCalledWith('Successfully Archived Run');
+    });
+  });
+}
+
+function unarchive() {
+  describe('unarchive()', () => {
+    it('should unarchive a run', () => {
+      component.unarchive();
+      expect(component.run.archived).toEqual(false);
+      expect(snackBarSpy).toHaveBeenCalledWith('Successfully Unarchived Run');
+    });
+  });
+}

src/app/teacher/run-menu/run-menu.component.ts

@@ -1,4 +1,4 @@
-import { Component, Input, OnInit } from '@angular/core';
+import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';
 import { MatDialog } from '@angular/material/dialog';
 import { ShareRunDialogComponent } from '../share-run-dialog/share-run-dialog.component';
 import { LibraryProjectDetailsComponent } from '../../modules/library/library-project-details/library-project-details.component';
@@ -8,6 +8,9 @@ import { ConfigService } from '../../services/config.service';
 import { RunSettingsDialogComponent } from '../run-settings-dialog/run-settings-dialog.component';
 import { EditRunWarningDialogComponent } from '../edit-run-warning-dialog/edit-run-warning-dialog.component';
 import { Router } from '@angular/router';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { ArchiveProjectService } from '../../services/archive-project.service';
+import { ArchiveProjectResponse } from '../../domain/archiveProjectResponse';
 
 @Component({
   selector: 'app-run-menu',
@@ -16,21 +19,26 @@ import { Router } from '@angular/router';
 })
 export class RunMenuComponent implements OnInit {
   @Input() run: TeacherRun;
+  @Output() runArchiveStatusChangedEvent: EventEmitter<any> = new EventEmitter<any>();
 
   editLink: string = '';
+  isOwner: boolean;
   reportProblemLink: string = '';
 
   constructor(
+    private archiveProjectService: ArchiveProjectService,
     private dialog: MatDialog,
     private userService: UserService,
     private configService: ConfigService,
-    private router: Router
+    private router: Router,
+    private snackBar: MatSnackBar
   ) {}
 
   ngOnInit() {
     this.editLink = `${this.configService.getContextPath()}/teacher/edit/unit/${
       this.run.project.id
     }`;
+    this.isOwner = this.run.isOwner(this.userService.getUserId());
     this.reportProblemLink = `${this.configService.getContextPath()}/contact?runId=${this.run.id}`;
   }
 
@@ -57,10 +65,6 @@ export class RunMenuComponent implements OnInit {
     return this.run.canGradeAndManage(this.userService.getUserId());
   }
 
-  isOwner() {
-    return this.run.isOwner(this.userService.getUserId());
-  }
-
   isRunCompleted() {
     return this.run.isCompleted(this.configService.getCurrentServerTime());
   }
@@ -86,4 +90,32 @@ export class RunMenuComponent implements OnInit {
       this.router.navigateByUrl(this.editLink);
     }
   }
+
+  archive(): void {
+    const run = this.run;
+    this.archiveProjectService.archiveProject(run.project).subscribe({
+      next: (response: ArchiveProjectResponse) => {
+        run.archived = response.archived;
+        this.runArchiveStatusChangedEvent.emit(run);
+        this.snackBar.open($localize`Successfully Archived Run`);
+      },
+      error: () => {
+        this.snackBar.open($localize`Error Archiving Run`);
+      }
+    });
+  }
+
+  unarchive(): void {
+    const run = this.run;
+    this.archiveProjectService.unarchiveProject(run.project).subscribe({
+      next: (response: ArchiveProjectResponse) => {
+        run.archived = response.archived;
+        this.runArchiveStatusChangedEvent.emit(run);
+        this.snackBar.open($localize`Successfully Unarchived Run`);
+      },
+      error: () => {
+        this.snackBar.open($localize`Error Unarchiving Run`);
+      }
+    });
+  }
 }

src/app/teacher/select-runs-controls/select-runs-controls.component.html

@@ -0,0 +1,20 @@
+<div fxLayout="row wrap" fxLayoutAlign="start center">
+  <mat-checkbox
+    class="select-all-checkbox"
+    color="primary"
+    [checked]="selectedAllRuns"
+    [indeterminate]="selectedSomeRuns"
+    (click)="selectAllRunsCheckboxClicked()"
+  ></mat-checkbox>
+  <div class="select-all-drop-down">
+    <button mat-button [matMenuTriggerFor]="selectRunsMenu">
+      <mat-icon>arrow_drop_down</mat-icon>
+    </button>
+    <mat-menu #selectRunsMenu="matMenu">
+      <button mat-menu-item (click)="selectRunsOptionChosen('all')" i18n>All</button>
+      <button mat-menu-item (click)="selectRunsOptionChosen('none')" i18n>None</button>
+      <button mat-menu-item (click)="selectRunsOptionChosen('running')" i18n>Running</button>
+      <button mat-menu-item (click)="selectRunsOptionChosen('completed')" i18n>Completed</button>
+    </mat-menu>
+  </div>
+</div>

src/app/teacher/select-runs-controls/select-runs-controls.component.scss

@@ -0,0 +1,11 @@
+.select-all-checkbox {
+  margin-right: 6px;
+}
+
+.select-all-drop-down {
+  margin-right: 24px;
+}
+
+.mat-icon {
+  margin: 0px;
+}

src/app/teacher/select-runs-controls/select-runs-controls.component.spec.ts

@@ -0,0 +1,22 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { SelectRunsControlsComponent } from './select-runs-controls.component';
+import { SelectRunsControlsModule } from './select-runs-controls.module';
+
+describe('SelectRunsControlsComponent', () => {
+  let component: SelectRunsControlsComponent;
+  let fixture: ComponentFixture<SelectRunsControlsComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [SelectRunsControlsModule]
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(SelectRunsControlsComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});