@@ -49,15 +32,14 @@ Campuses
Abbreviation |
@if (!editing(campus)) {
-
- {{ campus.abbreviation }}
-
- } @else { #edit| }
-
+
+ {{ campus.abbreviation }}
+
+ } @else {
-
+ }
|
@@ -71,11 +53,10 @@ Campuses
Default Sync Mode |
@if (!editing(campus)) {
-
- {{ campus.mode | titlecase }}
-
- } @else { #edit| }
-
+
+ {{ campus.mode | titlecase }}
+
+ } @else {
Default Sync Mode
@@ -86,7 +67,7 @@ Campuses
}
-
+ }
|
@@ -102,18 +83,41 @@ Campuses
|
+
+
+ Timezone |
+
+ @if (!editing(campus)) {
+
+ {{ campus.timezone }}
+
+ } @else {
+
+ Timezone
+
+
+
+ }
+ |
+
+
+ Timezone
+
+
+ |
+
+
Active |
@if (!editing(campus)) {
-
-
-
- } @else { #edit| }
-
+
+
+
+ } @else {
-
+ }
|
@@ -135,8 +139,7 @@ Campuses
- } @else { #edit| }
-
+ } @else {
-
+ }
|
diff --git a/src/app/admin/institution-settings/campuses/campus-list/campus-list.component.ts b/src/app/admin/institution-settings/campuses/campus-list/campus-list.component.ts
index 3ab6b9e71e..1fa8871cc3 100644
--- a/src/app/admin/institution-settings/campuses/campus-list/campus-list.component.ts
+++ b/src/app/admin/institution-settings/campuses/campus-list/campus-list.component.ts
@@ -18,7 +18,7 @@ export class CampusListComponent extends EntityFormComponent {
syncModes = ['timetable', 'automatic', 'manual'];
// Set up the table
- columns: string[] = ['name', 'abbreviation', 'mode', 'active', 'options'];
+ columns: string[] = ['name', 'abbreviation', 'mode', 'timezone', 'active', 'options'];
campuses: Campus[] = new Array();
dataSource = new MatTableDataSource(this.campuses);
@@ -33,6 +33,7 @@ export class CampusListComponent extends EntityFormComponent {
abbreviation: new UntypedFormControl('', [Validators.required]),
name: new UntypedFormControl('', [Validators.required]),
mode: new UntypedFormControl('', [Validators.required]),
+ timezone: new UntypedFormControl('', [Validators.required]),
active: new UntypedFormControl(false),
},
'Campus',
@@ -91,6 +92,7 @@ export class CampusListComponent extends EntityFormComponent {
case 'name':
case 'abbreviation':
case 'mode':
+ case 'timezone':
case 'active':
return super.sortTableData(sort);
}
diff --git a/src/app/admin/institution-settings/institution-settings.component.html b/src/app/admin/institution-settings/institution-settings.component.html
index fdaa85dddc..590a56f54f 100644
--- a/src/app/admin/institution-settings/institution-settings.component.html
+++ b/src/app/admin/institution-settings/institution-settings.component.html
@@ -9,6 +9,17 @@
+
+
+
+
+
+
@if (overseerEnabled) {
diff --git a/src/app/admin/institution-settings/institution-settings.component.scss b/src/app/admin/institution-settings/institution-settings.component.scss
index 8681f6dbfa..7017d84036 100644
--- a/src/app/admin/institution-settings/institution-settings.component.scss
+++ b/src/app/admin/institution-settings/institution-settings.component.scss
@@ -1,3 +1,16 @@
.institution-settings-container {
padding: 0 5rem 0 5rem;
}
+.learning-outcomes-container {
+ padding: 0 1rem 1rem 1rem;
+}
+table {
+ width: 100%;
+}
+.header {
+ display: flex;
+ .interactions {
+ margin-left: auto;
+ margin-top: auto;
+ }
+}
diff --git a/src/app/admin/institution-settings/overseer-images/overseer-image-list.component.html b/src/app/admin/institution-settings/overseer-images/overseer-image-list.component.html
index d2e70e730d..9ca1c6a6ba 100644
--- a/src/app/admin/institution-settings/overseer-images/overseer-image-list.component.html
+++ b/src/app/admin/institution-settings/overseer-images/overseer-image-list.component.html
@@ -1,11 +1,28 @@
+
+
+ {{ data.text }}
+
+
+
-
+
| Name |
@@ -51,7 +68,9 @@ Overseer Images
|
-
+
|
|
@@ -62,7 +81,7 @@ Overseer Images
Last Pulled |
- {{ overseerImage.lastPulledDate }}
+ {{ overseerImage.lastPulledDate | humanizedDate }}
|
|
@@ -80,10 +99,10 @@ Overseer Images
overseerImage.pulledImageStatus === 'success'
? 'green'
: overseerImage.pulledImageStatus === 'loading'
- ? 'orange'
- : overseerImage.pulledImageStatus === 'failed'
- ? 'red'
- : ''
+ ? 'orange'
+ : overseerImage.pulledImageStatus === 'failed'
+ ? 'red'
+ : ''
}"
>
@@ -113,7 +133,11 @@ Overseer Images
|
-
+
| Active |
@@ -32,6 +43,26 @@ Teaching periods
| {{ element.activeUntil | date }} |
+
+ Actions |
+
+
+
+
+
+
+
+ |
+
+
|
|
- |
+ |
-
+
diff --git a/src/app/admin/states/teaching-periods/teaching-period-list/teaching-period-list.component.ts b/src/app/admin/states/teaching-periods/teaching-period-list/teaching-period-list.component.ts
index 87be5fbef8..f4099456cf 100644
--- a/src/app/admin/states/teaching-periods/teaching-period-list/teaching-period-list.component.ts
+++ b/src/app/admin/states/teaching-periods/teaching-period-list/teaching-period-list.component.ts
@@ -1,13 +1,14 @@
-import { Component, Inject, OnInit, ViewChild } from '@angular/core';
-import { MAT_DIALOG_DATA, MatDialog, MatDialogRef } from '@angular/material/dialog';
-import { MatPaginator } from '@angular/material/paginator';
-import { MatSnackBar } from '@angular/material/snack-bar';
-import { MatSort } from '@angular/material/sort';
-import { MatTableDataSource } from '@angular/material/table';
-import { TeachingPeriodBreak } from 'src/app/api/models/teaching-period';
-import { TeachingPeriod } from 'src/app/api/models/teaching-period';
-import { TeachingPeriodBreakService } from 'src/app/api/services/teaching-period-break.service';
-import { TeachingPeriodService } from 'src/app/api/services/teaching-period.service';
+import {Component, Inject, OnInit, ViewChild} from '@angular/core';
+import {MAT_DIALOG_DATA, MatDialog, MatDialogRef} from '@angular/material/dialog';
+import {MatPaginator} from '@angular/material/paginator';
+import {MatSort, Sort} from '@angular/material/sort';
+import {MatTableDataSource} from '@angular/material/table';
+import {TeachingPeriodBreak} from 'src/app/api/models/teaching-period';
+import {TeachingPeriod} from 'src/app/api/models/teaching-period';
+import {TeachingPeriodBreakService} from 'src/app/api/services/teaching-period-break.service';
+import {TeachingPeriodService} from 'src/app/api/services/teaching-period.service';
+import {TeachingPeriodUnitImportService} from '../teaching-period-unit-import/teaching-period-unit-import.dialog';
+import {AlertService} from 'src/app/common/services/alert.service';
@Component({
selector: 'f-teaching-period-list',
@@ -20,8 +21,13 @@ export class TeachingPeriodListComponent implements OnInit {
public dataSource = new MatTableDataSource();
- displayedColumns: string[] = ['active', 'name', 'startDate', 'endDate', 'activeUntil'];
- constructor(private teachingPeriodsService: TeachingPeriodService, public dialog: MatDialog) {}
+ displayedColumns: string[] = ['active', 'name', 'startDate', 'endDate', 'activeUntil', 'actions'];
+
+ constructor(
+ private teachingPeriodsService: TeachingPeriodService,
+ public dialog: MatDialog,
+ public teachingPeriodUnitImportService: TeachingPeriodUnitImportService,
+ ) {}
ngOnInit(): void {
// update the Teaching Periods
@@ -35,6 +41,10 @@ export class TeachingPeriodListComponent implements OnInit {
});
}
+ importUnits(teachingPeriod: TeachingPeriod) {
+ this.teachingPeriodUnitImportService.openImportUnitsDialog(teachingPeriod);
+ }
+
addTeachingPeriod() {
this.dialog.open(NewTeachingPeriodDialogComponent, {
data: {},
@@ -43,9 +53,42 @@ export class TeachingPeriodListComponent implements OnInit {
selectTeachingPeriod(selectedTeachingPeriod: TeachingPeriod) {
this.teachingPeriodsService.get(selectedTeachingPeriod.id).subscribe((teachingPeriod) => {
- this.dialog.open(NewTeachingPeriodDialogComponent, { data: { teachingPeriod: teachingPeriod } });
+ this.dialog.open(NewTeachingPeriodDialogComponent, {data: {teachingPeriod: teachingPeriod}});
});
}
+
+ /**
+ * Function used by implemented sortTableData to determine the order
+ * of values within the EntityForm once sorting has been triggered.
+ *
+ * @param aValue value to be compared against bValue.
+ * @param bValue value to be compared against aValue.
+ *
+ * @returns truthy comparison between aValue and bValue.
+ */
+ protected sortCompare(aValue: number | string, bValue: number | string, isAsc: boolean) {
+ return (aValue < bValue ? -1 : 1) * (isAsc ? 1 : -1);
+ }
+
+ // Sorting function to sort data when sort
+ // event is triggered
+ sortTableData(sort: Sort) {
+ if (!sort.active || sort.direction === '') {
+ return;
+ }
+ switch (sort.active) {
+ case 'active':
+ case 'name':
+ case 'startDate':
+ case 'endDate':
+ case 'activeUntil':
+ this.dataSource.data = this.dataSource.data.sort((a, b) => {
+ const isAsc = sort.direction === 'asc';
+ return this.sortCompare(a[sort.active], b[sort.active], isAsc);
+ });
+ return;
+ }
+ }
}
@Component({
@@ -58,18 +101,24 @@ export class NewTeachingPeriodDialogComponent {
private dialogRef: MatDialogRef,
public teachingPeriodService: TeachingPeriodService,
public teachingPeriodBreakService: TeachingPeriodBreakService,
- private _snackBar: MatSnackBar
+ public alertService: AlertService,
) {}
public newOrSelectedTeachingPeriod = this.data.teachingPeriod || new TeachingPeriod();
public tempBreak = new TeachingPeriodBreak();
addTeachingBreak() {
- this.newOrSelectedTeachingPeriod.addBreak(this.tempBreak.startDate, this.tempBreak.numberOfWeeks).subscribe({
- next: (teachingPeriodBreak) => {
- console.log(teachingPeriodBreak);
- },
- });
+ this.newOrSelectedTeachingPeriod
+ .addBreak(this.tempBreak.startDate, this.tempBreak.numberOfWeeks)
+ .subscribe({
+ next: (teachingPeriodBreak) => {
+ this.alertService.success('Break added');
+ console.log(teachingPeriodBreak);
+ },
+ error: (response) => {
+ this.alertService.error(`Error adding break. ${response}`);
+ },
+ });
}
deleteBreak(teachingPeriod: TeachingPeriod, teachingBreak: TeachingPeriodBreak): void {
@@ -77,26 +126,25 @@ export class NewTeachingPeriodDialogComponent {
next: (teachingPeriodBreak) => {
console.log(teachingPeriodBreak);
},
- error: (response) => {},
+ error: (response) => {
+ this.alertService.error(`Error deleting break. ${response}`);
+ },
});
}
submitTeachingPeriod() {
- // todo: use alert service
- this.teachingPeriodService.store(this.newOrSelectedTeachingPeriod).subscribe({
+ // Check if we are updating or creating a new teaching period
+ const observer = this.newOrSelectedTeachingPeriod.id
+ ? this.teachingPeriodService.update(this.newOrSelectedTeachingPeriod)
+ : this.teachingPeriodService.store(this.newOrSelectedTeachingPeriod);
+
+ // Save the teaching period
+ observer.subscribe({
next: (teachingPeriod) => {
- this._snackBar.open(`${teachingPeriod.name} saved`, 'dismiss', {
- duration: 2000,
- horizontalPosition: 'end',
- verticalPosition: 'top',
- });
+ this.alertService.success(`${teachingPeriod.name} saved`);
},
error: (response) => {
- this._snackBar.open(response, 'dismiss', {
- duration: 5000,
- horizontalPosition: 'end',
- verticalPosition: 'top',
- });
+ this.alertService.error(`Error saving teaching period. ${response}`);
},
});
}
diff --git a/src/app/admin/states/teaching-periods/teaching-period-unit-import/teaching-period-unit-import.dialog.ts b/src/app/admin/states/teaching-periods/teaching-period-unit-import/teaching-period-unit-import.dialog.ts
index 2925b4b59e..53416abcc8 100644
--- a/src/app/admin/states/teaching-periods/teaching-period-unit-import/teaching-period-unit-import.dialog.ts
+++ b/src/app/admin/states/teaching-periods/teaching-period-unit-import/teaching-period-unit-import.dialog.ts
@@ -126,6 +126,10 @@ export class TeachingPeriodUnitImportDialogComponent implements OnInit {
public codeChange(code: string, value: UnitImportData) {
value.relatedUnits = this.relatedUnits(code);
+ // add source unit to realted units - so that it is retained on code change
+ if (value.sourceUnit && !value.relatedUnits.find((u) => u.value.id === value.sourceUnit.id)) {
+ value.relatedUnits.unshift({value: value.sourceUnit, text: value.sourceUnit.codeAndPeriod});
+ }
value.sourceUnit = value.relatedUnits.length > 0 ? value.relatedUnits[0].value : null;
}
@@ -197,36 +201,43 @@ export class TeachingPeriodUnitImportDialogComponent implements OnInit {
}
private importExistingUnit(unitToImport: UnitImportData, idx: number) {
- unitToImport.sourceUnit.rolloverTo({ teaching_period_id: this.data.teachingPeriod.id }).subscribe({
- next: (newUnit: Unit) => {
- unitToImport.done = true;
- // Employ the convenor
- if (unitToImport.convenor && unitToImport.convenor !== newUnit.mainConvenorUser) {
- newUnit.addStaff(unitToImport.convenor, 'Convenor').subscribe({
- next: (newRole) => {
- console.log(`Employed ${unitToImport.convenor.name} in ${newUnit.code}`);
- newUnit.changeMainConvenor(newRole).subscribe({
- next: () => {
- console.log(`Set ${unitToImport.convenor.name} as main convenor in ${newUnit.code}`);
- },
- error: (failure) => {
- console.log(failure);
- },
- });
- },
- error: (failure) => {
- console.log(failure);
- },
- });
- }
- this.importUnit(idx + 1);
- },
- error: (failure) => {
- console.log(failure);
- unitToImport.done = false;
- this.importUnit(idx + 1);
- },
- });
+ unitToImport.sourceUnit
+ .rolloverTo({
+ new_unit_code: unitToImport.unitCode,
+ teaching_period_id: this.data.teachingPeriod.id,
+ })
+ .subscribe({
+ next: (newUnit: Unit) => {
+ unitToImport.done = true;
+ // Employ the convenor
+ if (unitToImport.convenor && unitToImport.convenor !== newUnit.mainConvenorUser) {
+ newUnit.addStaff(unitToImport.convenor, 'Convenor').subscribe({
+ next: (newRole) => {
+ console.log(`Employed ${unitToImport.convenor.name} in ${newUnit.code}`);
+ newUnit.changeMainConvenor(newRole).subscribe({
+ next: () => {
+ console.log(
+ `Set ${unitToImport.convenor.name} as main convenor in ${newUnit.code}`,
+ );
+ },
+ error: (failure) => {
+ console.log(failure);
+ },
+ });
+ },
+ error: (failure) => {
+ console.log(failure);
+ },
+ });
+ }
+ this.importUnit(idx + 1);
+ },
+ error: (failure) => {
+ console.log(failure);
+ unitToImport.done = false;
+ this.importUnit(idx + 1);
+ },
+ });
}
private createNewUnit(unitToImport: UnitImportData, idx: number) {
diff --git a/src/app/api/models/campus/campus.ts b/src/app/api/models/campus/campus.ts
index 164b3704f6..9491e29e53 100644
--- a/src/app/api/models/campus/campus.ts
+++ b/src/app/api/models/campus/campus.ts
@@ -7,6 +7,7 @@ export class Campus extends Entity {
name: string;
mode: campusModes;
abbreviation: string;
+ timezone: string;
public override toJson(mappingData: EntityMapping, ignoreKeys?: string[]): object {
return {
diff --git a/src/app/api/models/d2l/d2l_assessment_mapping.service.ts b/src/app/api/models/d2l/d2l_assessment_mapping.service.ts
new file mode 100644
index 0000000000..3f2fe47087
--- /dev/null
+++ b/src/app/api/models/d2l/d2l_assessment_mapping.service.ts
@@ -0,0 +1,23 @@
+import {Injectable} from '@angular/core';
+import {EntityService} from 'ngx-entity-service';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {HttpClient} from '@angular/common/http';
+import {D2lAssessmentMapping} from './d2l_assessment_mapping';
+import {Unit} from '../doubtfire-model';
+
+@Injectable()
+export class D2lAssessmentMappingService extends EntityService {
+ protected readonly endpointFormat = 'units/:unitId:/d2l/:id:';
+
+ constructor(httpClient: HttpClient) {
+ super(httpClient, API_URL);
+
+ this.mapping.addKeys('id', 'orgUnitId', 'gradeObjectId');
+
+ this.mapping.mapAllKeysToJsonExcept('id');
+ }
+
+ public createInstanceFrom(_json: object, other: Unit): D2lAssessmentMapping {
+ return new D2lAssessmentMapping(other);
+ }
+}
diff --git a/src/app/api/models/d2l/d2l_assessment_mapping.ts b/src/app/api/models/d2l/d2l_assessment_mapping.ts
new file mode 100644
index 0000000000..ac228bdbb6
--- /dev/null
+++ b/src/app/api/models/d2l/d2l_assessment_mapping.ts
@@ -0,0 +1,15 @@
+import {Entity} from 'ngx-entity-service';
+import {Unit} from '../unit';
+
+export class D2lAssessmentMapping extends Entity {
+ id: number;
+ unit: Unit;
+
+ orgUnitId: string;
+ gradeObjectId: string;
+
+ constructor(unit: Unit) {
+ super();
+ this.unit = unit;
+ }
+}
diff --git a/src/app/api/models/discussion-prompt.ts b/src/app/api/models/discussion-prompt.ts
new file mode 100644
index 0000000000..e984847084
--- /dev/null
+++ b/src/app/api/models/discussion-prompt.ts
@@ -0,0 +1,59 @@
+import {Entity} from 'ngx-entity-service';
+import {AppInjector} from 'src/app/app-injector';
+import {AlertService} from 'src/app/common/services/alert.service';
+import {DiscussionPromptService} from '../services/discussion-prompt.service';
+import {Project, TaskDefinition, Unit, User} from './doubtfire-model';
+
+export class DiscussionPrompt extends Entity {
+ id: number;
+ unit: Unit;
+ taskDefinition: TaskDefinition;
+ project: Project | null;
+ createdBy: User;
+ content: string;
+ priority: number;
+ discussedAt: Date;
+
+ public readonly PRIORITY = {
+ 1: 'Low',
+ 2: 'Medium',
+ 3: 'High',
+ } as const;
+
+ constructor(data?: Project | TaskDefinition | Unit) {
+ super();
+ if (data) {
+ if (data instanceof Project) {
+ this.project = data;
+ } else if (data instanceof TaskDefinition) {
+ this.taskDefinition = data;
+ } else if (data instanceof Unit) {
+ this.unit = data;
+ }
+ } else {
+ console.error('Failed to get project');
+ }
+ }
+
+ public get priorityLabel() {
+ return this.PRIORITY[this.priority] ?? this.priority;
+ }
+
+ public delete() {
+ const discussionPromptService: DiscussionPromptService =
+ AppInjector.get(DiscussionPromptService);
+ discussionPromptService
+ .delete(
+ {task_definition_id: this.taskDefinition.id, id: this.id},
+ {cache: this.taskDefinition.discussionPromptsCache},
+ )
+ .subscribe({
+ next: (_response: object) => {
+ AppInjector.get(AlertService).success('Successfully deleted discussion note', 4000);
+ },
+ error: (error: any) => {
+ AppInjector.get(AlertService).error(error?.message || error || 'Unknown error', 2000);
+ },
+ });
+ }
+}
diff --git a/src/app/api/models/doubtfire-model.ts b/src/app/api/models/doubtfire-model.ts
index 3cb4911083..ed485c939a 100644
--- a/src/app/api/models/doubtfire-model.ts
+++ b/src/app/api/models/doubtfire-model.ts
@@ -32,6 +32,12 @@ export * from './task-comment/discussion-comment';
export * from '../services/task-outcome-alignment.service';
export * from './task-similarity';
export * from './tii-action';
+export * from './scorm-datamodel';
+export * from './scorm-player-context';
+export * from './test-attempt';
+export * from './task-comment/scorm-comment';
+export * from './task-comment/scorm-extension-comment';
+export * from './feedback-template';
// Users -- are students or staff
export * from './user/user';
@@ -39,7 +45,6 @@ export * from './user/user';
// WebCal -- calendars used to track task due dates
export * from './webcal/webcal';
-
export * from '../services/authentication.service';
export * from '../services/unit.service';
export * from '../services/project.service';
@@ -56,3 +61,6 @@ export * from '../services/teaching-period-break.service';
export * from '../services/learning-outcome.service';
export * from '../services/group-set.service';
export * from '../services/task-similarity.service';
+export * from '../services/test-attempt.service';
+export * from '../models/d2l/d2l_assessment_mapping.service';
+export * from '../services/feedback-template.service';
diff --git a/src/app/api/models/feedback-template.ts b/src/app/api/models/feedback-template.ts
new file mode 100644
index 0000000000..1634cb70d6
--- /dev/null
+++ b/src/app/api/models/feedback-template.ts
@@ -0,0 +1,72 @@
+import {Entity, EntityMapping} from 'ngx-entity-service';
+import {Observable, tap} from 'rxjs';
+import {AppInjector} from 'src/app/app-injector';
+import {FeedbackTemplateService} from '../services/feedback-template.service';
+
+export class FeedbackTemplate extends Entity {
+ id: number;
+ type: 'group' | 'template';
+ chipText: string;
+ description: string;
+ commentText: string;
+ summaryText: string;
+ taskStatus: 'fix_and_resubmit' | 'discuss' | 'redo' | 'complete' | 'feedback_exceeded';
+ parentChipId: number;
+ learningOutcomeId: number;
+
+ public save(): Observable {
+ const svc = AppInjector.get(FeedbackTemplateService);
+
+ if (this.isNew) {
+ return svc
+ .create({}, {entity: this, endpointFormat: FeedbackTemplateService.addEndpoint})
+ .pipe(
+ tap((response: FeedbackTemplate) => {
+ Object.assign(this, response);
+ }),
+ );
+ } else {
+ return svc
+ .update(
+ {id: this.id},
+ {entity: this, endpointFormat: FeedbackTemplateService.updateEndpoint},
+ )
+ .pipe(
+ tap((response: FeedbackTemplate) => {
+ Object.assign(this, response);
+ }),
+ );
+ }
+ }
+
+ private originalSaveData: string;
+
+ public get hasOriginalSaveData(): boolean {
+ return this.originalSaveData !== undefined && this.originalSaveData !== null;
+ }
+
+ public setOriginalSaveData(mapping: EntityMapping) {
+ this.originalSaveData = JSON.stringify(this.toJson(mapping));
+ }
+
+ public hasChanges(mapping: EntityMapping): boolean {
+ if (!this.originalSaveData) {
+ return false;
+ }
+
+ return this.originalSaveData != JSON.stringify(this.toJson(mapping));
+ }
+
+ public get isNew(): boolean {
+ return !this.id;
+ }
+
+ public delete(): Observable {
+ const svc = AppInjector.get(FeedbackTemplateService);
+
+ return svc.delete(
+ {id: this.id},
+ {entity: this, endpointFormat: FeedbackTemplateService.updateEndpoint},
+ );
+ }
+}
diff --git a/src/app/api/models/learning-outcome.ts b/src/app/api/models/learning-outcome.ts
index 40a19d893a..dfdc55fa19 100644
--- a/src/app/api/models/learning-outcome.ts
+++ b/src/app/api/models/learning-outcome.ts
@@ -1,12 +1,158 @@
-import { Entity } from 'ngx-entity-service';
-
+import {Entity, EntityMapping} from 'ngx-entity-service';
+import {Observable, tap} from 'rxjs';
+import {AppInjector} from 'src/app/app-injector';
+import {LearningOutcomeService, TaskDefinition, Unit} from './doubtfire-model';
+import {DoubtfireConstants} from 'src/app/config/constants/doubtfire-constants';
export class LearningOutcome extends Entity {
-
id: number;
- iloNumber: number;
+ contextType: string;
+ contextId: number;
abbreviation: string;
- name: string;
- description: string;
+ shortDescription: string;
+ fullOutcomeDescription: string;
+ linkedOutcomeIds: number[] = [];
+
+ context?: TaskDefinition | Unit;
+
+ private readonly contextTypePath = {
+ 'Unit': 'units',
+ 'TaskDefinition': 'task_definitions',
+ 'Course': 'courses',
+ };
+
+ public save(): Observable {
+ const svc = AppInjector.get(LearningOutcomeService);
+
+ if (this.context) {
+ if (this.isNew) {
+ return svc
+ .create(
+ {
+ contextType: this.contextTypePath[this.contextType],
+ contextId: this.contextId,
+ },
+ {
+ entity: this,
+ cache: this.context.learningOutcomesCache,
+ },
+ )
+ .pipe(
+ tap((response: LearningOutcome) => {
+ Object.assign(this, response);
+ }),
+ );
+ } else {
+ return svc
+ .update(
+ {
+ contextType: this.contextTypePath[this.contextType],
+ contextId: this.contextId,
+ id: this.id,
+ },
+ {
+ entity: this,
+ cache: this.context.learningOutcomesCache,
+ endpointFormat: LearningOutcomeService.updateEndpoint,
+ },
+ )
+ .pipe(
+ tap((response: LearningOutcome) => {
+ Object.assign(this, response);
+ }),
+ );
+ }
+ } else {
+ // GLO
+ if (this.isNew) {
+ return svc
+ .create({}, {entity: this, endpointFormat: LearningOutcomeService.globalEndpoint})
+ .pipe(
+ tap((response: LearningOutcome) => {
+ Object.assign(this, response);
+ }),
+ );
+ } else {
+ return svc
+ .update(
+ {
+ id: this.id,
+ },
+ {
+ entity: this,
+ endpointFormat: LearningOutcomeService.updateGlobalEndpoint,
+ },
+ )
+ .pipe(
+ tap((response: LearningOutcome) => {
+ Object.assign(this, response);
+ }),
+ );
+ }
+ }
+ }
+
+ private originalSaveData: string;
+
+ public get hasOriginalSaveData(): boolean {
+ return this.originalSaveData !== undefined && this.originalSaveData !== null;
+ }
+
+ /**
+ * To check if things have changed, we need to get the initial save data... as it
+ * isn't empty by default. We can then use
+ * this to check if there are changes.
+ *
+ * @param mapping the mapping to get changes
+ */
+ public setOriginalSaveData(mapping: EntityMapping) {
+ this.originalSaveData = JSON.stringify(this.toJson(mapping));
+ }
+
+ public hasChanges(mapping: EntityMapping): boolean {
+ if (!this.originalSaveData) {
+ return false;
+ }
+
+ return this.originalSaveData != JSON.stringify(this.toJson(mapping));
+ }
+
+ public get isNew(): boolean {
+ return !this.id;
+ }
+
+ public delete(): Observable {
+ const svc = AppInjector.get(LearningOutcomeService);
+
+ if (this.context) {
+ return svc.delete(
+ {
+ contextType: this.contextTypePath[this.contextType],
+ contextId: this.contextId,
+ id: this.id,
+ },
+ {
+ entity: this,
+ cache: this.context.learningOutcomesCache,
+ endpointFormat: LearningOutcomeService.updateEndpoint,
+ },
+ );
+ } else {
+ // GLO
+ return svc.delete(
+ {
+ id: this.id,
+ },
+ {
+ entity: this,
+ endpointFormat: LearningOutcomeService.updateGlobalEndpoint,
+ },
+ );
+ }
+ }
+ public getFeedbackTemplateBatchUploadUrl(): string {
+ const constants = AppInjector.get(DoubtfireConstants);
+ return `${constants.API_URL}/${this.contextTypePath[this.contextType]}/${this.contextId}/outcomes/${this.id}/feedback_chips/csv`;
+ }
}
diff --git a/src/app/api/models/marking-session.ts b/src/app/api/models/marking-session.ts
new file mode 100644
index 0000000000..8bfbe3a446
--- /dev/null
+++ b/src/app/api/models/marking-session.ts
@@ -0,0 +1,40 @@
+import {Entity, EntityMapping} from 'ngx-entity-service';
+import {User} from './doubtfire-model';
+import {Unit} from './unit';
+
+export class MarkingSession extends Entity {
+ id: number;
+
+ // Marking tutor
+ user: User;
+
+ unit: Unit;
+
+ startTime: Date;
+ endTime: Date;
+ duringTutorial: boolean;
+ durationMinutes: number;
+
+ // Aggregated session activities count
+ commentsAdded: number;
+ assessments: number;
+ submissionsOpened: number;
+
+ constructor(data?: Unit) {
+ super();
+ if (data) {
+ this.unit = data;
+ } else {
+ console.error('Failed to get unit');
+ }
+ }
+
+ public override toJson(
+ mappingData: EntityMapping,
+ ignoreKeys?: string[],
+ ): object {
+ return {
+ markingSession: super.toJson(mappingData, ignoreKeys),
+ };
+ }
+}
diff --git a/src/app/api/models/overseer/overseer-assessment.ts b/src/app/api/models/overseer/overseer-assessment.ts
index 7ca6d62464..a41bcbb5d2 100644
--- a/src/app/api/models/overseer/overseer-assessment.ts
+++ b/src/app/api/models/overseer/overseer-assessment.ts
@@ -1,30 +1,63 @@
-import { Entity, EntityMapping } from 'ngx-entity-service';
+import {Entity, EntityCache, EntityMapping} from 'ngx-entity-service';
+import {AppInjector} from 'src/app/app-injector';
+import {DoubtfireConstants} from 'src/app/config/constants/doubtfire-constants';
+import {Task} from '../doubtfire-model';
+import {OverseerStepResult} from './overseer-step-result';
export class OverseerAssessment extends Entity {
id: number;
+ // overseerStepId: number;
timestamp: Date;
timestampString: string;
- content?: [{ label: string; result: string }];
- task?: any;
- taskStatus?: any;
- submissionStatus?: any;
- createdAt?: any;
- updatedAt?: any;
- taskId?: any;
+ content?: [{label: string; result: string}];
+ task?: Task;
+ taskStatus?: string;
+ submissionStatus?: 'queued' | 'executing' | 'passed' | 'failed' | 'error';
+ createdAt?: Date;
+ updatedAt?: Date;
+ taskId?: number;
+
+ totalSteps: number;
+ passedSteps: number;
label: string;
+ hasSubmissionFiles?: boolean;
+
+ public readonly stepResultsCache: EntityCache =
+ new EntityCache();
- constructor(task?: object) {
+ constructor(task?: Task) {
super();
- if ( task ) {
+ if (task) {
this.task = task;
}
}
- public override toJson(mappingData: EntityMapping, ignoreKeys?: string[]): object {
+ public override toJson(
+ mappingData: EntityMapping,
+ ignoreKeys?: string[],
+ ): object {
return {
- overseer_assessment: super.toJson(mappingData, ignoreKeys)
+ overseer_assessment: super.toJson(mappingData, ignoreKeys),
};
}
+
+ public get stepsSkipped() {
+ return this.task?.definition.overseerStepsCache.currentValues.filter(
+ (step) =>
+ !this.stepResultsCache.currentValues.find((result) => result.overseerStepId === step.id),
+ );
+ }
+
+ public get reportReady() {
+ return this.submissionStatus === 'passed' || this.submissionStatus === 'failed';
+ }
+
+ public submissionFilesUrl(): string {
+ const constants = AppInjector.get(DoubtfireConstants);
+ const timestamp =
+ this.timestampString ?? Math.floor(this.timestamp.getTime() / 1000).toString();
+ return `${constants.API_URL}/projects/${this.task.project.id}/task_def_id/${this.task.definition.id}/submissions/timestamps/${timestamp}/files`;
+ }
}
diff --git a/src/app/api/models/overseer/overseer-step-result.ts b/src/app/api/models/overseer/overseer-step-result.ts
new file mode 100644
index 0000000000..2a44371825
--- /dev/null
+++ b/src/app/api/models/overseer/overseer-step-result.ts
@@ -0,0 +1,35 @@
+import {Entity, EntityMapping} from 'ngx-entity-service';
+import {OverseerAssessment} from './overseer-assessment';
+import {OverseerStep} from './overseer-step';
+
+export class OverseerStepResult extends Entity {
+ id: number;
+ overseerAssessment: OverseerAssessment;
+ overseerStep: OverseerStep;
+ overseerStepId: number;
+
+ exitStatus: number;
+ pass: boolean;
+ stdout: string;
+ stdin: string;
+ expectedOutput: string;
+ stdoutSha256: string;
+ stdinSha256: string;
+ expectedOutputSha256: string;
+ feedbackMessage: string;
+
+ constructor(oa?: OverseerAssessment, os?: OverseerStep) {
+ super();
+ this.overseerAssessment = oa;
+ // this.overseerStep = os;
+ }
+
+ public override toJson(
+ mappingData: EntityMapping,
+ ignoreKeys?: string[],
+ ): object {
+ return {
+ overseer_step_result: super.toJson(mappingData, ignoreKeys),
+ };
+ }
+}
diff --git a/src/app/api/models/overseer/overseer-step.ts b/src/app/api/models/overseer/overseer-step.ts
new file mode 100644
index 0000000000..6fa14bf1bf
--- /dev/null
+++ b/src/app/api/models/overseer/overseer-step.ts
@@ -0,0 +1,77 @@
+import {Entity, EntityMapping} from 'ngx-entity-service';
+import {TaskDefinition} from '../task-definition';
+import {TaskStatus, TaskStatusEnum} from '../task-status';
+import {OverseerStepService} from '../../services/overseer-step.service';
+import {AppInjector} from 'src/app/app-injector';
+import {AlertService} from 'src/app/common/services/alert.service';
+
+export class OverseerStep extends Entity {
+ id: number;
+ taskDefinition: TaskDefinition;
+
+ name: string;
+ description: string;
+
+ // Shown to the student's
+ displayName: string;
+ displayDescription: string;
+
+ runCommand: string;
+ decodedRunCommand: string;
+
+ commandLanguage: string;
+ timeout: number;
+ sortOrder: number;
+ stepType: 'status_check' | 'output_diff';
+ partialOutputDiff: boolean;
+ stdinInputFile: string;
+ expectedOutputFile: string;
+
+ feedbackMessage: string;
+ statusOnSuccess: TaskStatusEnum | 'no_change';
+ statusOnFailure: TaskStatusEnum | 'no_change';
+
+ haltOnSuccess: boolean;
+ haltOnFailure: boolean;
+
+ showExpectedOutput: boolean;
+ showStdin: boolean;
+ showStdout: boolean;
+
+ enabled: boolean;
+
+ // showStdOutToStudent: boolean
+
+ constructor(td?: TaskDefinition) {
+ super();
+ this.taskDefinition = td;
+ }
+
+ public override toJson(
+ mappingData: EntityMapping,
+ ignoreKeys?: string[],
+ ): object {
+ return {
+ overseer_step: super.toJson(mappingData, ignoreKeys),
+ };
+ }
+
+ public delete() {
+ const overseerStepService: OverseerStepService = AppInjector.get(OverseerStepService);
+ overseerStepService
+ .delete(
+ {
+ id: this.id,
+ },
+ {cache: this.taskDefinition.overseerStepsCache, endpointFormat: 'overseer_steps/:id:'},
+ )
+ .subscribe({
+ next: (_response: object) => {
+ AppInjector.get(AlertService).success('Successfully deleted overseer step', 4000);
+ },
+ error: (error) => {
+ AppInjector.get(AlertService).error(error?.message || error || 'Unknown error', 2000);
+ },
+ });
+ }
+}
diff --git a/src/app/api/models/project.ts b/src/app/api/models/project.ts
index bde396b74b..b799ed01d6 100644
--- a/src/app/api/models/project.ts
+++ b/src/app/api/models/project.ts
@@ -23,6 +23,7 @@ import {
} from './doubtfire-model';
import { TaskOutcomeAlignment } from './task-outcome-alignment';
import { AlertService } from 'src/app/common/services/alert.service';
+import { StaffNote } from './staff-note';
export class Project extends Entity {
public id: number;
@@ -38,9 +39,13 @@ export class Project extends Entity {
public portfolioAvailable: boolean;
public usesDraftLearningSummary: boolean;
+ public specConDays: number = 0;
+
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 portfolioSubmissionDate: Date;
public taskStats: {
key: TaskStatusEnum;
@@ -50,6 +55,7 @@ export class Project extends Entity {
public burndownChartData: { key: string; values: number[] }[];
public readonly taskCache: EntityCache = new EntityCache();
+ public readonly staffNoteCache: EntityCache = new EntityCache();
public readonly tutorialEnrolmentsCache: EntityCache = new EntityCache();
public readonly groupCache: EntityCache = new EntityCache();
public readonly taskOutcomeAlignmentsCache: EntityCache =
@@ -60,6 +66,8 @@ export class Project extends Entity {
public similarityFlag: boolean = false;
+ public staffNoteCount: number;
+
public constructor(unit?: Unit) {
super();
this.unit = unit;
@@ -177,13 +185,13 @@ export class Project extends Entity {
public calcTopTasks() {
// We will assign current weight to tasks...
- var currentWeight: number = 0;
+ let currentWeight: number = 0;
// Assign weights to tasks in final state - complete, fail, etc
const sortedCompletedTasks: Task[] = this.taskCache.currentValues
.filter((task) => task.inFinalState())
.sort((a, b) => a.definition.seq - b.definition.seq)
- .sort((a, b) => a.definition.startDate.getTime() - b.definition.startDate.getTime());
+ .sort((a, b) => a.startDate.getTime() - b.startDate.getTime());
sortedCompletedTasks.forEach((task) => {
task.topWeight = currentWeight;
@@ -193,8 +201,8 @@ export class Project extends Entity {
// Sort valid top tasks by start date - tasks in non-final state
const sortedTasks: Task[] = this.taskCache.currentValues
.filter((task) => task.isValidTopTask())
- .sort((a, b) => a.definition.seq - b.definition.seq)
- .sort((a, b) => a.definition.startDate.getTime() - b.definition.startDate.getTime());
+ .sort((a, b) => a.startDate.getTime() - b.startDate.getTime())
+ .sort((a, b) => a.definition.seq - b.definition.seq);
const overdueTasks: Task[] = sortedTasks.filter((task) => task.daysUntilDueDate() <= 7);
@@ -215,7 +223,7 @@ export class Project extends Entity {
const toAdd: Task[] = sortedTasks
.filter((task) => task.daysUntilDueDate() > 7)
.sort((a, b) => a.definition.targetGrade - b.definition.targetGrade)
- .sort((a, b) => a.definition.startDate.getTime() - b.definition.startDate.getTime());
+ .sort((a, b) => a.startDate.getTime() - b.startDate.getTime());
// Sort by the targetGrade. Pass task are done first if same due date as others.
@@ -229,7 +237,7 @@ export class Project extends Entity {
public assignGrade(score: number, rationale: string): void {
const alerts = AppInjector.get(AlertService);
const projectService: ProjectService = AppInjector.get(ProjectService);
- const oldGrade: number = this.grade;
+ const oldGrade: number = this.grade || 0;
this.grade = score;
this.gradeRationale = rationale;
@@ -407,7 +415,7 @@ export class Project extends Entity {
const tasks = this.tasks;
const readyOrCompleteTasks = tasks.filter((task) =>
- ['ready_for_feedback', 'discuss', 'demonstrate', 'complete'].includes(task.status),
+ ['ready_for_feedback', 'discuss', 'demonstrate', 'complete', 'assess_in_portfolio'].includes(task.status),
);
let lastTargetDate: Date;
@@ -513,4 +521,35 @@ export class Project extends Entity {
this.burndownChartData = result;
}
+
+ public applySpecCon(days: number): Observable {
+ const projectService: ProjectService = AppInjector.get(ProjectService);
+ return projectService.update(this, {body: {spec_con_days: days}, endpointFormat: 'projects/:id:/spec_con'}).pipe(
+ tap((project: Project) => {
+ project.specConDays = days;
+ }),
+ );
+ }
+
+ public tasksIncludedInPortfolioUrl(): string {
+ return `${AppInjector.get(DoubtfireConstants).API_URL}/projects/${this.id}/portfolio_tasks`;
+ }
+
+ public getTasksIncludedInPortfolio(): Observable {
+ const httpClient = AppInjector.get(HttpClient);
+ return httpClient.get(this.tasksIncludedInPortfolioUrl());
+ }
+
+ public resetTargetDates(): Observable {
+ const projectService: ProjectService = AppInjector.get(ProjectService);
+ return projectService.update(
+ {
+ projectId: this.id,
+ },
+ {
+ endpointFormat: '/projects/:projectId:/reset_target_dates',
+ entity: this,
+ },
+ );
+ }
}
diff --git a/src/app/api/models/scorm-datamodel.ts b/src/app/api/models/scorm-datamodel.ts
new file mode 100644
index 0000000000..0fdc2d3a06
--- /dev/null
+++ b/src/app/api/models/scorm-datamodel.ts
@@ -0,0 +1,50 @@
+export class ScormDataModel {
+ dataModel: {[key: string]: any} = {};
+ readonly msgPrefix = 'SCORM DataModel: ';
+
+ constructor() {
+ this.dataModel = {};
+ }
+
+ public restore(dataModel: string) {
+ // console.log(this.msgPrefix + 'restoring DataModel with provided data');
+ this.dataModel = JSON.parse(dataModel);
+ }
+
+ public get(key: string): string {
+ // console.log(`SCORM DataModel: get ${key} ${this.dataModel[key]}`);
+ return this.dataModel[key] ?? '';
+ }
+
+ public dump(): {[key: string]: any} {
+ return this.dataModel;
+ }
+
+ public set(key: string, value: any): string {
+ // console.log(this.msgPrefix + 'set: ', key, value);
+ this.dataModel[key] = value;
+ if (key.match('cmi.interactions.\\d+.id')) {
+ // cmi.interactions._count must be incremented after a new interaction is created
+ const interactionPath = key.match('cmi.interactions.\\d+');
+ const objectivesCounterForInteraction = interactionPath.toString() + '.objectives._count';
+ // console.log('Incrementing cmi.interactions._count');
+ this.dataModel['cmi.interactions._count']++;
+ // cmi.interactions.n.objectives._count must be initialized after an interaction is created
+ // console.log(`Initializing ${objectivesCounterForInteraction}`);
+ this.dataModel[objectivesCounterForInteraction] = 0;
+ }
+ if (key.match('cmi.interactions.\\d+.objectives.\\d+.id')) {
+ const interactionPath = key.match('cmi.interactions.\\d+.objectives');
+ const objectivesCounterForInteraction = interactionPath.toString() + '._count';
+ // cmi.interactions.n.objectives._count must be incremented after objective creation
+ // console.log(`Incrementing ${objectivesCounterForInteraction}`);
+ this.dataModel[objectivesCounterForInteraction.toString()]++;
+ }
+ if (key.match('cmi.objectives.\\d+.id')) {
+ // cmi.objectives._count must be incremented after a new objective is created
+ // console.log('Incrementing cmi.objectives._count');
+ this.dataModel['cmi.objectives._count']++;
+ }
+ return 'true';
+ }
+}
diff --git a/src/app/api/models/scorm-player-context.ts b/src/app/api/models/scorm-player-context.ts
new file mode 100644
index 0000000000..e8eed9b12e
--- /dev/null
+++ b/src/app/api/models/scorm-player-context.ts
@@ -0,0 +1,66 @@
+import {User} from 'src/app/api/models/doubtfire-model';
+
+type DataModelState = 'Uninitialized' | 'Initialized' | 'Terminated';
+
+type DataModelError = Record;
+const CMIErrorCodes: DataModelError = {
+ 0: 'No Error',
+ 101: 'General Exception',
+ 102: 'General Initialization Failure',
+ 103: 'Already Initialized',
+ 104: 'Content Instance Terminated',
+ 111: 'General Termination Failure',
+ 112: 'Termination Before Initialization',
+ 113: 'Termination After Termination',
+ 122: 'Retrieve Data Before Initialization',
+ 123: 'Retrieve Data After Termination',
+ 132: 'Store Data Before Initialization',
+ 133: 'Store Data After Termination',
+ 142: 'Commit Before Initialization',
+ 143: 'Commit After Termination',
+ 201: 'General Argument Error',
+ 301: 'General Get Failure',
+ 351: 'General Set Failure',
+ 391: 'General Commit Failure',
+ 401: 'Undefined Data Model Element',
+ 402: 'Unimplemented Data Model Element',
+ 403: 'Data Model Element Value Not Initialized',
+ 404: 'Data Model Element Is Read Only',
+ 405: 'Data Model Element Is Write Only',
+ 406: 'Data Model Element Type Mismatch',
+ 407: 'Data Model Element Value Out Of Range',
+ 408: 'Data Model Dependency Not Established',
+};
+
+export class ScormPlayerContext {
+ mode: 'browse' | 'normal' | 'review' | 'preview';
+ state: DataModelState;
+
+ private _errorCode: number;
+ get errorCode() {
+ return this._errorCode;
+ }
+ set errorCode(value: number) {
+ this._errorCode = value;
+ }
+
+ getErrorMessage(value: string): string {
+ return CMIErrorCodes[value];
+ }
+
+ projectId: number;
+ taskDefId: number;
+ user: User;
+
+ attemptId: number;
+ learnerName: string;
+ learnerId: number;
+
+ constructor(user: User) {
+ this.user = user;
+ this.learnerId = user.id;
+ this.learnerName = user.firstName + ' ' + user.lastName;
+ this.state = 'Uninitialized';
+ this.errorCode = 0;
+ }
+}
diff --git a/src/app/api/models/sidekiq-job.ts b/src/app/api/models/sidekiq-job.ts
new file mode 100644
index 0000000000..127db2062e
--- /dev/null
+++ b/src/app/api/models/sidekiq-job.ts
@@ -0,0 +1,19 @@
+import {Entity} from 'ngx-entity-service';
+
+export class SidekiqJob extends Entity {
+ id: string;
+ status: 'queued' | 'working' | 'retrying' | 'complete' | 'stopped' | 'failed' | 'interrupted';
+ message?: string;
+
+ pctComplete: number;
+ processedCount?: number;
+ totalCount?: number;
+
+ jobClass: string; // name of the job, eg "StudentImportJob"
+
+ // Custom data unique to each job
+ result?: string;
+
+ createdAt: number;
+ updatedAt: number;
+}
diff --git a/src/app/api/models/staff-note.ts b/src/app/api/models/staff-note.ts
new file mode 100644
index 0000000000..bcd1b00e34
--- /dev/null
+++ b/src/app/api/models/staff-note.ts
@@ -0,0 +1,54 @@
+import {Entity} from 'ngx-entity-service';
+import {Project, Unit, User, UserService} from './doubtfire-model';
+import {AppInjector} from 'src/app/app-injector';
+import {AlertService} from 'src/app/common/services/alert.service';
+import {StaffNoteService} from '../services/staff-note.service';
+
+export class StaffNote extends Entity {
+ id: number;
+
+ project: Project;
+ user: User;
+ note: string;
+ replyTo?: StaffNote;
+ replyToId: number;
+ createdAt: Date;
+ updatedAt: Date;
+
+ constructor(data?: Project) {
+ super();
+ if (data) {
+ this.project = data;
+ } else {
+ console.error('Failed to get project');
+ }
+ }
+
+ /**
+ * Provide the project id to allow mapping in service.
+ */
+ public get projectId(): number {
+ return this.project.id;
+ }
+
+ public get authorIsMe(): boolean {
+ const userService: UserService = AppInjector.get(UserService);
+ return this.user.id === userService.currentUser.id;
+ }
+
+ public delete() {
+ const staffNoteService: StaffNoteService = AppInjector.get(StaffNoteService);
+ staffNoteService
+ .delete({projectId: this.project.id, id: this.id}, {cache: this.project.staffNoteCache})
+ .subscribe({
+ next: (response: object) => {
+ AppInjector.get(AlertService).error('Successfully deleted staff note', 4000);
+ this.project.staffNoteCount--;
+ staffNoteService.updateStaffNoteReplies(this.project.staffNoteCache.currentValues);
+ },
+ error: (error: any) => {
+ AppInjector.get(AlertService).error(error?.message || error || 'Unknown error', 2000);
+ },
+ });
+ }
+}
diff --git a/src/app/api/models/task-comment/scorm-comment.ts b/src/app/api/models/task-comment/scorm-comment.ts
new file mode 100644
index 0000000000..b15a2c50c8
--- /dev/null
+++ b/src/app/api/models/task-comment/scorm-comment.ts
@@ -0,0 +1,12 @@
+import {Task, TaskComment, TestAttempt} from '../doubtfire-model';
+
+export class ScormComment extends TaskComment {
+ testAttempt: TestAttempt;
+
+ // UI rendering data
+ lastInScormSeries: boolean = false;
+
+ constructor(task: Task) {
+ super(task);
+ }
+}
diff --git a/src/app/api/models/task-comment/scorm-extension-comment.ts b/src/app/api/models/task-comment/scorm-extension-comment.ts
new file mode 100644
index 0000000000..b8aac7909b
--- /dev/null
+++ b/src/app/api/models/task-comment/scorm-extension-comment.ts
@@ -0,0 +1,33 @@
+import {Observable} from 'rxjs';
+import {tap} from 'rxjs/operators';
+import {AppInjector} from 'src/app/app-injector';
+import {TaskCommentService} from '../../services/task-comment.service';
+import {TaskComment, Task} from '../doubtfire-model';
+
+export class ScormExtensionComment extends TaskComment {
+ assessed: boolean;
+ granted: boolean;
+ dateAssessed: Date;
+ taskScormExtensions: number;
+
+ constructor(task: Task) {
+ super(task);
+ }
+
+ private assessScormExtension(): Observable {
+ const tcs: TaskCommentService = AppInjector.get(TaskCommentService);
+ return tcs.assessScormExtension(this).pipe(
+ tap((tc: TaskComment) => {
+ const scormExtension: ScormExtensionComment = tc as ScormExtensionComment;
+
+ const task = tc.task;
+ task.scormExtensions = scormExtension.taskScormExtensions;
+ }),
+ );
+ }
+
+ public grant(): Observable {
+ this.granted = true;
+ return this.assessScormExtension();
+ }
+}
diff --git a/src/app/api/models/task-comment/task-comment.ts b/src/app/api/models/task-comment/task-comment.ts
index 03b7ea4559..5d49c9ef9f 100644
--- a/src/app/api/models/task-comment/task-comment.ts
+++ b/src/app/api/models/task-comment/task-comment.ts
@@ -1,10 +1,10 @@
-import { AppInjector } from 'src/app/app-injector';
-import { Entity } from 'ngx-entity-service';
-import { Project, Task, TaskCommentService, User } from 'src/app/api/models/doubtfire-model';
-import { UserService } from '../../services/user.service';
-import API_URL from 'src/app/config/constants/apiURL';
-import { DoubtfireConstants } from 'src/app/config/constants/doubtfire-constants';
-import { AlertService } from 'src/app/common/services/alert.service';
+import {AppInjector} from 'src/app/app-injector';
+import {Entity} from 'ngx-entity-service';
+import {Project, Task, TaskCommentService, User} from 'src/app/api/models/doubtfire-model';
+import {UserService} from '../../services/user.service';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {DoubtfireConstants} from 'src/app/config/constants/doubtfire-constants';
+import {AlertService} from 'src/app/common/services/alert.service';
export class TaskComment extends Entity {
// Linked objects
@@ -19,7 +19,7 @@ export class TaskComment extends Entity {
recipient: User;
createdAt: Date;
recipientReadTime: string;
- commentType: string = "text";
+ commentType: string = 'text';
isNew: boolean;
replyToId: number;
@@ -68,7 +68,10 @@ export class TaskComment extends Entity {
public delete() {
const tcs: TaskCommentService = AppInjector.get(TaskCommentService);
tcs
- .delete({ projectId: this.project.id, taskDefinitionId: this.task.definition.id, id: this.id }, { cache: this.task.commentCache })
+ .delete(
+ {projectId: this.project.id, taskDefinitionId: this.task.definition.id, id: this.id},
+ {cache: this.task.commentCache},
+ )
.subscribe({
next: (response: object) => {
// this.task.comments = this.task.comments.filter((e: TaskComment) => e.id !== this.id);
@@ -76,12 +79,11 @@ export class TaskComment extends Entity {
},
error: (error: any) => {
AppInjector.get(AlertService).error(error?.message || error || 'Unknown error', 2000);
- }
- }
- );
+ },
+ });
}
public get attachmentUrl(): string {
- return `${AppInjector.get(DoubtfireConstants).API_URL}/projects/${this.project.id}/task_def_id/${this.task.definition.id}/comments/${this.id}?as_attachment=false`
+ return `${AppInjector.get(DoubtfireConstants).API_URL}/projects/${this.project.id}/task_def_id/${this.task.definition.id}/comments/${this.id}?as_attachment=false`;
}
}
diff --git a/src/app/api/models/task-definition.ts b/src/app/api/models/task-definition.ts
index 1b49a2e856..c8f88d1e9e 100644
--- a/src/app/api/models/task-definition.ts
+++ b/src/app/api/models/task-definition.ts
@@ -1,14 +1,25 @@
-import { HttpClient } from '@angular/common/http';
-import { Entity, EntityMapping } from 'ngx-entity-service';
-import { Observable, tap } from 'rxjs';
-import { AppInjector } from 'src/app/app-injector';
-import { DoubtfireConstants } from 'src/app/config/constants/doubtfire-constants';
-import { Grade, GroupSet, TutorialStream, Unit } from './doubtfire-model';
-import { TaskDefinitionService } from '../services/task-definition.service';
-
-export type UploadRequirement = { key: string; name: string; type: string; tiiCheck?: boolean; tiiPct?: number };
+import {HttpClient} from '@angular/common/http';
+import {Entity, EntityCache, EntityMapping} from 'ngx-entity-service';
+import {Observable, tap} from 'rxjs';
+import {AppInjector} from 'src/app/app-injector';
+import {AlertService} from 'src/app/common/services/alert.service';
+import {DoubtfireConstants} from 'src/app/config/constants/doubtfire-constants';
+import {TaskDefinitionService} from '../services/task-definition.service';
+import {Grade, GroupSet, LearningOutcome, Project, TutorialStream, Unit} from './doubtfire-model';
+import {Task} from './doubtfire-model';
+import {TaskPrerequisite} from './task-prerequisite';
+import {DiscussionPrompt} from './discussion-prompt';
+import {OverseerStep} from './overseer/overseer-step';
+
+export type UploadRequirement = {
+ key: string;
+ name: string;
+ type: string;
+ tiiCheck?: boolean;
+ tiiPct?: number;
+};
-export type SimilarityCheck = { key: string; type: string; pattern: string };
+export type SimilarityCheck = {key: string; type: string; pattern: string};
export class TaskDefinition extends Entity {
id: number;
@@ -21,7 +32,7 @@ export class TaskDefinition extends Entity {
targetDate: Date;
dueDate: Date;
startDate: Date;
- uploadRequirements: UploadRequirement[];
+ uploadRequirements: UploadRequirement[] = [];
tutorialStream: TutorialStream = null;
plagiarismChecks: SimilarityCheck[] = [];
plagiarismReportUrl: string;
@@ -31,12 +42,46 @@ export class TaskDefinition extends Entity {
groupSet: GroupSet = null;
hasTaskSheet: boolean;
hasTaskResources: boolean;
+ scormEnabled: boolean;
+ hasScormData: boolean;
+ scormAllowReview: boolean;
+ scormBypassTest: boolean;
+ scormTimeDelayEnabled: boolean;
+ scormAttemptLimit: number = 0;
hasTaskAssessmentResources: boolean;
+ hasTaskAssessmentScript: boolean;
isGraded: boolean;
maxQualityPts: number;
overseerImageId: number;
assessmentEnabled: boolean;
- mossLanguage: string = 'moss c';
+ similarityLanguage: string = 'c';
+ hasJplagReport: boolean;
+ assessInPortfolioOnly: boolean;
+ requiresDiscussion: boolean;
+ useResourcesForJplagBaseCode: boolean;
+ lockAssessmentsToTutorialStream: boolean;
+ discussionPromptsCount: number;
+ overseerResourceFiles: string[] = [];
+
+ // pTargetDate: Date;
+ cTargetDate: Date;
+ dTargetDate: Date;
+ hdTargetDate: Date;
+
+ cStartDate: Date;
+ dStartDate: Date;
+ hdStartDate: Date;
+
+ public readonly taskPrerequisitesCache: EntityCache =
+ new EntityCache();
+
+ public readonly discussionPromptsCache: EntityCache =
+ new EntityCache();
+
+ public readonly learningOutcomesCache: EntityCache =
+ new EntityCache();
+
+ public readonly overseerStepsCache: EntityCache = new EntityCache();
readonly unit: Unit;
@@ -67,7 +112,7 @@ export class TaskDefinition extends Entity {
entity: this,
cache: this.unit.taskDefinitionCache,
constructorParams: this.unit,
- }
+ },
);
} else {
return svc.update(
@@ -75,7 +120,7 @@ export class TaskDefinition extends Entity {
unitId: this.unit.id,
id: this.id,
},
- { entity: this }
+ {entity: this},
);
}
}
@@ -105,6 +150,21 @@ export class TaskDefinition extends Entity {
return this.originalSaveData != JSON.stringify(this.toJson(mapping));
}
+ public refresh(): void {
+ const alerts = AppInjector.get(AlertService);
+ AppInjector.get(TaskDefinitionService)
+ .fetch({
+ unitId: this.unit.id,
+ id: this.id,
+ })
+ .subscribe({
+ next: (taskDefinition) => {
+ console.log(taskDefinition.name);
+ },
+ error: (message) => alerts.error(message, 6000),
+ });
+ }
+
public get isNew(): boolean {
return !this.id;
}
@@ -121,8 +181,19 @@ export class TaskDefinition extends Entity {
return this.dueDate;
}
+ public get dueWeek(): number {
+ const startDate = this.unit.startDate;
+ const dueDate = this.localDueDate() || this.unit.endDate;
+
+ const diffInMs = dueDate.getTime() - startDate.getTime();
+ return Math.ceil(diffInMs / (1000 * 60 * 60 * 24 * 7)); // Convert ms to weeks
+ }
+
public matches(text: string): boolean {
- return this.abbreviation.toLowerCase().indexOf(text) !== -1 || this.name.toLowerCase().indexOf(text) !== -1;
+ return (
+ this.abbreviation.toLowerCase().indexOf(text) !== -1 ||
+ this.name.toLowerCase().indexOf(text) !== -1
+ );
}
/**
@@ -152,6 +223,30 @@ export class TaskDefinition extends Entity {
}`;
}
+ public getScormDataUrl(asAttachment: boolean = false) {
+ const constants = AppInjector.get(DoubtfireConstants);
+ return `${constants.API_URL}/units/${this.unit.id}/task_definitions/${this.id}/scorm_data.json${
+ asAttachment ? '?as_attachment=true' : ''
+ }`;
+ }
+
+ public getOutcomeBatchUploadUrl(): string {
+ const constants = AppInjector.get(DoubtfireConstants);
+ return `${constants.API_URL}/task_definitions/${this.id}/outcomes/csv`;
+ }
+
+ public getFeedbackTemplateBatchUploadUrl(): string {
+ const constants = AppInjector.get(DoubtfireConstants);
+ return `${constants.API_URL}/task_definitions/${this.id}/feedback_chips/csv`;
+ }
+
+ /**
+ * Open the SCORM test in a new tab - using preview mode.
+ */
+ public previewScormTest(): void {
+ window.open(`#/task_def_id/${this.id}/preview-scorm`, '_blank');
+ }
+
public get targetGradeText(): string {
return Grade.GRADES[this.targetGrade];
}
@@ -160,7 +255,7 @@ export class TaskDefinition extends Entity {
return this.plagiarismChecks?.length > 0;
}
- public get needsMoss(): boolean {
+ public get needsJplag(): boolean {
return this.uploadRequirements.some((upreq) => upreq.type === 'code' && upreq.tiiCheck);
}
@@ -176,18 +271,38 @@ export class TaskDefinition extends Entity {
}/task_resources`;
}
- public get taskAssessmentResourcesUploadUrl(): string {
+ public get scormDataUploadUrl(): string {
+ return `${AppInjector.get(DoubtfireConstants).API_URL}/units/${this.unit.id}/task_definitions/${
+ this.id
+ }/scorm_data`;
+ }
+
+ public get taskPrerequisiteUrl(): string {
+ return `${AppInjector.get(DoubtfireConstants).API_URL}/units/${this.unit.id}/task_definitions/${
+ this.id
+ }/prerequisites`;
+ }
+
+ public get taskOverseerResourcesUploadUrl(): string {
return `${AppInjector.get(DoubtfireConstants).API_URL}/units/${this.unit.id}/task_definitions/${
this.id
}/task_assessment_resources`;
}
- public getTaskAssessmentResourcesUrl(): string {
+ public getOverseerResourcesUrl(): string {
return `${AppInjector.get(DoubtfireConstants).API_URL}/units/${this.unit.id}/task_definitions/${
this.id
}/task_assessment_resources.json`;
}
+ public get taskOverseerExecutionScriptUrl() {
+ return `${AppInjector.get(DoubtfireConstants).API_URL}/units/${this.unit.id}/task_definitions/${this.id}/overseer_script`;
+ }
+
+ public getJplagReportUrl() {
+ return `${AppInjector.get(DoubtfireConstants).API_URL}/units/${this.unit.id}/task_definitions/${this.id}/jplag_report`;
+ }
+
public deleteTaskSheet(): Observable {
const httpClient = AppInjector.get(HttpClient);
return httpClient.delete(this.taskSheetUploadUrl).pipe(tap(() => (this.hasTaskSheet = false)));
@@ -195,13 +310,24 @@ export class TaskDefinition extends Entity {
public deleteTaskResources(): Observable {
const httpClient = AppInjector.get(HttpClient);
- return httpClient.delete(this.taskResourcesUploadUrl).pipe(tap(() => (this.hasTaskResources = false)));
+ return httpClient
+ .delete(this.taskResourcesUploadUrl)
+ .pipe(tap(() => (this.hasTaskResources = false)));
+ }
+
+ public deleteScormData(): Observable {
+ const httpClient = AppInjector.get(HttpClient);
+ return httpClient.delete(this.scormDataUploadUrl).pipe(tap(() => (this.hasScormData = false)));
}
- public deleteTaskAssessmentResources(): Observable {
+ public deleteOverseerResources(): Observable {
const httpClient = AppInjector.get(HttpClient);
return httpClient
- .delete(this.taskAssessmentResourcesUploadUrl)
+ .delete(this.taskOverseerResourcesUploadUrl)
.pipe(tap(() => (this.hasTaskAssessmentResources = false)));
}
+
+ public projectTask(project?: Project): Task | undefined {
+ return project?.tasks?.find((p) => p.definition.id === this.id);
+ }
}
diff --git a/src/app/api/models/task-prerequisite.ts b/src/app/api/models/task-prerequisite.ts
new file mode 100644
index 0000000000..9645adfe5b
--- /dev/null
+++ b/src/app/api/models/task-prerequisite.ts
@@ -0,0 +1,89 @@
+import {Entity, EntityMapping} from 'ngx-entity-service';
+import {Observable, tap} from 'rxjs';
+import {AppInjector} from 'src/app/app-injector';
+import {AlertService} from 'src/app/common/services/alert.service';
+import {TaskPrerequisiteService} from '../services/task-prerequisite.service';
+import {Project, TaskDefinition, TaskStatus, TaskStatusEnum} from './doubtfire-model';
+
+export class TaskPrerequisite extends Entity {
+ id: number;
+
+ prerequisite: TaskDefinition;
+ prerequisiteId: number;
+ taskStatusId: number;
+
+ // Minimum required status
+ taskStatus: TaskStatusEnum;
+
+ // Parent
+ taskDefinition: TaskDefinition;
+ taskDefinitionId: number;
+
+ public readonly STATES: Partial> = {
+ ready_for_feedback: 1,
+ assess_in_portfolio: 1,
+ discuss: 2,
+ attention_required: 0,
+ demonstrate: 2,
+ complete: 3,
+ };
+
+ constructor(json: any) {
+ super();
+ this.taskDefinitionId = json.taskDefinitionId;
+ this.prerequisiteId = json.prerequisiteId;
+ this.taskStatus = json.taskStatus;
+ }
+
+ public toJson(mappingData: EntityMapping, ignoreKeys?: string[]): object {
+ return {
+ task_prerequisite: super.toJson(mappingData, ignoreKeys),
+ };
+ }
+
+ public requiredStatusLabel() {
+ return TaskStatus.STATUS_LABELS.get(this.taskStatus);
+ }
+
+ public hasMetRequiredState(project: Project) {
+ if (!this.prerequisite || !project) {
+ return false;
+ }
+ const prerequisiteTask = this.prerequisite.projectTask(project);
+ if (!prerequisiteTask) {
+ return false;
+ }
+ const currentStatus = prerequisiteTask.status;
+ const requiredStatus = this.taskStatus;
+ if (this.STATES[currentStatus] >= this.STATES[requiredStatus]) {
+ return true;
+ }
+ return false;
+ }
+
+ public delete(): Observable {
+ const taskPrerequisiteService: TaskPrerequisiteService =
+ AppInjector.get(TaskPrerequisiteService);
+
+ return taskPrerequisiteService
+ .delete(
+ {
+ unitId: this.taskDefinition.unit.id,
+ taskDefId: this.taskDefinitionId,
+ prerequisiteId: this.prerequisiteId,
+ },
+ {cache: this.taskDefinition.taskPrerequisitesCache},
+ )
+ .pipe(
+ tap({
+ next: () => {
+ AppInjector.get(AlertService).error('Successfully deleted prerequisite', 4000);
+ this.taskDefinition.taskPrerequisitesCache.delete(this.id);
+ },
+ error: (error) => {
+ AppInjector.get(AlertService).error(error?.message || error || 'Unknown error', 2000);
+ },
+ }),
+ );
+ }
+}
diff --git a/src/app/api/models/task-similarity.ts b/src/app/api/models/task-similarity.ts
index c3a72e556f..cb9640966c 100644
--- a/src/app/api/models/task-similarity.ts
+++ b/src/app/api/models/task-similarity.ts
@@ -1,21 +1,26 @@
-import { Entity } from 'ngx-entity-service';
-import { AppInjector } from 'src/app/app-injector';
-import { Task, TaskSimilarityService } from './doubtfire-model';
-import { DoubtfireConstants } from 'src/app/config/constants/doubtfire-constants';
-import { Observable } from 'rxjs';
+import {Entity} from 'ngx-entity-service';
+import {AppInjector} from 'src/app/app-injector';
+import {Task, TaskSimilarityService, User} from './doubtfire-model';
+import {DoubtfireConstants} from 'src/app/config/constants/doubtfire-constants';
+import {Observable} from 'rxjs';
export enum TaskSimilarityType {
+ Jplag = 'JplagTaskSimilarity',
Moss = 'MossTaskSimilarity',
TurnItIn = 'TiiTaskSimilarity',
}
/**
* Represents teh format for a part of a similarity report for a task.
- * This is html for moss, and pdf for turn it in.
+ *
+ * HTML for moss
+ * PDF for TurnItIn
+ * jplag for JPlag
*/
export enum TaskSimilarityPartFormat {
Html = 'html',
Pdf = 'pdf',
+ Jplag = 'jplag',
}
export class TaskSimilarityPart {
@@ -36,6 +41,8 @@ export class TaskSimilarity extends Entity {
parts: TaskSimilarityPart[];
task: Task;
readyForViewer: boolean = false;
+ otherTask?: Task;
+ otherStudent?: User;
constructor(task: Task) {
super();
@@ -62,6 +69,8 @@ export class TaskSimilarity extends Entity {
public get friendlyTypeName(): string {
switch (this.type) {
+ case TaskSimilarityType.Jplag:
+ return 'JPLAG';
case TaskSimilarityType.Moss:
return 'MOSS';
case TaskSimilarityType.TurnItIn:
diff --git a/src/app/api/models/task-status.ts b/src/app/api/models/task-status.ts
index 0ab0f8f2d9..0933627924 100644
--- a/src/app/api/models/task-status.ts
+++ b/src/app/api/models/task-status.ts
@@ -1,4 +1,4 @@
-import { Task } from './task';
+import {Task} from './task';
export type TaskStatusEnum =
| 'not_started'
@@ -12,14 +12,16 @@ export type TaskStatusEnum =
| 'demonstrate'
| 'complete'
| 'fail'
- | 'time_exceeded';
+ | 'time_exceeded'
+ | 'assess_in_portfolio'
+ | 'attention_required';
export type TaskStatusUiData = {
status: TaskStatusEnum;
icon: string;
label: string;
class: string;
- help: { detail: string; reason: string; action: string };
+ help: {detail: string; reason: string; action: string};
};
export class TaskStatus {
@@ -36,6 +38,8 @@ export class TaskStatus {
'complete',
'fail',
'time_exceeded',
+ 'assess_in_portfolio',
+ 'attention_required',
];
public static readonly VALID_TOP_TASKS: TaskStatusEnum[] = [
@@ -46,6 +50,7 @@ export class TaskStatus {
'fix_and_resubmit',
'ready_for_feedback',
'discuss',
+ 'attention_required',
'demonstrate',
];
@@ -57,15 +62,37 @@ export class TaskStatus {
'complete',
'fail',
'time_exceeded',
+ 'assess_in_portfolio',
+ 'attention_required',
];
- public static readonly FINAL_STATUSES: TaskStatusEnum[] = ['complete', 'fail', 'feedback_exceeded', 'time_exceeded'];
+ public static readonly FINAL_STATUSES: TaskStatusEnum[] = [
+ 'complete',
+ 'fail',
+ 'feedback_exceeded',
+ 'time_exceeded',
+ 'assess_in_portfolio',
+ ];
- public static readonly GRADEABLE_STATUSES: TaskStatusEnum[] = ['fail', 'discuss', 'demonstrate', 'complete'];
+ public static readonly GRADEABLE_STATUSES: TaskStatusEnum[] = [
+ 'fail',
+ 'discuss',
+ 'demonstrate',
+ 'complete',
+ ];
- public static readonly TO_BE_WORKED_ON: TaskStatusEnum[] = ['not_started', 'redo', 'need_help', 'working_on_it'];
+ public static readonly TO_BE_WORKED_ON: TaskStatusEnum[] = [
+ 'not_started',
+ 'redo',
+ 'need_help',
+ 'working_on_it',
+ ];
- public static readonly DISCUSSION_STATES: TaskStatusEnum[] = ['discuss', 'demonstrate'];
+ public static readonly DISCUSSION_STATES: TaskStatusEnum[] = [
+ 'discuss',
+ 'attention_required',
+ 'demonstrate',
+ ];
public static readonly STATE_THAT_ALLOWS_EXTENSION: TaskStatusEnum[] = [
'not_started',
@@ -89,7 +116,11 @@ export class TaskStatus {
'redo',
];
- public static readonly SUBMITTABLE_STATUSES: TaskStatusEnum[] = ['ready_for_feedback', 'need_help'];
+ public static readonly SUBMITTABLE_STATUSES: TaskStatusEnum[] = [
+ 'ready_for_feedback',
+ 'need_help',
+ 'assess_in_portfolio',
+ ];
public static readonly MARKED_STATUSES: TaskStatusEnum[] = [
'redo',
@@ -99,9 +130,22 @@ export class TaskStatus {
'discuss',
'demonstrate',
'complete',
+ 'attention_required',
+ ];
+
+ public static readonly FEEDBACK_TEMPLATE_STATUSES: TaskStatusEnum[] = [
+ 'complete',
+ 'discuss',
+ 'fix_and_resubmit',
+ 'redo',
+ 'feedback_exceeded',
+ 'attention_required',
];
- public static readonly LEARNING_WEIGHT: Map = new Map([
+ public static readonly LEARNING_WEIGHT: Map = new Map<
+ TaskStatusEnum,
+ number
+ >([
['fail', 0.0],
['not_started', 0.0],
['working_on_it', 0.0],
@@ -114,9 +158,14 @@ export class TaskStatus {
['demonstrate', 0.8],
['complete', 1.0],
['time_exceeded', 0.3],
+ ['assess_in_portfolio', 1.0],
+ ['attention_required', 0.1],
]);
- public static readonly STATUS_ACRONYM: Map = new Map([
+ public static readonly STATUS_ACRONYM: Map = new Map<
+ TaskStatusEnum,
+ string
+ >([
['ready_for_feedback', 'RFF'],
['not_started', 'NOS'],
['working_on_it', 'WRK'],
@@ -129,6 +178,8 @@ export class TaskStatus {
['complete', 'COM'],
['fail', 'FAL'],
['time_exceeded', 'TIE'],
+ ['assess_in_portfolio', 'AIP'],
+ ['attention_required', 'AR'],
]);
// Which status should not show up in the task status drop down... for students
@@ -148,6 +199,8 @@ export class TaskStatus {
['feedback_exceeded', ['ready_for_feedback', 'not_started', 'working_on_it', 'need_help']],
['time_exceeded', ['ready_for_feedback', 'not_started', 'working_on_it', 'need_help']],
['fail', ['ready_for_feedback', 'not_started', 'working_on_it', 'need_help']],
+ ['assess_in_portfolio', ['not_started']],
+ ['attention_required', ['ready_for_feedback', 'not_started', 'working_on_it', 'need_help']],
]);
public static readonly STATUS_LABELS = new Map([
@@ -163,6 +216,8 @@ export class TaskStatus {
['complete', 'Complete'],
['fail', 'Fail'],
['time_exceeded', 'Time Exceeded'],
+ ['assess_in_portfolio', 'Assess in Portfolio'],
+ ['attention_required', 'Attention Required'],
]);
public static readonly STATUS_ICONS = new Map([
@@ -178,6 +233,8 @@ export class TaskStatus {
['complete', 'fa fa-check'],
['fail', 'fa fa-times'],
['time_exceeded', 'fa fa-clock-o'],
+ ['assess_in_portfolio', 'fa fa-folder-open'],
+ ['attention_required', 'fa fa-commenting'],
]);
// Please make sure this matches task-status-colors.less
@@ -194,6 +251,8 @@ export class TaskStatus {
['complete', '#5BB75B'],
['fail', '#d93713'],
['time_exceeded', '#d93713'],
+ ['assess_in_portfolio', '#f2d85c'],
+ ['attention_required', '#f1814d'],
]);
public static readonly STATUS_SEQ = new Map([
@@ -209,11 +268,23 @@ export class TaskStatus {
['discuss', 10],
['demonstrate', 11],
['complete', 12],
+ ['assess_in_portfolio', 13],
+ ['attention_required', 14],
]);
public static readonly SWITCHABLE_STATES = {
student: ['not_started', 'working_on_it', 'need_help', 'ready_for_feedback'],
- tutor: ['complete', 'discuss', 'demonstrate', 'fix_and_resubmit', 'redo', 'feedback_exceeded', 'fail'],
+ tutor: [
+ 'complete',
+ 'discuss',
+ 'attention_required',
+ 'demonstrate',
+ 'fix_and_resubmit',
+ 'redo',
+ 'feedback_exceeded',
+ 'fail',
+ 'assess_in_portfolio',
+ ],
};
// detail = in a brief context to the student
@@ -221,14 +292,16 @@ export class TaskStatus {
// action = action student can take
public static readonly HELP_DESCRIPTIONS = new Map<
TaskStatusEnum,
- { detail: string; reason: string; action: string }
+ {detail: string; reason: string; action: string}
>([
[
'ready_for_feedback',
{
detail: 'Submitted this task for feedback',
- reason: 'You have finished working on the task and have uploaded it for your tutor to assess.',
- action: 'No further action is required. Your tutor will change this task status once they have assessed it.',
+ reason:
+ 'You have finished working on the task and have uploaded it for your tutor to assess.',
+ action:
+ 'No further action is required. Your tutor will change this task status once they have assessed it.',
},
],
[
@@ -252,7 +325,8 @@ export class TaskStatus {
{
detail: 'Need help for the task',
reason: 'You are working on the task but would like some help to get it complete.',
- action: 'Upload the task with what you have completed so far and add a comment on what you would like help on.',
+ action:
+ 'Upload the task with what you have completed so far and add a comment on what you would like help on.',
},
],
[
@@ -269,7 +343,8 @@ export class TaskStatus {
'feedback_exceeded',
{
detail: 'Feedback will no longer be given',
- reason: 'This work is not complete to an acceptable standard and your tutor will not reassess it again.',
+ reason:
+ 'This work is not complete to an acceptable standard and your tutor will not reassess it again.',
action:
"It is now your responsibility to ensure this task is at an adequate standard in your portfolio. You should fix your work according to your tutor's prior feedback and include a corrected version in your portfolio.",
},
@@ -287,17 +362,28 @@ export class TaskStatus {
[
'discuss',
{
- detail: "You're almost complete!",
- reason: 'Your work looks good and your tutor believes it is complete.',
- action: 'To mark as complete, attend class and discuss it with your tutor.',
+ detail: 'Your work needs to be discussed further.',
+ reason: 'Your work looks good and your tutor believes it is on track.',
+ action: 'For this to be marked as complete, attend class and discuss it with your tutor.',
+ },
+ ],
+ [
+ 'attention_required',
+ {
+ detail: 'Your work is off track and needs focused discussion.',
+ reason:
+ 'It seems you have misunderstood some key requirements for this task. Previous feedback has not led to sufficient progress.',
+ action:
+ 'Attend class so your tutor can go through your work in detail and help you get back on track.',
},
],
[
'demonstrate',
{
- detail: "You're almost complete!",
- reason: 'Your work looks good and your tutor believes it is complete.',
- action: 'To mark as complete, attend class and demonstrate how your submission works to your tutor.',
+ detail: 'Your work needs to be demonstrated.',
+ reason: 'Your work looks good and your tutor believes it is on track.',
+ action:
+ 'For this to be marked as complete you need to attend class and demonstrate how your submission works for your tutor.',
},
],
[
@@ -305,7 +391,8 @@ export class TaskStatus {
{
detail: 'You are finished with this task 🎉',
reason: 'Your tutor is happy with your work and it has been discussed with them.',
- action: 'No further action required. Move onto the next task, or go party if everything is done.',
+ action:
+ 'No further action required. Move onto the next task, or go party if everything is done.',
},
],
[
@@ -321,11 +408,21 @@ export class TaskStatus {
'time_exceeded',
{
detail: 'Time limit exceeded',
- reason: 'This work was submitted after the deadline, having missed both the target date and deadline.',
+ reason:
+ 'This work was submitted after the deadline, having missed both the target date and deadline.',
action:
'Work submitted after the feedback deadline will not be checked by tutors prior to the portfolio assessment. You will need to ensure this task is at an adequate standard in your portfolio.',
},
],
+ [
+ 'assess_in_portfolio',
+ {
+ detail: 'Your submission will be assessed in your portfolio',
+ reason:
+ 'This task will no longer be checked by tutors, and will be assessed directly in your final portfolio submission.',
+ action: 'You will need to ensure this task is at an adequate standard in your portfolio.',
+ },
+ ],
// [
// "awaiting_extension",
// {
diff --git a/src/app/api/models/task.ts b/src/app/api/models/task.ts
index 2aa167adfd..2d7d995792 100644
--- a/src/app/api/models/task.ts
+++ b/src/app/api/models/task.ts
@@ -15,6 +15,11 @@ import {
TaskCommentService,
TaskSimilarity,
TaskSimilarityService,
+ TestAttempt,
+ TestAttemptService,
+ ScormComment,
+ UnitRoleService,
+ UnitRole,
} from './doubtfire-model';
import {Grade} from './grade';
import {LOCALE_ID} from '@angular/core';
@@ -24,12 +29,26 @@ 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',
+ Snooze: 'snooze',
+} as const;
+
+export type FeedbackModerationActionType =
+ (typeof FeedbackModerationAction)[keyof typeof FeedbackModerationAction];
+
export class Task extends Entity {
id: number;
status: TaskStatusEnum = 'not_started';
dueDate: Date;
extensions: number;
+ scormExtensions: number;
submissionDate: Date;
completionDate: Date;
timesAssessed: number;
@@ -40,19 +59,30 @@ export class Task extends Entity {
numNewComments: number = 0;
hasExtensions: boolean;
+ moderationType: 'random_sample' | 'escalation' | 'first_feedback';
+
project: Project;
definition: TaskDefinition;
//TODO: map task submission details
hasPdf: boolean = false;
processingPdf: boolean = false;
+ claimedByUnitRoleId: number | null;
+
+ loadingSubmissionDetails: boolean = false;
pinned: boolean = false;
+ targetStartDate: Date;
+ targetDueDate: Date;
+
public topWeight: number = 0;
public readonly commentCache: EntityCache = new EntityCache();
public readonly similarityCache: EntityCache = new EntityCache();
+ public readonly testAttemptCache: EntityCache = new EntityCache();
+
+ suggestedTaskStatus;
private _unit: Unit;
@@ -83,6 +113,28 @@ export class Task extends Entity {
return this.commentCache.currentValues;
}
+ public get hasDiscussedInClassComment(): boolean {
+ return this.comments.some((comment) => comment.commentType === 'discussed_in_class');
+ }
+
+ public get requiresDiscussionForComplete(): boolean {
+ return !!this.definition?.requiresDiscussion;
+ }
+
+ public get canMarkComplete(): boolean {
+ return !this.requiresDiscussionForComplete || this.hasDiscussedInClassComment;
+ }
+
+ 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')
@@ -160,11 +212,29 @@ export class Task extends Entity {
}
public localDueDate(): Date {
+ if (this.unit.allowFlexibleDates) {
+ if (this.targetDueDate) {
+ // Student's custom planned date
+ return this.targetDueDate;
+ }
+
+ // Unit target dates per grade guidelines
+ if (this.project.targetGrade === 1 && this.definition.cTargetDate) {
+ return this.definition.cTargetDate;
+ }
+ if (this.project.targetGrade === 2 && this.definition.dTargetDate) {
+ return this.definition.dTargetDate;
+ }
+ if (this.project.targetGrade === 3 && this.definition.hdTargetDate) {
+ return this.definition.hdTargetDate;
+ }
+ }
+
if (this.dueDate) {
return this.dueDate;
- } else {
- return this.definition.localDueDate();
}
+
+ return this.definition.localDueDate();
}
public localDueDateString(): string {
@@ -172,8 +242,80 @@ export class Task extends Entity {
return formatDate(this.localDueDate(), 'd MMM', locale);
}
+ public localDeadlineDateString(): string {
+ const locale: string = AppInjector.get(LOCALE_ID);
+ return formatDate(this.localDeadlineDate(), 'd MMM', locale);
+ }
+
+ public get dueWeek(): number {
+ const startDate: Date = this.unit.startDate;
+ const dueDate: Date = this.localDueDate();
+ const diffInMs: number = dueDate.getTime() - startDate.getTime();
+ const diffInDays: number = Math.ceil(diffInMs / (1000 * 3600 * 24));
+
+ return Math.ceil(diffInDays / 7);
+ }
+
+ /**
+ * Set the task to be due in a specific week.
+ *
+ * @returns the new due week
+ */
+ public set dueWeek(week: number) {
+ // Get original due week and current due week
+ const tdDueWeek: number = this.definition.dueWeek;
+ const currentDueWeek = this.dueWeek;
+
+ // Determine how long the extension needs to be
+ this.extensions = week - tdDueWeek;
+
+ // Map to ms to adjust due date
+ const currentWeekDueMs = MappingFunctions.weeksMs(currentDueWeek);
+ const newWeekDueMs = MappingFunctions.weeksMs(week);
+
+ // Adjust due date based on difference in current and new due weeks
+ this.dueDate = new Date(this.localDueDate().getTime() - currentWeekDueMs + newWeekDueMs);
+ }
+
public localDeadlineDate(): Date {
- return this.definition.localDeadlineDate();
+ return MappingFunctions.addDays(this.definition.localDeadlineDate(), this.project.specConDays);
+ }
+
+ public savePlannedDate(): Observable {
+ const taskService: TaskService = AppInjector.get(TaskService);
+
+ return taskService.update(
+ {
+ projectId: this.project.id,
+ taskDefId: this.definition.id,
+ },
+ {
+ endpointFormat: '/projects/:projectId:/task_def_id/:taskDefId:/plan',
+ entity: this,
+ body: {
+ extensions: this.extensions,
+ },
+ },
+ );
+ }
+
+ public saveTargetDates(startDate: Date | string, dueDate: Date | string): Observable {
+ const taskService: TaskService = AppInjector.get(TaskService);
+
+ return taskService.update(
+ {
+ projectId: this.project.id,
+ taskDefId: this.definition.id,
+ },
+ {
+ endpointFormat: '/projects/:projectId:/task_def_id/:taskDefId:/target_dates',
+ entity: this,
+ body: {
+ target_start_date: startDate,
+ target_due_date: dueDate,
+ },
+ },
+ );
}
/**
@@ -236,12 +378,39 @@ export class Task extends Entity {
return this.daysUntilDueDate() == 0 && !this.inSubmittedState();
}
+ public get startDate(): Date {
+ if (this.unit.allowFlexibleDates) {
+ if (this.targetStartDate) {
+ return this.targetStartDate;
+ }
+
+ // Unit start dates per grade guidelines
+ if (this.project.targetGrade === 1 && this.definition.cStartDate) {
+ return this.definition.cStartDate;
+ }
+ if (this.project.targetGrade === 2 && this.definition.dStartDate) {
+ return this.definition.dStartDate;
+ }
+ if (this.project.targetGrade === 3 && this.definition.hdStartDate) {
+ return this.definition.hdStartDate;
+ }
+ }
+
+ if (this.extensions < 0) {
+ // If the task has an extension, the start date is the due date minus the extension
+ return MappingFunctions.addWeeks(this.definition.startDate, this.extensions);
+ } else {
+ // If the task does not have an extension, the start date is the definition's start date
+ return this.definition.startDate;
+ }
+ }
+
public timeUntilStartDate(): number {
- return this.timeBetween(new Date(), this.definition.startDate);
+ return this.timeBetween(new Date(), this.startDate);
}
public daysUntilStartDate() {
- return this.daysBetween(new Date(), this.definition.startDate);
+ return this.daysBetween(new Date(), this.startDate);
}
public isBeforeStartDate(): boolean {
@@ -275,9 +444,7 @@ export class Task extends Entity {
// Always show in days, Hours, Minutes and Seconds.
return `${diff} ${data.period.charAt(0).toUpperCase() + data.period.substring(1)}`;
} else if (diff === 1 && data.period !== 'weeks') {
- return `1 ${
- data.period.charAt(0).toUpperCase() + data.period.substring(1, data.period.length - 2)
- }`;
+ return `1 ${data.period.charAt(0).toUpperCase() + data.period.slice(1, -1)}`;
}
}
@@ -381,6 +548,14 @@ export class Task extends Entity {
if (comments[i].replyToId) {
comments[i].originalComment = comments.find((tc) => tc.id === comments[i].replyToId);
}
+
+ // Scorm series
+ if (comments[i].commentType === 'scorm') {
+ comments[i].firstInSeries = i === 0 || comments[i - 1].commentType !== 'scorm';
+ (comments[i] as ScormComment).lastInScormSeries =
+ i + 1 === comments.length || comments[i + 1]?.commentType !== 'scorm';
+ if (!comments[i].firstInSeries) comments[i].shouldShowTimestamp = false;
+ }
}
comments[comments.length - 1].shouldShowAvatar = true;
@@ -396,7 +571,7 @@ export class Task extends Entity {
public taskKeyToIdString(): string {
const key = this.taskKey();
- return `task-key-${key.studentId}-${key.taskDefAbbr}`.replace(/[.#]/g, '-');
+ return `task-key-${key.studentId}-${key.taskDefAbbr}`.replace(/[.# ]/g, '-');
}
public get similaritiesDetected(): boolean {
@@ -482,7 +657,7 @@ export class Task extends Entity {
public getSubmissionDetails(): Observable {
const http: HttpClient = AppInjector.get(HttpClient);
-
+ this.loadingSubmissionDetails = true;
return http
.get(
`${AppInjector.get(DoubtfireConstants).API_URL}/projects/${this.project.id}/task_def_id/${
@@ -491,20 +666,50 @@ export class Task extends Entity {
)
.pipe(
map((response: object) => {
+ this.loadingSubmissionDetails = false;
this.hasPdf = response['has_pdf'];
this.processingPdf = response['processing_pdf'];
this.submissionDate = MappingFunctions.mapDate(response, 'submission_date', this);
+ if (response['task_status'] && TaskStatus.STATUS_KEYS.includes(response['task_status'])) {
+ this.status = response['task_status'];
+ }
+ if ('claimed_by_unit_role_id' in response) {
+ this.claimedByUnitRoleId = response['claimed_by_unit_role_id'] as number | null;
+ }
return this;
}),
);
}
public get overseerEnabled(): boolean {
- return (
- this.unit.overseerEnabled &&
- this.definition.assessmentEnabled &&
- this.definition.hasTaskAssessmentResources
- );
+ return this.unit.overseerEnabled && this.definition.assessmentEnabled;
+ }
+
+ public get scormEnabled(): boolean {
+ return this.definition.scormEnabled && this.definition.hasScormData;
+ }
+
+ public get scormPassed(): boolean {
+ if (this.latestCompletedTestAttempt) {
+ return this.latestCompletedTestAttempt.successStatus;
+ }
+ return false;
+ }
+
+ /**
+ * Launch the SCORM player for this task in a new window.
+ */
+ public launchScormPlayer(): void {
+ const url = `#/projects/${this.project.id}/task_def_id/${this.taskDefId}/scorm-player/normal`;
+ window.open(url, '_blank');
+ }
+
+ public get isReadyForUpload(): boolean {
+ return !this.scormEnabled || this.definition.scormBypassTest || this.scormPassed;
+ }
+
+ public get latestCompletedTestAttempt(): TestAttempt {
+ return this.testAttemptCache.currentValues.find((attempt) => attempt.terminated);
}
public submissionUrl(asAttachment: boolean = false): string {
@@ -571,7 +776,7 @@ export class Task extends Entity {
}
const alerts: any = AppInjector.get(AlertService);
alerts.message('Submission cancelled. Status was reverted.', 6000);
- }
+ },
);
}
@@ -590,10 +795,46 @@ export class Task extends Entity {
}
}
- public updateTaskStatus(status: TaskStatusEnum) {
+ public markAsDiscussed() {
+ const alerts: AlertService = AppInjector.get(AlertService);
+ const taskService: TaskService = AppInjector.get(TaskService);
+
+ const options: RequestOptions = {
+ entity: this,
+ cache: this.project.taskCache,
+ body: {
+ discussed: true,
+ },
+ };
+
+ taskService
+ .update(
+ {
+ projectId: this.project.id,
+ taskDefId: this.definition.id,
+ },
+ options,
+ )
+ .subscribe({
+ next: (_response) => {
+ taskService.notifyStatusChange(this);
+ alerts.success('Task successfully marked as discussed in class.', 4000);
+ },
+ error: (error) => {
+ alerts.error(error, 6000);
+ },
+ });
+ }
+
+ public updateTaskStatus(status: TaskStatusEnum, markAsDiscussed?: boolean) {
const oldStatus = this.status;
const alerts: AlertService = AppInjector.get(AlertService);
+ if (status === 'complete' && !this.canMarkComplete) {
+ alerts.error('This task must be discussed in class before it can marked complete.', 6000);
+ return;
+ }
+
const updateFunc = () => {
const taskService: TaskService = AppInjector.get(TaskService);
const options: RequestOptions = {
@@ -605,6 +846,11 @@ export class Task extends Entity {
quality_pts: this.qualityPts,
},
};
+
+ if (markAsDiscussed === true) {
+ options.body['discussed'] = true;
+ }
+
const hasId: boolean = this.id > 0;
taskService
@@ -622,6 +868,7 @@ export class Task extends Entity {
this.project.taskCache.add(this);
}
this.processTaskStatusChange(status, alerts);
+ taskService.notifyStatusChange(this);
},
error: (error) => {
this.status = oldStatus;
@@ -659,12 +906,16 @@ export class Task extends Entity {
public triggerTransition(status: TaskStatusEnum): void {
if (this.status === status) return;
+ const alerts: AlertService = AppInjector.get(AlertService);
const requiresFileUpload =
- ['ready_for_feedback', 'need_help'].includes(status) && this.requiresFileUpload();
+ ['ready_for_feedback', 'need_help', 'assess_in_portfolio'].includes(status) &&
+ this.requiresFileUpload();
- if (requiresFileUpload) {
+ if (requiresFileUpload && this.isReadyForUpload) {
this.presentTaskSubmissionModal(status);
+ } else if (requiresFileUpload && !this.isReadyForUpload) {
+ alerts.error('Complete Knowledge Check first to submit files', 6000);
} else {
this.updateTaskStatus(status);
}
@@ -718,7 +969,8 @@ export class Task extends Entity {
public canApplyForExtension(): boolean {
return (
- this.unit.allowStudentExtensionRequests &&
+ (this.unit.allowStudentExtensionRequests || this.unit.currentUserIsStaff) &&
+ !this.unit.allowFlexibleDates &&
this.inStateThatAllowsExtension() &&
(!this.isPastDeadline() || this.wasSubmittedOnTime()) &&
this.maxWeeksCanExtend() > 0
@@ -733,9 +985,7 @@ export class Task extends Entity {
}
public maxWeeksCanExtend(): number {
- return Math.ceil(
- this.daysBetween(this.localDueDate(), this.definition.localDeadlineDate()) / 7,
- );
+ return Math.ceil(this.daysBetween(this.localDueDate(), this.localDeadlineDate()) / 7);
}
/**
@@ -764,4 +1014,89 @@ export class Task extends Entity {
},
);
}
+
+ /**
+ * Fetch the SCORM test attempts for this task.
+ */
+ public fetchTestAttempts(): Observable {
+ const testAttemptService: TestAttemptService = AppInjector.get(TestAttemptService);
+ return testAttemptService.query(
+ {
+ project_id: this.project.id,
+ task_def_id: this.taskDefId,
+ },
+ {
+ cache: this.testAttemptCache,
+ constructorParams: this,
+ },
+ );
+ }
+
+ public hasPrerequisiteTasks(): boolean {
+ if (!this.project) {
+ return false;
+ }
+ return this.definition.taskPrerequisitesCache.currentValues.length > 0;
+ }
+
+ /**
+ * Returns true if this task has prerequisite tasks that are not in a submitted state
+ */
+ public blockedByPrerequisiteTasks(): boolean {
+ if (!this.project) {
+ return false;
+ }
+
+ const prereqs = this.definition.taskPrerequisitesCache.currentValues;
+ if (!prereqs.length) {
+ return false;
+ }
+
+ for (const prerequisiteLink of prereqs) {
+ const prerequisiteTask = prerequisiteLink.prerequisite;
+ const task = this.project.tasks.find((t) => t.definition.id === prerequisiteTask.id);
+
+ // If the task doesnt exist or its state has not met the minimum require state, block submission
+ if (!task || !prerequisiteLink.hasMetRequiredState(this.project)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public moderateFeedback(
+ action: FeedbackModerationActionType,
+ applyToAll: boolean = false,
+ ): Observable {
+ 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 {
+ 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(url, {});
+ }
}
diff --git a/src/app/api/models/test-attempt.ts b/src/app/api/models/test-attempt.ts
new file mode 100644
index 0000000000..4497028a75
--- /dev/null
+++ b/src/app/api/models/test-attempt.ts
@@ -0,0 +1,28 @@
+import {Entity} from 'ngx-entity-service';
+import {Task} from './doubtfire-model';
+
+export class TestAttempt extends Entity {
+ id: number;
+ terminated: boolean;
+ completionStatus: boolean;
+ successStatus: boolean;
+ scoreScaled: number;
+ cmiDatamodel: string;
+ attemptedTime: Date;
+
+ task: Task;
+
+ constructor(task: Task) {
+ super();
+ this.task = task;
+ }
+
+ /**
+ * Open a test attempt window in review mode
+ */
+ public review() {
+ const url = `#/projects/${this.task.project.id}/task_def_id/${this.task.taskDefId}/scorm-player/review/${this.id}`;
+
+ window.open(url, '_blank');
+ }
+}
diff --git a/src/app/api/models/tutor-note.ts b/src/app/api/models/tutor-note.ts
new file mode 100644
index 0000000000..148d5fa9eb
--- /dev/null
+++ b/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);
+ },
+ });
+ }
+}
diff --git a/src/app/api/models/unit-role.ts b/src/app/api/models/unit-role.ts
index 5868fa2f05..967d542381 100644
--- a/src/app/api/models/unit-role.ts
+++ b/src/app/api/models/unit-role.ts
@@ -1,16 +1,26 @@
-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;
+ canMarkOverflowTasks: boolean;
+ mentorId: number;
+ tutorNoteCount: number;
+
+ public get mentor(): UnitRole {
+ return this.unit?.staff.find((ur) => ur.id === this.mentorId);
+ }
+
+ public readonly tutorNotesCache: EntityCache = new EntityCache();
/**
* The id for updated roles - but we need to move away from this to the role string...
@@ -28,10 +38,12 @@ export class UnitRole extends Entity {
return this.user.matches(text) || this.unit.matches(text);
}
- public override toJson(mappingData: EntityMapping, ignoreKeys?: string[]): object {
+ public override toJson(
+ mappingData: EntityMapping,
+ ignoreKeys?: string[],
+ ): object {
return {
unit_role: super.toJson(mappingData, ignoreKeys),
- }
+ };
}
-
}
diff --git a/src/app/api/models/unit.ts b/src/app/api/models/unit.ts
index 5c70a6eb42..e9f48f02f9 100644
--- a/src/app/api/models/unit.ts
+++ b/src/app/api/models/unit.ts
@@ -22,9 +22,19 @@ import {
Project,
TutorialStreamService,
UnitRoleService,
+ D2lAssessmentMappingService,
+ OverseerImage,
+ OverseerImageService,
} from './doubtfire-model';
import {LearningOutcome} from './learning-outcome';
import {AlertService} from 'src/app/common/services/alert.service';
+import {D2lAssessmentMapping} from './d2l/d2l_assessment_mapping';
+import {SidekiqJob} from './sidekiq-job';
+import {HttpClient, HttpParams} from '@angular/common/http';
+import {TaskPrerequisiteService} from '../services/task-prerequisite.service';
+import {MarkingSession} from './marking-session';
+import {MarkingSessionService} from '../services/marking-session.service';
+import {TaskPrerequisite} from './task-prerequisite';
export class Unit extends Entity {
id: number;
@@ -51,6 +61,7 @@ export class Unit extends Entity {
assessmentEnabled: boolean;
overseerImageId: number = null; // image needs to be lazy loadaed
+ private _overseerImage: OverseerImage;
autoApplyExtensionBeforeDeadline: boolean;
sendNotifications: boolean;
@@ -60,8 +71,15 @@ export class Unit extends Entity {
draftTaskDefinition: TaskDefinition;
allowStudentExtensionRequests: boolean;
+ allowFlexibleDates: boolean = false;
extensionWeeksOnResubmitRequest: number;
allowStudentChangeTutorial: boolean;
+ markLateSubmissionsAsAssessInPortfolio: boolean;
+
+ feedbackWarningThresholdDays: number;
+ feedbackOverflowThresholdDays: number;
+
+ d2lMapping: D2lAssessmentMapping;
public readonly learningOutcomesCache: EntityCache =
new EntityCache();
@@ -93,6 +111,12 @@ export class Unit extends Entity {
};
}
+ public hasChanges(): boolean {
+ const unitService = AppInjector.get(UnitService);
+ const changes = this.toJson(unitService.mapping);
+ return JSON.stringify(changes) !== '{"unit":{}}';
+ }
+
public get nameAndPeriod(): string {
return `${this.name} (${
this.teachingPeriod ? this.teachingPeriod.name : this.startDate.toLocaleDateString()
@@ -213,6 +237,20 @@ export class Unit extends Entity {
}
}
+ /**
+ * Get the total duration of the unit in milliseconds.
+ */
+ public get totalDuration(): number {
+ return this.endDate.valueOf() - this.startDate.valueOf();
+ }
+
+ /**
+ * Get the number of weeks in the unit's teaching period.
+ */
+ public get totalWeeks(): number {
+ return Math.ceil(this.totalDuration / (1000 * 60 * 60 * 24 * 7));
+ }
+
/**
* Calculate how much time has elapsed in the teaching period, based on the start and
* end date of the unit relative to the current date.
@@ -227,12 +265,12 @@ export class Unit extends Entity {
if (today >= this.endDate) return 100;
const startToNow = Math.abs(today.valueOf() - this.startDate.valueOf());
- const totalDuration = Math.abs(this.endDate.valueOf() - this.startDate.valueOf());
+ const totalDuration = Math.abs(this.totalDuration);
return Math.round((startToNow / totalDuration) * 100);
}
- public rolloverTo(body: {start_date: Date; end_date: Date}): Observable;
- public rolloverTo(body: {teaching_period_id: number}): Observable;
+ public rolloverTo(body: {new_unit_code?: string, start_date: Date; end_date: Date}): Observable;
+ public rolloverTo(body: {new_unit_code?: string, teaching_period_id: number}): Observable;
public rolloverTo(body: any): Observable {
const unitService = AppInjector.get(UnitService);
@@ -370,7 +408,7 @@ export class Unit extends Entity {
return alignment.taskDefinition.id === td.id;
})
.sort((a: TaskOutcomeAlignment, b: TaskOutcomeAlignment) => {
- return a.learningOutcome.iloNumber - b.learningOutcome.iloNumber;
+ return a.learningOutcome.id - b.learningOutcome.id;
});
}
@@ -380,6 +418,10 @@ export class Unit extends Entity {
}/learning_alignments/csv.json`;
}
+ public get gradesCSVUploadUrl(): string {
+ return `${AppInjector.get(DoubtfireConstants).API_URL}/units/${this.id}/grades/csv`;
+ }
+
public taskStatusFactor(td: TaskDefinition): number {
return 1;
}
@@ -388,6 +430,10 @@ export class Unit extends Entity {
return `${AppInjector.get(DoubtfireConstants).API_URL}/units/${this.id}/outcomes/csv`;
}
+ public getFeedbackTemplateBatchUploadUrl(): string {
+ return `${AppInjector.get(DoubtfireConstants).API_URL}/units/${this.id}/feedback_chips/csv`;
+ }
+
public hasStreams(): boolean {
return this.tutorialStreamsCache.size > 1;
}
@@ -436,6 +482,15 @@ export class Unit extends Entity {
return this.groupSetsCache.currentValues;
}
+ public set overseerImage(image: OverseerImage) {
+ this._overseerImage = image;
+ this.overseerImageId = image.id;
+ }
+
+ public get overseerImage(): OverseerImage {
+ return this._overseerImage;
+ }
+
public get overseerEnabled(): boolean {
return this.assessmentEnabled && AppInjector.get(DoubtfireConstants).IsOverseerEnabled.value; // && this.overseerImageId !== null && this.overseerImageId !== undefined;
}
@@ -534,17 +589,160 @@ export class Unit extends Entity {
return `${AppInjector.get(DoubtfireConstants).API_URL}/csv/task_definitions?unit_id=${this.id}`;
}
- public downloadTaskCompletionCsv(): void {
- AppInjector.get(FileDownloaderService).downloadFile(
- `${AppInjector.get(DoubtfireConstants).API_URL}/csv/units/${this.id}/task_completion.json`,
- `${this.name}-task-completion.csv`,
+ public downloadTaskCompletionCsv(): Observable {
+ return AppInjector.get(HttpClient).get(
+ `${AppInjector.get(DoubtfireConstants).API_URL}/csv/units/${this.id}/task_completion`,
+ );
+ }
+
+ public downloadTasksAwaitingFeedbackCsv(): Observable {
+ return AppInjector.get(HttpClient).get(
+ `${AppInjector.get(DoubtfireConstants).API_URL}/csv/units/${this.id}/tasks_awaiting_feedback`,
+ );
+ }
+
+ public downloadTaskAssessmentCountsCsv(): Observable {
+ return AppInjector.get(HttpClient).get(
+ `${AppInjector.get(DoubtfireConstants).API_URL}/csv/units/${this.id}/task_assessment_counts`,
+ );
+ }
+
+ public downloadTutorAssessmentCsv(): Observable {
+ return AppInjector.get(HttpClient).get(
+ `${AppInjector.get(DoubtfireConstants).API_URL}/csv/units/${this.id}/tutor_assessments`,
+ );
+ }
+
+ public getUserMarkingSessions(
+ startDate?: Date,
+ endDate?: Date,
+ timezone?: string,
+ ): Observable {
+ let params = new HttpParams();
+ if (startDate) {
+ params = params.set(
+ 'start_date',
+ `${startDate.getFullYear()}-${(startDate.getMonth() + 1).toString().padStart(2, '0')}-${startDate.getDate().toString().padStart(2, '0')}`,
+ );
+ }
+
+ if (endDate) {
+ params = params.set(
+ 'end_date',
+ `${endDate.getFullYear()}-${(endDate.getMonth() + 1).toString().padStart(2, '0')}-${endDate.getDate().toString().padStart(2, '0')}`,
+ );
+ }
+
+ params = params.set('timezone', timezone);
+
+ // TODO: we should cache the data by the same start/end date
+ const markingSessionService = AppInjector.get(MarkingSessionService);
+ return markingSessionService.fetchAll(
+ {
+ unitId: this.id,
+ },
+ {params, constructorParams: this},
+ );
+ }
+
+ public downloadTutorTimesSummaryCsv(
+ startDate?: Date,
+ endDate?: Date,
+ timezone?: string,
+ ignoreSessionsDuringTutorials?: boolean,
+ ): Observable {
+ let params = new HttpParams();
+
+ if (startDate) {
+ params = params.set(
+ 'start_date',
+ `${startDate.getFullYear()}-${(startDate.getMonth() + 1).toString().padStart(2, '0')}-${startDate.getDate().toString().padStart(2, '0')}`,
+ );
+ }
+
+ if (endDate) {
+ params = params.set(
+ 'end_date',
+ `${endDate.getFullYear()}-${(endDate.getMonth() + 1).toString().padStart(2, '0')}-${endDate.getDate().toString().padStart(2, '0')}`,
+ );
+ }
+
+ params = params.set('timezone', timezone);
+
+ params = params.set('ignore_sessions_during_tutorials', ignoreSessionsDuringTutorials ?? false);
+
+ return AppInjector.get(HttpClient).get(
+ `${AppInjector.get(DoubtfireConstants).API_URL}/csv/units/${this.id}/tutor_times_summary`,
+ {params},
+ );
+ }
+
+ public downloadMyTutorTimeSessionsCsv(
+ startDate?: Date,
+ endDate?: Date,
+ timezone?: string,
+ ): Observable {
+ let params = new HttpParams();
+
+ if (startDate) {
+ params = params.set(
+ 'start_date',
+ `${startDate.getFullYear()}-${(startDate.getMonth() + 1).toString().padStart(2, '0')}-${startDate.getDate().toString().padStart(2, '0')}`,
+ );
+ }
+
+ if (endDate) {
+ params = params.set(
+ 'end_date',
+ `${endDate.getFullYear()}-${(endDate.getMonth() + 1).toString().padStart(2, '0')}-${endDate.getDate().toString().padStart(2, '0')}`,
+ );
+ }
+
+ params = params.set('timezone', timezone);
+
+ return AppInjector.get(HttpClient).get(
+ `${AppInjector.get(DoubtfireConstants).API_URL}/csv/units/${this.id}/my_marking_sessions`,
+ {params},
+ );
+ }
+
+ public hasD2lMapping(): boolean {
+ const doubtfireConstants = AppInjector.get(DoubtfireConstants);
+ return (
+ doubtfireConstants.IsD2LEnabled.value &&
+ this.d2lMapping !== undefined &&
+ this.d2lMapping.orgUnitId !== undefined &&
+ this.d2lMapping.orgUnitId.length > 0
);
}
- public downloadTutorAssessmentCsv(): void {
+ public loadD2lMapping(): Observable {
+ const d2lMappingSvc = AppInjector.get(D2lAssessmentMappingService);
+
+ return d2lMappingSvc.get({unitId: this.id}).pipe(
+ tap((mappings) => {
+ this.d2lMapping = mappings;
+ }),
+ );
+ }
+
+ public get staffNotesCsvDownloadUrl(): string {
+ return `${AppInjector.get(DoubtfireConstants).API_URL}/csv/units/${this.id}/staff_notes`;
+ }
+
+ public downloadStaffNotesCsv(): void {
AppInjector.get(FileDownloaderService).downloadFile(
- `${AppInjector.get(DoubtfireConstants).API_URL}/csv/units/${this.id}/tutor_assessments.json`,
- `${this.name}-tutor-assessments.csv`,
+ `${AppInjector.get(DoubtfireConstants).API_URL}/csv/units/${this.id}/staff_notes`,
+ `${this.name}-StaffNotes.csv`,
);
}
+
+ public get taskDefinitionsPrerequisitesUrl(): string {
+ return `${AppInjector.get(DoubtfireConstants).API_URL}/units/${this.id}/task_prerequisites`;
+ }
+
+ public getTaskPrerequisites(): Observable {
+ const prerequisiteService = AppInjector.get(TaskPrerequisiteService);
+ return prerequisiteService.getUnitPrerequisites(this.id);
+ }
}
diff --git a/src/app/api/models/user/user.ts b/src/app/api/models/user/user.ts
index 10357a1898..b11826505a 100644
--- a/src/app/api/models/user/user.ts
+++ b/src/app/api/models/user/user.ts
@@ -1,31 +1,37 @@
-import { HttpClient } from '@angular/common/http';
-import { Entity, EntityMapping } from 'ngx-entity-service';
-import { Observable, map } from 'rxjs';
-import { AppInjector } from 'src/app/app-injector';
-import { DoubtfireConstants } from 'src/app/config/constants/doubtfire-constants';
-import { AuthenticationService } from '../doubtfire-model';
+import {HttpClient} from '@angular/common/http';
+import {Entity, EntityMapping} from 'ngx-entity-service';
+import {Observable, map} from 'rxjs';
+import {AppInjector} from 'src/app/app-injector';
+import {DoubtfireConstants} from 'src/app/config/constants/doubtfire-constants';
+import {AuthenticationService} from '../doubtfire-model';
export type Tutor = User;
export class User extends Entity {
- id: number;
- firstName: string;
- lastName: string;
- optInToResearch: boolean;
- studentId: string;
- email: string;
- username: string;
- nickname: string;
- systemRole: 'Admin' | 'Convenor' | 'Tutor' | 'Student' | 'Auditor';
- receiveTaskNotifications: boolean;
- receivePortfolioNotifications: boolean;
- receiveFeedbackNotifications: boolean;
- hasRunFirstTimeSetup: boolean;
- authenticationToken: string;
- pronouns: string | null;
- acceptedTiiEula: boolean;
+ public id: number;
+ public firstName: string;
+ public lastName: string;
+ public optInToResearch: boolean;
+ public studentId: string;
+ public email: string;
+ public username: string;
+ public nickname: string;
+ public systemRole: 'Admin' | 'Convenor' | 'Tutor' | 'Student' | 'Auditor';
+ public receiveTaskNotifications: boolean;
+ public receivePortfolioNotifications: boolean;
+ public receiveFeedbackNotifications: boolean;
+ public hasRunFirstTimeSetup: boolean;
+ public authenticationToken: string;
+ public pronouns: string | null;
+ public acceptedTiiEula: boolean;
- public override toJson(mappingData: EntityMapping, ignoreKeys?: string[]): object {
+ // LTI Token
+ public ltik: string;
+
+ public override toJson(
+ mappingData: EntityMapping,
+ ignoreKeys?: string[],
+ ): object {
return {
user: super.toJson(mappingData, ignoreKeys),
};
@@ -40,12 +46,22 @@ export class User extends Entity {
}
public get name(): string {
- const fn = this.firstName.slice(0, 11);
- const sn = this.lastName.slice(0, 11);
- const nn = this.nickname && this.nickname.trim() ? ` (${this.nickname.trim().slice(0, 11)})` : '';
+ const fn = this.firstName.slice(0, 11).trim();
+ const sn = this.lastName.slice(0, 11).trim();
+ const nn =
+ this.nickname && this.nickname.trim() ? ` (${this.nickname.trim().slice(0, 11).trim()})` : '';
return `${fn} ${sn}${nn}`;
}
+ public get preferredName(): string {
+ const nickname = this.nickname?.trim();
+ const firstName = this.firstName.trim();
+ if (nickname) {
+ return nickname;
+ }
+ return firstName;
+ }
+
public matches(text: string): boolean {
return (
this.studentId?.toLowerCase().indexOf(text) >= 0 ||
@@ -60,10 +76,12 @@ export class User extends Entity {
public acceptTiiEula(): Observable {
const httpClient = AppInjector.get(HttpClient);
const uri = `${AppInjector.get(DoubtfireConstants).API_URL}/tii_eula/users/${this.id}/accept`;
- return httpClient.put(uri, {}).pipe(map(() => {
- this.acceptedTiiEula = true;
- AppInjector.get(AuthenticationService).saveCurrentUser();
- return true;
- }));
+ return httpClient.put(uri, {}).pipe(
+ map(() => {
+ this.acceptedTiiEula = true;
+ // AppInjector.get(AuthenticationService).saveCurrentUser();
+ return true;
+ }),
+ );
}
}
diff --git a/src/app/api/services/activity-type.service.ts b/src/app/api/services/activity-type.service.ts
index bd89cb9256..628acde622 100644
--- a/src/app/api/services/activity-type.service.ts
+++ b/src/app/api/services/activity-type.service.ts
@@ -1,8 +1,8 @@
-import { ActivityType } from 'src/app/api/models/doubtfire-model';
-import { Injectable } from '@angular/core';
-import { CachedEntityService } from 'ngx-entity-service';
-import API_URL from 'src/app/config/constants/apiURL';
-import { HttpClient } from '@angular/common/http';
+import {ActivityType} from 'src/app/api/models/doubtfire-model';
+import {Injectable} from '@angular/core';
+import {CachedEntityService} from 'ngx-entity-service';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {HttpClient} from '@angular/common/http';
@Injectable()
export class ActivityTypeService extends CachedEntityService {
@@ -11,11 +11,7 @@ export class ActivityTypeService extends CachedEntityService {
constructor(httpClient: HttpClient) {
super(httpClient, API_URL);
- this.mapping.addKeys(
- 'id',
- 'name',
- 'abbreviation',
- );
+ this.mapping.addKeys('id', 'name', 'abbreviation');
this.mapping.mapAllKeysToJsonExcept('id');
}
diff --git a/src/app/api/services/authentication.service.ts b/src/app/api/services/authentication.service.ts
index b2cb12f402..be59c71786 100644
--- a/src/app/api/services/authentication.service.ts
+++ b/src/app/api/services/authentication.service.ts
@@ -1,15 +1,45 @@
import {User, UserService} from 'src/app/api/models/doubtfire-model';
-import {Inject, Injectable} from '@angular/core';
+import {Injectable} from '@angular/core';
import {HttpClient} from '@angular/common/http';
import {DoubtfireConstants} from 'src/app/config/constants/doubtfire-constants';
import {StateService, UIRouter, UIRouterGlobals} from '@uirouter/angular';
import {GlobalStateService, ViewType} from 'src/app/projects/states/index/global-state.service';
import {AppInjector} from 'src/app/app-injector';
-import {map, Observable} from 'rxjs';
+import {AsyncSubject, catchError, map, Observable, throwError} from 'rxjs';
import {AlertService} from 'src/app/common/services/alert.service';
+/**
+ * The format for the data returned from the auth api.
+ */
+interface AuthResponse {
+ user: object;
+ auth_token: string;
+ lti_token?: string;
+}
+
@Injectable()
export class AuthenticationService {
+ /**
+ * The URL for the authentication API endpoint
+ */
+ private readonly AUTH_URL: string;
+
+ /**
+ * The key used to store the username in local storage - now removed.
+ */
+ public readonly USERNAME_KEY: string = 'doubtfire_user';
+
+ /**
+ * The key used to store the remember me option in local storage.
+ */
+ public readonly REMEMBER_DOUBTFIRE_CREDENTIALS_TOKEN: string =
+ 'remember_doubtfire_credentials_token';
+
+ /**
+ * AsyncSubject to indicate when the authentication process is complete.
+ */
+ private authComplete$: AsyncSubject = new AsyncSubject();
+
constructor(
private httpClient: HttpClient,
private userService: UserService,
@@ -20,92 +50,100 @@ export class AuthenticationService {
private uiRouterGlobals: UIRouterGlobals,
) {
this.AUTH_URL = `${this.doubtfireConstants.API_URL}/auth`;
+ // Ensure any only user data is removed from local storage
+ localStorage.removeItem(this.USERNAME_KEY);
}
- public checkUserCookie(): void {
- const userData = JSON.parse(localStorage.getItem(this.USERNAME_KEY));
- const user = new User();
- Object.assign(user, userData);
-
- if (userData && this.tryChangeUser(user)) {
- // Ensure current user is in cache
- this.userService.cache.add(user);
- this.userService.currentUser = user;
-
- const resetTime = new Date(
- Number.parseInt(localStorage.getItem(this.DOUBTFIRE_LOGIN_TIME)) + 60 * 60 * 1000,
- );
- const waitTime = resetTime.valueOf() - new Date().valueOf();
-
- setTimeout(() => this.updateAuth(), waitTime);
- }
+ private actionAuthFailed() {
+ this.signOut(false);
}
- private readonly AUTH_URL: string;
- public readonly USERNAME_KEY: string = 'doubtfire_user';
- public readonly REMEMBER_DOUBTFIRE_CREDENTIALS_TOKEN: string =
- 'remember_doubtfire_credentials_token';
- public readonly DOUBTFIRE_LOGIN_TIME: string = 'doubtfire_login_time';
-
- public saveCurrentUser(
- remember: boolean = localStorage.getItem(this.REMEMBER_DOUBTFIRE_CREDENTIALS_TOKEN) === 'true',
+ /**
+ * Attempt to login using the refresh token secure cookie.
+ * This requires the remember option to be true - and the server to have sent a
+ * secure cookie.
+ * @param loginResultCallback - Callback function to indicate success or failure of login.
+ */
+ public attemptLoginUsingRefreshToken(
+ loginResultCallback: (result: boolean) => void,
+ firstTime: boolean = true,
): void {
- if (remember && this.userService.currentUser.id) {
- localStorage.setItem(this.USERNAME_KEY, JSON.stringify(this.userService.currentUser));
- localStorage.setItem(this.REMEMBER_DOUBTFIRE_CREDENTIALS_TOKEN, 'true');
- localStorage.setItem(this.DOUBTFIRE_LOGIN_TIME, JSON.stringify(new Date().getTime()));
- } else {
- localStorage.removeItem(this.USERNAME_KEY);
- localStorage.setItem(this.REMEMBER_DOUBTFIRE_CREDENTIALS_TOKEN, 'false');
- localStorage.removeItem(this.DOUBTFIRE_LOGIN_TIME);
+ // Check we have indication of secure cookie in local storage
+ const remember: boolean = this.rememberMe;
+
+ if (!remember) {
+ loginResultCallback(false);
+ return;
}
+
+ // Attempt to get an access token using the refresh token cookie
+ this.httpClient.post(this.AUTH_URL + '/access-token', {}).subscribe({
+ next: (response: AuthResponse | null) => {
+ if (response && response.auth_token) {
+ this.setupUserFromResponse(response, firstTime);
+ loginResultCallback(true);
+ } else {
+ this.actionAuthFailed();
+ loginResultCallback(false);
+ }
+ },
+ error: (_error) => {
+ // Will occur on 404 when the refresh token cookie is not present
+ this.actionAuthFailed();
+ loginResultCallback(false);
+ },
+ });
}
+ /**
+ * Check if the user is authenticated.
+ *
+ * @returns true if the user is authenticated, false otherwise.
+ */
public isAuthenticated(): boolean {
- return this.userService.currentUser.id !== undefined;
+ return (
+ this.userService.currentUser.id !== undefined &&
+ !!this.userService.currentUser.authenticationToken
+ );
}
- private updateAuth() {
- if (!this.isAuthenticated()) {
- return;
- }
+ public get rememberMe(): boolean {
+ return localStorage.getItem(this.REMEMBER_DOUBTFIRE_CREDENTIALS_TOKEN) !== 'false';
+ }
- const remember: boolean =
- localStorage.getItem(this.REMEMBER_DOUBTFIRE_CREDENTIALS_TOKEN) === 'true';
- localStorage.setItem(this.DOUBTFIRE_LOGIN_TIME, JSON.stringify(new Date().getTime()));
-
- this.httpClient
- .put(this.AUTH_URL, {
- username: this.userService.currentUser.username,
- remember: remember,
- })
- .subscribe({
- next: (response) => {
- this.userService.currentUser.authenticationToken = response['auth_token'];
- this.saveCurrentUser(remember);
-
- // Update auth each hour
- setTimeout(() => this.updateAuth(), 1000 * 60 * 60);
- },
- });
+ public set rememberMe(remember: boolean) {
+ localStorage.setItem(this.REMEMBER_DOUBTFIRE_CREDENTIALS_TOKEN, remember ? 'true' : 'false');
}
- private tryChangeUser(user: User, remember?: boolean) {
- if (user) {
- // Clear the current user object and populate it with the new values.
- // Note how the actual user object reference doesn't change.
- // delete currentUser[prop] for prop of currentUser
- // _.extend currentUser, user
- this.userService.currentUser = user;
- this.saveCurrentUser(remember);
+ /**
+ * Get a new access token - and delete the old one.
+ *
+ * @returns void
+ */
+ private cycleAccessToken() {
+ const remember: boolean = this.rememberMe;
- return true;
- } else {
- return false;
+ // We cant get a new token if there is no refresh token cookie
+ if (!this.isAuthenticated() || !remember) {
+ return;
}
+
+ // Attempt to get a new access token using the refresh token cookie
+ this.attemptLoginUsingRefreshToken((result: boolean) => {
+ if (result) {
+ console.log('Successfully refreshed access token');
+ }
+ });
}
- private readonly validRoles: string[] = ['anon', 'Student', 'Tutor', 'Convenor', 'Admin', 'Auditor'];
+ private readonly validRoles: string[] = [
+ 'anon',
+ 'Student',
+ 'Tutor',
+ 'Convenor',
+ 'Admin',
+ 'Auditor',
+ ];
private isValidRoleWhitelist(roleWhitelist: string[]) {
return roleWhitelist.filter((role: string) => this.validRoles.includes(role)).length !== 0;
@@ -123,6 +161,54 @@ export class AuthenticationService {
);
}
+ /**
+ * Use the user service to get or create a user object, and update it
+ * from the response. Ensure that the authentication token is set.
+ *
+ * @param response the response from the authentication API
+ */
+ private setupUserFromResponse(response: AuthResponse, firstTime: boolean = true): void {
+ // Extract relevant data from response and construct user object to store in cache.
+ const user: User = this.userService.cache.getOrCreate(
+ response.user['id'],
+ this.userService,
+ response.user,
+ );
+
+ // Set the user's authentication token for access to api.
+ user.authenticationToken = response['auth_token'];
+
+ // Record the current user
+ this.userService.currentUser = user;
+
+ if (firstTime) {
+ // Load everything!
+ AppInjector.get(GlobalStateService).loadGlobals();
+ // Update token in one hour
+ setTimeout(() => this.cycleAccessToken(), 1000 * 60 * 60);
+ }
+
+ // Inidcate that the authentication was successful
+ this.authComplete$.next(true);
+ this.authComplete$.complete();
+ }
+
+ /**
+ * Register a callback to be called when the authentication process is complete.
+ * This is used by the runtime.coffee for now to check authorisation after login
+ * completes. The callback will be called with true if user is authorised and if
+ * not will redirect to another page.
+ *
+ * @param callback the callback function to call
+ */
+ public afterAuthCall(callback: (result: boolean) => void): void {
+ this.authComplete$.subscribe({
+ next: (result) => {
+ callback(result);
+ },
+ });
+ }
+
public signIn(
userCredentials:
| {
@@ -135,39 +221,56 @@ export class AuthenticationService {
username: string;
remember: boolean;
},
- ): Observable {
+ ): Observable {
return this.httpClient.post(this.AUTH_URL, userCredentials).pipe(
- map((response: any) => {
- // Extract relevant data from response and construct user object to store in cache.
- const user: User = this.userService.cache.getOrCreate(
- response['user']['id'],
- this.userService,
- response['user'],
- );
-
- user.authenticationToken = response['auth_token'];
-
- if (this.tryChangeUser(user, userCredentials.remember)) {
- AppInjector.get(GlobalStateService).loadGlobals();
- } else {
- return new Error('Failed to change user');
- }
+ map((response: AuthResponse) => {
+ this.setupUserFromResponse(response);
+ }),
+ catchError((error) => {
+ // this.authComplete$.next(false);
+ // this.authComplete$.complete();
+
+ return throwError(() => error);
+ }),
+ );
+ }
- // Update token in one hour
- setTimeout(() => this.updateAuth(), 1000 * 60 * 60);
+ public signInWithLti(userCredentials: {ltik: string; lti_token: string}): Observable {
+ return this.httpClient.post(`${this.AUTH_URL}/lti`, userCredentials).pipe(
+ map((response: AuthResponse) => {
+ const username = encodeURIComponent(response.user['username']);
+ const authToken = encodeURIComponent(response.auth_token);
+ const ltik = encodeURIComponent(userCredentials.ltik);
+ setTimeout(() => {
+ window.location.href = `/sign_in?username=${username}&authToken=${authToken}<ik=${ltik}&isLtiLogin=true`;
+ });
+ }),
+ catchError((error) => {
+ return throwError(() => error);
}),
);
}
public signOut(ssoSignOut = true): void {
+ // This function is called after the token is deleted...
const doSignOut = () => {
- this.tryChangeUser(this.userService.anonymousUser, false);
+ // Setup ability to auth again
+ this.authComplete$.complete();
+ this.authComplete$ = new AsyncSubject();
+
+ // Change the current user to the anonymous user
+ this.userService.currentUser = this.userService.anonymousUser;
+
+ // Clear global state
const globalStateService = AppInjector.get(GlobalStateService);
+ globalStateService.clearUnitsAndProjects();
+ this.userService.cache.clear();
+
+ // Trigger the UI changes
globalStateService.hideHeader();
globalStateService.setView(ViewType.OTHER);
- globalStateService.clearUnitsAndProjects();
- // if string is not null
+ // if we have a signout URL, redirect to it
if (ssoSignOut && this.doubtfireConstants.SignoutURL) {
window.location.assign(this.doubtfireConstants.SignoutURL);
} else {
@@ -175,8 +278,9 @@ export class AuthenticationService {
}
};
+ // If we have a token, delete it...
if (this.userService.currentUser.authenticationToken) {
- this.httpClient.delete(this.AUTH_URL).subscribe({
+ this.httpClient.delete(this.AUTH_URL, {params: {remember: false}}).subscribe({
next: (_response) => doSignOut(),
error: (_response) => doSignOut(),
});
@@ -191,4 +295,12 @@ export class AuthenticationService {
setTimeout(() => this.router.stateService.go('timeout'), 500);
}
}
+
+ public getScormToken(): Observable {
+ return this.httpClient.get(this.AUTH_URL + '/scorm').pipe(
+ map((response) => {
+ return response['scorm_auth_token'];
+ }),
+ );
+ }
}
diff --git a/src/app/api/services/campus.service.ts b/src/app/api/services/campus.service.ts
index ddf491c6d4..d46d793cc3 100644
--- a/src/app/api/services/campus.service.ts
+++ b/src/app/api/services/campus.service.ts
@@ -1,8 +1,8 @@
-import { Campus } from 'src/app/api/models/doubtfire-model';
-import { Injectable } from '@angular/core';
-import { CachedEntityService } from 'ngx-entity-service';
-import { HttpClient } from '@angular/common/http';
-import API_URL from 'src/app/config/constants/apiURL';
+import {Campus} from 'src/app/api/models/doubtfire-model';
+import {Injectable} from '@angular/core';
+import {CachedEntityService} from 'ngx-entity-service';
+import {HttpClient} from '@angular/common/http';
+import API_URL from 'src/app/config/constants/apiUrl';
@Injectable()
export class CampusService extends CachedEntityService {
@@ -11,13 +11,7 @@ export class CampusService extends CachedEntityService {
constructor(httpClient: HttpClient) {
super(httpClient, API_URL);
- this.mapping.addKeys(
- 'id',
- 'name',
- 'mode',
- 'abbreviation',
- 'active'
- );
+ this.mapping.addKeys('id', 'name', 'mode', 'abbreviation', 'active', 'timezone');
this.mapping.mapAllKeysToJsonExcept('id');
}
diff --git a/src/app/api/services/discussion-prompt.service.ts b/src/app/api/services/discussion-prompt.service.ts
new file mode 100644
index 0000000000..c102fbcbf1
--- /dev/null
+++ b/src/app/api/services/discussion-prompt.service.ts
@@ -0,0 +1,128 @@
+import {HttpClient} from '@angular/common/http';
+import {Injectable} from '@angular/core';
+import {CachedEntityService, RequestOptions} from 'ngx-entity-service';
+import {Observable} from 'rxjs';
+import {
+ Project,
+ ProjectService,
+ TaskDefinition,
+ Unit,
+ UserService,
+} from 'src/app/api/models/doubtfire-model';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {DiscussionPrompt} from '../models/discussion-prompt';
+
+@Injectable()
+export class DiscussionPromptService extends CachedEntityService {
+ protected readonly endpointFormat =
+ 'task_definitions/:task_definition_id:/discussion_prompts/:id:';
+
+ protected readonly projectEndpointFormat = 'projects/:projectId:/discussion_prompts';
+ protected readonly taskDefinitionProjectEndpointFormat =
+ 'projects/:projectId:/discussion_prompts';
+ protected readonly taskDefinitionEndpointFormat =
+ 'task_definitions/:taskDefinitionId:/discussion_prompts';
+
+ constructor(
+ httpClient: HttpClient,
+ private userService: UserService,
+ private projectService: ProjectService,
+ ) {
+ super(httpClient, API_URL);
+
+ this.mapping.addKeys(
+ 'id',
+ 'content',
+ 'priority',
+ {
+ keys: ['createdBy', 'created_by_id'],
+ toEntityFn: (data: object, key: string, prompt: DiscussionPrompt) => {
+ if (prompt.project) {
+ return prompt.project.unit.staff.find((s) => s.user.id === data['created_by_id']).user;
+ } else if (prompt.taskDefinition) {
+ return prompt.taskDefinition.unit.staff.find((s) => s.user.id === data['created_by_id'])
+ ?.user;
+ } else if (prompt.unit) {
+ return prompt.unit.staff.find((s) => s.user.id === data['created_by_id'])?.user;
+ }
+ },
+ },
+ {
+ keys: ['taskDefinition', 'task_definition_id'],
+ toEntityFn: (data: object, key: string, entity: DiscussionPrompt) => {
+ if (entity.project) {
+ return entity.project.unit.taskDef(data[key]);
+ } else if (entity.unit) {
+ return entity.unit.taskDef(data[key]);
+ }
+ return entity.taskDefinition;
+ },
+ toJsonFn: (entity: DiscussionPrompt, key: string) => {
+ return entity.taskDefinition?.id;
+ },
+ },
+ );
+
+ this.mapping.addJsonKey('project', 'taskDefinition', 'unit', 'createdBy');
+ }
+
+ public createInstanceFrom(
+ _json: object,
+ other?: Project | Unit | TaskDefinition,
+ ): DiscussionPrompt {
+ return new DiscussionPrompt(other);
+ }
+
+ // TODO: loadDiscussionPromptsForProject and overload for loadTaskDefinitionDiscussionPrompts()
+
+ public loadDiscussionPromptsForPoject(project: Project) {
+ const options: RequestOptions = {
+ endpointFormat: this.taskDefinitionProjectEndpointFormat,
+ cacheBehaviourOnGet: 'cacheQuery',
+ constructorParams: project,
+ };
+
+ return super.fetchAll(
+ {
+ projectId: project?.id,
+ },
+ options,
+ );
+ }
+
+ public loadDiscussionPrompts(
+ project: Project,
+ taskDefinition?: TaskDefinition,
+ useFetch: boolean = true,
+ ): Observable {
+ const options: RequestOptions = {
+ endpointFormat: project
+ ? taskDefinition
+ ? this.taskDefinitionProjectEndpointFormat
+ : this.projectEndpointFormat
+ : this.taskDefinitionEndpointFormat,
+ cache: taskDefinition.discussionPromptsCache,
+ sourceCache: taskDefinition.discussionPromptsCache,
+ // cacheBehaviourOnGet: 'cacheQuery',
+ constructorParams: project ? project : taskDefinition,
+ };
+
+ if (useFetch) {
+ return super.fetchAll(
+ {
+ projectId: project?.id,
+ taskDefinitionId: taskDefinition?.id,
+ },
+ options,
+ );
+ } else {
+ return super.query(
+ {
+ projectId: project?.id,
+ taskDefinitionId: taskDefinition?.id,
+ },
+ options,
+ );
+ }
+ }
+}
diff --git a/src/app/api/services/feedback-template.service.ts b/src/app/api/services/feedback-template.service.ts
new file mode 100644
index 0000000000..54d981d56b
--- /dev/null
+++ b/src/app/api/services/feedback-template.service.ts
@@ -0,0 +1,35 @@
+import {Injectable} from '@angular/core';
+import {CachedEntityService} from 'ngx-entity-service';
+import {FeedbackTemplate} from '../models/feedback-template';
+import {HttpClient} from '@angular/common/http';
+import API_URL from 'src/app/config/constants/apiUrl';
+
+@Injectable()
+export class FeedbackTemplateService extends CachedEntityService {
+ protected readonly endpointFormat = ':contextType:/:contextId:/feedback_chips';
+ public static addEndpoint = 'feedback_chips';
+ public static updateEndpoint = 'feedback_chips/:id:';
+ public static globalEndpoint = 'global/feedback_chips';
+
+ constructor(httpClient: HttpClient) {
+ super(httpClient, API_URL);
+
+ this.mapping.addKeys(
+ 'id',
+ 'type',
+ 'chipText',
+ 'description',
+ 'commentText',
+ 'summaryText',
+ 'taskStatus',
+ 'parentChipId',
+ 'learningOutcomeId',
+ );
+
+ this.mapping.mapAllKeysToJsonExcept('id');
+ }
+
+ public override createInstanceFrom(json: object, other?: any): FeedbackTemplate {
+ return new FeedbackTemplate();
+ }
+}
diff --git a/src/app/api/services/group-set.service.ts b/src/app/api/services/group-set.service.ts
index 4c976a6e4d..20fe97277e 100644
--- a/src/app/api/services/group-set.service.ts
+++ b/src/app/api/services/group-set.service.ts
@@ -1,8 +1,8 @@
-import { CachedEntityService } from 'ngx-entity-service';
-import { GroupSet, Unit } from 'src/app/api/models/doubtfire-model';
-import { Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import API_URL from 'src/app/config/constants/apiURL';
+import {CachedEntityService} from 'ngx-entity-service';
+import {GroupSet, Unit} from 'src/app/api/models/doubtfire-model';
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import API_URL from 'src/app/config/constants/apiUrl';
@Injectable()
export class GroupSetService extends CachedEntityService {
diff --git a/src/app/api/services/group.service.ts b/src/app/api/services/group.service.ts
index 0c3aa086a4..c9a7435828 100644
--- a/src/app/api/services/group.service.ts
+++ b/src/app/api/services/group.service.ts
@@ -1,8 +1,8 @@
-import { CachedEntityService } from 'ngx-entity-service';
-import { Group, Unit } from 'src/app/api/models/doubtfire-model';
-import { Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import API_URL from 'src/app/config/constants/apiURL';
+import {CachedEntityService} from 'ngx-entity-service';
+import {Group, Unit} from 'src/app/api/models/doubtfire-model';
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import API_URL from 'src/app/config/constants/apiUrl';
@Injectable()
export class GroupService extends CachedEntityService {
@@ -15,22 +15,22 @@ export class GroupService extends CachedEntityService {
'id',
'name',
{
- keys: ['groupSet','group_set_id'],
+ keys: ['groupSet', 'group_set_id'],
toEntityFn: (data: object, jsonKey: string, grp: Group) => {
return grp.unit.groupSetsCache.get(data[jsonKey]);
- }
+ },
},
'capacityAdjustment',
'locked',
'studentCount',
{
- keys: ['tutorial','tutorial_id'],
+ keys: ['tutorial', 'tutorial_id'],
toEntityFn: (data: object, jsonKey: string, grp: Group) => {
return grp.unit.tutorialsCache.get(data[jsonKey]);
},
toJsonFn: (group: Group, key: string) => {
return group.tutorial.id;
- }
+ },
},
);
diff --git a/src/app/api/services/learning-outcome.service.ts b/src/app/api/services/learning-outcome.service.ts
index c69ebc7224..2c4d6181c8 100644
--- a/src/app/api/services/learning-outcome.service.ts
+++ b/src/app/api/services/learning-outcome.service.ts
@@ -1,25 +1,30 @@
-import { CachedEntityService } from 'ngx-entity-service';
-import { LearningOutcome } from 'src/app/api/models/doubtfire-model';
-import { Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import API_URL from 'src/app/config/constants/apiURL';
+import {CachedEntityService} from 'ngx-entity-service';
+import {LearningOutcome} from 'src/app/api/models/doubtfire-model';
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import API_URL from 'src/app/config/constants/apiUrl';
@Injectable()
export class LearningOutcomeService extends CachedEntityService {
- protected readonly endpointFormat = 'units/:unitId:/outcomes/:id:';
+ protected readonly endpointFormat = ':contextType:/:contextId:/outcomes';
+ public static updateEndpoint = ':contextType:/:contextId:/outcomes/:id:';
+ public static globalEndpoint = 'global/outcomes';
+ public static updateGlobalEndpoint = 'global/outcomes/:id:';
constructor(httpClient: HttpClient) {
super(httpClient, API_URL);
this.mapping.addKeys(
'id',
- 'name',
- 'description',
+ 'contextId',
+ 'contextType',
'abbreviation',
- 'iloNumber'
+ 'shortDescription',
+ 'fullOutcomeDescription',
+ 'linkedOutcomeIds',
);
- this.mapping.mapAllKeysToJsonExcept('id');
+ this.mapping.mapAllKeysToJsonExcept('id', 'context');
}
public createInstanceFrom(json: object, other?: any): LearningOutcome {
diff --git a/src/app/api/services/lti.service.ts b/src/app/api/services/lti.service.ts
new file mode 100644
index 0000000000..3f97e32fda
--- /dev/null
+++ b/src/app/api/services/lti.service.ts
@@ -0,0 +1,74 @@
+import {HttpClient} from '@angular/common/http';
+import {Injectable} from '@angular/core';
+import {Observable} from 'rxjs';
+import LTI_API_URL from 'src/app/config/constants/ltiApiUrl';
+import {Project} from '../models/project';
+import {SidekiqJob} from '../models/sidekiq-job';
+
+interface info {
+ name?: string;
+ email?: string;
+ roles?: string[];
+ custom?: any;
+ context?:
+ | {
+ id?: string;
+ label?: string;
+ title?: string;
+ type?: string[];
+ }
+ | undefined;
+}
+
+export interface RetrievedGrade {
+ id: string;
+ scoreOf: string;
+ userId: string;
+ resultScore: number;
+ resultMaximum: number;
+ comment: string;
+}
+
+export interface UnitLink {
+ contextId?: string;
+ unitId: string;
+}
+
+@Injectable()
+export class LtiService {
+ constructor(private httpClient: HttpClient) {}
+
+ public getInfo(): Observable {
+ return this.httpClient.get(`${LTI_API_URL}/info`);
+ }
+
+ public getUnitLink(): Observable {
+ return this.httpClient.get(`${LTI_API_URL}/link`);
+ }
+
+ public setUnitLink(data: UnitLink): Observable {
+ return this.httpClient.post(`${LTI_API_URL}/link`, data);
+ }
+
+ public removeUnitLink(): Observable {
+ return this.httpClient.delete(`${LTI_API_URL}/link`);
+ }
+
+ public enrolUser(unit: UnitLink): Observable {
+ return this.httpClient.post(`${LTI_API_URL}/enrol`, unit);
+ }
+
+ public getMembers(): Observable {
+ return this.httpClient.get(`${LTI_API_URL}/members`);
+ }
+
+ // Sync grades for all members in the context (course)
+ public syncStudentsGrades(): Observable {
+ return this.httpClient.post(`${LTI_API_URL}/grades`, {});
+ }
+
+ // Sync grades for all members in the context (course)
+ public syncEnrolments(): Observable {
+ return this.httpClient.post(`${LTI_API_URL}/enrolments`, {});
+ }
+}
diff --git a/src/app/api/services/mapping-fn.ts b/src/app/api/services/mapping-fn.ts
index 7302bb387f..8da53e0bb0 100644
--- a/src/app/api/services/mapping-fn.ts
+++ b/src/app/api/services/mapping-fn.ts
@@ -1,23 +1,34 @@
+import moment from 'moment';
+
export class MappingFunctions {
- public static mapDateToEndOfDay(data, key, entity, params?) {
+ public static mapDateToEndOfDay(data, key, _entity, _params?) {
const jsonDate = new Date(data[key]);
- return new Date(jsonDate.getFullYear(), jsonDate.getMonth(), jsonDate.getDate(), 23, 59, 59, 999);
+ return new Date(
+ jsonDate.getFullYear(),
+ jsonDate.getMonth(),
+ jsonDate.getDate(),
+ 23, // all dates map to end of day
+ 59,
+ 59,
+ 999,
+ );
}
- public static mapDateToDay(data, key, entity, params?) {
+ public static mapDateToDay(data, key: string, _entity, _params?) {
const jsonDate = new Date(data[key]);
return new Date(jsonDate.getFullYear(), jsonDate.getMonth(), jsonDate.getDate());
}
- public static mapDate(data, key, entity, params?) {
+ public static mapDate(data, key: string, _entity, _params?) {
return new Date(data[key]);
}
public static mapDayToJson(entity: T, key: string): string {
if (entity[key]) {
- const month = entity[key].getMonth() + 1;
- const day = entity[key].getDate();
- return `${entity[key].getFullYear()}-${month < 10 ? '0' : ''}${month}-${day < 10 ? '0' : ''}${day}`;
+ const dateValue = moment.isMoment(entity[key]) ? entity[key].toDate() : entity[key];
+ const month = dateValue.getMonth() + 1;
+ const day = dateValue.getDate();
+ return `${dateValue.getFullYear()}-${month < 10 ? '0' : ''}${month}-${day < 10 ? '0' : ''}${day}`;
} else {
return undefined;
}
@@ -50,12 +61,34 @@ export class MappingFunctions {
}
/**
- * Calculate the time between two dates
- *
- * @param date1 days from this date
- * @param date2 to this date
- * @returns the time from date1 to date2
- */
+ * Add a number of days to a date.
+ *
+ * @param date starting date
+ * @param days days to add
+ * @returns the date that is `days` days after `date`
+ */
+ public static addDays(date: Date, days: number): Date {
+ return new Date(date.getTime() + MappingFunctions.dayMs(days));
+ }
+
+ /**
+ * Add a number of weeks to a date.
+ *
+ * @param date starting date
+ * @param weeks days to add
+ * @returns the date that is `days` days after `date`
+ */
+ public static addWeeks(date: Date, weeks: number): Date {
+ return new Date(date.getTime() + MappingFunctions.weeksMs(weeks));
+ }
+
+ /**
+ * Calculate the time between two dates
+ *
+ * @param date1 days from this date
+ * @param date2 to this date
+ * @returns the time from date1 to date2
+ */
public static timeBetween(date1: Date, date2: Date): number {
return date2.getTime() - date1.getTime();
}
@@ -67,7 +100,7 @@ export class MappingFunctions {
* @param date2 to this date
* @returns the days from date1 to date2
*/
- public static daysBetween(date1: Date, date2: Date): number {
+ public static daysBetween(date1: Date, date2: Date): number {
const diff = this.timeBetween(date1, date2);
return Math.ceil(diff / (1000 * 3600 * 24));
}
diff --git a/src/app/api/services/marking-session.service.ts b/src/app/api/services/marking-session.service.ts
new file mode 100644
index 0000000000..a621dfa5f0
--- /dev/null
+++ b/src/app/api/services/marking-session.service.ts
@@ -0,0 +1,39 @@
+import {HttpClient} from '@angular/common/http';
+import {Injectable} from '@angular/core';
+import {CachedEntityService} from 'ngx-entity-service';
+import {Unit} from 'src/app/api/models/doubtfire-model';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {MarkingSession} from '../models/marking-session';
+
+@Injectable()
+export class MarkingSessionService extends CachedEntityService {
+ protected readonly endpointFormat = 'units/:unitId:/marking_sessions/:id:';
+
+ constructor(httpClient: HttpClient) {
+ super(httpClient, API_URL);
+
+ this.mapping.addKeys(
+ 'id',
+ 'startTime',
+ 'endTime',
+ 'duringTutorial',
+ 'durationMinutes',
+
+ 'commentsAdded',
+ 'assessments',
+ 'submissionsOpened',
+
+ {
+ keys: ['user', 'user_id'],
+ toEntityFn: (data: object, _key: string, markingSession: MarkingSession) => {
+ const userRole = markingSession.unit.staff.find((s) => s.user.id === data['user_id']);
+ return userRole?.user;
+ },
+ },
+ );
+ }
+
+ public createInstanceFrom(json: object, other?: Unit): MarkingSession {
+ return new MarkingSession(other);
+ }
+}
diff --git a/src/app/api/services/overseer-assessment.service.ts b/src/app/api/services/overseer-assessment.service.ts
index 9f0017dc98..82c41e3dbc 100644
--- a/src/app/api/services/overseer-assessment.service.ts
+++ b/src/app/api/services/overseer-assessment.service.ts
@@ -1,16 +1,23 @@
-import { Injectable } from '@angular/core';
-import { EntityService } from 'ngx-entity-service';
-import { Observable } from 'rxjs';
-import { HttpClient } from '@angular/common/http';
-import API_URL from 'src/app/config/constants/apiURL';
-import { OverseerAssessment } from '../models/overseer/overseer-assessment';
+import {Injectable} from '@angular/core';
+import {EntityService} from 'ngx-entity-service';
+import {Observable} from 'rxjs';
+import {HttpClient} from '@angular/common/http';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {OverseerAssessment} from '../models/overseer/overseer-assessment';
+import {Task} from '../models/doubtfire-model';
+import {OverseerStepResultService} from './overseer-step-result.service';
@Injectable()
export class OverseerAssessmentService extends EntityService {
- protected readonly endpointFormat = 'projects/:project_id:/task_def_id/:td_id:/submissions/timestamps/:timestamp:';
- protected readonly triggerEndpointFormat = 'projects/:project_id:/task_def_id/:td_id:/overseer_assessment/:id:/trigger';
+ protected readonly endpointFormat =
+ 'projects/:project_id:/task_def_id/:td_id:/submissions/timestamps/:timestamp:';
+ protected readonly triggerEndpointFormat =
+ 'projects/:project_id:/task_def_id/:td_id:/overseer_assessment/:id:/trigger';
- constructor(httpClient: HttpClient) {
+ constructor(
+ httpClient: HttpClient,
+ private overseerStepResultService: OverseerStepResultService,
+ ) {
super(httpClient, API_URL);
this.mapping.addKeys(
@@ -25,9 +32,28 @@ export class OverseerAssessmentService extends EntityService
keys: ['timestamp', 'submission_timestamp'],
toEntityFn: (data, key, entity, params?) => {
return new Date(data['submission_timestamp'] * 1000);
- }
+ },
},
- ['timestampString', 'submission_timestamp']
+ ['timestampString', 'submission_timestamp'],
+ {
+ keys: 'overseerStepResults',
+ toEntityOp: (data: object, key: string, overseerAssesment: OverseerAssessment) => {
+ data[key]?.forEach((overseerStep) => {
+ overseerAssesment.stepResultsCache.getOrCreate(
+ overseerStep['id'],
+ this.overseerStepResultService,
+ overseerStep,
+ {
+ constructorParams: overseerAssesment,
+ },
+ );
+ });
+ },
+ },
+ 'overseerStepId',
+ 'totalSteps',
+ 'passedSteps',
+ 'hasSubmissionFiles',
);
}
@@ -35,22 +61,23 @@ export class OverseerAssessmentService extends EntityService
return new OverseerAssessment(other);
}
- public queryForTask(task: any): Observable {
+ public queryForTask(task: Task): Observable {
const pathIds = {
project_id: task.project.id,
- td_id: task.definition.id
+ td_id: task.definition.id,
};
- return this.query(pathIds, task);
+ return this.query(pathIds, {
+ constructorParams: task,
+ });
}
- public triggerOverseer(assessment: OverseerAssessment) : Observable {
+ public triggerOverseer(assessment: OverseerAssessment): Observable {
const pathIds = {
project_id: assessment.task.project.id,
td_id: assessment.task.definition.id,
- id: assessment.id
- }
- return this.put(pathIds, { endpointFormat: this.triggerEndpointFormat });
+ id: assessment.id,
+ };
+ return this.put(pathIds, {endpointFormat: this.triggerEndpointFormat});
}
-
}
diff --git a/src/app/api/services/overseer-image.service.ts b/src/app/api/services/overseer-image.service.ts
index 53a5616f56..7edc65932f 100644
--- a/src/app/api/services/overseer-image.service.ts
+++ b/src/app/api/services/overseer-image.service.ts
@@ -1,9 +1,10 @@
-import { CachedEntityService } from 'ngx-entity-service';
-import { Observable, switchMap } from 'rxjs';
-import { OverseerImage } from 'src/app/api/models/doubtfire-model';
-import { Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import API_URL from 'src/app/config/constants/apiURL';
+import {CachedEntityService} from 'ngx-entity-service';
+import {Observable, switchMap} from 'rxjs';
+import {OverseerImage} from 'src/app/api/models/doubtfire-model';
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {SidekiqJob} from '../models/sidekiq-job';
@Injectable()
export class OverseerImageService extends CachedEntityService {
@@ -19,20 +20,16 @@ export class OverseerImageService extends CachedEntityService {
'tag',
'pulledImageText',
'pulledImageStatus',
- 'lastPulledDate'
+ 'lastPulledDate',
);
this.mapping.mapAllKeysToJsonExcept('id');
}
- public pullDockerImage(image: OverseerImage): Observable {
+ public pullDockerImage(image: OverseerImage): Observable {
return super.put(image, {
- endpointFormat: this.pullImageEndpointFormat
- }).pipe(
- switchMap(response => {
- return super.update(image);
- })
- )
+ endpointFormat: this.pullImageEndpointFormat,
+ });
}
public createInstanceFrom(json: object, other?: any): OverseerImage {
diff --git a/src/app/api/services/overseer-step-result.service.ts b/src/app/api/services/overseer-step-result.service.ts
new file mode 100644
index 0000000000..f7e873281b
--- /dev/null
+++ b/src/app/api/services/overseer-step-result.service.ts
@@ -0,0 +1,52 @@
+import {HttpClient} from '@angular/common/http';
+import {Injectable} from '@angular/core';
+import {CachedEntityService} from 'ngx-entity-service';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {OverseerAssessment} from '../models/doubtfire-model';
+import {OverseerStepResult} from '../models/overseer/overseer-step-result';
+import {Observable} from 'rxjs';
+
+@Injectable()
+export class OverseerStepResultService extends CachedEntityService {
+ protected readonly endpointFormat =
+ 'units/:unitId:/task_definitions/:taskDefId:/overseer_step_results/:id:';
+
+ constructor(httpClient: HttpClient) {
+ super(httpClient, API_URL);
+
+ this.mapping.addKeys(
+ 'id',
+ 'overseerStepId',
+ 'exitStatus',
+ 'pass',
+ 'feedbackMessage',
+ 'stdout',
+ 'stdin',
+ 'expectedOutput',
+ 'stdoutSha256',
+ 'stdinSha256',
+ 'expectedOutputSha256',
+ );
+
+ this.mapping.mapAllKeysToJsonExcept('id');
+ }
+
+ public createInstanceFrom(json: object, other?: any): OverseerStepResult {
+ return new OverseerStepResult(other as OverseerAssessment);
+ }
+
+ public getOverseerStepResults(assessment: OverseerAssessment): Observable {
+ const pathIds = {
+ projectId: assessment.task.project.id,
+ taskDefId: assessment.task.definition.id,
+ id: assessment.id,
+ };
+
+ return this.query(pathIds, {
+ endpointFormat:
+ 'projects/:projectId:/task_definitions/:taskDefId:/overseer_assessments_results/:id:',
+ constructorParams: assessment.task,
+ cache: assessment.stepResultsCache,
+ });
+ }
+}
diff --git a/src/app/api/services/overseer-step.service.ts b/src/app/api/services/overseer-step.service.ts
new file mode 100644
index 0000000000..3d8a8fca9a
--- /dev/null
+++ b/src/app/api/services/overseer-step.service.ts
@@ -0,0 +1,60 @@
+import {HttpClient} from '@angular/common/http';
+import {Injectable} from '@angular/core';
+import {CachedEntityService} from 'ngx-entity-service';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {OverseerStep} from '../models/overseer/overseer-step';
+import {TaskDefinition} from '../models/task-definition';
+
+@Injectable()
+export class OverseerStepService extends CachedEntityService {
+ protected readonly endpointFormat =
+ 'units/:unitId:/task_definitions/:taskDefId:/overseer_steps/:id:';
+
+ constructor(httpClient: HttpClient) {
+ super(httpClient, API_URL);
+
+ this.mapping.addKeys(
+ 'id',
+ // 'taskDefinition',
+ 'name',
+ 'description',
+ 'displayName',
+ 'displayDescription',
+ // 'runCommand',
+ {
+ keys: 'runCommand',
+ toEntityFn: (data: object, key: string, entity: OverseerStep, params?: any) => {
+ const raw = data['run_command'];
+ if (raw?.startsWith('b64:')) {
+ entity.decodedRunCommand = atob(raw.slice(4));
+ } else {
+ entity.decodedRunCommand = raw;
+ }
+
+ return raw;
+ },
+ },
+ 'timeout',
+ 'sortOrder',
+ 'stepType',
+ 'partialOutputDiff',
+ 'stdinInputFile',
+ 'expectedOutputFile',
+ 'feedbackMessage',
+ 'statusOnSuccess',
+ 'statusOnFailure',
+ 'haltOnSuccess',
+ 'haltOnFailure',
+ 'showExpectedOutput',
+ 'showStdin',
+ 'showStdout',
+ 'enabled',
+ );
+
+ this.mapping.mapAllKeysToJsonExcept('id');
+ }
+
+ public createInstanceFrom(json: object, other?: any): OverseerStep {
+ return new OverseerStep(other as TaskDefinition);
+ }
+}
diff --git a/src/app/api/services/project.service.ts b/src/app/api/services/project.service.ts
index e9ffc791ed..fe7aaa30d0 100644
--- a/src/app/api/services/project.service.ts
+++ b/src/app/api/services/project.service.ts
@@ -1,14 +1,20 @@
-import { CachedEntityService, RequestOptions } from 'ngx-entity-service';
-import { CampusService, Project, Unit, UnitService, UserService } from 'src/app/api/models/doubtfire-model';
-import { Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import API_URL from 'src/app/config/constants/apiURL';
-import { AppInjector } from 'src/app/app-injector';
-import { Observable } from 'rxjs';
-import { TaskService } from './task.service';
-import { MappingProcess } from 'ngx-entity-service/lib/mapping-process';
-import { TaskOutcomeAlignmentService } from './task-outcome-alignment.service';
-import { GroupService } from './group.service';
+import {CachedEntityService, RequestOptions} from 'ngx-entity-service';
+import {
+ CampusService,
+ Project,
+ Unit,
+ UnitService,
+ UserService,
+} from 'src/app/api/models/doubtfire-model';
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {AppInjector} from 'src/app/app-injector';
+import {Observable} from 'rxjs';
+import {TaskService} from './task.service';
+import {MappingProcess} from 'ngx-entity-service/lib/mapping-process';
+import {TaskOutcomeAlignmentService} from './task-outcome-alignment.service';
+import {GroupService} from './group.service';
@Injectable()
export class ProjectService extends CachedEntityService {
@@ -22,7 +28,7 @@ export class ProjectService extends CachedEntityService {
private userService: UserService,
private taskService: TaskService,
private taskOutcomeAlignmentService: TaskOutcomeAlignmentService,
- private groupService: GroupService
+ private groupService: GroupService,
) {
super(httpClient, API_URL);
@@ -33,12 +39,14 @@ export class ProjectService extends CachedEntityService {
keys: ['campus', 'campus_id'],
toEntityOp: (data: object, key: string, entity: Project, params?: any) => {
if (data['campus_id']) {
- return this.campusService.get(data['campus_id']).subscribe(campus => { entity.campus = campus; });
+ return this.campusService.get(data['campus_id']).subscribe((campus) => {
+ entity.campus = campus;
+ });
}
},
toJsonFn: (entity: Project, key: string) => {
return entity.campus ? entity.campus.id : entity.originalJson['camput_id'] ? -1 : null;
- }
+ },
},
{
keys: 'student',
@@ -46,7 +54,7 @@ export class ProjectService extends CachedEntityService {
const userData = data['student'];
return this.userService.cache.getOrCreate(userData.id, this.userService, userData);
- }
+ },
},
{
keys: 'userId',
@@ -56,9 +64,9 @@ export class ProjectService extends CachedEntityService {
this.userService.get(userId).subscribe({
next: (user) => {
entity.student = user;
- }
+ },
});
- }
+ },
},
'enrolled',
'targetGrade',
@@ -66,6 +74,8 @@ export class ProjectService extends CachedEntityService {
'portfolioFiles',
'compilePortfolio',
'similarityFlag',
+ 'specConDays',
+ 'staffNoteCount',
{
keys: 'hasPortfolio',
toEntityFn: (data: object, key: string, entity: Project, params?: any) => {
@@ -76,7 +86,7 @@ export class ProjectService extends CachedEntityService {
else entity.portfolioStatus = 0;
return result;
- }
+ },
},
'portfolioAvailable',
'usesDraftLearningSummary',
@@ -86,29 +96,29 @@ export class ProjectService extends CachedEntityService {
const values = data[key];
entity.taskStats = [
{
- key: "fail",
- value: Math.round((values['red_pct'] || 0) * 100)
+ key: 'fail',
+ value: Math.round((values['red_pct'] || 0) * 100),
},
{
- key: "not_started",
+ key: 'not_started',
value: Math.round((values['grey_pct'] || 1) * 100),
},
{
- key: "working_on_it",
- value: Math.round((values['orange_pct'] || 0) * 100),
+ key: 'working_on_it',
+ value: Math.round((values['orange_pct'] || 0) * 100),
},
{
- key: "ready_for_feedback",
+ key: 'ready_for_feedback',
value: Math.round((values['blue_pct'] || 0) * 100),
},
{
- key: "complete",
- value: Math.round((values['green_pct'] || 0) * 100)
- }
+ key: 'complete',
+ value: Math.round((values['green_pct'] || 0) * 100),
+ },
];
entity.orderScale = Math.round((values['order_scale'] || 0) * 100);
- }
+ },
},
'grade',
'gradeRationale',
@@ -123,7 +133,7 @@ export class ProjectService extends CachedEntityService {
},
toJsonFn: (entity: Project, key: string) => {
return entity.unit?.id;
- }
+ },
},
{
keys: 'unitId',
@@ -131,66 +141,74 @@ export class ProjectService extends CachedEntityService {
const unitService: UnitService = AppInjector.get(UnitService);
const unitId = process.data['unit_id'];
// Load what we have... or a a stub for now...
- process.entity.unit = unitService.cache.getOrCreate(unitId, unitService, { id: unitId });
- return unitService.get(unitId).subscribe(unit => {
+ process.entity.unit = unitService.cache.getOrCreate(unitId, unitService, {id: unitId});
+ return unitService.get(unitId).subscribe((unit) => {
process.entity.unit = unit;
unit.studentCache.add(process.entity);
process.continue();
});
- }
+ },
},
{
keys: 'tutorialEnrolments',
toEntityOp: (data: object, key: string, project: Project, params?: any) => {
const unit: Unit = project.unit;
- data[key].forEach((tutorialEnrolment: { tutorial_id: number; }) => {
+ data[key]?.forEach((tutorialEnrolment: {tutorial_id: number}) => {
if (tutorialEnrolment.tutorial_id) {
const tutorial = unit.tutorialsCache.get(tutorialEnrolment.tutorial_id);
project.tutorialEnrolmentsCache.add(tutorial);
}
});
- }
+ },
},
{
keys: 'groups',
toEntityOp: (data: object, key: string, project: Project, params?: any) => {
- data[key].forEach((group) => {
- const theGroup = project.unit.groupSetsCache.get(group.group_set_id).groupsCache.getOrCreate(group.id, this.groupService, group, {constructorParams: project.unit});
+ data[key]?.forEach((group) => {
+ const theGroup = project.unit.groupSetsCache
+ .get(group.group_set_id)
+ .groupsCache.getOrCreate(group.id, this.groupService, group, {
+ constructorParams: project.unit,
+ });
project.groupCache.add(theGroup);
theGroup.projectsCache.add(project);
- })
+ });
},
toJsonFn: (entity: Project, key: string) => {
return entity.unit?.id;
- }
+ },
},
{
keys: 'tasks',
toEntityOp: (data: object, key: string, project: Project, params?: any) => {
// create tasks from json
- data['tasks'].forEach(taskData => {
- project.taskCache.getOrCreate(taskData['id'], this.taskService, taskData, {constructorParams: project});
+ data['tasks']?.forEach((taskData) => {
+ project.taskCache.getOrCreate(taskData['id'], this.taskService, taskData, {
+ constructorParams: project,
+ });
});
project.unit.setupTasksForStudent(project);
- }
+ },
},
{
keys: 'taskOutcomeAlignments',
toEntityOp: (data: object, key: string, project: Project, params?: any) => {
- data[key].forEach(alignment => {
+ data[key]?.forEach((alignment) => {
project.taskOutcomeAlignmentsCache.getOrCreate(
alignment['id'],
taskOutcomeAlignmentService,
alignment,
{
- constructorParams: project
- }
+ constructorParams: project,
+ },
);
});
- }
+ },
},
+ 'escalationAttemptsRemaining',
+ 'portfolioSubmissionDate',
);
this.mapping.addJsonKey(
@@ -200,7 +218,7 @@ export class ProjectService extends CachedEntityService {
'compilePortfolio',
'grade',
'gradeRationale',
- 'campus'
+ 'campus',
);
}
@@ -208,16 +226,20 @@ export class ProjectService extends CachedEntityService {
return new Project(other as Unit);
}
- public loadStudents(unit: Unit, withdrawnOnly: boolean = false, useFetch: boolean = false): Observable {
+ public loadStudents(
+ unit: Unit,
+ withdrawnOnly: boolean = false,
+ useFetch: boolean = false,
+ ): Observable {
const options: RequestOptions = {
cache: unit.studentCache,
endpointFormat: this.studentEndpointFormat,
params: {
withdrawn: withdrawnOnly,
- unit_id: unit.id
+ unit_id: unit.id,
},
- constructorParams: unit
- }
+ constructorParams: unit,
+ };
if (useFetch) {
return super.fetchAll(undefined, options);
@@ -226,13 +248,17 @@ export class ProjectService extends CachedEntityService {
}
}
- public loadProject(proj: Project | number, unit: Unit, useFetch: boolean = false): Observable {
+ public loadProject(
+ proj: Project | number,
+ unit: Unit,
+ useFetch: boolean = false,
+ ): Observable {
const options: RequestOptions = {
cache: unit.studentCache,
sourceCache: unit.studentCache,
constructorParams: unit,
- cacheBehaviourOnGet: "cacheQuery"
- }
+ cacheBehaviourOnGet: 'cacheQuery',
+ };
if (useFetch) {
return super.fetch(proj, options);
diff --git a/src/app/api/services/scorm-adapter.service.ts b/src/app/api/services/scorm-adapter.service.ts
new file mode 100644
index 0000000000..bdeb14fc77
--- /dev/null
+++ b/src/app/api/services/scorm-adapter.service.ts
@@ -0,0 +1,283 @@
+import {Injectable} from '@angular/core';
+import {UserService} from './user.service';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {ScormDataModel, ScormPlayerContext} from 'src/app/api/models/doubtfire-model';
+
+@Injectable({
+ providedIn: 'root',
+})
+export class ScormAdapterService {
+ private dataModel: ScormDataModel;
+ private context: ScormPlayerContext;
+ private xhr: XMLHttpRequest;
+
+ constructor(private userService: UserService) {
+ this.dataModel = new ScormDataModel();
+ this.context = new ScormPlayerContext(this.userService.currentUser);
+ this.xhr = new XMLHttpRequest();
+ }
+
+ set projectId(projectId: number) {
+ this.context.projectId = projectId;
+ }
+
+ set taskDefId(taskDefId: number) {
+ this.context.taskDefId = taskDefId;
+ }
+
+ set mode(mode: 'browse' | 'normal' | 'review' | 'preview') {
+ this.context.mode = mode;
+ }
+
+ set testAttemptId(testAttemptId: number) {
+ this.context.attemptId = testAttemptId;
+ }
+
+ get state() {
+ return this.context.state;
+ }
+
+ destroy() {
+ this.dataModel = new ScormDataModel();
+ this.context.state = 'Uninitialized';
+ }
+
+ Initialize(): string {
+ // console.log('API_1484_11: Initialize');
+
+ // TODO: error handling and reporting
+ switch (this.context.state) {
+ case 'Initialized':
+ this.context.errorCode = 103;
+ // console.log('Already Initialized');
+ break;
+ case 'Terminated':
+ this.context.errorCode = 104;
+ // console.log('Content Instance Terminated');
+ break;
+ }
+
+ if (this.context.mode === 'review') {
+ this.xhr.open('GET', `${API_URL}/test_attempts/${this.context.attemptId}/review`, false);
+ this.xhr.setRequestHeader('Auth-Token', this.context.user.authenticationToken);
+ this.xhr.setRequestHeader('Username', this.context.user.username);
+
+ this.xhr.send();
+ // console.log(this.xhr.responseText);
+
+ const reviewSession = JSON.parse(this.xhr.responseText);
+ this.dataModel.restore(reviewSession.cmi_datamodel);
+ // console.log(this.dataModel.dump());
+
+ this.context.state = 'Initialized';
+ return 'true';
+ }
+
+ // TODO: move this part into the player component
+ this.xhr.open(
+ 'GET',
+ `${API_URL}/projects/${this.context.projectId}/task_def_id/${this.context.taskDefId}/test_attempts/latest`,
+ false,
+ );
+ this.xhr.setRequestHeader('Auth-Token', this.context.user.authenticationToken);
+ this.xhr.setRequestHeader('Username', this.context.user.username);
+
+ let noTestFound = false;
+ let startNewTest = false;
+
+ this.xhr.onload = () => {
+ if (this.xhr.status == 404) {
+ noTestFound = true;
+ }
+
+ // if (this.xhr.status >= 200 && this.xhr.status < 400) {
+ // console.log('Retrieved the latest attempt.');
+ // } else if (this.xhr.status == 404) {
+ // console.log('Not found.');
+ // noTestFound = true;
+ // } else {
+ // console.error('Error saving DataModel:', this.xhr.responseText);
+ // }
+ };
+
+ this.xhr.send();
+ // console.log(this.xhr.responseText);
+
+ if (!noTestFound) {
+ const latestSession = JSON.parse(this.xhr.responseText);
+ // console.log('Latest exam session:', latestSession);
+ this.context.attemptId = latestSession.id;
+ if (latestSession.completion_status) {
+ startNewTest = true;
+ }
+ } else {
+ startNewTest = true;
+ }
+
+ if (!startNewTest) {
+ this.xhr.open('PATCH', `${API_URL}/test_attempts/${this.context.attemptId}`, false);
+ this.xhr.setRequestHeader('Auth-Token', this.context.user.authenticationToken);
+ this.xhr.setRequestHeader('Username', this.context.user.username);
+ this.xhr.send();
+ // console.log(this.xhr.responseText);
+
+ const currentSession = JSON.parse(this.xhr.responseText);
+ // console.log('Current exam session:', currentSession);
+ this.context.attemptId = currentSession.id;
+ this.dataModel.restore(currentSession.cmi_datamodel);
+ // console.log(this.dataModel.dump());
+ } else {
+ this.xhr.open(
+ 'POST',
+ `${API_URL}/projects/${this.context.projectId}/task_def_id/${this.context.taskDefId}/test_attempts`,
+ false,
+ );
+ this.xhr.setRequestHeader('Auth-Token', this.context.user.authenticationToken);
+ this.xhr.setRequestHeader('Username', this.context.user.username);
+ this.xhr.send();
+ // console.log(this.xhr.responseText);
+
+ const currentSession = JSON.parse(this.xhr.responseText);
+ // console.log('Current exam session:', currentSession);
+ this.context.attemptId = currentSession.id;
+ this.dataModel.restore(currentSession.cmi_datamodel);
+ // console.log(this.dataModel.dump());
+ }
+
+ this.context.state = 'Initialized';
+ return 'true';
+ }
+
+ Terminate(): string {
+ // console.log('API_1484_11: Terminate');
+
+ // TODO: error handling and reporting
+ switch (this.context.state) {
+ case 'Uninitialized':
+ this.context.errorCode = 112;
+ // console.log('Termination Before Initialization');
+ break;
+ case 'Terminated':
+ this.context.errorCode = 113;
+ // console.log('Termination After Termination');
+ break;
+ }
+
+ this.xhr.open('PATCH', `${API_URL}/test_attempts/${this.context.attemptId}`, false);
+ this.xhr.setRequestHeader('Auth-Token', this.context.user.authenticationToken);
+ this.xhr.setRequestHeader('Username', this.context.user.username);
+ this.xhr.setRequestHeader('Content-Type', 'application/json');
+ const requestData = {
+ cmi_datamodel: JSON.stringify(this.dataModel.dump()),
+ terminated: true,
+ };
+ this.xhr.send(JSON.stringify(requestData));
+ // console.log(this.xhr.responseText);
+
+ // all done, clearing datamodel and setting state to terminated
+ this.dataModel = new ScormDataModel();
+ this.context.state = 'Terminated';
+ return 'true';
+ }
+
+ GetValue(element: string): string {
+ const value = this.dataModel.get(element);
+
+ // TODO: error reporting
+ // TODO: can't get until init is done
+ switch (this.context.state) {
+ case 'Uninitialized':
+ this.context.errorCode = 122;
+ // console.log('Retrieve Data Before Initialization');
+ break;
+ case 'Terminated':
+ this.context.errorCode = 123;
+ // console.log('Retrieve Data After Termination');
+ break;
+ }
+
+ // console.log(`API_1484_11: GetValue:`, element, value);
+ return value;
+ }
+
+ SetValue(element: string, value: any): string {
+ // console.log(`API_1484_11: SetValue:`, element, value);
+
+ // TODO: error reporting
+ // TODO: can't set until init is done
+ switch (this.context.state) {
+ case 'Uninitialized':
+ this.context.errorCode = 132;
+ // console.log('Store Data Before Initialization');
+ break;
+ case 'Terminated':
+ this.context.errorCode = 133;
+ // console.log('Store Data After Termination');
+ break;
+ }
+
+ this.dataModel.set(element, value);
+ return 'true';
+ }
+
+ Commit(): string {
+ // console.log('API_1484_11: Commit');
+
+ // TODO: error reporting
+ // TODO: can't commit until init is done
+ switch (this.context.state) {
+ case 'Uninitialized':
+ this.context.errorCode = 142;
+ // console.log('Commit Before Initialization');
+ break;
+ case 'Terminated':
+ this.context.errorCode = 143;
+ // console.log('Commit After Termination');
+ break;
+ }
+
+ this.xhr.open('PATCH', `${API_URL}/test_attempts/${this.context.attemptId}`, true);
+ this.xhr.setRequestHeader('Auth-Token', this.context.user.authenticationToken);
+ this.xhr.setRequestHeader('Username', this.context.user.username);
+ this.xhr.setRequestHeader('Content-Type', 'application/json');
+ const requestData = {
+ cmi_datamodel: JSON.stringify(this.dataModel.dump()),
+ };
+
+ // this.xhr.onload = () => {
+ // if (this.xhr.status >= 200 && this.xhr.status < 400) {
+ // console.log('DataModel saved successfully.');
+ // } else {
+ // console.error('Error saving DataModel:', this.xhr.responseText);
+ // }
+ // };
+
+ // this.xhr.onerror = () => {
+ // console.error('Request failed.');
+ // };
+
+ this.xhr.send(JSON.stringify(requestData));
+ this.context.errorCode = 0;
+ return 'true';
+ }
+
+ GetLastError(): string {
+ const lastError = this.context.errorCode.toString();
+ // if (lastError !== '0') {
+ // console.log(`API_1484_11: GetLastError: ${lastError}`);
+ // }
+ return lastError;
+ }
+
+ GetErrorString(errorCode: string): string {
+ const errorString = this.context.getErrorMessage(errorCode);
+ // console.log(`API_1484_11: GetErrorString:`, errorCode, errorString);
+ return errorString;
+ }
+
+ GetDiagnostic(errorCode: string): string {
+ // TODO: implement this
+ // console.log(`API_1484_11: GetDiagnostic:`, errorCode);
+ return 'GetDiagnostic is currently not implemented';
+ }
+}
diff --git a/src/app/api/services/sidekiq-job.service.ts b/src/app/api/services/sidekiq-job.service.ts
new file mode 100644
index 0000000000..dd5332a258
--- /dev/null
+++ b/src/app/api/services/sidekiq-job.service.ts
@@ -0,0 +1,100 @@
+import {HttpClient} from '@angular/common/http';
+import {Injectable} from '@angular/core';
+import {CachedEntityService} from 'ngx-entity-service';
+import {BehaviorSubject, Observable, Subject} from 'rxjs';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {SidekiqJob} from '../models/sidekiq-job';
+
+export interface SidekiqJobEntry {
+ job?: SidekiqJob;
+ title: string;
+ resultSubject: Subject;
+}
+
+@Injectable()
+export class SidekiqJobService extends CachedEntityService {
+ protected readonly endpointFormat = 'sidekiq/:id:';
+
+ public jobEntries: Map = new Map();
+
+ // Allow components to track changes to jobEntries
+ public sidekiqJobsSubject = new BehaviorSubject([]);
+
+ public setJob(jobId: string, title: string, subject: Subject, job?: SidekiqJob) {
+ this.jobEntries.set(jobId, {
+ job,
+ title,
+ resultSubject: subject,
+ });
+ this.emitJobs();
+ }
+
+ public removeJob(jobId: string) {
+ this.jobEntries.delete(jobId);
+ this.emitJobs();
+ }
+
+ private emitJobs() {
+ this.sidekiqJobsSubject.next(Array.from(this.jobEntries.values()));
+ }
+
+ constructor(httpClient: HttpClient) {
+ super(httpClient, API_URL);
+
+ this.mapping.addKeys(
+ 'id',
+ 'jobClass',
+ 'status',
+ {
+ keys: 'pctComplete',
+ toEntityOp: (data: object, jsonKey: string, job: SidekiqJob, _params?) => {
+ job.pctComplete = Number(data[jsonKey]);
+ },
+ },
+ 'message',
+ {
+ keys: 'processedCount',
+ toEntityOp: (data: object, jsonKey: string, job: SidekiqJob, _params?) => {
+ job.processedCount = Number(data[jsonKey]);
+ },
+ },
+ {
+ keys: 'totalCount',
+ toEntityOp: (data: object, jsonKey: string, job: SidekiqJob, _params?) => {
+ job.totalCount = Number(data[jsonKey]);
+ },
+ },
+ 'result',
+ 'createdAt',
+ 'updatedAt',
+ );
+
+ this.mapping.addJsonKey(
+ 'id',
+ 'jobClass',
+ 'status',
+ 'message',
+ 'result',
+ 'createdAt',
+ 'updatedAt',
+ );
+ }
+
+ public createInstanceFrom(_json: object): SidekiqJob {
+ return new SidekiqJob();
+ }
+
+ public getSidekiqJob(jobId: string): Observable {
+ // TODO: cache the response to avoid fetching the same result data when the job is complete
+ return this.fetch(
+ {
+ id: jobId,
+ },
+ {
+ endpointFormat: this.endpointFormat,
+ },
+ );
+ }
+
+ // TODO: we could create endpoints to cancel/retry sidekiq jobs
+}
diff --git a/src/app/api/services/staff-note.service.ts b/src/app/api/services/staff-note.service.ts
new file mode 100644
index 0000000000..0a707fea8c
--- /dev/null
+++ b/src/app/api/services/staff-note.service.ts
@@ -0,0 +1,123 @@
+import {HttpClient} from '@angular/common/http';
+import {EventEmitter, Injectable} from '@angular/core';
+import {CachedEntityService, RequestOptions} from 'ngx-entity-service';
+import {Project, ProjectService, UserService} from 'src/app/api/models/doubtfire-model';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {StaffNote} from '../models/staff-note';
+import {Observable, tap} from 'rxjs';
+
+@Injectable()
+export class StaffNoteService extends CachedEntityService {
+ public readonly staffNoteAdded$: EventEmitter = new EventEmitter();
+
+ protected readonly endpointFormat = 'projects/:projectId:/staff_notes/:id:';
+
+ constructor(
+ httpClient: HttpClient,
+ private userService: UserService,
+ private projectService: ProjectService,
+ ) {
+ super(httpClient, API_URL);
+
+ this.mapping.addKeys('id', 'note', 'createdAt', 'updatedAt', 'replyToId', {
+ keys: ['user', 'user_id'],
+ toEntityFn: (data: object, key: string, staffNote: StaffNote) => {
+ const userRole = staffNote.project.unit.staff.find((s) => s.user.id === data['user_id']);
+
+ // const user = this.userService.cache.getOrCreate(data[key]?.id, userService, data[key]);
+ return userRole.user;
+ },
+ });
+
+ this.mapping.addJsonKey('note', 'createdAt', 'updatedAt');
+ }
+
+ public createInstanceFrom(json: object, other?: Project): StaffNote {
+ return new StaffNote(other);
+ }
+
+ public addNote(project: Project, text: string, originalNote: StaffNote): Observable {
+ const pathId = {
+ projectId: project.id,
+ };
+
+ const body: FormData = new FormData();
+ if (originalNote) {
+ body.append('reply_to_id', originalNote?.id.toString());
+ }
+
+ body.append('note', text);
+
+ const opts: RequestOptions = {endpointFormat: this.endpointFormat};
+ opts.cache = project.staffNoteCache;
+ opts.body = body;
+ opts.constructorParams = project;
+
+ return this.create(pathId, opts).pipe(
+ tap((note: StaffNote) => {
+ this.staffNoteAdded$.emit(note);
+ }),
+ );
+ }
+
+ public updateStaffNoteReplies(staffNotes: readonly StaffNote[]) {
+ for (const note of staffNotes) {
+ if (note.replyToId) {
+ const repliedTo = staffNotes.find((n) => n.id === note.replyToId);
+ if (repliedTo) {
+ note.replyTo = repliedTo;
+ } else {
+ // Remove deleted replies
+ note.replyTo = null;
+ }
+ }
+ }
+ }
+
+ public updateNote(project: Project, note: StaffNote, text: string): Observable {
+ const pathId = {
+ projectId: project.id,
+ id: note.id,
+ };
+
+ const body: FormData = new FormData();
+ body.append('note', text);
+
+ const opts: RequestOptions = {endpointFormat: this.endpointFormat};
+ opts.cache = project.staffNoteCache;
+ opts.body = body;
+ opts.constructorParams = project;
+
+ return this.put(pathId, opts).pipe(
+ tap((_note: StaffNote) => {
+ note.note = text;
+ }),
+ );
+ }
+
+ public loadStaffNotes(project: Project, useFetch: boolean = false): Observable {
+ const options: RequestOptions = {
+ endpointFormat: this.endpointFormat,
+ cache: project.staffNoteCache,
+ sourceCache: project.staffNoteCache,
+ cacheBehaviourOnGet: 'cacheQuery',
+ constructorParams: project,
+ };
+
+ if (useFetch) {
+ return super.fetchAll(
+ {
+ projectId: project.id,
+ },
+ options,
+ );
+ } else {
+ return super.query(
+ {
+ projectId: project.id,
+ },
+ options,
+ );
+ }
+ }
+}
diff --git a/src/app/api/services/task-comment.service.ts b/src/app/api/services/task-comment.service.ts
index 9e646be77d..6761bc715c 100644
--- a/src/app/api/services/task-comment.service.ts
+++ b/src/app/api/services/task-comment.service.ts
@@ -1,30 +1,44 @@
-import { Task, TaskComment, UserService } from 'src/app/api/models/doubtfire-model';
-import { EventEmitter, Injectable } from '@angular/core';
-import { Observable } from 'rxjs';
-import { tap } from 'rxjs/operators';
-import { CachedEntityService } from 'ngx-entity-service';
-import { DiscussionComment } from '../models/task-comment/discussion-comment';
-import { ExtensionComment } from '../models/task-comment/extension-comment';
-import { RequestOptions } from 'ngx-entity-service/lib/request-options';
-import { HttpClient } from '@angular/common/http';
-import API_URL from 'src/app/config/constants/apiURL';
-import { EmojiService } from 'src/app/common/services/emoji.service';
-import { MappingFunctions } from './mapping-fn';
-import { FileDownloaderService } from 'src/app/common/file-downloader/file-downloader.service';
+import {
+ ScormComment,
+ Task,
+ TaskComment,
+ TestAttemptService,
+ UserService,
+} from 'src/app/api/models/doubtfire-model';
+import {EventEmitter, Injectable} from '@angular/core';
+import {Observable} from 'rxjs';
+import {tap} from 'rxjs/operators';
+import {CachedEntityService} from 'ngx-entity-service';
+import {DiscussionComment} from '../models/task-comment/discussion-comment';
+import {ExtensionComment} from '../models/task-comment/extension-comment';
+import {RequestOptions} from 'ngx-entity-service/lib/request-options';
+import {HttpClient} from '@angular/common/http';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {EmojiService} from 'src/app/common/services/emoji.service';
+import {MappingFunctions} from './mapping-fn';
+import {FileDownloaderService} from 'src/app/common/file-downloader/file-downloader.service';
+import {ScormExtensionComment} from '../models/task-comment/scorm-extension-comment';
@Injectable()
export class TaskCommentService extends CachedEntityService {
public readonly commentAdded$: EventEmitter = new EventEmitter();
- private readonly commentEndpointFormat = 'projects/:projectId:/task_def_id/:taskDefinitionId:/comments/:id:';
- private readonly discussionEndpointFormat = 'projects/:projectId:/task_def_id/:taskDefinitionId:/discussion_comments';
+ private readonly commentEndpointFormat =
+ 'projects/:projectId:/task_def_id/:taskDefinitionId:/comments/:id:';
+ private readonly discussionEndpointFormat =
+ 'projects/:projectId:/task_def_id/:taskDefinitionId:/discussion_comments';
private readonly extensionGrantEndpointFormat =
'projects/:projectId:/task_def_id/:taskDefinitionId:/assess_extension/:id:';
private readonly requestExtensionEndpointFormat =
'projects/:projectId:/task_def_id/:taskDefinitionId:/request_extension';
- private readonly discussionCommentReplyEndpointFormat = "/projects/:project_id:/task_def_id/:task_definition_id:/comments/:task_comment_id:/discussion_comment/reply";
- private readonly getDiscussionCommentPromptEndpointFormat = "/projects/:project_id:/task_def_id/:task_definition_id:/comments/:task_comment_id:/discussion_comment/prompt_number/:prompt_number:";
-
+ private readonly scormExtensionGrantEndpointFormat =
+ 'projects/:projectId:/task_def_id/:taskDefinitionId:/assess_scorm_extension/:id:';
+ private readonly scormRequestExtensionEndpointFormat =
+ 'projects/:projectId:/task_def_id/:taskDefinitionId:/request_scorm_extension';
+ private readonly discussionCommentReplyEndpointFormat =
+ '/projects/:project_id:/task_def_id/:task_definition_id:/comments/:task_comment_id:/discussion_comment/reply';
+ private readonly getDiscussionCommentPromptEndpointFormat =
+ '/projects/:project_id:/task_def_id/:task_definition_id:/comments/:task_comment_id:/discussion_comment/prompt_number/:prompt_number:';
protected readonly endpointFormat = this.commentEndpointFormat;
@@ -32,7 +46,8 @@ export class TaskCommentService extends CachedEntityService {
httpClient: HttpClient,
private emojiService: EmojiService,
private userService: UserService,
- private downloader: FileDownloaderService
+ private downloader: FileDownloaderService,
+ private testAttemptService: TestAttemptService,
) {
super(httpClient, API_URL);
@@ -41,16 +56,16 @@ export class TaskCommentService extends CachedEntityService {
{
keys: 'author',
toEntityFn: (data: object, key: string, comment: TaskComment) => {
- const user = this.userService.cache.getOrCreate(data[key].id, userService, data[key]);
- comment.initials = `${user.firstName[0]}${user.lastName[0]}`.toUpperCase();
+ const user = this.userService.cache.getOrCreate(data[key]?.id, userService, data[key]);
+ comment.initials = `${user.preferredName[0]}${user.lastName[0]}`.toUpperCase();
return user;
- }
+ },
},
{
keys: 'recipient',
toEntityFn: (data: object, key: string, comment: TaskComment) => {
- return this.userService.cache.getOrCreate(data[key].id, userService, data[key]);
- }
+ return this.userService.cache.getOrCreate(data[key]?.id, userService, data[key]);
+ },
},
'recipientReadTime',
'replyToId',
@@ -59,17 +74,17 @@ export class TaskCommentService extends CachedEntityService {
keys: ['text', 'comment'],
toEntityFn: (data, key, entity) => {
return this.emojiService.colonsToNative(data['comment']);
- }
+ },
},
{
keys: 'createdAt',
- toEntityFn: MappingFunctions.mapDate
+ toEntityFn: MappingFunctions.mapDate,
},
{
keys: 'type',
- toEntityOp: (data: object, key: string, comment:TaskComment) => {
+ toEntityOp: (data: object, key: string, comment: TaskComment) => {
comment.commentType = data[key];
- }
+ },
},
// Extension comments
'assessed',
@@ -85,13 +100,34 @@ export class TaskCommentService extends CachedEntityService {
'status',
'numberOfPrompts',
'timeDiscussionComplete',
- 'timeDiscussionStarted'
- );
+ 'timeDiscussionStarted',
- this.mapping.addJsonKey(
- 'granted',
+ // Scorm Comments
+ {
+ keys: 'testAttempt',
+ toEntityFn: (data: object, key: string, comment: ScormComment) => {
+ const testAttempt = this.testAttemptService.cache.getOrCreate(
+ data[key].id,
+ testAttemptService,
+ data[key],
+ {
+ constructorParams: comment.task,
+ },
+ );
+ return testAttempt;
+ },
+ },
+ // Scorm Extension Comments
+ ['taskScormExtensions', 'scorm_extensions'],
+ 'overseerAssessmentId',
+ 'overseerPassedSteps',
+ 'overseerTotalSteps',
+ 'overseerInProgress',
+ 'overseerStatus',
);
+
+ this.mapping.addJsonKey('granted');
}
/**
@@ -103,6 +139,10 @@ export class TaskCommentService extends CachedEntityService {
return new DiscussionComment(other);
case 'extension':
return new ExtensionComment(other);
+ case 'scorm':
+ return new ScormComment(other);
+ case 'scorm_extension':
+ return new ScormExtensionComment(other);
default:
return new TaskComment(other);
}
@@ -115,13 +155,17 @@ export class TaskCommentService extends CachedEntityService {
* @param other Contains the related Tasks used to construct the TaskComments
* @param options
*/
- public query(pathIds?: object, other?: object, options?: RequestOptions): Observable {
+ public query(
+ pathIds?: object,
+ other?: object,
+ options?: RequestOptions,
+ ): Observable {
return super.query(pathIds, options).pipe(
tap((result) => {
// Access the task and set the number of new comments to 0 - they are now read on the server
const task = other as any; //TODO: change to Task object
task.numNewComments = 0;
- })
+ }),
);
}
@@ -130,7 +174,7 @@ export class TaskCommentService extends CachedEntityService {
data: string | File | Blob,
commentType: string,
originalComment?: TaskComment,
- prompts?: Blob[]
+ prompts?: Blob[],
): Observable {
const pathId = {
projectId: task.project.id,
@@ -142,10 +186,10 @@ export class TaskCommentService extends CachedEntityService {
body.append('reply_to_id', originalComment?.id.toString());
}
- const opts: RequestOptions = { endpointFormat: this.commentEndpointFormat };
+ const opts: RequestOptions = {endpointFormat: this.commentEndpointFormat};
// Based on the comment type - add to the body and configure the end point
- if (commentType === 'text') {
+ if (commentType === 'text' || commentType === 'scorm') {
body.append('comment', data);
} else if (commentType === 'discussion') {
opts.endpointFormat = this.discussionEndpointFormat;
@@ -164,7 +208,7 @@ export class TaskCommentService extends CachedEntityService {
tap((tc: TaskComment) => {
task.refreshCommentData();
this.commentAdded$.emit(tc);
- })
+ }),
);
}
@@ -180,34 +224,71 @@ export class TaskCommentService extends CachedEntityService {
projectId: extension.project.id,
taskDefinitionId: extension.task.definition.id,
},
- opts
+ opts,
);
}
- public requestExtension(reason: string, weeksRequested: number, task: any): Observable {
+ public requestExtension(
+ reason: string,
+ weeksRequested: number,
+ task: any,
+ ): Observable {
const opts: RequestOptions = {
endpointFormat: this.requestExtensionEndpointFormat,
body: {
comment: reason,
weeks_requested: weeksRequested,
},
- cache: task.commentCache
+ cache: task.commentCache,
+ };
+ return super.create(
+ {
+ projectId: task.project.id,
+ taskDefinitionId: task.definition.id,
+ },
+ opts,
+ );
+ }
+
+ public assessScormExtension(extension: ScormExtensionComment): Observable {
+ const opts: RequestOptions = {
+ endpointFormat: this.scormExtensionGrantEndpointFormat,
+ entity: extension,
+ };
+
+ return super.update(
+ {
+ id: extension.id,
+ projectId: extension.project.id,
+ taskDefinitionId: extension.task.definition.id,
+ },
+ opts,
+ );
+ }
+
+ public requestScormExtension(reason: string, task: any): Observable {
+ const opts: RequestOptions = {
+ endpointFormat: this.scormRequestExtensionEndpointFormat,
+ body: {
+ comment: reason,
+ },
+ cache: task.commentCache,
};
return super.create(
{
projectId: task.project.id,
taskDefinitionId: task.definition.id,
},
- opts
+ opts,
);
}
- public postDiscussionReply(comment: TaskComment, replyAudio: Blob): Observable{
+ public postDiscussionReply(comment: TaskComment, replyAudio: Blob): Observable {
const form = new FormData();
const pathIds = {
project_id: comment.project.id,
task_definition_id: comment.task.id,
- task_comment_id: comment.id
+ task_comment_id: comment.id,
};
form.append('attachment', replyAudio);
diff --git a/src/app/api/services/task-definition.service.ts b/src/app/api/services/task-definition.service.ts
index 13a1dd2797..d420f2c1fc 100644
--- a/src/app/api/services/task-definition.service.ts
+++ b/src/app/api/services/task-definition.service.ts
@@ -1,17 +1,32 @@
-import { CachedEntityService } from 'ngx-entity-service';
-import { TaskDefinition, Unit } from 'src/app/api/models/doubtfire-model';
-import { Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import API_URL from 'src/app/config/constants/apiURL';
-import { MappingFunctions } from './mapping-fn';
-import { AppInjector } from 'src/app/app-injector';
-import { Observable } from 'rxjs';
+import {CachedEntityService} from 'ngx-entity-service';
+import {
+ LearningOutcomeService,
+ TaskDefinition,
+ TaskStatusEnum,
+ Unit,
+} from 'src/app/api/models/doubtfire-model';
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import API_URL from 'src/app/config/constants/apiUrl';
+import {MappingFunctions} from './mapping-fn';
+import {AppInjector} from 'src/app/app-injector';
+import {Observable} from 'rxjs';
+import {TaskPrerequisiteService} from './task-prerequisite.service';
+import {TaskPrerequisite} from '../models/task-prerequisite';
+import {DoubtfireConstants} from 'src/app/config/constants/doubtfire-constants';
+import {SidekiqJob} from '../models/sidekiq-job';
+import {OverseerStepService} from './overseer-step.service';
@Injectable()
export class TaskDefinitionService extends CachedEntityService {
protected readonly endpointFormat = 'units/:unitId:/task_definitions/:id:';
- constructor(httpClient: HttpClient) {
+ constructor(
+ httpClient: HttpClient,
+ private learningOutcomeService: LearningOutcomeService,
+ private taskPrerequisiteService: TaskPrerequisiteService,
+ private overseerStepService: OverseerStepService,
+ ) {
super(httpClient, API_URL);
this.mapping.addKeys(
@@ -21,7 +36,10 @@ export class TaskDefinitionService extends CachedEntityService {
'description',
'weighting',
'targetGrade',
- 'mossLanguage',
+ 'similarityLanguage',
+ 'hasJplagReport',
+ 'assessInPortfolioOnly',
+ 'requiresDiscussion',
{
keys: 'targetDate',
toEntityFn: MappingFunctions.mapDateToEndOfDay,
@@ -41,7 +59,7 @@ export class TaskDefinitionService extends CachedEntityService {
keys: 'uploadRequirements',
toJsonFn: (taskDef: TaskDefinition, key: string) => {
return JSON.stringify(
- taskDef.uploadRequirements.map((upreq) => {
+ taskDef.uploadRequirements?.map((upreq) => {
return {
key: upreq.key,
name: upreq.name,
@@ -49,13 +67,19 @@ export class TaskDefinitionService extends CachedEntityService {
tii_check: upreq.tiiCheck,
tii_pct: upreq.tiiPct,
};
- })
+ }),
);
},
toEntityFn: (data: object, key: string, taskDef: TaskDefinition, params?: any) => {
return (
- data[key] as Array<{ key: string; name: string; type: string; tii_check: boolean; tii_pct: number }>
- ).map((upreq) => {
+ data[key] as Array<{
+ key: string;
+ name: string;
+ type: string;
+ tii_check: boolean;
+ tii_pct: number;
+ }>
+ )?.map((upreq) => {
return {
key: upreq.key,
name: upreq.name,
@@ -93,17 +117,92 @@ export class TaskDefinitionService extends CachedEntityService | | |