640 lines
25 KiB
TypeScript
640 lines
25 KiB
TypeScript
// (C) Copyright 2015 Moodle Pty Ltd.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
import { Injectable } from '@angular/core';
|
|
import { CoreFileProvider } from '@providers/file';
|
|
import { CoreGroupsProvider } from '@providers/groups';
|
|
import { CoreLoggerProvider } from '@providers/logger';
|
|
import { CoreSitesProvider, CoreSitesCommonWSOptions } from '@providers/sites';
|
|
import { CoreUtilsProvider } from '@providers/utils/utils';
|
|
import { CoreFileUploaderProvider } from '@core/fileuploader/providers/fileuploader';
|
|
import { AddonModAssignFeedbackDelegate } from './feedback-delegate';
|
|
import { AddonModAssignSubmissionDelegate } from './submission-delegate';
|
|
import {
|
|
AddonModAssignProvider, AddonModAssignAssign, AddonModAssignSubmission, AddonModAssignParticipant,
|
|
AddonModAssignSubmissionFeedback
|
|
} from './assign';
|
|
import { AddonModAssignOfflineProvider } from './assign-offline';
|
|
|
|
/**
|
|
* Service that provides some helper functions for assign.
|
|
*/
|
|
@Injectable()
|
|
export class AddonModAssignHelperProvider {
|
|
protected logger;
|
|
|
|
constructor(logger: CoreLoggerProvider, private sitesProvider: CoreSitesProvider, private fileProvider: CoreFileProvider,
|
|
private assignProvider: AddonModAssignProvider, private utils: CoreUtilsProvider,
|
|
private assignOffline: AddonModAssignOfflineProvider, private feedbackDelegate: AddonModAssignFeedbackDelegate,
|
|
private submissionDelegate: AddonModAssignSubmissionDelegate, private fileUploaderProvider: CoreFileUploaderProvider,
|
|
private groupsProvider: CoreGroupsProvider) {
|
|
this.logger = logger.getInstance('AddonModAssignHelperProvider');
|
|
}
|
|
|
|
/**
|
|
* Check if a submission can be edited in offline.
|
|
*
|
|
* @param assign Assignment.
|
|
* @param submission Submission.
|
|
* @return Whether it can be edited offline.
|
|
*/
|
|
canEditSubmissionOffline(assign: AddonModAssignAssign, submission: AddonModAssignSubmission): Promise<boolean> {
|
|
if (!submission) {
|
|
return Promise.resolve(false);
|
|
}
|
|
|
|
if (submission.status == AddonModAssignProvider.SUBMISSION_STATUS_NEW ||
|
|
submission.status == AddonModAssignProvider.SUBMISSION_STATUS_REOPENED) {
|
|
// It's a new submission, allow creating it in offline.
|
|
return Promise.resolve(true);
|
|
}
|
|
|
|
const promises = [];
|
|
let canEdit = true;
|
|
|
|
for (let i = 0; i < submission.plugins.length; i++) {
|
|
const plugin = submission.plugins[i];
|
|
promises.push(this.submissionDelegate.canPluginEditOffline(assign, submission, plugin).then((canEditPlugin) => {
|
|
if (!canEditPlugin) {
|
|
canEdit = false;
|
|
}
|
|
}));
|
|
}
|
|
|
|
return Promise.all(promises).then(() => {
|
|
return canEdit;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Clear plugins temporary data because a submission was cancelled.
|
|
*
|
|
* @param assign Assignment.
|
|
* @param submission Submission to clear the data for.
|
|
* @param inputData Data entered in the submission form.
|
|
*/
|
|
clearSubmissionPluginTmpData(assign: AddonModAssignAssign, submission: AddonModAssignSubmission, inputData: any): void {
|
|
submission.plugins.forEach((plugin) => {
|
|
this.submissionDelegate.clearTmpData(assign, submission, plugin, inputData);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Copy the data from last submitted attempt to the current submission.
|
|
* Since we don't have any WS for that we'll have to re-submit everything manually.
|
|
*
|
|
* @param assign Assignment.
|
|
* @param previousSubmission Submission to copy.
|
|
* @return Promise resolved when done.
|
|
*/
|
|
copyPreviousAttempt(assign: AddonModAssignAssign, previousSubmission: AddonModAssignSubmission): Promise<any> {
|
|
const pluginData = {},
|
|
promises = [];
|
|
|
|
previousSubmission.plugins.forEach((plugin) => {
|
|
promises.push(this.submissionDelegate.copyPluginSubmissionData(assign, plugin, pluginData));
|
|
});
|
|
|
|
return Promise.all(promises).then(() => {
|
|
// We got the plugin data. Now we need to submit it.
|
|
if (Object.keys(pluginData).length) {
|
|
// There's something to save.
|
|
return this.assignProvider.saveSubmissionOnline(assign.id, pluginData);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Create an empty feedback object.
|
|
*
|
|
* @return Feedback.
|
|
*/
|
|
createEmptyFeedback(): AddonModAssignSubmissionFeedback {
|
|
return {
|
|
grade: undefined,
|
|
gradefordisplay: undefined,
|
|
gradeddate: undefined
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Create an empty submission object.
|
|
*
|
|
* @return Submission.
|
|
*/
|
|
createEmptySubmission(): AddonModAssignSubmissionFormatted {
|
|
return {
|
|
id: undefined,
|
|
userid: undefined,
|
|
attemptnumber: undefined,
|
|
timecreated: undefined,
|
|
timemodified: undefined,
|
|
status: undefined,
|
|
groupid: undefined
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Delete stored submission files for a plugin. See storeSubmissionFiles.
|
|
*
|
|
* @param assignId Assignment ID.
|
|
* @param folderName Name of the plugin folder. Must be unique (both in submission and feedback plugins).
|
|
* @param userId User ID. If not defined, site's current user.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when done.
|
|
*/
|
|
deleteStoredSubmissionFiles(assignId: number, folderName: string, userId?: number, siteId?: string): Promise<any> {
|
|
return this.assignOffline.getSubmissionPluginFolder(assignId, folderName, userId, siteId).then((folderPath) => {
|
|
return this.fileProvider.removeDir(folderPath);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Delete all drafts of the feedback plugin data.
|
|
*
|
|
* @param assignId Assignment Id.
|
|
* @param userId User Id.
|
|
* @param feedback Feedback data.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when done.
|
|
*/
|
|
discardFeedbackPluginData(assignId: number, userId: number, feedback: AddonModAssignSubmissionFeedback,
|
|
siteId?: string): Promise<any> {
|
|
|
|
const promises = [];
|
|
|
|
feedback.plugins.forEach((plugin) => {
|
|
promises.push(this.feedbackDelegate.discardPluginFeedbackData(assignId, userId, plugin, siteId));
|
|
});
|
|
|
|
return Promise.all(promises);
|
|
}
|
|
|
|
/**
|
|
* Check if a submission has no content.
|
|
*
|
|
* @param assign Assignment object.
|
|
* @param submission Submission to inspect.
|
|
* @return Whether the submission is empty.
|
|
*/
|
|
isSubmissionEmpty(assign: AddonModAssignAssign, submission?: AddonModAssignSubmission): boolean {
|
|
if (!submission) {
|
|
return true;
|
|
}
|
|
|
|
for (const plugin of submission.plugins) {
|
|
// If any plugin is not empty, we consider that the submission is not empty either.
|
|
if (!this.submissionDelegate.isPluginEmpty(assign, plugin)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// If all the plugins were empty (or there were no plugins), we consider the submission to be empty.
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* List the participants for a single assignment, with some summary info about their submissions.
|
|
*
|
|
* @param assign Assignment object.
|
|
* @param groupId Group Id.
|
|
* @param options Other options.
|
|
* @return Promise resolved with the list of participants and summary of submissions.
|
|
*/
|
|
getParticipants(assign: AddonModAssignAssign, groupId?: number, options: CoreSitesCommonWSOptions = {})
|
|
: Promise<AddonModAssignParticipant[]> {
|
|
|
|
groupId = groupId || 0;
|
|
options.siteId = options.siteId || this.sitesProvider.getCurrentSiteId();
|
|
|
|
const modOptions = {cmId: assign.cmid, ...options}; // Create new options including all existing ones.
|
|
|
|
return this.assignProvider.listParticipants(assign.id, groupId, modOptions).then((participants) => {
|
|
if (groupId || participants && participants.length > 0) {
|
|
return participants;
|
|
}
|
|
|
|
// If no participants returned and all groups specified, get participants by groups.
|
|
return this.groupsProvider.getActivityGroupInfo(assign.cmid, false, undefined, modOptions.siteId).then((info) => {
|
|
const promises = [],
|
|
participants: {[id: number]: AddonModAssignParticipant} = {};
|
|
|
|
info.groups.forEach((userGroup) => {
|
|
promises.push(this.assignProvider.listParticipants(assign.id, userGroup.id, modOptions).then((parts) => {
|
|
// Do not get repeated users.
|
|
parts.forEach((participant) => {
|
|
participants[participant.id] = participant;
|
|
});
|
|
}));
|
|
});
|
|
|
|
return Promise.all(promises).then(() => {
|
|
return this.utils.objectToArray(participants);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get plugin config from assignment config.
|
|
*
|
|
* @param assign Assignment object including all config.
|
|
* @param subtype Subtype name (assignsubmission or assignfeedback)
|
|
* @param type Name of the subplugin.
|
|
* @return Object containing all configurations of the subplugin selected.
|
|
*/
|
|
getPluginConfig(assign: AddonModAssignAssign, subtype: string, type: string): {[name: string]: string} {
|
|
const configs: {[name: string]: string} = {};
|
|
|
|
assign.configs.forEach((config) => {
|
|
if (config.subtype == subtype && config.plugin == type) {
|
|
configs[config.name] = config.value;
|
|
}
|
|
});
|
|
|
|
return configs;
|
|
}
|
|
|
|
/**
|
|
* Get enabled subplugins.
|
|
*
|
|
* @param assign Assignment object including all config.
|
|
* @param subtype Subtype name (assignsubmission or assignfeedback)
|
|
* @return List of enabled plugins for the assign.
|
|
*/
|
|
getPluginsEnabled(assign: AddonModAssignAssign, subtype: string): any[] {
|
|
const enabled = [];
|
|
|
|
assign.configs.forEach((config) => {
|
|
if (config.subtype == subtype && config.name == 'enabled' && parseInt(config.value, 10) === 1) {
|
|
// Format the plugin objects.
|
|
enabled.push({
|
|
type: config.plugin
|
|
});
|
|
}
|
|
});
|
|
|
|
return enabled;
|
|
}
|
|
|
|
/**
|
|
* Get a list of stored submission files. See storeSubmissionFiles.
|
|
*
|
|
* @param assignId Assignment ID.
|
|
* @param folderName Name of the plugin folder. Must be unique (both in submission and feedback plugins).
|
|
* @param userId User ID. If not defined, site's current user.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved with the files.
|
|
*/
|
|
getStoredSubmissionFiles(assignId: number, folderName: string, userId?: number, siteId?: string): Promise<any[]> {
|
|
return this.assignOffline.getSubmissionPluginFolder(assignId, folderName, userId, siteId).then((folderPath) => {
|
|
return this.fileProvider.getDirectoryContents(folderPath);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get the size that will be uploaded to perform an attempt copy.
|
|
*
|
|
* @param assign Assignment.
|
|
* @param previousSubmission Submission to copy.
|
|
* @return Promise resolved with the size.
|
|
*/
|
|
getSubmissionSizeForCopy(assign: AddonModAssignAssign, previousSubmission: AddonModAssignSubmission): Promise<number> {
|
|
const promises = [];
|
|
let totalSize = 0;
|
|
|
|
previousSubmission.plugins.forEach((plugin) => {
|
|
promises.push(this.submissionDelegate.getPluginSizeForCopy(assign, plugin).then((size) => {
|
|
totalSize += size;
|
|
}));
|
|
});
|
|
|
|
return Promise.all(promises).then(() => {
|
|
return totalSize;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get the size that will be uploaded to save a submission.
|
|
*
|
|
* @param assign Assignment.
|
|
* @param submission Submission to check data.
|
|
* @param inputData Data entered in the submission form.
|
|
* @return Promise resolved with the size.
|
|
*/
|
|
getSubmissionSizeForEdit(assign: AddonModAssignAssign, submission: AddonModAssignSubmission, inputData: any): Promise<number> {
|
|
|
|
const promises = [];
|
|
let totalSize = 0;
|
|
|
|
submission.plugins.forEach((plugin) => {
|
|
promises.push(this.submissionDelegate.getPluginSizeForEdit(assign, submission, plugin, inputData).then((size) => {
|
|
totalSize += size;
|
|
}));
|
|
});
|
|
|
|
return Promise.all(promises).then(() => {
|
|
return totalSize;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get user data for submissions since they only have userid.
|
|
*
|
|
* @param assign Assignment object.
|
|
* @param submissions Submissions to get the data for.
|
|
* @param groupId Group Id.
|
|
* @param options Other options.
|
|
* @return Promise always resolved. Resolve param is the formatted submissions.
|
|
*/
|
|
getSubmissionsUserData(assign: AddonModAssignAssign, submissions: AddonModAssignSubmissionFormatted[], groupId?: number,
|
|
options: CoreSitesCommonWSOptions = {}): Promise<AddonModAssignSubmissionFormatted[]> {
|
|
|
|
const modOptions = {cmId: assign.cmid, ...options}; // Create new options including all existing ones.
|
|
|
|
return this.getParticipants(assign, groupId, modOptions).then((parts) => {
|
|
const blind = assign.blindmarking && !assign.revealidentities;
|
|
const promises = [];
|
|
const result: AddonModAssignSubmissionFormatted[] = [];
|
|
const participants: {[id: number]: AddonModAssignParticipant} = this.utils.arrayToObject(parts, 'id');
|
|
|
|
submissions.forEach((submission) => {
|
|
submission.submitid = submission.userid > 0 ? submission.userid : submission.blindid;
|
|
if (submission.submitid <= 0) {
|
|
return;
|
|
}
|
|
|
|
const participant = participants[submission.submitid];
|
|
if (participant) {
|
|
delete participants[submission.submitid];
|
|
} else {
|
|
// Avoid permission denied error. Participant not found on list.
|
|
return;
|
|
}
|
|
|
|
if (!blind) {
|
|
submission.userfullname = participant.fullname;
|
|
submission.userprofileimageurl = participant.profileimageurl;
|
|
}
|
|
|
|
submission.manyGroups = !!participant.groups && participant.groups.length > 1;
|
|
submission.noGroups = !!participant.groups && participant.groups.length == 0;
|
|
if (participant.groupname) {
|
|
submission.groupid = participant.groupid;
|
|
submission.groupname = participant.groupname;
|
|
}
|
|
|
|
let promise;
|
|
if (submission.userid > 0 && blind) {
|
|
// Blind but not blinded! (Moodle < 3.1.1, 3.2).
|
|
delete submission.userid;
|
|
|
|
promise = this.assignProvider.getAssignmentUserMappings(assign.id, submission.submitid, modOptions)
|
|
.then((blindId) => {
|
|
submission.blindid = blindId;
|
|
});
|
|
}
|
|
|
|
promise = promise || Promise.resolve();
|
|
|
|
promises.push(promise.then(() => {
|
|
// Add to the list.
|
|
if (submission.userfullname || submission.blindid) {
|
|
result.push(submission);
|
|
}
|
|
}));
|
|
});
|
|
|
|
return Promise.all(promises).then(() => {
|
|
// Create a submission for each participant left in the list (the participants already treated were removed).
|
|
this.utils.objectToArray(participants).forEach((participant: AddonModAssignParticipant) => {
|
|
const submission = this.createEmptySubmission();
|
|
|
|
submission.submitid = participant.id;
|
|
|
|
if (!blind) {
|
|
submission.userid = participant.id;
|
|
submission.userfullname = participant.fullname;
|
|
submission.userprofileimageurl = participant.profileimageurl;
|
|
} else {
|
|
submission.blindid = participant.id;
|
|
}
|
|
|
|
submission.manyGroups = !!participant.groups && participant.groups.length > 1;
|
|
submission.noGroups = !!participant.groups && participant.groups.length == 0;
|
|
if (participant.groupname) {
|
|
submission.groupid = participant.groupid;
|
|
submission.groupname = participant.groupname;
|
|
}
|
|
submission.status = participant.submitted ? AddonModAssignProvider.SUBMISSION_STATUS_SUBMITTED :
|
|
AddonModAssignProvider.SUBMISSION_STATUS_NEW;
|
|
|
|
result.push(submission);
|
|
});
|
|
|
|
return result;
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Check if the feedback data has changed for a certain submission and assign.
|
|
*
|
|
* @param assign Assignment.
|
|
* @param submission The submission.
|
|
* @param feedback Feedback data.
|
|
* @param userId The user ID.
|
|
* @return Promise resolved with true if data has changed, resolved with false otherwise.
|
|
*/
|
|
hasFeedbackDataChanged(assign: AddonModAssignAssign, submission: AddonModAssignSubmission,
|
|
feedback: AddonModAssignSubmissionFeedback, userId: number): Promise<boolean> {
|
|
|
|
const promises = [];
|
|
let hasChanged = false;
|
|
|
|
feedback.plugins.forEach((plugin) => {
|
|
promises.push(this.prepareFeedbackPluginData(assign.id, userId, feedback).then((inputData) => {
|
|
return this.feedbackDelegate.hasPluginDataChanged(assign, submission, plugin, inputData, userId).then((changed) => {
|
|
if (changed) {
|
|
hasChanged = true;
|
|
}
|
|
});
|
|
}).catch(() => {
|
|
// Ignore errors.
|
|
}));
|
|
});
|
|
|
|
return this.utils.allPromises(promises).then(() => {
|
|
return hasChanged;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Check if the submission data has changed for a certain submission and assign.
|
|
*
|
|
* @param assign Assignment.
|
|
* @param submission Submission to check data.
|
|
* @param inputData Data entered in the submission form.
|
|
* @return Promise resolved with true if data has changed, resolved with false otherwise.
|
|
*/
|
|
hasSubmissionDataChanged(assign: AddonModAssignAssign, submission: AddonModAssignSubmission, inputData: any)
|
|
: Promise<boolean> {
|
|
|
|
const promises = [];
|
|
let hasChanged = false;
|
|
|
|
submission.plugins.forEach((plugin) => {
|
|
promises.push(this.submissionDelegate.hasPluginDataChanged(assign, submission, plugin, inputData).then((changed) => {
|
|
if (changed) {
|
|
hasChanged = true;
|
|
}
|
|
}).catch(() => {
|
|
// Ignore errors.
|
|
}));
|
|
});
|
|
|
|
return this.utils.allPromises(promises).then(() => {
|
|
return hasChanged;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Prepare and return the plugin data to send for a certain feedback and assign.
|
|
*
|
|
* @param assignId Assignment Id.
|
|
* @param userId User Id.
|
|
* @param feedback Feedback data.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved with plugin data to send to server.
|
|
*/
|
|
prepareFeedbackPluginData(assignId: number, userId: number, feedback: AddonModAssignSubmissionFeedback, siteId?: string)
|
|
: Promise<any> {
|
|
|
|
const pluginData = {},
|
|
promises = [];
|
|
|
|
feedback.plugins.forEach((plugin) => {
|
|
promises.push(this.feedbackDelegate.preparePluginFeedbackData(assignId, userId, plugin, pluginData, siteId));
|
|
});
|
|
|
|
return Promise.all(promises).then(() => {
|
|
return pluginData;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Prepare and return the plugin data to send for a certain submission and assign.
|
|
*
|
|
* @param assign Assignment.
|
|
* @param submission Submission to check data.
|
|
* @param inputData Data entered in the submission form.
|
|
* @param offline True to prepare the data for an offline submission, false otherwise.
|
|
* @return Promise resolved with plugin data to send to server.
|
|
*/
|
|
prepareSubmissionPluginData(assign: AddonModAssignAssign, submission: AddonModAssignSubmission, inputData: any,
|
|
offline?: boolean): Promise<any> {
|
|
|
|
const pluginData = {},
|
|
promises = [];
|
|
|
|
submission.plugins.forEach((plugin) => {
|
|
promises.push(this.submissionDelegate.preparePluginSubmissionData(assign, submission, plugin, inputData, pluginData,
|
|
offline));
|
|
});
|
|
|
|
return Promise.all(promises).then(() => {
|
|
return pluginData;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Given a list of files (either online files or local files), store the local files in a local folder
|
|
* to be submitted later.
|
|
*
|
|
* @param assignId Assignment ID.
|
|
* @param folderName Name of the plugin folder. Must be unique (both in submission and feedback plugins).
|
|
* @param files List of files.
|
|
* @param userId User ID. If not defined, site's current user.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved if success, rejected otherwise.
|
|
*/
|
|
storeSubmissionFiles(assignId: number, folderName: string, files: any[], userId?: number, siteId?: string): Promise<any> {
|
|
// Get the folder where to store the files.
|
|
return this.assignOffline.getSubmissionPluginFolder(assignId, folderName, userId, siteId).then((folderPath) => {
|
|
return this.fileUploaderProvider.storeFilesToUpload(folderPath, files);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Upload a file to a draft area. If the file is an online file it will be downloaded and then re-uploaded.
|
|
*
|
|
* @param assignId Assignment ID.
|
|
* @param file Online file or local FileEntry.
|
|
* @param itemId Draft ID to use. Undefined or 0 to create a new draft ID.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved with the itemId.
|
|
*/
|
|
uploadFile(assignId: number, file: any, itemId?: number, siteId?: string): Promise<number> {
|
|
return this.fileUploaderProvider.uploadOrReuploadFile(file, itemId, AddonModAssignProvider.COMPONENT, assignId, siteId);
|
|
}
|
|
|
|
/**
|
|
* Given a list of files (either online files or local files), upload them to a draft area and return the draft ID.
|
|
* Online files will be downloaded and then re-uploaded.
|
|
* If there are no files to upload it will return a fake draft ID (1).
|
|
*
|
|
* @param assignId Assignment ID.
|
|
* @param files List of files.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved with the itemId.
|
|
*/
|
|
uploadFiles(assignId: number, files: any[], siteId?: string): Promise<number> {
|
|
return this.fileUploaderProvider.uploadOrReuploadFiles(files, AddonModAssignProvider.COMPONENT, assignId, siteId);
|
|
}
|
|
|
|
/**
|
|
* Upload or store some files, depending if the user is offline or not.
|
|
*
|
|
* @param assignId Assignment ID.
|
|
* @param folderName Name of the plugin folder. Must be unique (both in submission and feedback plugins).
|
|
* @param files List of files.
|
|
* @param offline True if files sould be stored for offline, false to upload them.
|
|
* @param userId User ID. If not defined, site's current user.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when done.
|
|
*/
|
|
uploadOrStoreFiles(assignId: number, folderName: string, files: any[], offline?: boolean, userId?: number, siteId?: string)
|
|
: Promise<any> {
|
|
|
|
if (offline) {
|
|
return this.storeSubmissionFiles(assignId, folderName, files, userId, siteId);
|
|
} else {
|
|
return this.uploadFiles(assignId, files, siteId);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Assign submission with some calculated data.
|
|
*/
|
|
export type AddonModAssignSubmissionFormatted = AddonModAssignSubmission & {
|
|
blindid?: number; // Calculated in the app. Blindid of the user that did the submission.
|
|
submitid?: number; // Calculated in the app. Userid or blindid of the user that did the submission.
|
|
userfullname?: string; // Calculated in the app. Full name of the user that did the submission.
|
|
userprofileimageurl?: string; // Calculated in the app. Avatar of the user that did the submission.
|
|
manyGroups?: boolean; // Calculated in the app. Whether the user belongs to more than 1 group.
|
|
noGroups?: boolean; // Calculated in the app. Whether the user doesn't belong to any group.
|
|
groupname?: string; // Calculated in the app. Name of the group the submission belongs to.
|
|
};
|