Vmeda.Online/src/addons/mod/assign/services/assign.ts

// (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 { CoreSites, CoreSitesCommonWSOptions, CoreSitesReadingStrategy } from '@services/sites';
import { CoreSite, CoreSiteWSPreSets } from '@classes/site';
import { CoreInterceptor } from '@classes/interceptor';
import { CoreWSExternalWarning, CoreWSExternalFile } from '@services/ws';
import { makeSingleton } from '@singletons';
import { CoreCourseCommonModWSOptions } from '@features/course/services/course';
import { CoreTextUtils } from '@services/utils/text';
import { CoreGrades } from '@features/grades/services/grades';
import { CoreFilepool } from '@services/filepool';
import { CoreTimeUtils } from '@services/utils/time';
import { CoreCourseLogHelper } from '@features/course/services/log-helper';
import { CoreError } from '@classes/errors/error';
import { CoreApp } from '@services/app';
import { CoreUtils } from '@services/utils/utils';
import { AddonModAssignOffline } from './assign-offline';
import { AddonModAssignSubmissionDelegate } from './submission-delegate';
import { CoreComments } from '@features/comments/services/comments';
import { AddonModAssignSubmissionFormatted } from './assign-helper';
import { CoreWSError } from '@classes/errors/wserror';
import { AddonModAssignAutoSyncData, AddonModAssignManualSyncData, AddonModAssignSyncProvider } from './assign-sync';

const ROOT_CACHE_KEY = 'mmaModAssign:';

declare module '@singletons/events' {

    /**
     * Augment CoreEventsData interface with events specific to this service.
     *
     * @see https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
     */
    export interface CoreEventsData {
        [AddonModAssignProvider.SUBMISSION_SAVED_EVENT]: AddonModAssignSubmissionSavedEventData;
        [AddonModAssignProvider.SUBMITTED_FOR_GRADING_EVENT]: AddonModAssignSubmittedForGradingEventData;
        [AddonModAssignProvider.GRADED_EVENT]: AddonModAssignGradedEventData;
        [AddonModAssignSyncProvider.MANUAL_SYNCED]: AddonModAssignManualSyncData;
        [AddonModAssignSyncProvider.AUTO_SYNCED]: AddonModAssignAutoSyncData;
    }

}

/**
 * Service that provides some functions for assign.
 */
@Injectable({ providedIn: 'root' })
export class AddonModAssignProvider {

    static readonly COMPONENT = 'mmaModAssign';
    static readonly SUBMISSION_COMPONENT = 'mmaModAssignSubmission';
    static readonly UNLIMITED_ATTEMPTS = -1;

    // Submission status.
    static readonly SUBMISSION_STATUS_NEW = 'new';
    static readonly SUBMISSION_STATUS_REOPENED = 'reopened';
    static readonly SUBMISSION_STATUS_DRAFT = 'draft';
    static readonly SUBMISSION_STATUS_SUBMITTED = 'submitted';

    // "Re-open" methods (to retry the assign).
    static readonly ATTEMPT_REOPEN_METHOD_NONE = 'none';
    static readonly ATTEMPT_REOPEN_METHOD_MANUAL = 'manual';

    // Grading status.
    static readonly GRADING_STATUS_GRADED = 'graded';
    static readonly GRADING_STATUS_NOT_GRADED = 'notgraded';
    static readonly MARKING_WORKFLOW_STATE_RELEASED = 'released';
    static readonly NEED_GRADING = 'needgrading';
    static readonly GRADED_FOLLOWUP_SUBMIT = 'gradedfollowupsubmit';

    // Group submissions warnings.
    static readonly WARN_GROUPS_REQUIRED = 'warnrequired';
    static readonly WARN_GROUPS_OPTIONAL = 'warnoptional';

    // Events.
    static readonly SUBMISSION_SAVED_EVENT = 'addon_mod_assign_submission_saved';
    static readonly SUBMITTED_FOR_GRADING_EVENT = 'addon_mod_assign_submitted_for_grading';
    static readonly GRADED_EVENT = 'addon_mod_assign_graded';

    protected gradingOfflineEnabled: {[siteId: string]: boolean}  = {};

    /**
     * Check if the user can submit in offline. This should only be used if submissionStatus.lastattempt.cansubmit cannot
     * be used (offline usage).
     * This function doesn't check if the submission is empty, it should be checked before calling this function.
     *
     * @param assign Assignment instance.
     * @param submissionStatus Submission status returned by getSubmissionStatus.
     * @return Whether it can submit.
     */
    canSubmitOffline(assign: AddonModAssignAssign, submissionStatus: AddonModAssignGetSubmissionStatusWSResponse): boolean {
        if (!this.isSubmissionOpen(assign, submissionStatus)) {
            return false;
        }

        const userSubmission = submissionStatus.lastattempt?.submission;
        const teamSubmission = submissionStatus.lastattempt?.teamsubmission;

        if (teamSubmission) {
            if (teamSubmission.status === AddonModAssignProvider.SUBMISSION_STATUS_SUBMITTED) {
                // The assignment submission has been completed.
                return false;
            } else if (userSubmission && userSubmission.status === AddonModAssignProvider.SUBMISSION_STATUS_SUBMITTED) {
                // The user has already clicked the submit button on the team submission.
                return false;
            } else if (assign.preventsubmissionnotingroup && !submissionStatus.lastattempt?.submissiongroup) {
                return false;
            }
        } else if (userSubmission) {
            if (userSubmission.status === AddonModAssignProvider.SUBMISSION_STATUS_SUBMITTED) {
                // The assignment submission has been completed.
                return false;
            }
        } else {
            // No valid submission or team submission.
            return false;
        }

        // Last check is that this instance allows drafts.
        return !!assign.submissiondrafts;
    }

    /**
     * Fix some submission status params.
     *
     * @param site Site to use.
     * @param userId User Id (empty for current user).
     * @param groupId Group Id (empty for all participants).
     * @param isBlind If blind marking is enabled or not.
     * @return Object with fixed params.
     */
    protected fixSubmissionStatusParams(
        site: CoreSite,
        userId?: number,
        groupId?: number,
        isBlind = false,
    ): AddonModAssignFixedSubmissionParams {

        return {
            isBlind: !userId ? false : !!isBlind,
            groupId: site.isVersionGreaterEqualThan('3.5') ? groupId || 0 : 0,
            userId: userId || site.getUserId(),
        };
    }

    /**
     * Get an assignment by course module ID.
     *
     * @param courseId Course ID the assignment belongs to.
     * @param cmId Assignment module ID.
     * @param options Other options.
     * @return Promise resolved with the assignment.
     */
    getAssignment(courseId: number, cmId: number, options: CoreSitesCommonWSOptions = {}): Promise<AddonModAssignAssign> {
        return this.getAssignmentByField(courseId, 'cmid', cmId, options);
    }

