"use strict";
/**
* Functions for interacting with assignments within courses
* @namespace api.course.assignment
*/
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
// Import shared classes
var EndpointCategory_1 = __importDefault(require("../../shared/EndpointCategory"));
var caccl_error_1 = __importDefault(require("caccl-error"));
var ErrorCode_1 = __importDefault(require("../../shared/types/ErrorCode"));
// Import shared helpers
var utils_1 = __importDefault(require("../../shared/helpers/utils"));
var waitForCompletion_1 = __importDefault(require("../../shared/helpers/waitForCompletion"));
var parallelLimit_1 = __importDefault(require("../../shared/helpers/parallelLimit"));
// Import shared constants
var API_PREFIX_1 = __importDefault(require("../../shared/constants/API_PREFIX"));
// Endpoint category
var ECatAssignment = /** @class */ (function (_super) {
__extends(ECatAssignment, _super);
function ECatAssignment() {
return _super !== null && _super.apply(this, arguments) || this;
}
/*------------------------------------------------------------------------*/
/* Table of Contents: */
/* - Assignments */
/* - Grading */
/* - Overrides */
/* - Submissions */
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
/* Assignment Endpoints */
/*------------------------------------------------------------------------*/
/**
* Lists the assignments in a course
* @author Gabe Abrams
* @method list
* @memberof api.course.assignment
* @instance
* @async
* @param {object} [opts] object containing all arguments
* @param {number} [opts.courseId=default course id] Canvas course Id to
* query
* @param {boolean} [opts.ignoreOverridesForDates] if true, assignment
* dates are taken from the default dates instead of from the ones in
* overrides
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasAssignment[]>} list of Canvas Assignments {@link https://canvas.instructure.com/doc/api/assignments.html#Assignment}
*/
ECatAssignment.prototype.list = function (opts, config) {
var _a;
if (opts === void 0) { opts = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'get the list of assignments in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments"),
method: 'GET',
params: {
override_assignment_dates: !opts.ignoreOverridesForDates,
},
})];
});
});
};
/**
* Get info on a specific assignment in a course
* @author Gabe Abrams
* @method get
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas assignment Id
* @param {number} [opts.courseId=default course id] Canvas course Id to query
* @param {boolean} [opts.ignoreOverridesForDates] if true, assignment
* dates are taken from the default dates instead of from the ones in
* overrides
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasAssignment>} Canvas Assignment {@link https://canvas.instructure.com/doc/api/assignments.html#Assignment}
*/
ECatAssignment.prototype.get = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'get info on a specific assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId),
method: 'GET',
params: {
override_assignment_dates: !opts.ignoreOverridesForDates,
},
})];
});
});
};
/**
* Updates a Canvas assignment
* @author Gabe Abrams
* @method update
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts - object containing all arguments
* @param {number} opts.assignmentId Canvas assignment Id to update
* @param {number} [opts.courseId=default course id] Canvas course Id to query
* @param {string} [opts.name=current value] The name of the assignment
* @param {number} [opts.pointsPossible=current value] Points possible
* @param {date} [opts.dueAt=current value] Due at datetime
* @param {date} [opts.lockAt=current value] Due at datetime
* @param {date} [opts.unlockAt=current value] Due at datetime
* @param {string} [opts.description=current value] html description of
* the assignment
* @param {string[]} [opts.submissionTypes=current value] Submission type(s)
* @param {string} [opts.allowedExtensions=current value] List of allowed
* file extensions (exclude period). Online upload must be enabled
* @param {string} [opts.gradingType=current value] Grading type
* @param {number} [opts.position=current value] Position in assignment
* list
* @param {boolean} [opts.published=current value] If true, publish page
* upon creation. Must be a boolean
* @param {boolean} [opts.muted=current value] If true, assignment is
* muted. Must be a boolean
* @param {number} [opts.groupSetId=current value] Student group set Id
* @param {number} [opts.assignmentGroupId=current value] Assignment group
* Id
* @param {boolean} [opts.peerReviewsEnabled=current value] If true, users
* asked to submit peer reviews. Must be a boolean
* @param {boolean} [opts.automaticPeerReviewsEnabled=current value] If
* true, Canvas will automatically assign peer reviews. Must be a boolean
* @param {boolean} [opts.omitFromFinalGrade=current value] If true,
* assignment is omitted from the final grade. Must be a boolean
* @param {boolean} [opts.gradeGroupStudentsIndividually=current value] If
* true, students in groups can be given separate grades and when one student
* in a group gets a grade, other students do not get graded. Must be a
* boolean
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasAssignment>} Canvas Assignment {@link https://canvas.instructure.com/doc/api/assignments.html#Assignment}
*/
ECatAssignment.prototype.update = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'update an assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId),
method: 'PUT',
params: {
'assignment[name]': utils_1.default.includeIfTruthy(opts.name),
'assignment[submission_types]': utils_1.default.includeIfTruthy(opts.submissionTypes),
'assignment[grading_type]': utils_1.default.includeIfTruthy(opts.gradingType),
position: utils_1.default.includeIfTruthy(opts.position),
'assignment[peer_reviews]': utils_1.default.includeIfBoolean(opts.peerReviewsEnabled),
'assignment[automatic_peer_reviews]': utils_1.default.includeIfBoolean(opts.automaticPeerReviewsEnabled),
'assignment[grade_group_students_individually]': utils_1.default.includeIfBoolean(opts.gradeGroupStudentsIndividually),
'assignment[description]': utils_1.default.includeIfTruthy(opts.description),
'assignment[allowed_extensions]': utils_1.default.includeIfTruthy(opts.allowedExtensions),
'assignment[group_category_id]': utils_1.default.includeIfTruthy(opts.groupSetId),
'assignment[points_possible]': utils_1.default.includeIfNumber(opts.pointsPossible),
'assignment[due_at]': utils_1.default.includeIfDate(opts.dueAt),
'assignment[lock_at]': utils_1.default.includeIfDate(opts.lockAt),
'assignment[unlock_at]': utils_1.default.includeIfDate(opts.unlockAt),
'assignment[published]': utils_1.default.includeIfBoolean(opts.published),
'assignment[assignment_group_id]': utils_1.default.includeIfNumber(opts.assignmentGroupId),
'assignment[omit_from_final_grade]': utils_1.default.includeIfBoolean(opts.omitFromFinalGrade),
'assignment[muted]': utils_1.default.includeIfBoolean(opts.muted),
},
})];
});
});
};
/**
* Creates a Canvas assignment
* @author Gabe Abrams
* @method create
* @memberof api.course.assignment
* @instance
* @async
* @param {object} [opts] object containing all arguments
* @param {number} [opts.courseId=default course id] Canvas course Id to
* create an assignment in
* @param {string} [opts.name=Unnamed Assignment] The name of the
* assignment
* @param {number} [opts.pointsPossible=null] Points possible
* @param {date} [opts.dueAt=null] Due at datetime
* @param {date} [opts.lockAt=null] Due at datetime
* @param {date} [opts.unlockAt=null] Due at datetime
* @param {string} [opts.description=null] html description of
* the assignment
* @param {string} [opts.submissionTypes=null] Submission type(s)
* @param {string} [opts.allowedExtensions=any] List of allowed file
* extensions (exclude period). Online upload must be enabled
* @param {string} [opts.gradingType=points] Grading type
* @param {number} [opts.position=last] Position in assignment list
* @param {boolean} [opts.published] If true, publish page upon
* creation
* @param {boolean} [opts.muted] If true, assignment is muted
* @param {number} [opts.groupSetId=null] Student group set Id
* @param {number} [opts.assignmentGroupId=top assignment group] Assignment
* group Id
* @param {boolean} [opts.peerReviewsEnabled] If true, users asked to
* submit peer reviews
* @param {boolean} [opts.automaticPeerReviewsEnabled] If true,
* Canvas will automatically assign peer reviews
* @param {boolean} [opts.omitFromFinalGrade] If true, assignment is
* omitted from the final grade
* @param {boolean} [opts.gradeGroupStudentsIndividually] If true,
* students in groups can be given separate grades and when one student in a
* group gets a grade, other students do not get graded
* @param {string} [opts.assignmentAppId=null] If defined, the external
* tool that matches this id will be used for submissions. Also, the
* submission types will be overwritten with ['external_tool'] and the
* student will be redirected via LTI to the assignmentAppURL when they
* launch the assignment
* @param {string} [opts.assignmentAppURL=tool launch url] The launch URL
* of the external tool. If not included and assignmentAppId is defined, we
* will first request info on the external tool to get its launchURL and
* will use that value here. Only relevant if assignmentAppId is defined.
* @param {boolean} [opts.assignmentAppNewTab] Only relevant if
* assignmentAppId is defined. If true, when a student clicks the
* assignment, their LTI session with the external tool will be opened in a
* new tab
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasAssignment>} Canvas Assignment {@link https://canvas.instructure.com/doc/api/assignments.html#Assignment}
*/
ECatAssignment.prototype.create = function (opts, config) {
var _a, _b;
if (opts === void 0) { opts = {}; }
return __awaiter(this, void 0, void 0, function () {
var params, app;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
params = {
'assignment[name]': (opts.name || 'Unnamed Assignment'),
'assignment[grading_type]': (opts.gradingType || 'points'),
position: utils_1.default.includeIfTruthy(opts.position),
'assignment[peer_reviews]': (utils_1.default.isTruthy(opts.peerReviewsEnabled)),
'assignment[automatic_peer_reviews]': utils_1.default.isTruthy(opts.automaticPeerReviewsEnabled),
'assignment[grade_group_students_individually]': utils_1.default.isTruthy(opts.gradeGroupStudentsIndividually),
'assignment[description]': (utils_1.default.includeIfTruthy(opts.description)),
'assignment[allowed_extensions]': (utils_1.default.includeIfTruthy(opts.allowedExtensions)),
'assignment[group_category_id]': (utils_1.default.includeIfTruthy(opts.groupSetId)),
'assignment[points_possible]': (utils_1.default.includeIfNumber(opts.pointsPossible)),
'assignment[due_at]': utils_1.default.includeIfDate(opts.dueAt),
'assignment[lock_at]': utils_1.default.includeIfDate(opts.lockAt),
'assignment[unlock_at]': utils_1.default.includeIfDate(opts.unlockAt),
'assignment[published]': (utils_1.default.isTruthy(opts.published)),
'assignment[assignment_group_id]': (utils_1.default.includeIfNumber(opts.assignmentGroupId)),
'assignment[omit_from_final_grade]': (utils_1.default.isTruthy(opts.omitFromFinalGrade)),
'assignment[muted]': utils_1.default.isTruthy(opts.muted),
};
if (!opts.assignmentAppId) return [3 /*break*/, 4];
// Using an external tool
params['assignment[external_tool_tag_attributes][new_tab]'] = (!!opts.assignmentAppNewTab);
params['assignment[external_tool_tag_attributes][content_type]'] = ('context_external_tool');
params['assignment[external_tool_tag_attributes][content_id]'] = (opts.assignmentAppId);
params['assignment[submission_types]'] = ['external_tool'];
if (!opts.assignmentAppURL) return [3 /*break*/, 1];
// No need to fetch the launchURL
params['assignment[external_tool_tag_attributes][url]'] = (opts.assignmentAppURL);
return [3 /*break*/, 3];
case 1: return [4 /*yield*/, this.api.course.app.get({
courseId: ((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId),
appId: opts.assignmentAppId,
}, config)];
case 2:
app = _c.sent();
params['assignment[external_tool_tag_attributes][url]'] = app.url;
_c.label = 3;
case 3: return [3 /*break*/, 5];
case 4:
params['assignment[submission_types]'] = (opts.submissionTypes || ['none']);
_c.label = 5;
case 5: return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'create a new assignment in a course',
params: params,
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_b = opts.courseId) !== null && _b !== void 0 ? _b : this.defaultCourseId, "/assignments"),
method: 'POST',
})];
}
});
});
};
/**
* Delete an assignment
* @author Gabe Abrams
* @method delete
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas assignment Id
* @param {number} [opts.courseId=default course id] Canvas course Id
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasAssignment>} Canvas Assignment {@link https://canvas.instructure.com/doc/api/assignments.html#Assignment}
*/
ECatAssignment.prototype.delete = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'delete an assignment from a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId),
method: 'DELETE',
})];
});
});
};
/*------------------------------------------------------------------------*/
/* Grading Endpoints */
/*------------------------------------------------------------------------*/
/**
* List gradeable students for a specific assignment
* @author Gabe Abrams
* @method listGradeableStudents
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas assignment Id to query
* @param {number} [opts.courseId=default course id] Canvas course Id to
* query
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasUser[]>} list of Canvas users {@link https://canvas.instructure.com/doc/api/users.html#User}
*/
ECatAssignment.prototype.listGradeableStudents = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
var students;
return __generator(this, function (_b) {
switch (_b.label) {
case 0: return [4 /*yield*/, this.visitEndpoint({
config: config,
action: 'get the list of students who are gradeable in a specific assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/gradeable_students"),
method: 'GET',
})];
case 1:
students = _b.sent();
return [2 /*return*/, students.filter(function (s) {
return !s.fake_student;
})];
}
});
});
};
/**
* Adds a comment to a submission
* @author Gabe Abrams
* @method createSubmissionComment
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas course Id
* @param {number} opts.studentId Canvas student Id of the sub to comment
* on
* @param {string} opts.comment The text of the comment
* @param {number} [opts.courseId=default course id] Canvas course Id
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasSubmission>} Canvas submission {@link https://canvas.instructure.com/doc/api/submissions.html#Submission}
*/
ECatAssignment.prototype.createSubmissionComment = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'create a new comment on a submission',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/submissions/").concat(opts.studentId),
method: 'PUT',
params: {
'comment[text_comment]': opts.comment,
},
})];
});
});
};
/**
* Updates a student's grade and/or comment
* @author Gabe Abrams
* @method updateGrade
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas assignment id
* @param {number} opts.studentId Canvas student id
* @param {number} [opts.courseId=default course id] Canvas course id
* @param {number} [opts.points] the overall points to assign to the
* student
* @param {string} [opts.comment] the grader comment to leave on the
* submission
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasSubmission>} Canvas submission {@link https://canvas.instructure.com/doc/api/submissions.html#Submission}
*/
ECatAssignment.prototype.updateGrade = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'update student grade and/or comments for a specific assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/submissions/").concat(opts.studentId),
method: 'PUT',
params: {
'comment[text_comment]': utils_1.default.includeIfTruthy(opts.comment),
'submission[posted_grade]': utils_1.default.includeIfNumber(opts.points),
},
})];
});
});
};
/**
* Batch updates grades and/or comments. Also supports updating rubric items
* @author Gabe Abrams
* @method updateGrades
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas assignment Id
* @param {Array} opts.gradeItems List of grade items to upload to Canvas:
* [{
* studentId: <student id>,
* points: <optional, points to overwrite with>,
* comment: <optional, comment to append (or overwrite if rubric comment)>,
* rubricId: <optional, rubric item (overall grade/comment if excluded)>
* },...]
* @param {number} [opts.courseId=default course id] Canvas course Id
* @param {boolean} [opts.waitForCompletion] If true, promise won't
* resolve until Canvas has finished updating the grades, instead of resolving
* once the grade changes have been queued
* @param {number} [opts.waitForCompletionTimeout=2] The number of minutes
* to wait before timing out the grade update job
* @param {boolean} [opts.dontMergeRubricItemUpdates] When uploading
* grades to a rubric item, we intelligently merge rubric item updates with
* previous rubric assessments. For instance, if the assignment's rubric is:
* { grammar, argument, formatting }
* And the student of interest has the following rubric assessment so far:
* { grammar: 10/10, argument: 8/10, formatting: ungraded }
* When we upload a new gradeItem (9/10 points) to the student's
* formatting rubric item, the result is:
* { grammar: 10/10, argument: 8/10, formatting: 9/10 }
* However, if dontMergeRubricItemUpdates=true, the result is:
* { grammar: ungraded, argument: ungraded, formatting: 9/10 }
* Note: merging is an added feature. By default, the Canvas API does not
* merge rubric assessments.
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasProgress>} Canvas Progress object {@link https://canvas.instructure.com/doc/api/progress.html#Progress}
*/
ECatAssignment.prototype.updateGrades = function (opts, config) {
var _a, _b;
return __awaiter(this, void 0, void 0, function () {
var studentsToMerge, performRubricItemMerge, assignment, realRubricItemIds_1, numRubricItems_1, studentToRubricItemsOverwritten_1, allStudentsWithRubricItems_1, subs, params, overwritingMap_1, progress, finishedProgress;
var _this = this;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
studentsToMerge = [];
performRubricItemMerge = false;
if (!opts.dontMergeRubricItemUpdates) {
performRubricItemMerge = opts.gradeItems.some(function (item) {
return item.rubricId;
});
}
if (!performRubricItemMerge) return [3 /*break*/, 2];
return [4 /*yield*/, this.api.course.assignment.get({
courseId: ((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId),
assignmentId: opts.assignmentId,
}, config)];
case 1:
assignment = _c.sent();
// Make sure the assignment has a rubric
if (!assignment.rubric) {
// This assignment doesn't have a rubric
throw new caccl_error_1.default({
message: 'We could not upload grades because the rubric we were trying to upload to didn\'t exist.',
code: ErrorCode_1.default.NoRubricOnBatchGradeUpload,
});
}
realRubricItemIds_1 = new Set();
numRubricItems_1 = assignment.rubric.length;
assignment.rubric.forEach(function (rubricItem) {
realRubricItemIds_1.add(rubricItem.id);
});
studentToRubricItemsOverwritten_1 = (new Map());
allStudentsWithRubricItems_1 = new Set();
// ^ {studentId => { Set of rubric ids being uploaded }}
opts.gradeItems.forEach(function (gradeItem) {
var rubricId = gradeItem.rubricId, studentId = gradeItem.studentId;
allStudentsWithRubricItems_1.add(studentId);
// Skip if this item isn't a (real) rubric item
if (!rubricId || realRubricItemIds_1.has(rubricId)) {
return;
}
// Only mark this rubric item as being overwritten if both points and
// comments are being overwritten
if (gradeItem.points === undefined
|| gradeItem.points === null
|| !gradeItem.comment) {
// Not completely overwriting
return;
}
// Keep track of rubric items that are found
if (!studentToRubricItemsOverwritten_1.has(studentId)) {
// Initialize student map
studentToRubricItemsOverwritten_1.set(studentId, new Set());
}
studentToRubricItemsOverwritten_1.get(studentId).add(rubricId);
});
// > Find students that need to be merged (has some rubric items but not
// completely overwriting all of them)
allStudentsWithRubricItems_1.forEach(function (studentId) {
var numOverwrittenItems = ((studentToRubricItemsOverwritten_1.get(studentId)
|| { size: 0 }).size);
if (numOverwrittenItems < numRubricItems_1) {
// Need to merge this student
studentsToMerge.push(studentId);
}
});
_c.label = 2;
case 2: return [4 /*yield*/, (0, parallelLimit_1.default)(studentsToMerge.map(function (studentId) {
return function () { return __awaiter(_this, void 0, void 0, function () {
var _a;
return __generator(this, function (_b) {
return [2 /*return*/, this.api.course.assignment.getSubmission({
studentId: studentId,
courseId: ((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId),
assignmentId: opts.assignmentId,
includeRubricAssessment: true,
excludeUser: true, // Save request space
}, config)];
});
}); };
}), 10)];
case 3:
subs = _c.sent();
params = {};
if (subs.length > 0) {
overwritingMap_1 = {};
// ^ {studentId => rubricId => {
// points: true/false, is being overwritten,
// comment: true/false, is being overwritten
// }}
opts.gradeItems.forEach(function (gradeItem) {
if (!gradeItem.rubricId) {
// No need to keep track of non-rubric item updates
// (these are not being merged)
return;
}
var sid = gradeItem.studentId;
var rid = gradeItem.rubricId;
// Initialize map if needed
if (!overwritingMap_1[sid]) {
overwritingMap_1[sid] = {};
}
if (!overwritingMap_1[sid][rid]) {
overwritingMap_1[sid][rid] = { points: false, comment: false };
}
// Save points and comments
if (gradeItem.points !== undefined) {
overwritingMap_1[sid][rid].points = true;
}
if (gradeItem.comment !== undefined) {
overwritingMap_1[sid][rid].comment = true;
}
});
// Perform actual merge
subs.forEach(function (sub) {
if (!sub.rubric_assessment) {
// No need to merge: submission has no rubric content yet
return;
}
var sid = sub.user_id;
// Loop through rubric items and merge
Object.keys(sub.rubric_assessment).forEach(function (rubricId) {
// Get previous values
var oldPoints = sub.rubric_assessment[rubricId].points;
var oldComment = sub.rubric_assessment[rubricId].comments;
// Check if we're overwriting these values
var overwritePoints;
var overwriteComment;
if (overwritingMap_1[sid] && overwritingMap_1[sid][rubricId]) {
overwritePoints = overwritingMap_1[sid][rubricId].points;
overwriteComment = overwritingMap_1[sid][rubricId].comment;
}
// Add old value
if (oldPoints !== undefined
&& oldPoints !== null
&& !overwritePoints) {
// We have an old points val and we're not overwriting it
// (include the old points value)
params["grade_data[".concat(sid, "][rubric_assessment][").concat(rubricId, "][points]")] = oldPoints;
}
if (oldComment && !overwriteComment) {
// We have an old comment and we're not overwriting it
// (include the old comment)
params["grade_data[".concat(sid, "][rubric_assessment][").concat(rubricId, "][comments]")] = oldComment;
}
});
});
}
// Add rest of grade item updates to params
opts.gradeItems.forEach(function (gradeItem) {
if (gradeItem.rubricId) {
if (gradeItem.points !== undefined) {
params["grade_data[".concat(gradeItem.studentId, "][rubric_assessment][").concat(gradeItem.rubricId, "][points]")] = gradeItem.points;
}
if (gradeItem.comment) {
params["grade_data[".concat(gradeItem.studentId, "][rubric_assessment][").concat(gradeItem.rubricId, "][comments]")] = gradeItem.comment;
}
}
else {
if (gradeItem.points !== undefined) {
params["grade_data[".concat(gradeItem.studentId, "][posted_grade]")] = gradeItem.points;
}
if (gradeItem.comment) {
params["grade_data[".concat(gradeItem.studentId, "][text_comment]")] = gradeItem.comment;
}
}
});
return [4 /*yield*/, this.visitEndpoint({
params: params,
config: config,
action: 'update student grades, comments, and/or rubric assessments for a specific assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_b = opts.courseId) !== null && _b !== void 0 ? _b : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/submissions/update_grades"),
method: 'POST',
})];
case 4:
progress = _c.sent();
if (!opts.waitForCompletion) return [3 /*break*/, 6];
return [4 /*yield*/, (0, waitForCompletion_1.default)({
progress: progress,
visitEndpoint: this.visitEndpoint,
timeoutMin: opts.waitForCompletionTimeout,
})];
case 5:
finishedProgress = _c.sent();
return [2 /*return*/, finishedProgress];
case 6: return [2 /*return*/, progress];
}
});
});
};
/*------------------------------------------------------------------------*/
/* Assignment Override Endpoints */
/*------------------------------------------------------------------------*/
/**
* Gets the list of overrides for an assignment
* @author Gabe Abrams
* @method listOverrides
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas assignment id to look up
* @param {number} [opts.courseId=default course id] Canvas course id to query
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasAssignmentOverride[]>} list of Canvas AssignmentOverrides {@link https://canvas.instructure.com/doc/api/assignments.html#AssignmentOverride}
*/
ECatAssignment.prototype.listOverrides = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'get a list of assignment overrides for a specific assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/overrides"),
method: 'GET',
})];
});
});
};
/**
* Get a specific override on an assignment in a course
* @author Gabe Abrams
* @method getOverride
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas assignment id to query
* @param {number} opts.overrideId Canvas override id to look up
* @param {number} [opts.courseId=default course id] Canvas course id to query
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasAssignmentOverride>} Canvas AssignmentOverride {@link https://canvas.instructure.com/doc/api/assignments.html#AssignmentOverride}
*/
ECatAssignment.prototype.getOverride = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'get a list of assignment overrides for a specific assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/overrides/").concat(opts.overrideId),
method: 'GET',
})];
});
});
};
/**
* Create assignment override. Note that if any dates (dueAt, unlockAt, or
* lockAt) are left out, they will be set to "none" for the target(s) of this
* override. If dueAt is omitted, the target(s) will have no deadline. If
* unlockAt is omitted, the target(s) will immediately be able to see the
* assignment (even if everyone else has to wait until the unlockAt date). If
* lockAt is omitted, the target(s) will be able to submit at any
* time in the future (even if everyone else can't submit because their lock
* date has passed). In short, it is not recommended to omit dates that are
* defined in the assignment.
* @author Gabe Abrams
* @method createOverride
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas assignment id
* @param {number} [opts.courseId=default course id] Canvas course id
* @param {number[]} [opts.studentIds] List of Canvas student IDs to override
* (Note: either studentIds, groupId, or sectionId must be included)
* @param {number} [opts.groupId] Group to override, must be a group
* assignment (Note: either studentIds, groupId, or sectionId must be
* included)
* @param {number} [opts.sectionId] Section to override (Note: either
* studentIds, groupId, or sectionId must be included)
* @param {string} [opts.title=Override for X students] Title of the
* override
* @param {date} [opts.dueAt=no due date] New due date. If excluded, the
* target(s) of this override have no due date (they can submit whenever they
* want without being marked as late)
* @param {date} [opts.unlockAt=no unlock date] New unlock date. If
* excluded, the target(s) of this override can immediately see the assignment
* (their unlock date is the beginning of time)
* @param {date} [opts.lockAt=no lock date] New lock date. If excluded,
* the target(s) of this override can see and submit the assignment at
* any point in the future (their lock date is the end of time)
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasAssignmentOverride>} Canvas AssignmentOverride {@link https://canvas.instructure.com/doc/api/assignments.html#AssignmentOverride}
*/
ECatAssignment.prototype.createOverride = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
var title, dueAt, unlockAt, lockAt;
return __generator(this, function (_b) {
title = opts.title;
if (!title) {
title = "Override for ".concat(opts.studentIds.length, " student").concat(utils_1.default.sIfPlural(opts.studentIds.length));
}
dueAt = utils_1.default.includeIfDate(opts.dueAt) || null;
unlockAt = utils_1.default.includeIfDate(opts.unlockAt) || null;
lockAt = utils_1.default.includeIfDate(opts.lockAt) || null;
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'create a new override for a specific assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/overrides"),
method: 'POST',
params: {
'assignment_override[title]': utils_1.default.includeIfTruthy(title),
'assignment_override[student_ids]': utils_1.default.includeIfTruthy(opts.studentIds),
'assignment_override[group_id]': utils_1.default.includeIfTruthy(opts.groupId),
'assignment_override[course_section_id]': utils_1.default.includeIfTruthy(opts.sectionId),
'assignment_override[due_at]': dueAt,
'assignment_override[unlock_at]': unlockAt,
'assignment_override[lock_at]': lockAt,
},
})];
});
});
};
/**
* Update an assignment override. Note: target can only be updated if the
* override is a student override (if this is a group or section override,
* the target remains unchanged).
* Also, note that if any dates (dueAt, unlockAt, or lockAt) are omitted,
* their previous override values will be changed to "none." For instance,
* if the previous override has a dueAt and the update does not, the updated
* override will have no dueAt date (the target(s) of the override will have
* no deadline).
* @author Gabe Abrams
* @method updateOverride
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas assignment id
* @param {number} opts.overrideId the override id to update
* @param {number[]} opts.studentIds List of Canvas student IDs being
* overridden
* @param {number} [opts.courseId=default course id] Canvas course id
* @param {string} [opts.title=current value] New title of the
* override
* @param {date} [opts.dueAt=no due date] New due date. If excluded, the
* target(s) of this override have no due date (they can submit whenever they
* want without being marked as late)
* @param {date} [opts.unlockAt=no unlock date] New unlock date. If
* excluded, the target(s) of this override can immediately see the assignment
* (their unlock date is the beginning of time)
* @param {date} [opts.lockAt=no lock date] New lock date. If excluded,
* the target(s) of this override can see and submit the assignment at
* any point in the future (their lock date is the end of time)
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasAssignmentOverride>} Canvas AssignmentOverride {@link https://canvas.instructure.com/doc/api/assignments.html#AssignmentOverride}
*/
ECatAssignment.prototype.updateOverride = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
var dueAt, unlockAt, lockAt;
return __generator(this, function (_b) {
dueAt = utils_1.default.includeIfDate(opts.dueAt) || null;
unlockAt = utils_1.default.includeIfDate(opts.unlockAt) || null;
lockAt = utils_1.default.includeIfDate(opts.lockAt) || null;
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'update an override for a specific assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/overrides/").concat(opts.overrideId),
method: 'PUT',
params: {
'assignment_override[title]': utils_1.default.includeIfTruthy(opts.title),
'assignment_override[student_ids]': utils_1.default.includeIfTruthy(opts.studentIds),
'assignment_override[due_at]': dueAt,
'assignment_override[unlock_at]': unlockAt,
'assignment_override[lock_at]': lockAt,
},
})];
});
});
};
/**
* Deletes an assignment override
* @author Gabe Abrams
* @method deleteOverride
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId Canvas assignment id to query
* @param {number} opts.overrideId Canvas override id to look up
* @param {number} [opts.courseId=default course id] Canvas course id to query
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasAssignmentOverride>} Canvas AssignmentOverride {@link https://canvas.instructure.com/doc/api/assignments.html#AssignmentOverride}
*/
ECatAssignment.prototype.deleteOverride = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'delete an override for a specific assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/overrides/").concat(opts.overrideId),
method: 'DELETE',
})];
});
});
};
/*------------------------------------------------------------------------*/
/* Assignment Submission Endpoints */
/*------------------------------------------------------------------------*/
/**
* Lists the submissions to a specific assignment in a course. If the assignment
* has anonymous grading turned on, to exclude the test user, we will also
* pull the list of students in the course. If including the user object for
* an anonymously graded assignment, fake user objects will be created where
* each submissions[i].user object contains a isAnonymousUser boolean that is
* true
* @author Gabe Abrams
* @method listSubmissions
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId The Canvas assignment Id to query
* @param {number} [opts.courseId=default course id] Canvas course Id
* @param {boolean} [opts.includeComments] If truthy, includes all
* comments on submissions
* @param {boolean} [opts.includeRubricAssessment] If truthy,
* includes rubric assessments: breakdown of score for each rubric item
* @param {boolean} [opts.excludeUser] If truthy, excludes
* submission[i].user value with the submission's user information
* @param {boolean} [opts.includeTestStudent] If truthy, includes
* dummy submission by test student (student view) if there is one. Note:
* if anonymous grading is enabled for this assignment, includeTestStudent
* will be true because we don't know which student is the test student
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasSubmission[]>} list of Canvas submissions {@link https://canvas.instructure.com/doc/api/submissions.html#Submission}
*/
ECatAssignment.prototype.listSubmissions = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
var fetchUser, subs, realSubs;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
fetchUser = (!opts.includeTestStudent
|| !opts.excludeUser);
return [4 /*yield*/, this.visitEndpoint({
config: config,
action: 'list the submissions to a specific assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/submissions"),
method: 'GET',
params: {
include: utils_1.default.genIncludesList({
submission_comments: opts.includeComments,
rubric_assessment: opts.includeRubricAssessment,
user: fetchUser,
}),
},
})];
case 1:
subs = _b.sent();
// Filter test student if applicable
if (!opts.includeTestStudent) {
// Handle empty list case
if (!subs || subs.length === 0) {
return [2 /*return*/, []];
}
realSubs = subs.filter(function (sub) {
return (!sub.user
|| sub.user.name !== 'Test Student');
});
// Finish
return [2 /*return*/, realSubs];
}
// Not filtering out test student. Just return subs
return [2 /*return*/, subs];
}
});
});
};
/**
* Lists the submissions for a batch of assignment/students in a course
* @author Gabe Abrams
* @method listAllSubmissions
* @memberof api.course.assignment
* @instance
* @async
* @param {object} [opts] object containing all arguments
* @param {number} [opts.courseId=default course id] Canvas course Id
* @param {number[]} [opts.studentIds=all students] a list of
* specific students to pull submissions for
* @param {number[]} [opts.assignmentIds=all assignments] a list of
* assignments to get submissions for
* @param {Date} [opts.submittedSince=beginning of time] Exclude
* submissions that were not submitted or were submitted before this date
* @param {Date} [opts.gradedSince=beginning of time] Exclude
* submissions that were not graded or were graded before this date
* @param {string} [opts.workflowState=all workflows] a workflow state
* to filter by. Allowed values: 'submitted', 'unsubmitted', 'graded', or
* 'pending_review'
* @param {string} [opts.enrollmentState=all states except deleted] an
* enrollment state to filter by. Allowed values: 'active' or 'concluded'
* @param {boolean} [opts.includeSubmissionHistory] if true, submission
* history is included
* @param {boolean} [opts.includeComments] if true, includes all comments
* on submissions
* @param {boolean} [opts.includeRubricAssessment] if true,
* rubric assessment is included
* @param {boolean} [opts.includeAssignment] if true, the assignment is
* included for each submission
* @param {boolean} [opts.includeTotalScores] if true, include the total
* scores
* @param {boolean} [opts.includeVisibility] if true, include visibility
* @param {boolean} [opts.includeUser] if true, include the user info
* with each submission
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasSubmission[]>} list of submissions {@link https://canvas.instructure.com/doc/api/submissions.html#Submission}
*/
ECatAssignment.prototype.listAllSubmissions = function (opts, config) {
var _a;
if (opts === void 0) { opts = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'list a batch of submissions in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/students/submissions"),
method: 'GET',
params: {
student_ids: (opts.studentIds
? opts.studentIds
: ['all']),
assignment_ids: opts.assignmentIds,
submitted_since: utils_1.default.includeIfDate(opts.submittedSince),
graded_since: utils_1.default.includeIfDate(opts.gradedSince),
workflow_state: utils_1.default.includeIfTruthy(opts.workflowState),
enrollment_state: utils_1.default.includeIfTruthy(opts.enrollmentState),
include: utils_1.default.genIncludesList({
submission_history: opts.includeSubmissionHistory,
submission_comments: opts.includeComments,
rubric_assessment: opts.includeRubricAssessment,
assignment: opts.includeAssignment,
total_scores: opts.includeTotalScores,
visibility: opts.includeVisibility,
user: opts.includeUser,
}),
},
})];
});
});
};
/**
* Gets a single submission for an assignment
* @author Gabe Abrams
* @method getSubmission
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId The Canvas assignment Id
* @param {number} opts.studentId The Canvas student Id
* @param {number} [opts.courseId=default course id] Canvas course Id
* @param {boolean} [opts.includeComments] If truthy, includes all
* comments on submissions
* @param {boolean} [opts.includeRubricAssessment] If truthy,
* includes rubric assessments: breakdown of score for each rubric item
* @param {boolean} [opts.excludeUser] If truthy, excludes
* submission[i].user value with the submission's user information
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasSubmission>} Canvas submission {@link https://canvas.instructure.com/doc/api/submissions.html#Submission}
*/
ECatAssignment.prototype.getSubmission = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'get a specific submission to an assignment in a course',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/submissions/").concat(opts.studentId),
method: 'GET',
params: {
include: utils_1.default.genIncludesList({
submission_comments: opts.includeComments,
rubric_assessment: opts.includeRubricAssessment,
user: !opts.excludeUser,
}),
},
})];
});
});
};
/**
* Creates a text submission on behalf of the current user
* @author Gabe Abrams
* @method createTextSubmission
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId The Canvas assignment Id
* @param {string} opts.text The text body of the submission
* @param {number} [opts.courseId=default course id] Canvas course Id
* @param {string} [opts.comment] A text student comment to include
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasSubmission>} Canvas submission {@link https://canvas.instructure.com/doc/api/submissions.html#Submission}
*/
ECatAssignment.prototype.createTextSubmission = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'create a text submission to a specific assignment in a course on behalf of the current user',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/submissions"),
method: 'POST',
params: {
'comment[text_comment]': utils_1.default.includeIfTruthy(opts.comment),
'submission[body]': opts.text,
'submission[submission_type]': 'online_text_entry',
},
})];
});
});
};
/**
* Creates a url submission on behalf of the current user
* @author Gabe Abrams
* @method createURLSubmission
* @memberof api.course.assignment
* @instance
* @async
* @param {object} opts object containing all arguments
* @param {number} opts.assignmentId The Canvas assignment Id
* @param {string} opts.url The url of the submission
* @param {number} [opts.courseId=default course id] Canvas course Id
* @param {string} [opts.comment] A text student comment to include
* @param {APIConfig} [config] custom configuration for this specific endpoint
* call (overwrites defaults that were included when api was initialized)
* @returns {Promise<CanvasSubmission>} Canvas submission {@link https://canvas.instructure.com/doc/api/submissions.html#Submission}
*/
ECatAssignment.prototype.createURLSubmission = function (opts, config) {
var _a;
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, this.visitEndpoint({
config: config,
action: 'create a url submission to a specific assignment in a course on behalf of the current user',
path: "".concat(API_PREFIX_1.default, "/courses/").concat((_a = opts.courseId) !== null && _a !== void 0 ? _a : this.defaultCourseId, "/assignments/").concat(opts.assignmentId, "/submissions"),
method: 'POST',
params: {
'comment[text_comment]': utils_1.default.includeIfTruthy(opts.comment),
'submission[url]': opts.url,
'submission[submission_type]': 'online_url',
},
})];
});
});
};
return ECatAssignment;
}(EndpointCategory_1.default));
/*------------------------------------------------------------------------*/
/* Export */
/*------------------------------------------------------------------------*/
exports.default = ECatAssignment;
//# sourceMappingURL=ECatAssignment.js.map