504 lines
21 KiB
TypeScript
504 lines
21 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 { TranslateService } from '@ngx-translate/core';
|
|
import { CoreAppProvider } from '@providers/app';
|
|
import { CoreEventsProvider } from '@providers/events';
|
|
import { CoreLoggerProvider } from '@providers/logger';
|
|
import { CoreSitesProvider, CoreSitesReadingStrategy } from '@providers/sites';
|
|
import { CoreSyncProvider } from '@providers/sync';
|
|
import { CoreTextUtilsProvider } from '@providers/utils/text';
|
|
import { CoreTimeUtilsProvider } from '@providers/utils/time';
|
|
import { CoreUtils } from '@providers/utils/utils';
|
|
import { CoreCourseProvider } from '@core/course/providers/course';
|
|
import { CoreCourseLogHelperProvider } from '@core/course/providers/log-helper';
|
|
import { CoreCourseModulePrefetchDelegate } from '@core/course/providers/module-prefetch-delegate';
|
|
import { CoreQuestionProvider } from '@core/question/providers/question';
|
|
import { CoreQuestionDelegate } from '@core/question/providers/delegate';
|
|
import { CoreCourseActivitySyncBaseProvider } from '@core/course/classes/activity-sync';
|
|
import { AddonModQuizProvider } from './quiz';
|
|
import { AddonModQuizOfflineProvider } from './quiz-offline';
|
|
import { AddonModQuizPrefetchHandler } from './prefetch-handler';
|
|
|
|
/**
|
|
* Data returned by a quiz sync.
|
|
*/
|
|
export interface AddonModQuizSyncResult {
|
|
/**
|
|
* List of warnings.
|
|
*/
|
|
warnings: string[];
|
|
|
|
/**
|
|
* Whether an attempt was finished in the site due to the sync,
|
|
*/
|
|
attemptFinished: boolean;
|
|
}
|
|
|
|
/**
|
|
* Service to sync quizzes.
|
|
*/
|
|
@Injectable()
|
|
export class AddonModQuizSyncProvider extends CoreCourseActivitySyncBaseProvider {
|
|
|
|
static AUTO_SYNCED = 'addon_mod_quiz_autom_synced';
|
|
|
|
protected componentTranslate: string;
|
|
|
|
constructor(loggerProvider: CoreLoggerProvider, sitesProvider: CoreSitesProvider, appProvider: CoreAppProvider,
|
|
syncProvider: CoreSyncProvider, textUtils: CoreTextUtilsProvider, translate: TranslateService,
|
|
private eventsProvider: CoreEventsProvider, timeUtils: CoreTimeUtilsProvider,
|
|
private quizProvider: AddonModQuizProvider, private quizOfflineProvider: AddonModQuizOfflineProvider,
|
|
protected prefetchHandler: AddonModQuizPrefetchHandler, private questionProvider: CoreQuestionProvider,
|
|
private questionDelegate: CoreQuestionDelegate, private logHelper: CoreCourseLogHelperProvider,
|
|
prefetchDelegate: CoreCourseModulePrefetchDelegate, private courseProvider: CoreCourseProvider) {
|
|
|
|
super('AddonModQuizSyncProvider', loggerProvider, sitesProvider, appProvider, syncProvider, textUtils, translate,
|
|
timeUtils, prefetchDelegate, prefetchHandler);
|
|
|
|
this.componentTranslate = courseProvider.translateModuleName('quiz');
|
|
}
|
|
|
|
/**
|
|
* Finish a sync process: remove offline data if needed, prefetch quiz data, set sync time and return the result.
|
|
*
|
|
* @param siteId Site ID.
|
|
* @param quiz Quiz.
|
|
* @param courseId Course ID.
|
|
* @param warnings List of warnings generated by the sync.
|
|
* @param options Other options.
|
|
* @return Promise resolved on success.
|
|
*/
|
|
protected finishSync(siteId: string, quiz: any, courseId: number, warnings: string[], options?: FinishSyncOptions)
|
|
: Promise<AddonModQuizSyncResult> {
|
|
options = options || {};
|
|
|
|
// Invalidate the data for the quiz and attempt.
|
|
return this.quizProvider.invalidateAllQuizData(quiz.id, courseId, options.attemptId, siteId).catch(() => {
|
|
// Ignore errors.
|
|
}).then(() => {
|
|
if (options.removeAttempt && options.attemptId) {
|
|
const promises = [];
|
|
|
|
promises.push(this.quizOfflineProvider.removeAttemptAndAnswers(options.attemptId, siteId));
|
|
|
|
if (options.onlineQuestions) {
|
|
for (const slot in options.onlineQuestions) {
|
|
promises.push(this.questionDelegate.deleteOfflineData(options.onlineQuestions[slot],
|
|
AddonModQuizProvider.COMPONENT, quiz.coursemodule, siteId));
|
|
}
|
|
}
|
|
|
|
return Promise.all(promises);
|
|
}
|
|
}).then(() => {
|
|
if (options.updated) {
|
|
// Data has been sent. Update prefetched data.
|
|
return this.courseProvider.getModuleBasicInfoByInstance(quiz.id, 'quiz', siteId).then((module) => {
|
|
return this.prefetchAfterUpdateQuiz(module, quiz, courseId, undefined, siteId);
|
|
}).catch(() => {
|
|
// Ignore errors.
|
|
});
|
|
}
|
|
}).then(() => {
|
|
return this.setSyncTime(quiz.id, siteId).catch(() => {
|
|
// Ignore errors.
|
|
});
|
|
}).then(() => {
|
|
// Check if online attempt was finished because of the sync.
|
|
if (options.onlineAttempt && !this.quizProvider.isAttemptFinished(options.onlineAttempt.state)) {
|
|
// Attempt wasn't finished at start. Check if it's finished now.
|
|
return this.quizProvider.getUserAttempts(quiz.id, {cmId: quiz.coursemodule, siteId}).then((attempts) => {
|
|
// Search the attempt.
|
|
for (const i in attempts) {
|
|
const attempt = attempts[i];
|
|
|
|
if (attempt.id == options.onlineAttempt.id) {
|
|
return this.quizProvider.isAttemptFinished(attempt.state);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
});
|
|
}
|
|
|
|
return false;
|
|
}).then((attemptFinished) => {
|
|
return {
|
|
warnings: warnings,
|
|
attemptFinished: attemptFinished
|
|
};
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Check if a quiz has data to synchronize.
|
|
*
|
|
* @param quizId Quiz ID.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved with boolean: whether it has data to sync.
|
|
*/
|
|
hasDataToSync(quizId: number, siteId?: string): Promise<boolean> {
|
|
return this.quizOfflineProvider.getQuizAttempts(quizId, siteId).then((attempts) => {
|
|
return !!attempts.length;
|
|
}).catch(() => {
|
|
return false;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Conveniece function to prefetch data after an update.
|
|
*
|
|
* @param module Module.
|
|
* @param quiz Quiz.
|
|
* @param courseId Course ID.
|
|
* @param regex If regex matches, don't download the data. Defaults to check files.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when done.
|
|
*/
|
|
prefetchAfterUpdateQuiz(module: any, quiz: any, courseId: number, regex?: RegExp, siteId?: string): Promise<any> {
|
|
regex = regex || /^.*files$/;
|
|
|
|
let shouldDownload;
|
|
|
|
// Get the module updates to check if the data was updated or not.
|
|
return this.prefetchDelegate.getModuleUpdates(module, courseId, true, siteId).then((result) => {
|
|
|
|
if (result && result.updates && result.updates.length > 0) {
|
|
// Only prefetch if files haven't changed.
|
|
shouldDownload = !result.updates.find((entry) => {
|
|
return entry.name.match(regex);
|
|
});
|
|
|
|
if (shouldDownload) {
|
|
return this.prefetchHandler.download(module, courseId, undefined, false, false);
|
|
}
|
|
}
|
|
|
|
}).then(() => {
|
|
// Prefetch finished or not needed, set the right status.
|
|
return this.prefetchHandler.setStatusAfterPrefetch(quiz, {
|
|
cmId: module.id,
|
|
readingStrategy: shouldDownload ? CoreSitesReadingStrategy.PreferCache : undefined,
|
|
siteId,
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Try to synchronize all the quizzes in a certain site or in all sites.
|
|
*
|
|
* @param siteId Site ID to sync. If not defined, sync all sites.
|
|
* @param force Wether to force sync not depending on last execution.
|
|
* @return Promise resolved if sync is successful, rejected if sync fails.
|
|
*/
|
|
syncAllQuizzes(siteId?: string, force?: boolean): Promise<any> {
|
|
return this.syncOnSites('all quizzes', this.syncAllQuizzesFunc.bind(this), [force], siteId);
|
|
}
|
|
|
|
/**
|
|
* Sync all quizzes on a site.
|
|
*
|
|
* @param siteId Site ID to sync.
|
|
* @param force Wether to force sync not depending on last execution.
|
|
* @param Promise resolved if sync is successful, rejected if sync fails.
|
|
*/
|
|
protected syncAllQuizzesFunc(siteId?: string, force?: boolean): Promise<any> {
|
|
// Get all offline attempts.
|
|
return this.quizOfflineProvider.getAllAttempts(siteId).then((attempts) => {
|
|
const quizzes = [],
|
|
ids = [], // To prevent duplicates.
|
|
promises = [];
|
|
|
|
// Get the IDs of all the quizzes that have something to be synced.
|
|
attempts.forEach((attempt) => {
|
|
if (ids.indexOf(attempt.quizid) == -1) {
|
|
ids.push(attempt.quizid);
|
|
|
|
quizzes.push({
|
|
id: attempt.quizid,
|
|
courseid: attempt.courseid
|
|
});
|
|
}
|
|
});
|
|
|
|
// Sync all quizzes that haven't been synced for a while and that aren't attempted right now.
|
|
quizzes.forEach((quiz) => {
|
|
if (!this.syncProvider.isBlocked(AddonModQuizProvider.COMPONENT, quiz.id, siteId)) {
|
|
|
|
// Quiz not blocked, try to synchronize it.
|
|
promises.push(this.quizProvider.getQuizById(quiz.courseid, quiz.id, {siteId}).then((quiz) => {
|
|
const promise = force ? this.syncQuiz(quiz, false, siteId) : this.syncQuizIfNeeded(quiz, false, siteId);
|
|
|
|
return promise.then((data) => {
|
|
if (data && data.warnings && data.warnings.length) {
|
|
// Store the warnings to show them when the user opens the quiz.
|
|
return this.setSyncWarnings(quiz.id, data.warnings, siteId).then(() => {
|
|
return data;
|
|
});
|
|
}
|
|
|
|
return data;
|
|
}).then((data) => {
|
|
if (typeof data != 'undefined') {
|
|
// Sync successful. Send event.
|
|
this.eventsProvider.trigger(AddonModQuizSyncProvider.AUTO_SYNCED, {
|
|
quizId: quiz.id,
|
|
attemptFinished: data.attemptFinished,
|
|
warnings: data.warnings
|
|
}, siteId);
|
|
}
|
|
});
|
|
}));
|
|
}
|
|
});
|
|
|
|
return Promise.all(promises);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Sync a quiz only if a certain time has passed since the last time.
|
|
*
|
|
* @param quiz Quiz.
|
|
* @param askPreflight Whether we should ask for preflight data if needed.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the quiz is synced or if it doesn't need to be synced.
|
|
*/
|
|
syncQuizIfNeeded(quiz: any, askPreflight?: boolean, siteId?: string): Promise<any> {
|
|
return this.isSyncNeeded(quiz.id, siteId).then((needed) => {
|
|
if (needed) {
|
|
return this.syncQuiz(quiz, askPreflight, siteId);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Try to synchronize a quiz.
|
|
* The promise returned will be resolved with an array with warnings if the synchronization is successful.
|
|
*
|
|
* @param quiz Quiz.
|
|
* @param askPreflight Whether we should ask for preflight data if needed.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved in success.
|
|
*/
|
|
syncQuiz(quiz: any, askPreflight?: boolean, siteId?: string): Promise<AddonModQuizSyncResult> {
|
|
siteId = siteId || this.sitesProvider.getCurrentSiteId();
|
|
|
|
if (this.isSyncing(quiz.id, siteId)) {
|
|
// There's already a sync ongoing for this quiz, return the promise.
|
|
return this.getOngoingSync(quiz.id, siteId);
|
|
}
|
|
|
|
// Verify that quiz isn't blocked.
|
|
if (this.syncProvider.isBlocked(AddonModQuizProvider.COMPONENT, quiz.id, siteId)) {
|
|
this.logger.debug('Cannot sync quiz ' + quiz.id + ' because it is blocked.');
|
|
|
|
return Promise.reject(this.translate.instant('core.errorsyncblocked', {$a: this.componentTranslate}));
|
|
}
|
|
|
|
return this.addOngoingSync(quiz.id, this.performSyncQuiz(quiz, askPreflight, siteId), siteId);
|
|
}
|
|
|
|
/**
|
|
* Perform the quiz sync.
|
|
*
|
|
* @param quiz Quiz.
|
|
* @param askPreflight Whether we should ask for preflight data if needed.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved in success.
|
|
*/
|
|
async performSyncQuiz(quiz: any, askPreflight?: boolean, siteId?: string): Promise<AddonModQuizSyncResult> {
|
|
siteId = siteId || this.sitesProvider.getCurrentSiteId();
|
|
|
|
const warnings = [];
|
|
const courseId = quiz.course;
|
|
const modOptions = {
|
|
cmId: quiz.coursemodule,
|
|
readingStrategy: CoreSitesReadingStrategy.OnlyNetwork,
|
|
siteId,
|
|
};
|
|
|
|
this.logger.debug('Try to sync quiz ' + quiz.id + ' in site ' + siteId);
|
|
|
|
// Sync offline logs.
|
|
await CoreUtils.instance.ignoreErrors(this.logHelper.syncIfNeeded(AddonModQuizProvider.COMPONENT, quiz.id, siteId));
|
|
|
|
// Get all the offline attempts for the quiz. It should always be 0 or 1 attempt
|
|
const offlineAttempts = await this.quizOfflineProvider.getQuizAttempts(quiz.id, siteId);
|
|
|
|
if (!offlineAttempts.length) {
|
|
// Nothing to sync, finish.
|
|
return this.finishSync(siteId, quiz, courseId, warnings);
|
|
}
|
|
|
|
if (!this.appProvider.isOnline()) {
|
|
// Cannot sync in offline.
|
|
throw new Error(this.translate.instant('core.cannotconnect'));
|
|
}
|
|
|
|
const offlineAttempt = offlineAttempts.pop();
|
|
|
|
// Now get the list of online attempts to make sure this attempt exists and isn't finished.
|
|
const onlineAttempts = await this.quizProvider.getUserAttempts(quiz.id, modOptions);
|
|
|
|
const lastAttemptId = onlineAttempts.length ? onlineAttempts[onlineAttempts.length - 1].id : undefined;
|
|
const onlineAttempt = onlineAttempts.find((attempt) => {
|
|
return attempt.id == offlineAttempt.id;
|
|
});
|
|
|
|
if (!onlineAttempt || this.quizProvider.isAttemptFinished(onlineAttempt.state)) {
|
|
// Attempt not found or it's finished in online. Discard it.
|
|
warnings.push(this.translate.instant('addon.mod_quiz.warningattemptfinished'));
|
|
|
|
return this.finishSync(siteId, quiz, courseId, warnings, {
|
|
attemptId: offlineAttempt.id,
|
|
offlineAttempt,
|
|
onlineAttempt,
|
|
removeAttempt: true,
|
|
});
|
|
}
|
|
|
|
// Get the data stored in offline.
|
|
const answersList = await this.quizOfflineProvider.getAttemptAnswers(offlineAttempt.id, siteId);
|
|
|
|
if (!answersList.length) {
|
|
// No answers stored, finish.
|
|
return this.finishSync(siteId, quiz, courseId, warnings, {
|
|
attemptId: lastAttemptId,
|
|
offlineAttempt,
|
|
onlineAttempt,
|
|
removeAttempt: true,
|
|
});
|
|
}
|
|
|
|
const offlineAnswers = this.questionProvider.convertAnswersArrayToObject(answersList);
|
|
const offlineQuestions = this.quizOfflineProvider.classifyAnswersInQuestions(offlineAnswers);
|
|
|
|
// We're going to need preflightData, get it.
|
|
const info = await this.quizProvider.getQuizAccessInformation(quiz.id, modOptions);
|
|
|
|
const preflightData = await this.prefetchHandler.getPreflightData(quiz, info, onlineAttempt, askPreflight,
|
|
'core.settings.synchronization', siteId);
|
|
|
|
// Now get the online questions data.
|
|
const onlineQuestions = await this.quizProvider.getAllQuestionsData(quiz, onlineAttempt, preflightData, {
|
|
pages: this.quizProvider.getPagesFromLayoutAndQuestions(onlineAttempt.layout, offlineQuestions),
|
|
readingStrategy: CoreSitesReadingStrategy.OnlyNetwork,
|
|
siteId,
|
|
});
|
|
|
|
// Validate questions, discarding the offline answers that can't be synchronized.
|
|
const discardedData = await this.validateQuestions(onlineAttempt.id, onlineQuestions, offlineQuestions, siteId);
|
|
|
|
// Let questions prepare the data to send.
|
|
await Promise.all(Object.keys(offlineQuestions).map(async (slot) => {
|
|
const onlineQuestion = onlineQuestions[slot];
|
|
|
|
await this.questionDelegate.prepareSyncData(onlineQuestion, offlineQuestions[slot].answers,
|
|
AddonModQuizProvider.COMPONENT, quiz.coursemodule, siteId);
|
|
}));
|
|
|
|
// Get the answers to send.
|
|
const answers = this.quizOfflineProvider.extractAnswersFromQuestions(offlineQuestions);
|
|
const finish = offlineAttempt.finished && !discardedData;
|
|
|
|
if (discardedData) {
|
|
if (offlineAttempt.finished) {
|
|
warnings.push(this.translate.instant('addon.mod_quiz.warningdatadiscardedfromfinished'));
|
|
} else {
|
|
warnings.push(this.translate.instant('addon.mod_quiz.warningdatadiscarded'));
|
|
}
|
|
}
|
|
|
|
// Send the answers.
|
|
await this.quizProvider.processAttempt(quiz, onlineAttempt, answers, preflightData, finish, false, false, siteId);
|
|
|
|
if (!finish) {
|
|
// Answers sent, now set the current page.
|
|
// Don't pass the quiz instance because we don't want to trigger a Firebase event in this case.
|
|
await CoreUtils.instance.ignoreErrors(this.quizProvider.logViewAttempt(onlineAttempt.id, offlineAttempt.currentpage,
|
|
preflightData, false, undefined, siteId));
|
|
}
|
|
|
|
// Data sent. Finish the sync.
|
|
return this.finishSync(siteId, quiz, courseId, warnings, {
|
|
attemptId: lastAttemptId,
|
|
offlineAttempt,
|
|
onlineAttempt,
|
|
removeAttempt: true,
|
|
updated: true,
|
|
onlineQuestions,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Validate questions, discarding the offline answers that can't be synchronized.
|
|
*
|
|
* @param attemptId Attempt ID.
|
|
* @param onlineQuestions Online questions
|
|
* @param offlineQuestions Offline questions.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved with boolean: true if some offline data was discarded, false otherwise.
|
|
*/
|
|
validateQuestions(attemptId: number, onlineQuestions: any, offlineQuestions: any, siteId?: string): Promise<boolean> {
|
|
const promises = [];
|
|
let discardedData = false;
|
|
|
|
for (const slot in offlineQuestions) {
|
|
const offlineQuestion = offlineQuestions[slot],
|
|
onlineQuestion = onlineQuestions[slot],
|
|
offlineSequenceCheck = offlineQuestion.answers[':sequencecheck'];
|
|
|
|
if (onlineQuestion) {
|
|
|
|
// We found the online data for the question, validate that the sequence check is ok.
|
|
if (!this.questionDelegate.validateSequenceCheck(onlineQuestion, offlineSequenceCheck)) {
|
|
// Sequence check is not valid, remove the offline data.
|
|
discardedData = true;
|
|
promises.push(this.quizOfflineProvider.removeQuestionAndAnswers(attemptId, Number(slot), siteId));
|
|
delete offlineQuestions[slot];
|
|
} else {
|
|
// Sequence check is valid. Use the online one to prevent synchronization errors.
|
|
offlineQuestion.answers[':sequencecheck'] = onlineQuestion.sequencecheck;
|
|
}
|
|
} else {
|
|
// Online question not found, it can happen for 2 reasons:
|
|
// 1- It's a sequential quiz and the question is in a page already passed.
|
|
// 2- Quiz layout has changed (shouldn't happen since it's blocked if there are attempts).
|
|
discardedData = true;
|
|
promises.push(this.quizOfflineProvider.removeQuestionAndAnswers(attemptId, Number(slot), siteId));
|
|
delete offlineQuestions[slot];
|
|
}
|
|
}
|
|
|
|
return Promise.all(promises).then(() => {
|
|
return discardedData;
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Options to pass to finish sync.
|
|
*/
|
|
type FinishSyncOptions = {
|
|
attemptId?: number; // Last attempt ID.
|
|
offlineAttempt?: any; // Offline attempt synchronized, if any.
|
|
onlineAttempt?: any; // Online data for the offline attempt.
|
|
removeAttempt?: boolean; // Whether the offline data should be removed.
|
|
updated?: boolean; // Whether the offline data should be removed.
|
|
onlineQuestions?: any; // Online questions indexed by slot.
|
|
};
|