    /**
     * Get an assigment with key=value. If more than one is found, only the first will be returned.
     *
     * @param courseId Course ID.
     * @param key Name of the property to check.
     * @param value Value to search.
     * @param options Other options.
     * @return Promise resolved when the assignment is retrieved.
     */
    protected async getAssignmentByField(
        courseId: number,
        key: string,
        value: number,
        options: CoreSitesCommonWSOptions = {},
    ): Promise<AddonModAssignAssign> {
        const site = await CoreSites.getSite(options.siteId);

        const params: AddonModAssignGetAssignmentsWSParams = {
            courseids: [courseId],
            includenotenrolledcourses: true,
        };

        const preSets: CoreSiteWSPreSets = {
            cacheKey: this.getAssignmentCacheKey(courseId),
            updateFrequency: CoreSite.FREQUENCY_RARELY,
            component: AddonModAssignProvider.COMPONENT,
            ...CoreSites.getReadingStrategyPreSets(options.readingStrategy), // Include reading strategy preSets.
        };

        let response: AddonModAssignGetAssignmentsWSResponse;

        try {
            response = await site.read<AddonModAssignGetAssignmentsWSResponse>('mod_assign_get_assignments', params, preSets);
        } catch {
            // In 3.6 we added a new parameter includenotenrolledcourses that could cause offline data not to be found.
            // Retry again without the param to check if the request is already cached.
            delete params.includenotenrolledcourses;

            response = await site.read('mod_assign_get_assignments', params, preSets);
        }

        // Search the assignment to return.
        if (response.courses.length) {
            const assignment = response.courses[0].assignments.find((assignment) => assignment[key] == value);

            if (assignment) {
                return assignment;
            }
        }

        throw new CoreError('Assignment not found');
    }

    /**
     * Get an assignment by instance ID.
     *
     * @param courseId Course ID the assignment belongs to.
     * @param id Assignment instance ID.
     * @param options Other options.
     * @return Promise resolved with the assignment.
     */
    getAssignmentById(courseId: number, id: number, options: CoreSitesCommonWSOptions = {}): Promise<AddonModAssignAssign> {
        return this.getAssignmentByField(courseId, 'id', id, options);
    }

    /**
     * Get cache key for assignment data WS calls.
     *
     * @param courseId Course ID.
     * @return Cache key.
     */
    protected getAssignmentCacheKey(courseId: number): string {
        return ROOT_CACHE_KEY + 'assignment:' + courseId;
    }

    /**
     * Get an assignment user mapping for blind marking.
     *
     * @param assignId Assignment Id.
     * @param userId User Id to be blinded.
     * @param options Other options.
     * @return Promise resolved with the user blind id.
     */
    async getAssignmentUserMappings(assignId: number, userId: number, options: CoreCourseCommonModWSOptions = {}): Promise<number> {
        if (!userId || userId < 0) {
            // User not valid, stop.
            return -1;
        }

        const site = await CoreSites.getSite(options.siteId);

        const params: AddonModAssignGetUserMappingsWSParams = {
            assignmentids: [assignId],
        };
        const preSets: CoreSiteWSPreSets = {
            cacheKey: this.getAssignmentUserMappingsCacheKey(assignId),
            updateFrequency: CoreSite.FREQUENCY_OFTEN,
            component: AddonModAssignProvider.COMPONENT,
            componentId: options.cmId,
            ...CoreSites.getReadingStrategyPreSets(options.readingStrategy),
        };

        const response = await site.read<AddonModAssignGetUserMappingsWSResponse>('mod_assign_get_user_mappings', params, preSets);

        // Search the user.
        if (response.assignments.length && response.assignments[0].assignmentid == assignId) {
            const mapping = response.assignments[0].mappings.find((mapping) => mapping.userid == userId);

            if (mapping) {
                return mapping.id;
            }
        } else if (response.warnings && response.warnings.length) {
            throw response.warnings[0];
        }

        throw new CoreError('Assignment user mappings not found');
    }

    /**
     * Get cache key for assignment user mappings data WS calls.
     *
     * @param assignId Assignment ID.
     * @return Cache key.
     */
    protected getAssignmentUserMappingsCacheKey(assignId: number): string {
        return ROOT_CACHE_KEY + 'usermappings:' + assignId;
    }

    /**
     * Returns grade information from assign_grades for the requested assignment id
     *
     * @param assignId Assignment Id.
     * @param options Other options.
     * @return Resolved with requested info when done.
     */
    async getAssignmentGrades(assignId: number, options: CoreCourseCommonModWSOptions = {}): Promise<AddonModAssignGrade[]> {
        const site = await CoreSites.getSite(options.siteId);

        const params: AddonModAssignGetGradesWSParams = {
            assignmentids: [assignId],
        };
        const preSets: CoreSiteWSPreSets = {
            cacheKey: this.getAssignmentGradesCacheKey(assignId),
            component: AddonModAssignProvider.COMPONENT,
            componentId: options.cmId,
            ...CoreSites.getReadingStrategyPreSets(options.readingStrategy),
        };

        const response = await site.read<AddonModAssignGetGradesWSResponse>('mod_assign_get_grades', params, preSets);

        // Search the assignment.
        if (response.assignments.length && response.assignments[0].assignmentid == assignId) {
            return response.assignments[0].grades;
        } else if (response.warnings && response.warnings.length) {
            if (response.warnings[0].warningcode == '3') {
                // No grades found.
                return [];
            }

            throw response.warnings[0];
        }

        throw new CoreError('Assignment grades not found.');
    }

    /**
     * Get cache key for assignment grades data WS calls.
     *
     * @param assignId Assignment ID.
     * @return Cache key.
     */
    protected getAssignmentGradesCacheKey(assignId: number): string {
        return ROOT_CACHE_KEY + 'assigngrades:' + assignId;
    }

    /**
     * Returns the color name for a given grading status name.
     *
     * @param status Grading status name
     * @return The color name.
     */
    getSubmissionGradingStatusColor(status?: string): string {
        if (!status) {
            return '';
        }

        if (status == AddonModAssignProvider.GRADING_STATUS_GRADED ||
                status == AddonModAssignProvider.MARKING_WORKFLOW_STATE_RELEASED) {
            return 'success';
        }

        return 'danger';
    }

    /**
     * Returns the translation id for a given grading status name.
     *
     * @param status Grading Status name
     * @return The status translation identifier.
     */
    getSubmissionGradingStatusTranslationId(status?: string): string | undefined {
        if (!status) {
            return;
        }

        if (status == AddonModAssignProvider.GRADING_STATUS_GRADED || status == AddonModAssignProvider.GRADING_STATUS_NOT_GRADED
               || status == AddonModAssignProvider.GRADED_FOLLOWUP_SUBMIT) {
            return 'addon.mod_assign.' + status;
        }

        return 'addon.mod_assign.markingworkflowstate' + status;
    }

    /**
     * Get the submission object from an attempt.
     *
     * @param assign Assign.
     * @param attempt Attempt.
     * @return Submission object or null.
     */
    getSubmissionObjectFromAttempt(
        assign: AddonModAssignAssign,
        attempt: AddonModAssignSubmissionAttempt | undefined,
    ): AddonModAssignSubmission | undefined {
        if (!attempt) {
            return;
        }

        return assign.teamsubmission ? attempt.teamsubmission : attempt.submission;
    }

    /**
     * Get attachments of a submission plugin.
     *
     * @param submissionPlugin Submission plugin.
     * @return Submission plugin attachments.
     */
    getSubmissionPluginAttachments(submissionPlugin: AddonModAssignPlugin): CoreWSExternalFile[] {
        if (!submissionPlugin.fileareas) {
            return [];
        }

        const files: CoreWSExternalFile[] = [];

        submissionPlugin.fileareas.forEach((filearea) => {
            if (!filearea || !filearea.files) {
                // No files to get.
                return;
            }

            filearea.files.forEach((file) => {
                if (!file.filename) {
                    // We don't have filename, extract it from the path.
                    file.filename = file.filepath?.charAt(0) == '/' ? file.filepath.substr(1) : file.filepath;
                }

                files.push(file);
            });
        });

        return files;
    }

    /**
     * Get text of a submission plugin.
     *
     * @param submissionPlugin Submission plugin.
     * @param keepUrls True if it should keep original URLs, false if they should be replaced.
     * @return Submission text.
     */
    getSubmissionPluginText(submissionPlugin: AddonModAssignPlugin, keepUrls = false): string {
        if (!submissionPlugin.editorfields) {
            return '';
        }
        let text = '';

        submissionPlugin.editorfields.forEach((field) => {
            text += field.text;
        });

        if (!keepUrls && submissionPlugin.fileareas && submissionPlugin.fileareas[0]) {
            text = CoreTextUtils.replacePluginfileUrls(text, submissionPlugin.fileareas[0].files || []);
        }

        return text;
    }

    /**
     * Get an assignment submissions.
     *
     * @param assignId Assignment id.
     * @param options Other options.
     * @return Promise resolved when done.
     */
    async getSubmissions(
        assignId: number,
        options: CoreCourseCommonModWSOptions = {},
    ): Promise<{ canviewsubmissions: boolean; submissions?: AddonModAssignSubmission[] }> {
        const site = await CoreSites.getSite(options.siteId);

        const params: ModAssignGetSubmissionsWSParams = {
            assignmentids: [assignId],
        };
        const preSets: CoreSiteWSPreSets = {
            cacheKey: this.getSubmissionsCacheKey(assignId),
            updateFrequency: CoreSite.FREQUENCY_OFTEN,
            component: AddonModAssignProvider.COMPONENT,
            componentId: options.cmId,
            ...CoreSites.getReadingStrategyPreSets(options.readingStrategy),
        };
        const response = await site.read<AddonModAssignGetSubmissionsWSResponse>('mod_assign_get_submissions', params, preSets);

        // Check if we can view submissions, with enough permissions.
        if (response.warnings?.length && response.warnings[0].warningcode == '1') {
            return { canviewsubmissions: false };
        }

        if (response.assignments && response.assignments.length) {
            return {
                canviewsubmissions: true,
                submissions: response.assignments[0].submissions,
            };
        }

        throw new CoreError('Assignment submissions not found');
    }

    /**
     * Get cache key for assignment submissions data WS calls.
     *
     * @param assignId Assignment id.
     * @return Cache key.
     */
    protected getSubmissionsCacheKey(assignId: number): string {
        return ROOT_CACHE_KEY + 'submissions:' + assignId;
    }

    /**
     * Get information about an assignment submission status for a given user.
     *
     * @param assignId Assignment instance id.
     * @param options Other options.
     * @return Promise always resolved with the user submission status.
     */
    async getSubmissionStatus(
        assignId: number,
        options: AddonModAssignSubmissionStatusOptions = {},
    ): Promise<AddonModAssignGetSubmissionStatusWSResponse> {
        const site = await CoreSites.getSite(options.siteId);

        options = {
            filter: true,
            ...options,
        };

        const fixedParams = this.fixSubmissionStatusParams(site, options.userId, options.groupId, options.isBlind);
        const params: AddonModAssignGetSubmissionStatusWSParams = {
            assignid: assignId,
            userid: fixedParams.userId,
        };
        if (fixedParams.groupId) {
            params.groupid = fixedParams.groupId;
        }

        const preSets: CoreSiteWSPreSets = {
            cacheKey: this.getSubmissionStatusCacheKey(
                assignId,
                fixedParams.userId,
                fixedParams.groupId,
                fixedParams.isBlind,
            ),
            getCacheUsingCacheKey: true,
            filter: options.filter,
            rewriteurls: options.filter,
            component: AddonModAssignProvider.COMPONENT,
            componentId: options.cmId,
            // Don't cache when getting text without filters.
            // @todo Change this to support offline editing.
            saveToCache: options.filter,
            ...CoreSites.getReadingStrategyPreSets(options.readingStrategy),
        };

        return site.read<AddonModAssignGetSubmissionStatusWSResponse>('mod_assign_get_submission_status', params, preSets);
    }

    /**
     * Get information about an assignment submission status for a given user.
     * If the data doesn't include the user submission, retry ignoring cache.
     *
     * @param assign Assignment.
     * @param options Other options.
     * @return Promise always resolved with the user submission status.
     */
    async getSubmissionStatusWithRetry(
        assign: AddonModAssignAssign,
        options: AddonModAssignSubmissionStatusOptions = {},
    ): Promise<AddonModAssignGetSubmissionStatusWSResponse> {
        options.cmId = options.cmId || assign.cmid;

        const response = await this.getSubmissionStatus(assign.id, options);

        const userSubmission = this.getSubmissionObjectFromAttempt(assign, response.lastattempt);
        if (userSubmission) {
            return response;
        }
        // Try again, ignoring cache.
        const newOptions = {
            ...options,
            readingStrategy: CoreSitesReadingStrategy.OnlyNetwork,
        };

        try {
            return this.getSubmissionStatus(assign.id, newOptions);
        } catch {
            // Error, return the first result even if it doesn't have the user submission.
            return response;
        }
    }

    /**
     * Get cache key for get submission status data WS calls.
     *
     * @param assignId Assignment instance id.
     * @param userId User id (empty for current user).
     * @param groupId Group Id (empty for all participants).
     * @param isBlind If blind marking is enabled or not.
     * @return Cache key.
     */
    protected getSubmissionStatusCacheKey(assignId: number, userId: number, groupId?: number, isBlind = false): string {
        return this.getSubmissionsCacheKey(assignId) + ':' + userId + ':' + (isBlind ? 1 : 0) + ':' + groupId;
    }

    /**
     * Returns the color name for a given status name.
     *
     * @param status Status name
     * @return The color name.
     */
    getSubmissionStatusColor(status: string): string {
        switch (status) {
            case 'submitted':
                return 'success';
            case 'draft':
                return 'info';
            case 'new':
            case 'noattempt':
            case 'noonlinesubmissions':
            case 'nosubmission':
            case 'gradedfollowupsubmit':
                return 'danger';
            default:
                return 'light';
        }
    }

    /**
     * Given a list of plugins, returns the plugin names that aren't supported for editing.
     *
     * @param plugins Plugins to check.
     * @return Promise resolved with unsupported plugin names.
     */
    async getUnsupportedEditPlugins(plugins: AddonModAssignPlugin[]): Promise<string[]> {
        const notSupported: string[] = [];
        const promises = plugins.map((plugin) =>
            AddonModAssignSubmissionDelegate.isPluginSupportedForEdit(plugin.type).then((enabled) => {
                if (!enabled) {
                    notSupported.push(plugin.name);
                }

                return;
            }));

        await Promise.all(promises);

        return notSupported;
    }

    /**
     * List the participants for a single assignment, with some summary info about their submissions.
     *
     * @param assignId Assignment id.
     * @param groupId Group id. If not defined, 0.
     * @param options Other options.
     * @return Promise resolved with the list of participants and summary of submissions.
     */
    async listParticipants(
        assignId: number,
        groupId?: number,
        options: CoreCourseCommonModWSOptions = {},
    ): Promise<AddonModAssignParticipant[]> {

        groupId = groupId || 0;

        const site = await CoreSites.getSite(options.siteId);
        if (!site.wsAvailable('mod_assign_list_participants')) {
            // Silently fail if is not available. (needs Moodle version >= 3.2)
            throw new CoreError('mod_assign_list_participants WS is only available 3.2 onwards');
        }

        const params: AddonModAssignListParticipantsWSParams = {
            assignid: assignId,
            groupid: groupId,
            filter: '',
        };

        const preSets: CoreSiteWSPreSets = {
            cacheKey: this.listParticipantsCacheKey(assignId, groupId),
            updateFrequency: CoreSite.FREQUENCY_OFTEN,
            component: AddonModAssignProvider.COMPONENT,
            componentId: options.cmId,
            ...CoreSites.getReadingStrategyPreSets(options.readingStrategy),
        };

        return site.read<AddonModAssignListParticipantsWSResponse>('mod_assign_list_participants', params, preSets);
    }

    /**
     * Get cache key for assignment list participants data WS calls.
     *
     * @param assignId Assignment id.
     * @param groupId Group id.
     * @return Cache key.
     */
    protected listParticipantsCacheKey(assignId: number, groupId: number): string {
        return this.listParticipantsPrefixCacheKey(assignId) + ':' + groupId;
    }

    /**
     * Get prefix cache key for assignment list participants data WS calls.
     *
     * @param assignId Assignment id.
     * @return Cache key.
     */
    protected listParticipantsPrefixCacheKey(assignId: number): string {
        return ROOT_CACHE_KEY + 'participants:' + assignId;
    }

    /**
     * Invalidates all submission status data.
     *
     * @param assignId Assignment instance id.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the data is invalidated.
     */
    async invalidateAllSubmissionData(assignId: number, siteId?: string): Promise<void> {
        const site = await CoreSites.getSite(siteId);

        await site.invalidateWsCacheForKeyStartingWith(this.getSubmissionsCacheKey(assignId));
    }

    /**
     * Invalidates assignment data WS calls.
     *
     * @param courseId Course ID.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the data is invalidated.
     */
    async invalidateAssignmentData(courseId: number, siteId?: string): Promise<void> {
        const site = await CoreSites.getSite(siteId);

        await site.invalidateWsCacheForKey(this.getAssignmentCacheKey(courseId));
    }

    /**
     * Invalidates assignment user mappings data WS calls.
     *
     * @param assignId Assignment ID.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the data is invalidated.
     */
    async invalidateAssignmentUserMappingsData(assignId: number, siteId?: string): Promise<void> {
        const site = await CoreSites.getSite(siteId);

        await site.invalidateWsCacheForKey(this.getAssignmentUserMappingsCacheKey(assignId));
    }

    /**
     * Invalidates assignment grades data WS calls.
     *
     * @param assignId Assignment ID.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the data is invalidated.
     */
    async invalidateAssignmentGradesData(assignId: number, siteId?: string): Promise<void> {
        const site = await CoreSites.getSite(siteId);

        await site.invalidateWsCacheForKey(this.getAssignmentGradesCacheKey(assignId));
    }

    /**
     * Invalidate the prefetched content except files.
     * To invalidate files, use AddonModAssignProvider.invalidateFiles.
     *
     * @param moduleId The module ID.
     * @param courseId Course ID.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the data is invalidated.
     */
    async invalidateContent(moduleId: number, courseId: number, siteId?: string): Promise<void> {
        siteId = siteId || CoreSites.getCurrentSiteId();

        const assign = await this.getAssignment(courseId, moduleId, { siteId });
        const promises: Promise<void>[] = [];
        // Do not invalidate assignment data before getting assignment info, we need it!
        promises.push(this.invalidateAllSubmissionData(assign.id, siteId));
        promises.push(this.invalidateAssignmentUserMappingsData(assign.id, siteId));
        promises.push(this.invalidateAssignmentGradesData(assign.id, siteId));
        promises.push(this.invalidateListParticipantsData(assign.id, siteId));
        promises.push(CoreComments.invalidateCommentsByInstance('module', assign.id, siteId));
        promises.push(this.invalidateAssignmentData(courseId, siteId));
        promises.push(CoreGrades.invalidateAllCourseGradesData(courseId));

        await Promise.all(promises);
    }

    /**
     * Invalidate the prefetched files.
     *
     * @param moduleId The module ID.
     * @return Promise resolved when the files are invalidated.
     */
    async invalidateFiles(moduleId: number): Promise<void> {
        await CoreFilepool.invalidateFilesByComponent(
            CoreSites.getCurrentSiteId(),
            AddonModAssignProvider.COMPONENT,
            moduleId,
        );
    }

    /**
     * Invalidates assignment submissions data WS calls.
     *
     * @param assignId Assignment instance id.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the data is invalidated.
     */
    async invalidateSubmissionData(assignId: number, siteId?: string): Promise<void> {
        const site = await CoreSites.getSite(siteId);

        await site.invalidateWsCacheForKey(this.getSubmissionsCacheKey(assignId));
    }

    /**
     * Invalidates submission status data.
     *
     * @param assignId Assignment instance id.
     * @param userId User id (empty for current user).
     * @param groupId Group Id (empty for all participants).
     * @param isBlind Whether blind marking is enabled or not.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the data is invalidated.
     */
    async invalidateSubmissionStatusData(
        assignId: number,
        userId?: number,
        groupId?: number,
        isBlind = false,
        siteId?: string,
    ): Promise<void> {
        const site = await CoreSites.getSite(siteId);
        const fixedParams = this.fixSubmissionStatusParams(site, userId, groupId, isBlind);

        await site.invalidateWsCacheForKey(this.getSubmissionStatusCacheKey(
            assignId,
            fixedParams.userId,
            fixedParams.groupId,
            fixedParams.isBlind,
        ));
    }

    /**
     * Invalidates assignment participants data.
     *
     * @param assignId Assignment instance id.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the data is invalidated.
     */
    async invalidateListParticipantsData(assignId: number, siteId?: string): Promise<void> {
        const site = await CoreSites.getSite(siteId);

        await site.invalidateWsCacheForKeyStartingWith(this.listParticipantsPrefixCacheKey(assignId));
    }

    /**
     * Convenience function to check if grading offline is enabled.
     *
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved with boolean: whether grading offline is enabled.
     */
    protected async isGradingOfflineEnabled(siteId?: string): Promise<boolean> {
        siteId = siteId || CoreSites.getCurrentSiteId();

        if (typeof this.gradingOfflineEnabled[siteId] != 'undefined') {
            return this.gradingOfflineEnabled[siteId];
        }

        this.gradingOfflineEnabled[siteId] = await CoreGrades.isGradeItemsAvalaible(siteId);

        return this.gradingOfflineEnabled[siteId];
    }

    /**
     * Outcomes only can be edited if mod_assign_submit_grading_form is avalaible.
     *
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved with true if outcomes edit is enabled, rejected or resolved with false otherwise.
     * @since 3.2
     */
    async isOutcomesEditEnabled(siteId?: string): Promise<boolean> {
        const site = await CoreSites.getSite(siteId);

        return site.wsAvailable('mod_assign_submit_grading_form');
    }

    /**
     * Check if assignments plugin is enabled in a certain site.
     *
     * @param siteId Site ID. If not defined, current site.
     * @return Whether the plugin is enabled.
     */
    isPluginEnabled(): boolean {
        return true;
    }

    /**
     * Check if a submission is open. This function is based on Moodle's submissions_open.
     *
     * @param assign Assignment instance.
     * @param submissionStatus Submission status returned by getSubmissionStatus.
     * @return Whether submission is open.
     */
    isSubmissionOpen(assign: AddonModAssignAssign, submissionStatus?: AddonModAssignGetSubmissionStatusWSResponse): boolean {
        if (!assign || !submissionStatus) {
            return false;
        }

        const time = CoreTimeUtils.timestamp();
        const lastAttempt = submissionStatus.lastattempt;
        const submission = this.getSubmissionObjectFromAttempt(assign, lastAttempt);

        let dateOpen = true;
        let finalDate: number | undefined;

        if (assign.cutoffdate) {
            finalDate = assign.cutoffdate;
        }

        if (lastAttempt && lastAttempt.locked) {
            return false;
        }

        // User extensions.
        if (finalDate) {
            if (lastAttempt && lastAttempt.extensionduedate) {
                // Extension can be before cut off date.
                if (lastAttempt.extensionduedate > finalDate) {
                    finalDate = lastAttempt.extensionduedate;
                }
            }
        }

        if (finalDate) {
            dateOpen = assign.allowsubmissionsfromdate <= time && time <= finalDate;
        } else {
            dateOpen = assign.allowsubmissionsfromdate <= time;
        }

        if (!dateOpen) {
            return false;
        }

        if (submission) {
            if (assign.submissiondrafts && submission.status == AddonModAssignProvider.SUBMISSION_STATUS_SUBMITTED) {
                // Drafts are tracked and the student has submitted the assignment.
                return false;
            }
        }

        return true;
    }

    /**
     * Report an assignment submission as being viewed.
     *
     * @param assignid Assignment ID.
     * @param name Name of the assign.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the WS call is successful.
     */
    async logSubmissionView(assignid: number, name?: string, siteId?: string): Promise<void> {
        const params: AddonModAssignViewSubmissionStatusWSParams = {
            assignid,
        };

        await CoreCourseLogHelper.logSingle(
            'mod_assign_view_submission_status',
            params,
            AddonModAssignProvider.COMPONENT,
            assignid,
            name,
            'assign',
            {},
            siteId,
        );
    }

    /**
     * Report an assignment grading table is being viewed.
     *
     * @param assignid Assignment ID.
     * @param name Name of the assign.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the WS call is successful.
     */
    async logGradingView(assignid: number, name?: string, siteId?: string): Promise<void> {
        const params: AddonModAssignViewGradingTableWSParams = {
            assignid,
        };

        await CoreCourseLogHelper.logSingle(
            'mod_assign_view_grading_table',
            params,
            AddonModAssignProvider.COMPONENT,
            assignid,
            name,
            'assign',
            {},
            siteId,
        );
    }

    /**
     * Report an assign as being viewed.
     *
     * @param assignid Assignment ID.
     * @param name Name of the assign.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when the WS call is successful.
     */
    async logView(assignid: number, name?: string, siteId?: string): Promise<void> {
        const params: AddonModAssignViewAssignWSParams = {
            assignid,
        };

        await CoreCourseLogHelper.logSingle(
            'mod_assign_view_assign',
            params,
            AddonModAssignProvider.COMPONENT,
            assignid,
            name,
            'assign',
            {},
            siteId,
        );
    }

    /**
     * Returns if a submissions needs to be graded.
     *
     * @param submission Submission.
     * @param assignId Assignment ID.
     * @return Promise resolved with boolean: whether it needs to be graded or not.
     */
    async needsSubmissionToBeGraded(submission: AddonModAssignSubmissionFormatted, assignId: number): Promise<boolean> {
        if (!submission.gradingstatus) {
            // This should not happen, but it's better to show rather than not showing any of the submissions.
            return true;
        }

        if (submission.gradingstatus != AddonModAssignProvider.GRADING_STATUS_GRADED &&
                submission.gradingstatus != AddonModAssignProvider.MARKING_WORKFLOW_STATE_RELEASED) {
            // Not graded.
            return true;
        }

        // We need more data to decide that.
        const response = await this.getSubmissionStatus(assignId, {
            userId: submission.submitid,
            isBlind: !!submission.blindid,
        });

        if (!response.feedback || !response.feedback.gradeddate) {
            // Not graded.
            return true;
        }

        return response.feedback.gradeddate < submission.timemodified;
    }

    /**
     * Save current user submission for a certain assignment.
     *
     * @param assignId Assign ID.
     * @param courseId Course ID the assign belongs to.
     * @param pluginData Data to save.
     * @param allowOffline Whether to allow offline usage.
     * @param timemodified The time the submission was last modified in online.
     * @param allowsDrafts Whether the assignment allows submission drafts.
     * @param userId User ID. If not defined, site's current user.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved with true if sent to server, resolved with false if stored in offline.
     */
    async saveSubmission(
        assignId: number,
        courseId: number,
        pluginData: AddonModAssignSavePluginData,
        allowOffline: boolean,
        timemodified: number,
        allowsDrafts = false,
        userId?: number,
        siteId?: string,
    ): Promise<boolean> {

        siteId = siteId || CoreSites.getCurrentSiteId();

        // Function to store the submission to be synchronized later.
        const storeOffline = async (): Promise<boolean> => {
            await AddonModAssignOffline.saveSubmission(
                assignId,
                courseId,
                pluginData,
                timemodified,
                !allowsDrafts,
                userId,
                siteId,
            );

            return false;
        };

        if (allowOffline && !CoreApp.isOnline()) {
            // App is offline, store the action.
            return storeOffline();
        }

        try {
            // If there's already a submission to be sent to the server, discard it first.
            await AddonModAssignOffline.deleteSubmission(assignId, userId, siteId);
            await this.saveSubmissionOnline(assignId, pluginData, siteId);

            return true;
        } catch (error) {
            if (allowOffline && error && !CoreUtils.isWebServiceError(error)) {
                // Couldn't connect to server, store in offline.
                return storeOffline();
            } else {
                // The WebService has thrown an error or offline not supported, reject.
                throw error;
            }
        }
    }

    /**
     * Save current user submission for a certain assignment. It will fail if offline or cannot connect.
     *
     * @param assignId Assign ID.
     * @param pluginData Data to save.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when saved, rejected otherwise.
     */
    async saveSubmissionOnline(assignId: number, pluginData: AddonModAssignSavePluginData, siteId?: string): Promise<void> {
        const site = await CoreSites.getSite(siteId);
        const params: AddonModAssignSaveSubmissionWSParams = {
            assignmentid: assignId,
            plugindata: pluginData,
        };
        const warnings = await site.write<CoreWSExternalWarning[]>('mod_assign_save_submission', params);

        if (warnings.length) {
            // The WebService returned warnings, reject.
            throw new CoreWSError(warnings[0]);
        }
    }

    /**
     * Submit the current user assignment for grading.
     *
     * @param assignId Assign ID.
     * @param courseId Course ID the assign belongs to.
     * @param acceptStatement True if submission statement is accepted, false otherwise.
     * @param timemodified The time the submission was last modified in online.
     * @param forceOffline True to always mark it in offline.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved with true if sent to server, resolved with false if stored in offline.
     */
    async submitForGrading(
        assignId: number,
        courseId: number,
        acceptStatement: boolean,
        timemodified: number,
        forceOffline = false,
        siteId?: string,
    ): Promise<boolean> {

        siteId = siteId || CoreSites.getCurrentSiteId();

        // Function to store the submission to be synchronized later.
        const storeOffline = async (): Promise<boolean> => {
            await AddonModAssignOffline.markSubmitted(
                assignId,
                courseId,
                true,
                acceptStatement,
                timemodified,
                undefined,
                siteId,
            );

            return false;
        };

        if (forceOffline || !CoreApp.isOnline()) {
            // App is offline, store the action.
            return storeOffline();
        }

        try {
            // If there's already a submission to be sent to the server, discard it first.
            await AddonModAssignOffline.deleteSubmission(assignId, undefined, siteId);
            await this.submitForGradingOnline(assignId, acceptStatement, siteId);

            return true;
        } catch (error) {
            if (error && !CoreUtils.isWebServiceError(error)) {
                // Couldn't connect to server, store in offline.
                return storeOffline();
            } else {
                // The WebService has thrown an error, reject.
                throw error;
            }
        }
    }

    /**
     * Submit the current user assignment for grading. It will fail if offline or cannot connect.
     *
     * @param assignId Assign ID.
     * @param acceptStatement True if submission statement is accepted, false otherwise.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when submitted, rejected otherwise.
     */
    async submitForGradingOnline(assignId: number, acceptStatement: boolean, siteId?: string): Promise<void> {
        const site = await CoreSites.getSite(siteId);

        const params: AddonModAssignSubmitForGradingWSParams = {
            assignmentid: assignId,
            acceptsubmissionstatement: acceptStatement,
        };

        const warnings = await site.write<CoreWSExternalWarning[]>('mod_assign_submit_for_grading', params);

        if (warnings.length) {
            // The WebService returned warnings, reject.
            throw new CoreWSError(warnings[0]);
        }
    }

    /**
     * Submit the grading for the current user and assignment. It will use old or new WS depending on availability.
     *
     * @param assignId Assign ID.
     * @param userId User ID.
     * @param courseId Course ID the assign belongs to.
     * @param grade Grade to submit.
     * @param attemptNumber Number of the attempt being graded.
     * @param addAttempt Admit the user to attempt again.
     * @param workflowState Next workflow State.
     * @param applyToAll If it's a team submission, whether the grade applies to all group members.
     * @param outcomes Object including all outcomes values. If empty, any of them will be sent.
     * @param pluginData Feedback plugin data to save.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved with true if sent to server, resolved with false if stored offline.
     */
    async submitGradingForm(
        assignId: number,
        userId: number,
        courseId: number,
        grade: number,
        attemptNumber: number,
        addAttempt: boolean,
        workflowState: string,
        applyToAll: boolean,
        outcomes: AddonModAssignOutcomes,
        pluginData: AddonModAssignSavePluginData,
        siteId?: string,
    ): Promise<boolean> {

        siteId = siteId || CoreSites.getCurrentSiteId();

        // Function to store the grading to be synchronized later.
        const storeOffline = async (): Promise<boolean> => {
            await AddonModAssignOffline.submitGradingForm(
                assignId,
                userId,
                courseId,
                grade,
                attemptNumber,
                addAttempt,
                workflowState,
                applyToAll,
                outcomes,
                pluginData,
                siteId,
            );

            return false;
        };

        // Grading offline is only allowed if WS of grade items is enabled to avoid inconsistency.
        const enabled = await this.isGradingOfflineEnabled(siteId);
        if (!enabled) {
            await this.submitGradingFormOnline(
                assignId,
                userId,
                grade,
                attemptNumber,
                addAttempt,
                workflowState,
                applyToAll,
                outcomes,
                pluginData,
                siteId,
            );

            return true;
        }

        if (!CoreApp.isOnline()) {
            // App is offline, store the action.
            return storeOffline();
        }

        try {
            // If there's already a grade to be sent to the server, discard it first.
            await AddonModAssignOffline.deleteSubmissionGrade(assignId, userId, siteId);
            await this.submitGradingFormOnline(
                assignId,
                userId,
                grade,
                attemptNumber,
                addAttempt,
                workflowState,
                applyToAll,
                outcomes,
                pluginData,
                siteId,
            );

            return true;
        } catch (error)  {
            if (error && !CoreUtils.isWebServiceError(error)) {
                // Couldn't connect to server, store in offline.
                return storeOffline();
            } else {
                // The WebService has thrown an error, reject.
                throw error;
            }
        }
    }

    /**
     * Submit the grading for the current user and assignment. It will use old or new WS depending on availability.
     * It will fail if offline or cannot connect.
     *
     * @param assignId Assign ID.
     * @param userId User ID.
     * @param grade Grade to submit.
     * @param attemptNumber Number of the attempt being graded.
     * @param addAttempt Allow the user to attempt again.
     * @param workflowState Next workflow State.
     * @param applyToAll If it's a team submission, if the grade applies to all group members.
     * @param outcomes Object including all outcomes values. If empty, any of them will be sent.
     * @param pluginData Feedback plugin data to save.
     * @param siteId Site ID. If not defined, current site.
     * @return Promise resolved when submitted, rejected otherwise.
     */
    async submitGradingFormOnline(
        assignId: number,
        userId: number,
        grade: number,
        attemptNumber: number,
        addAttempt: boolean,
        workflowState: string,
        applyToAll: boolean,
        outcomes: AddonModAssignOutcomes,
        pluginData: AddonModAssignSavePluginData,
        siteId?: string,
    ): Promise<void> {

        const site = await CoreSites.getSite(siteId);
        userId = userId || site.getUserId();

        if (site.wsAvailable('mod_assign_submit_grading_form')) {
            // WS available @since 3.2.

            const jsonData = {
                grade,
                attemptnumber: attemptNumber,
                addattempt: addAttempt ? 1 : 0,
                workflowstate: workflowState,
                applytoall: applyToAll ? 1 : 0,
            };

            for (const index in outcomes) {
                jsonData['outcome_' + index + '[' + userId + ']'] = outcomes[index];
            }

            for (const index in pluginData) {
                jsonData[index] = pluginData[index];
            }

            const serialized = CoreInterceptor.serialize(jsonData, true);
            const params: AddonModAssignSubmitGradingFormWSParams = {
                assignmentid: assignId,
                userid: userId,
                jsonformdata: JSON.stringify(serialized),
            };

            const warnings = await site.write<CoreWSExternalWarning[]>('mod_assign_submit_grading_form', params);

            if (warnings.length) {
                // The WebService returned warnings, reject.
                throw new CoreWSError(warnings[0]);
            }
        }

        // WS not available, fallback to save_grade.
        const params: AddonModAssignSaveGradeWSParams = {
            assignmentid: assignId,
            userid: userId,
            grade: grade,
            attemptnumber: attemptNumber,
            addattempt: addAttempt,
            workflowstate: workflowState,
            applytoall: applyToAll,
            plugindata: pluginData,
        };
        const preSets: CoreSiteWSPreSets = {
            responseExpected: false,
        };

        await site.write('mod_assign_save_grade', params, preSets);
    }

}
export const AddonModAssign = makeSingleton(AddonModAssignProvider);

/**
 * Options to pass to get submission status.
 */
export type AddonModAssignSubmissionStatusOptions = CoreCourseCommonModWSOptions & {
    userId?: number; // User Id (empty for current user).
    groupId?: number; // Group Id (empty for all participants).
    isBlind?: boolean; // If blind marking is enabled or not.
    filter?: boolean; // True to filter WS response and rewrite URLs, false otherwise. Defaults to true.
};

/**
 * Assign data returned by mod_assign_get_assignments.
 */
export type AddonModAssignAssign = {
    id: number; // Assignment id.
    cmid: number; // Course module id.
    course: number; // Course id.
    name: string; // Assignment name.
    nosubmissions: number; // No submissions.
    submissiondrafts: number; // Submissions drafts.
    sendnotifications: number; // Send notifications.
    sendlatenotifications: number; // Send notifications.
    sendstudentnotifications: number; // Send student notifications (default).
    duedate: number; // Assignment due date.
    allowsubmissionsfromdate: number; // Allow submissions from date.
    grade: number; // Grade type.
    timemodified: number; // Last time assignment was modified.
    completionsubmit: number; // If enabled, set activity as complete following submission.
    cutoffdate: number; // Date after which submission is not accepted without an extension.
    gradingduedate?: number; // @since 3.3. The expected date for marking the submissions.
    teamsubmission: number; // If enabled, students submit as a team.
    requireallteammemberssubmit: number; // If enabled, all team members must submit.
    teamsubmissiongroupingid: number; // The grouping id for the team submission groups.
    blindmarking: number; // If enabled, hide identities until reveal identities actioned.
    hidegrader?: number; // @since 3.7. If enabled, hide grader to student.
    revealidentities: number; // Show identities for a blind marking assignment.
    attemptreopenmethod: string; // Method used to control opening new attempts.
    maxattempts: number; // Maximum number of attempts allowed.
    markingworkflow: number; // Enable marking workflow.
    markingallocation: number; // Enable marking allocation.
    requiresubmissionstatement: number; // Student must accept submission statement.
    preventsubmissionnotingroup?: number; // @since 3.2. Prevent submission not in group.
    submissionstatement?: string; // @since 3.2. Submission statement formatted.
    submissionstatementformat?: number; // @since 3.2. Submissionstatement format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
    configs: AddonModAssignConfig[]; // Configuration settings.
    intro?: string; // Assignment intro, not allways returned because it deppends on the activity configuration.
    introformat?: number; // Intro format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
    introfiles?: CoreWSExternalFile[]; // @since 3.2.
    introattachments?: CoreWSExternalFile[];
};

/**
 * Config setting in an assign.
 */
export type AddonModAssignConfig = {
    id?: number; // Assign_plugin_config id.
    assignment?: number; // Assignment id.
    plugin: string; // Plugin.
    subtype: string; // Subtype.
    name: string; // Name.
    value: string; // Value.
};

/**
 * Grade of an assign, returned by mod_assign_get_grades.
 */
export type AddonModAssignGrade = {
    id: number; // Grade id.
    assignment?: number; // Assignment id.
    userid: number; // Student id.
    attemptnumber: number; // Attempt number.
    timecreated: number; // Grade creation time.
    timemodified: number; // Grade last modified time.
    grader: number; // Grader, -1 if grader is hidden.
    grade: string; // Grade.
    gradefordisplay?: string; // Grade rendered into a format suitable for display.
};

/**
 * Assign submission returned by mod_assign_get_submissions.
 */
export type AddonModAssignSubmission = {
    id: number; // Submission id.
    userid: number; // Student id.
    attemptnumber: number; // Attempt number.
    timecreated: number; // Submission creation time.
    timemodified: number; // Submission last modified time.
    status: string; // Submission status.
    groupid: number; // Group id.
    assignment?: number; // Assignment id.
    latest?: number; // Latest attempt.
    plugins?: AddonModAssignPlugin[]; // Plugins.
    gradingstatus?: string; // @since 3.2. Grading status.
};

/**
 * Assign plugin.
 */
export type AddonModAssignPlugin = {
    type: string; // Submission plugin type.
    name: string; // Submission plugin name.
    fileareas?: { // Fileareas.
        area: string; // File area.
        files?: CoreWSExternalFile[];
    }[];
    editorfields?: { // Editorfields.
        name: string; // Field name.
        description: string; // Field description.
        text: string; // Field value.
        format: number; // Text format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
    }[];
};

/**
 * Grading summary of an assign submission.
 */
export type AddonModAssignSubmissionGradingSummary = {
    participantcount: number; // Number of users who can submit.
    submissiondraftscount: number; // Number of submissions in draft status.
    submissionsenabled: boolean; // Whether submissions are enabled or not.
    submissionssubmittedcount: number; // Number of submissions in submitted status.
    submissionsneedgradingcount: number; // Number of submissions that need grading.
    warnofungroupedusers: string | boolean; // Whether we need to warn people about groups.
};

/**
 * Attempt of an assign submission.
 */
export type AddonModAssignSubmissionAttempt = {
    submission?: AddonModAssignSubmission; // Submission info.
    teamsubmission?: AddonModAssignSubmission; // Submission info.
    submissiongroup?: number; // The submission group id (for group submissions only).
    submissiongroupmemberswhoneedtosubmit?: number[]; // List of users who still need to submit (for group submissions only).
    submissionsenabled: boolean; // Whether submissions are enabled or not.
    locked: boolean; // Whether new submissions are locked.
    graded: boolean; // Whether the submission is graded.
    canedit: boolean; // Whether the user can edit the current submission.
    caneditowner?: boolean; // @since 3.2. Whether the owner of the submission can edit it.
    cansubmit: boolean; // Whether the user can submit.
    extensionduedate: number; // Extension due date.
    blindmarking: boolean; // Whether blind marking is enabled.
    gradingstatus: string; // Grading status.
    usergroups: number[]; // User groups in the course.
};

/**
 * Previous attempt of an assign submission.
 */
export type AddonModAssignSubmissionPreviousAttempt = {
    attemptnumber: number; // Attempt number.
    submission?: AddonModAssignSubmission; // Submission info.
    grade?: AddonModAssignGrade; // Grade information.
    feedbackplugins?: AddonModAssignPlugin[]; // Feedback info.
};

/**
 * Feedback of an assign submission.
 */
export type AddonModAssignSubmissionFeedback = {
    grade?: AddonModAssignGrade; // Grade information.
    gradefordisplay: string; // Grade rendered into a format suitable for display.
    gradeddate: number; // The date the user was graded.
    plugins?: AddonModAssignPlugin[]; // Plugins info.
};

/**
 * Params of mod_assign_list_participants WS.
 */
type AddonModAssignListParticipantsWSParams = {
    assignid: number; // Assign instance id.
    groupid: number; // Group id.
    filter: string; // Search string to filter the results.
    skip?: number; // Number of records to skip.
    limit?: number; // Maximum number of records to return.
    onlyids?: boolean; // Do not return all user fields.
    includeenrolments?: boolean; // Do return courses where the user is enrolled.
    tablesort?: boolean; // Apply current user table sorting preferences.
};

/**
 * Data returned by mod_assign_list_participants WS.
 */
type AddonModAssignListParticipantsWSResponse = AddonModAssignParticipant[];

/**
 * Participant returned by mod_assign_list_participants.
 */
export type AddonModAssignParticipant = {
    id: number; // ID of the user.
    username?: string; // The username.
    firstname?: string; // The first name(s) of the user.
    lastname?: string; // The family name of the user.
    fullname: string; // The fullname of the user.
    email?: string; // Email address.
    address?: string; // Postal address.
    phone1?: string; // Phone 1.
    phone2?: string; // Phone 2.
    icq?: string; // Icq number.
    skype?: string; // Skype id.
    yahoo?: string; // Yahoo id.
    aim?: string; // Aim id.
    msn?: string; // Msn number.
    department?: string; // Department.
    institution?: string; // Institution.
    idnumber?: string; // The idnumber of the user.
    interests?: string; // User interests (separated by commas).
    firstaccess?: number; // First access to the site (0 if never).
    lastaccess?: number; // Last access to the site (0 if never).
    suspended?: boolean; // @since 3.2. Suspend user account, either false to enable user login or true to disable it.
    description?: string; // User profile description.
    descriptionformat?: number; // Int format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
    city?: string; // Home city of the user.
    url?: string; // URL of the user.
    country?: string; // Home country code of the user, such as AU or CZ.
    profileimageurlsmall?: string; // User image profile URL - small version.
    profileimageurl?: string; // User image profile URL - big version.
    customfields?: { // User custom fields (also known as user profile fields).
        type: string; // The type of the custom field - text field, checkbox...
        value: string; // The value of the custom field.
        name: string; // The name of the custom field.
        shortname: string; // The shortname of the custom field - to be able to build the field class in the code.
    }[];
    preferences?: { // Users preferences.
        name: string; // The name of the preferences.
        value: string; // The value of the preference.
    }[];
    recordid?: number; // @since 3.7. Record id.
    groups?: { // User groups.
        id: number; // Group id.
        name: string; // Group name.
        description: string; // Group description.
    }[];
    roles?: { // User roles.
        roleid: number; // Role id.
        name: string; // Role name.
        shortname: string; // Role shortname.
        sortorder: number; // Role sortorder.
    }[];
    enrolledcourses?: { // Courses where the user is enrolled - limited by which courses the user is able to see.
        id: number; // Id of the course.
        fullname: string; // Fullname of the course.
        shortname: string; // Shortname of the course.
    }[];
    submitted: boolean; // Have they submitted their assignment.
    requiregrading: boolean; // Is their submission waiting for grading.
    grantedextension?: boolean; // @since 3.3. Have they been granted an extension.
    groupid?: number; // For group assignments this is the group id.
    groupname?: string; // For group assignments this is the group name.
};

/**
 * Result of WS mod_assign_get_assignments.
 */
export type AddonModAssignGetAssignmentsWSResponse = {
    courses: { // List of courses.
        id: number; // Course id.
        fullname: string; // Course full name.
        shortname: string; // Course short name.
        timemodified: number; // Last time modified.
        assignments: AddonModAssignAssign[]; // Assignment info.
    }[];
    warnings?: CoreWSExternalWarning[];
};

/**
 * Params of mod_assign_get_submissions WS.
 */
type ModAssignGetSubmissionsWSParams = {
    assignmentids: number[]; // 1 or more assignment ids.
    status?: string; // Status.
    since?: number; // Submitted since.
    before?: number; // Submitted before.
};

/**
 * Data returned by mod_assign_get_submissions WS.
 */
export type AddonModAssignGetSubmissionsWSResponse = {
    assignments: { // Assignment submissions.
        assignmentid: number; // Assignment id.
        submissions: AddonModAssignSubmission[];
    }[];
    warnings?: CoreWSExternalWarning[];
};

/**
 * Params of mod_assign_get_submission_status WS.
 */
type AddonModAssignGetSubmissionStatusWSParams = {
    assignid: number; // Assignment instance id.
    userid?: number; // User id (empty for current user).
    groupid?: number; // Filter by users in group (used for generating the grading summary). Empty or 0 for all groups information.
};

/**
 * Result of WS mod_assign_get_submission_status.
 */
export type AddonModAssignGetSubmissionStatusWSResponse = {
    gradingsummary?: AddonModAssignSubmissionGradingSummary; // Grading information.
    lastattempt?: AddonModAssignSubmissionAttempt; // Last attempt information.
    feedback?: AddonModAssignSubmissionFeedback; // Feedback for the last attempt.
    previousattempts?: AddonModAssignSubmissionPreviousAttempt[]; // List all the previous attempts did by the user.
    warnings?: CoreWSExternalWarning[];
};

/**
 * Params of mod_assign_view_submission_status WS.
 */
type AddonModAssignViewSubmissionStatusWSParams = {
    assignid: number; // Assign instance id.
};

/**
 * Params of mod_assign_view_grading_table WS.
 */
type AddonModAssignViewGradingTableWSParams = {
    assignid: number; // Assign instance id.
};

/**
 * Params of mod_assign_view_assign WS.
 */
type AddonModAssignViewAssignWSParams = {
    assignid: number; // Assign instance id.
};

type AddonModAssignFixedSubmissionParams = {
    userId: number;
    groupId: number;
    isBlind: boolean;
};

/**
 * Params of mod_assign_get_assignments WS.
 */
type AddonModAssignGetAssignmentsWSParams = {
    courseids?: number[]; // 0 or more course ids.
    capabilities?: string[]; // List of capabilities used to filter courses.
    includenotenrolledcourses?: boolean; // Whether to return courses that the user can see even if is not enroled in.
    // This requires the parameter courseids to not be empty.

};

/**
 * Params of mod_assign_get_user_mappings WS.
 */
type AddonModAssignGetUserMappingsWSParams = {
    assignmentids: number[]; // 1 or more assignment ids.
};

/**
 * Data returned by mod_assign_get_user_mappings WS.
 */
export type AddonModAssignGetUserMappingsWSResponse = {
    assignments: { // List of assign user mapping data.
        assignmentid: number; // Assignment id.
        mappings: {
            id: number; // User mapping id.
            userid: number; // Student id.
        }[];
    }[];
    warnings?: CoreWSExternalWarning[];
};

/**
 * Params of mod_assign_get_grades WS.
 */
type AddonModAssignGetGradesWSParams = {
    assignmentids: number[]; // 1 or more assignment ids.
    since?: number; // Timestamp, only return records where timemodified >= since.
};

/**
 * Data returned by mod_assign_get_grades WS.
 */
export type AddonModAssignGetGradesWSResponse = {
    assignments: { // List of assignment grade information.
        assignmentid: number; // Assignment id.
        grades: AddonModAssignGrade[];
    }[];
    warnings?: CoreWSExternalWarning[];
};

/**
 * Params of mod_assign_save_submission WS.
 */
type AddonModAssignSaveSubmissionWSParams = {
    assignmentid: number; // The assignment id to operate on.
    plugindata: AddonModAssignSavePluginData;
};

/**
 * All subplugins will decide what to add here.
 */
export type AddonModAssignSavePluginData = Record<string, unknown>;

/**
 * Params of mod_assign_submit_for_grading WS.
 */
type AddonModAssignSubmitForGradingWSParams = {
    assignmentid: number; // The assignment id to operate on.
    acceptsubmissionstatement: boolean; // Accept the assignment submission statement.
};

/**
 * Params of mod_assign_submit_grading_form WS.
 */
type AddonModAssignSubmitGradingFormWSParams = {
    assignmentid: number; // The assignment id to operate on.
    userid: number; // The user id the submission belongs to.
    jsonformdata: string; // The data from the grading form, encoded as a json array.
};

/**
 * Params of mod_assign_save_grade WS.
 */
type AddonModAssignSaveGradeWSParams = {
    assignmentid: number; // The assignment id to operate on.
    userid: number; // The student id to operate on.
    grade: number; // The new grade for this user. Ignored if advanced grading used.
    attemptnumber: number; // The attempt number (-1 means latest attempt).
    addattempt: boolean; // Allow another attempt if the attempt reopen method is manual.
    workflowstate: string; // The next marking workflow state.
    applytoall: boolean; // If true, this grade will be applied to all members of the group (for group assignments).
    plugindata?: AddonModAssignSavePluginData; // Plugin data.
    advancedgradingdata?: {
        guide?: {
            criteria: {
                criterionid: number; // Criterion id.
                fillings?: { // Filling.
                    criterionid: number; // Criterion id.
                    levelid?: number; // Level id.
                    remark?: string; // Remark.
                    remarkformat?: number; // Remark format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
                    score: number; // Maximum score.
                }[];
            }[];
        }; // Items.
        rubric?: {
            criteria: {
                criterionid: number; // Criterion id.
                fillings?: { // Filling.
                    criterionid: number; // Criterion id.
                    levelid?: number; // Level id.
                    remark?: string; // Remark.
                    remarkformat?: number; // Remark format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
                }[];
            }[];
        }; // Items.
    }; // Advanced grading data.
};

/**
 * Assignment grade outcomes.
 */
export type AddonModAssignOutcomes = { [itemNumber: number]: number };

/**
 * Data sent by SUBMITTED_FOR_GRADING_EVENT event.
 */
export type AddonModAssignSubmittedForGradingEventData = {
    assignmentId: number;
    submissionId: number;
    userId: number;
};

/**
 * Data sent by SUBMISSION_SAVED_EVENT event.
 */
export type AddonModAssignSubmissionSavedEventData = AddonModAssignSubmittedForGradingEventData;

/**
 * Data sent by GRADED_EVENT event.
 */
export type AddonModAssignGradedEventData = AddonModAssignSubmittedForGradingEventData;