EVOgeek
/
Vmeda.Online
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MOBILE-2310 course: Apply prefetch to section page

main
Dani Palou 2018-01-17 12:12:23 +01:00
parent 64f1551d56
commit fe2c4cce74
10 changed files with 1031 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/components/context-menu/context-menu-item.ts
View File

@ -38,7 +38,7 @@ export class CoreContextMenuItemComponent implements OnInit, OnDestroy, OnChange
@Input() iconDescription?: string; // Name of the icon to be shown on the left side of the item.
@Input() iconAction?: string; // Name of the icon to be shown on the right side of the item. It represents the action to do on
// click. If is "spinner" an spinner will be shown. If no icon or spinner is selected, no action
// or link will work. If href but no iconAction is provided ion-arrow-right-c will be used.
// or link will work. If href but no iconAction is provided arrow-right will be used.
@Input() ariaDescription?: string; // Aria label to add to iconDescription.
@Input() ariaAction?: string; // Aria label to add to iconAction. If not set, it will be equal to content.
@Input() href?: string; // Link to go if no action provided.

10
src/components/context-menu/context-menu-popover.ts
View File

@ -15,6 +15,7 @@
import { Component } from '@angular/core';
import { NavParams, ViewController } from 'ionic-angular';
import { CoreContextMenuItemComponent } from './context-menu-item';
import { CoreLoggerProvider } from '../../providers/logger';
/**
* Component to display a list of items received by param in a popover.
@ -26,10 +27,12 @@ import { CoreContextMenuItemComponent } from './context-menu-item';
export class CoreContextMenuPopoverComponent {
title: string;
items: CoreContextMenuItemComponent[];
protected logger: any;
constructor(navParams: NavParams, private viewCtrl: ViewController) {
constructor(navParams: NavParams, private viewCtrl: ViewController, logger: CoreLoggerProvider) {
this.title = navParams.get('title');
this.items = navParams.get('items') || [];
this.logger = logger.getInstance('CoreContextMenuPopoverComponent');
}
/**
@ -51,7 +54,10 @@ export class CoreContextMenuPopoverComponent {
event.preventDefault();
event.stopPropagation();
if (!item.iconAction || item.iconAction == 'spinner') {
if (!item.iconAction) {
this.logger.warn('Items with action must have an icon action to work', item);
return false;
} else if (item.iconAction == 'spinner') {
return false;
}

37
src/core/course/components/format/format.html
View File

@ -10,18 +10,14 @@
<core-loading [hideUntil]="loaded">
<!-- Section selector. -->
<ion-row *ngIf="!componentInstances.sectionSelector && displaySectionSelector && sections && sections.length">
<ion-col col-11>
<ion-item>
<ion-select [ngModel]="selectedSection" (ngModelChange)="sectionChanged($event)" [compareWith]="compareSections" [selectOptions]="selectOptions">
<div *ngIf="!componentInstances.sectionSelector && displaySectionSelector && sections && sections.length" no-padding class="clearfix">
<!-- @todo: How to display availabilityinfo and not visible messages? -->
<ion-select [ngModel]="selectedSection" (ngModelChange)="sectionChanged($event)" [compareWith]="compareSections" [selectOptions]="selectOptions" float-start>
<ion-option *ngFor="let section of sections" [value]="section">{{section.formattedName || section.name}}</ion-option>
</ion-select>
</ion-item>
</ion-col>
<ion-col col-1 class="text-right">
<!-- @todo Download button. -->
</ion-col>
</ion-row>
<!-- Section download. -->
<ng-container *ngTemplateOutlet="sectionDownloadTemplate; context: {section: selectedSection}"></ng-container>
</div>
<ng-template #sectionSelector></ng-template>
<!-- Single section. -->
@ -45,11 +41,14 @@
</core-loading>
</div>
<!-- Template to render a section. -->
<ng-template #sectionTemplate let-section="section">
<section ion-list *ngIf="section.hasContent">
<!-- Title is only displayed when viewing all sections. -->
<ion-item-divider text-wrap color="light" *ngIf="selectedSection.id == allSectionsId && section.name">
<core-format-text [text]="section.name"></core-format-text>
<!-- Section download. -->
<ng-container *ngTemplateOutlet="sectionDownloadTemplate; context: {section: section}"></ng-container>
</ion-item-divider>
<ion-item text-wrap *ngIf="section.summary">
@ -62,5 +61,23 @@
</section>
</ng-template>
<!-- Template to render a section download button/progress. -->
<ng-template #sectionDownloadTemplate let-section="section">
<div *ngIf="section && downloadEnabled" float-end>
<!-- Download button. -->
<button *ngIf="section.showDownload && !section.isDownloading && !section.isCalculating" (click)="prefetch($event, section)" ion-button icon-only clear color="dark" [attr.aria-label]="'core.download' | translate">
<ion-icon name="cloud-download"></ion-icon>
</button>
<!-- Refresh button. -->
<button *ngIf="section.showRefresh && !section.isDownloading && !section.isCalculating" (click)="prefetch($event, section)" ion-button icon-only clear color="dark" [attr.aria-label]="'core.refresh' | translate">
<ion-icon name="refresh"></ion-icon>
</button>
<!-- Spinner (downloading or calculating status). -->
<ion-spinner *ngIf="(section.isDownloading && section.total > 0) || section.isCalculating"></ion-spinner>
<!-- Download progress. -->
<ion-badge class="core-course-download-section-progress" *ngIf="section.isDownloading && section.total > 0 && section.count < section.total">{{section.count}} / {{section.total}}</ion-badge>
</div>
</ng-template>
<!-- Custom course format that overrides the default one. -->
<ng-template #courseFormat></ng-template>

119
src/core/course/components/format/format.ts
View File

@ -12,12 +12,17 @@
// See the License for the specific language governing permissions and
// limitations under the License.
import { Component, Input, OnInit, OnChanges, ViewContainerRef, ComponentFactoryResolver, ViewChild, ChangeDetectorRef,
import { Component, Input, OnInit, OnChanges, OnDestroy, ViewContainerRef, ComponentFactoryResolver, ViewChild, ChangeDetectorRef,
SimpleChange, Output, EventEmitter } from '@angular/core';
import { TranslateService } from '@ngx-translate/core';
import { CoreEventsProvider } from '../../../../providers/events';
import { CoreLoggerProvider } from '../../../../providers/logger';
import { CoreSitesProvider } from '../../../../providers/sites';
import { CoreDomUtilsProvider } from '../../../../providers/utils/dom';
import { CoreCourseProvider } from '../../../course/providers/course';
import { CoreCourseHelperProvider } from '../../../course/providers/helper';
import { CoreCourseFormatDelegate } from '../../../course/providers/format-delegate';
import { CoreCourseModulePrefetchDelegate } from '../../../course/providers/module-prefetch-delegate';
/**
* Component to display course contents using a certain format. If the format isn't found, use default one.
@ -33,9 +38,10 @@ import { CoreCourseFormatDelegate } from '../../../course/providers/format-deleg
selector: 'core-course-format',
templateUrl: 'format.html'
})
export class CoreCourseFormatComponent implements OnInit, OnChanges {
export class CoreCourseFormatComponent implements OnInit, OnChanges, OnDestroy {
@Input() course: any; // The course to render.
@Input() sections: any[]; // List of course sections.
@Input() downloadEnabled?: boolean; // Whether the download of sections and modules is enabled.
@Output() completionChanged?: EventEmitter<void>; // Will emit an event when any module completion changes.
// Get the containers where to inject dynamic components. We use a setter because they might be inside a *ngIf.
@ -71,12 +77,53 @@ export class CoreCourseFormatComponent implements OnInit, OnChanges {
loaded: boolean;
protected logger;
protected sectionStatusObserver;
constructor(logger: CoreLoggerProvider, private cfDelegate: CoreCourseFormatDelegate, translate: TranslateService,
private factoryResolver: ComponentFactoryResolver, private cdr: ChangeDetectorRef) {
private factoryResolver: ComponentFactoryResolver, private cdr: ChangeDetectorRef,
private courseHelper: CoreCourseHelperProvider, private domUtils: CoreDomUtilsProvider,
eventsProvider: CoreEventsProvider, private sitesProvider: CoreSitesProvider,
prefetchDelegate: CoreCourseModulePrefetchDelegate) {
this.logger = logger.getInstance('CoreCourseFormatComponent');
this.selectOptions.title = translate.instant('core.course.sections');
this.completionChanged = new EventEmitter();
// Listen for section status changes.
this.sectionStatusObserver = eventsProvider.on(CoreEventsProvider.SECTION_STATUS_CHANGED, (data) => {
if (this.downloadEnabled && this.sections && this.sections.length && this.course && data.sectionId &&
data.courseId == this.course.id) {
// Check if the affected section is being downloaded. If so, we don't update section status
// because it'll already be updated when the download finishes.
let downloadId = this.courseHelper.getSectionDownloadId({id: data.sectionId});
if (prefetchDelegate.isBeingDownloaded(downloadId)) {
return;
}
// Get the affected section.
let section;
for (let i = 0; i < this.sections.length; i++) {
let s = this.sections[i];
if (s.id === data.sectionId) {
section = s;
break;
}
}
if (!section) {
// Section not found, stop.
return;
}
// Recalculate the status.
this.courseHelper.calculateSectionStatus(section, this.course.id, false).then(() => {
if (section.isDownloading && !prefetchDelegate.isBeingDownloaded(downloadId)) {
// All the modules are now downloading, set a download all promise.
this.prefetch(section, false);
}
});
}
}, this.sitesProvider.getCurrentSiteId());
}
/**
@ -119,6 +166,10 @@ export class CoreCourseFormatComponent implements OnInit, OnChanges {
}
}
if (changes.downloadEnabled && this.downloadEnabled) {
this.calculateSectionsStatus(false);
}
// Apply the changes to the components and call ngOnChanges if it exists.
for (let type in this.componentInstances) {
let instance = this.componentInstances[type];
@ -164,6 +215,7 @@ export class CoreCourseFormatComponent implements OnInit, OnChanges {
// Set the Input data.
this.componentInstances[type].course = this.course;
this.componentInstances[type].sections = this.sections;
this.componentInstances[type].downloadEnabled = this.downloadEnabled;
return true;
} catch(ex) {
@ -202,4 +254,65 @@ export class CoreCourseFormatComponent implements OnInit, OnChanges {
compareSections(s1: any, s2: any) : boolean {
return s1 && s2 ? s1.id === s2.id : s1 === s2;
}
/**
* Calculate the status of sections.
*
* @param {boolean} refresh [description]
*/
protected calculateSectionsStatus(refresh?: boolean) : void {
this.courseHelper.calculateSectionsStatus(this.sections, this.course.id, refresh).catch(() => {
// Ignore errors (shouldn't happen).
});
}
/**
* Confirm and prefetch a section. If the section is "all sections", prefetch all the sections.
*
* @param {Event} e Click event.
* @param {any} section Section to download.
*/
prefetch(e: Event, section: any) : void {
e.preventDefault();
e.stopPropagation();
section.isCalculating = true;
this.courseHelper.confirmDownloadSizeSection(this.course.id, section, this.sections).then(() => {
this.prefetchSection(section, true);
}, (error) => {
// User cancelled or there was an error calculating the size.
if (error) {
this.domUtils.showErrorModal(error);
}
}).finally(() => {
section.isCalculating = false;
});
}
/**
* Prefetch a section.
*
* @param {any} section The section to download.
* @param {boolean} [manual] Whether the prefetch was started manually or it was automatically started because all modules
* are being downloaded.
*/
protected prefetchSection(section: any, manual?: boolean) {
this.courseHelper.prefetchSection(section, this.course.id, this.sections).catch((error) => {
// Don't show error message if it's an automatic download.
if (!manual) {
return;
}
this.domUtils.showErrorModalDefault(error, 'core.course.errordownloadingsection', true);
});
}
/**
* Component destroyed.
*/
ngOnDestroy() {
if (this.sectionStatusObserver) {
this.sectionStatusObserver.off();
}
}
}

5
src/core/course/pages/section/section.html
View File

@ -4,7 +4,8 @@
<ion-buttons end>
<core-context-menu>
<core-context-menu-item [priority]="900" [content]="'core.settings.enabledownloadsection' | translate" (action)="toggleDownload()" [iconAction]="'downloadSectionsIcon'"></core-context-menu-item>
<core-context-menu-item [priority]="900" [content]="'core.settings.enabledownloadsection' | translate" (action)="toggleDownload()" [iconAction]="downloadEnabledIcon"></core-context-menu-item>
<core-context-menu-item [priority]="850" [content]="'core.course.downloadcourse' | translate" (action)="prefetchCourse()" [iconAction]="prefetchCourseData.prefetchCourseIcon" [closeOnClick]="false"></core-context-menu-item>
</core-context-menu>
</ion-buttons>
</ion-navbar>
@ -19,6 +20,6 @@
<a ion-button class="tab-item">{{ 'core.course.contents' || translate }}</a>
<a *ngFor="let handler of courseHandlers" ion-button class="tab-item">{{ handler.data.title || translate }}</a>
</div>
<core-course-format [course]="course" [sections]="sections" (completionChanged)="onCompletionChange()"></core-course-format>
<core-course-format [course]="course" [sections]="sections" [downloadEnabled]="downloadEnabled" (completionChanged)="onCompletionChange()"></core-course-format>
</core-loading>
</ion-content>

76
src/core/course/pages/section/section.ts
View File

@ -16,12 +16,13 @@ import { Component, ViewChild, OnDestroy } from '@angular/core';
import { IonicPage, NavParams, Content } from 'ionic-angular';
import { TranslateService } from '@ngx-translate/core';
import { CoreEventsProvider } from '../../../../providers/events';
import { CoreSitesProvider } from '../../../../providers/sites';
import { CoreDomUtilsProvider } from '../../../../providers/utils/dom';
import { CoreTextUtilsProvider } from '../../../../providers/utils/text';
import { CoreCourseProvider } from '../../providers/course';
import { CoreCourseHelperProvider } from '../../providers/helper';
import { CoreCourseFormatDelegate } from '../../providers/format-delegate';
import { CoreCoursesDelegate } from '../../../courses/providers/delegate';
import { CoreCoursesDelegate, CoreCoursesHandlerToDisplay } from '../../../courses/providers/delegate';
import { CoreCoursesProvider } from '../../../courses/providers/courses';
/**
@ -38,16 +39,24 @@ export class CoreCourseSectionPage implements OnDestroy {
title: string;
course: any;
sections: any[];
courseHandlers: any[];
courseHandlers: CoreCoursesHandlerToDisplay[];
dataLoaded: boolean;
downloadEnabled: boolean;
downloadEnabledIcon: string = 'square-outline'; // Disabled by default.
prefetchCourseData = {
prefetchCourseIcon: 'spinner'
};
protected moduleId;
protected completionObserver;
protected courseStatusObserver;
protected isDestroyed = false;
constructor(navParams: NavParams, private courseProvider: CoreCourseProvider, private domUtils: CoreDomUtilsProvider,
private courseFormatDelegate: CoreCourseFormatDelegate, private coursesDelegate: CoreCoursesDelegate,
private translate: TranslateService, private courseHelper: CoreCourseHelperProvider, eventsProvider: CoreEventsProvider,
private textUtils: CoreTextUtilsProvider, private coursesProvider: CoreCoursesProvider) {
private textUtils: CoreTextUtilsProvider, private coursesProvider: CoreCoursesProvider,
sitesProvider: CoreSitesProvider) {
this.course = navParams.get('course');
this.title = courseFormatDelegate.getCourseTitle(this.course);
this.moduleId = navParams.get('moduleId');
@ -57,6 +66,13 @@ export class CoreCourseSectionPage implements OnDestroy {
this.refreshAfterCompletionChange();
}
});
// Listen for changes in course status.
this.courseStatusObserver = eventsProvider.on(CoreEventsProvider.COURSE_STATUS_CHANGED, (data) => {
if (data.courseId == this.course.id) {
this.prefetchCourseData.prefetchCourseIcon = this.courseHelper.getCourseStatusIconFromStatus(data.status);
}
}, sitesProvider.getCurrentSiteId());
}
/**
@ -66,6 +82,27 @@ export class CoreCourseSectionPage implements OnDestroy {
this.loadData().finally(() => {
this.dataLoaded = true;
delete this.moduleId; // Only load module automatically the first time.
// Determine the course prefetch status.
this.determineCoursePrefetchIcon().then(() => {
if (this.prefetchCourseData.prefetchCourseIcon == 'spinner') {
// Course is being downloaded. Get the download promise.
const promise = this.courseHelper.getCourseDownloadPromise(this.course.id);
if (promise) {
// There is a download promise. Show an error if it fails.
promise.catch((error) => {
if (!this.isDestroyed) {
this.domUtils.showErrorModalDefault(error, 'core.course.errordownloadingcourse', true);
}
});
} else {
// No download, this probably means that the app was closed while downloading. Set previous status.
this.courseProvider.setCoursePreviousStatus(this.course.id).then((status) => {
this.prefetchCourseData.prefetchCourseIcon = this.courseHelper.getCourseStatusIconFromStatus(status);
});
}
}
});
});
}
@ -184,10 +221,43 @@ export class CoreCourseSectionPage implements OnDestroy {
});
}
/**
* Determines the prefetch icon of the course.
*/
protected determineCoursePrefetchIcon() {
return this.courseHelper.getCourseStatusIcon(this.course.id).then((icon) => {
this.prefetchCourseData.prefetchCourseIcon = icon;
});
}
/**
* Prefetch the whole course.
*/
prefetchCourse() {
this.courseHelper.confirmAndPrefetchCourse(this.prefetchCourseData, this.course, this.sections, this.courseHandlers)
.then((downloaded) => {
if (downloaded && this.downloadEnabled) {
// Recalculate the status.
this.courseHelper.calculateSectionsStatus(this.sections, this.course.id).catch(() => {
// Ignore errors (shouldn't happen).
});
}
});
}
/**
* Toggle download enabled.
*/
toggleDownload() {
this.downloadEnabled = !this.downloadEnabled;
this.downloadEnabledIcon = this.downloadEnabled ? 'checkbox-outline' : 'square-outline';
}
/**
* Page destroyed.
*/
ngOnDestroy() {
this.isDestroyed = true;
if (this.completionObserver) {
this.completionObserver.off();
}

5
src/core/course/providers/course.ts
View File

@ -712,7 +712,7 @@ export class CoreCourseProvider {
}
/**
* Trigger mmCoreEventCourseStatusChanged with the right data.
* Trigger COURSE_STATUS_CHANGED with the right data.
*
* @param {number} courseId Course ID.
* @param {string} status New course status.
@ -720,9 +720,8 @@ export class CoreCourseProvider {
*/
protected triggerCourseStatusChanged(courseId: number, status: string, siteId?: string) : void {
this.eventsProvider.trigger(CoreEventsProvider.COURSE_STATUS_CHANGED, {
siteId: siteId,
courseId: courseId,
status: status
});
}, siteId);
}
}

683
src/core/course/providers/helper.ts
View File

@ -13,9 +13,89 @@
// limitations under the License.
import { Injectable } from '@angular/core';
import { TranslateService } from '@ngx-translate/core';
import { CoreFilepoolProvider } from '../../../providers/filepool';
import { CoreSitesProvider } from '../../../providers/sites';
import { CoreDomUtilsProvider } from '../../../providers/utils/dom';
import { CoreTextUtilsProvider } from '../../../providers/utils/text';
import { CoreTimeUtilsProvider } from '../../../providers/utils/time';
import { CoreUtilsProvider } from '../../../providers/utils/utils';
import { CoreCoursesDelegate, CoreCoursesHandlerToDisplay } from '../../courses/providers/delegate';
import { CoreCourseProvider } from './course';
import { CoreCourseModuleDelegate } from './module-delegate';
import { CoreCourseModulePrefetchDelegate, CoreCourseModulePrefetchHandler } from './module-prefetch-delegate';
import { CoreConstants } from '../../constants';
import * as moment from 'moment';
/**
* Prefetch info of a module.
*/
export type CoreCourseModulePrefetchInfo = {
/**
* Downloaded size.
* @type {number}
*/
size?: number;
/**
* Downloadable size in a readable format.
* @type {string}
*/
sizeReadable?: string;
/**
* Module status.
* @type {string}
*/
status?: string;
/**
* Icon's name of the module status.
* @type {string}
*/
statusIcon?: string;
/**
* Time when the module was last downloaded.
* @type {number}
*/
downloadTime?: number;
/**
* Download time in a readable format.
* @type {string}
*/
downloadTimeReadable?: string;
};
/**
* Progress of downloading a list of courses.
*/
export type CoreCourseCoursesProgress = {
/**
* Number of courses downloaded so far.
* @type {number}
*/
count: number;
/**
* Toal of courses to download.
* @type {number}
*/
total: number;
/**
* Whether the download has been successful so far.
* @type {boolean}
*/
success: boolean;
/**
* Last downloaded course.
* @type {number}
*/
courseId?: number;
};
/**
* Helper to gather some common course functions.
@ -23,8 +103,13 @@ import { CoreCourseModuleDelegate } from './module-delegate';
@Injectable()
export class CoreCourseHelperProvider {
protected courseDwnPromises: {[s: string]: {[id: number]: Promise<any>}} = {};
constructor(private courseProvider: CoreCourseProvider, private domUtils: CoreDomUtilsProvider,
private moduleDelegate: CoreCourseModuleDelegate) {}
private moduleDelegate: CoreCourseModuleDelegate, private prefetchDelegate: CoreCourseModulePrefetchDelegate,
private filepoolProvider: CoreFilepoolProvider, private sitesProvider: CoreSitesProvider,
private textUtils: CoreTextUtilsProvider, private timeUtils: CoreTimeUtilsProvider,
private utils: CoreUtilsProvider, private translate: TranslateService, private coursesDelegate: CoreCoursesDelegate) {}
/**
* This function treats every module on the sections provided to load the handler data, treat completion
@ -65,6 +150,329 @@ export class CoreCourseHelperProvider {
return hasContent;
}
/**
* Calculate the status of a section.
*
* @param {any} section Section to calculate its status. It can't be "All sections".
* @param {number} courseId Course ID the section belongs to.
* @param {boolean} [refresh] True if it shouldn't use module status cache (slower).
* @return {Promise<any>} Promise resolved when the status is calculated.
*/
calculateSectionStatus(section: any, courseId: number, refresh?: boolean) : Promise<any> {
if (section.id == CoreCourseProvider.ALL_SECTIONS_ID) {
return Promise.reject(null);
}
// Get the status of this section.
return this.prefetchDelegate.getModulesStatus(section.modules, courseId, section.id, refresh).then((result) => {
// Check if it's being downloaded.
const downloadId = this.getSectionDownloadId(section);
if (this.prefetchDelegate.isBeingDownloaded(downloadId)) {
result.status = CoreConstants.DOWNLOADING;
}
// Set this section data.
section.showDownload = result.status === CoreConstants.NOT_DOWNLOADED;
section.showRefresh = result.status === CoreConstants.OUTDATED;
if (result.status !== CoreConstants.DOWNLOADING || !this.prefetchDelegate.isBeingDownloaded(section.id)) {
section.isDownloading = false;
section.total = 0;
} else {
// Section is being downloaded.
section.isDownloading = true;
this.prefetchDelegate.setOnProgress(downloadId, (data) => {
section.count = data.count;
section.total = data.total;
});
}
return result;
});
}
/**
* Calculate the status of a list of sections, setting attributes to determine the icons/data to be shown.
*
* @param {any[]} sections Sections to calculate their status.
* @param {number} courseId Course ID the sections belong to.
* @param {boolean} [refresh] True if it shouldn't use module status cache (slower).
* @return {Promise<void>} Promise resolved when the states are calculated.
*/
calculateSectionsStatus(sections: any[], courseId: number, refresh?: boolean) : Promise<void> {
let allSectionsSection,
allSectionsStatus,
promises = [];
sections.forEach((section) => {
if (section.id === CoreCourseProvider.ALL_SECTIONS_ID) {
// "All sections" section status is calculated using the status of the rest of sections.
allSectionsSection = section;
section.isCalculating = true;
} else {
section.isCalculating = true;
promises.push(this.calculateSectionStatus(section, courseId, refresh).then((result) => {
// Calculate "All sections" status.
allSectionsStatus = this.filepoolProvider.determinePackagesStatus(allSectionsStatus, result.status);
}).finally(() => {
section.isCalculating = false;
}));
}
});
return Promise.all(promises).then(() => {
if (allSectionsSection) {
// Set "All sections" data.
allSectionsSection.showDownload = allSectionsStatus === CoreConstants.NOT_DOWNLOADED;
allSectionsSection.showRefresh = allSectionsStatus === CoreConstants.OUTDATED;
allSectionsSection.isDownloading = allSectionsStatus === CoreConstants.DOWNLOADING;
}
}).finally(() => {
if (allSectionsSection) {
allSectionsSection.isCalculating = false;
}
});
}
/**
* Show a confirm and prefetch a course. It will retrieve the sections and the course options if not provided.
* This function will set the icon to "spinner" when starting and it will also set it back to the initial icon if the
* user cancels. All the other updates of the icon should be made when CoreEventsProvider.COURSE_STATUS_CHANGED is received.
*
* @param {any} iconData An object where to store the course icon. It will be stored with the name "prefetchCourseIcon".
* @param {any} course Course to prefetch.
* @param {any[]} [sections] List of course sections.
* @param {CoreCoursesHandlerToDisplay[]} courseHandlers List of course handlers.
* @return {Promise<boolean>} Promise resolved with true when the download finishes, resolved with false if user doesn't
* confirm, rejected if an error occurs.
*/
confirmAndPrefetchCourse(iconData: any, course: any, sections?: any[], courseHandlers?: CoreCoursesHandlerToDisplay[])
: Promise<boolean> {
let initialIcon = iconData.prefetchCourseIcon,
promise,
siteId = this.sitesProvider.getCurrentSiteId();
iconData.prefetchCourseIcon = 'spinner';
// Get the sections first if needed.
if (sections) {
promise = Promise.resolve(sections);
} else {
promise = this.courseProvider.getSections(course.id, false, true);
}
return promise.then((sections) => {
// Confirm the download.
return this.confirmDownloadSizeSection(course.id, undefined, sections, true).then(() => {
// User confirmed, get the course handlers if needed.
if (courseHandlers) {
promise = Promise.resolve(courseHandlers);
} else {
promise = this.coursesDelegate.getHandlersToDisplay(course);
}
return promise.then((handlers: CoreCoursesHandlerToDisplay[]) => {
// Now we have all the data, download the course.
return this.prefetchCourse(course, sections, handlers, siteId);
}).then(() => {
// Download successful.
return true;
});
}, (error) : any => {
// User cancelled or there was an error calculating the size.
iconData.prefetchCourseIcon = initialIcon;
if (error) {
return Promise.reject(error);
}
return false;
});
});
};
/**
* Confirm and prefetches a list of courses.
*
* @param {Object[]} courses List of courses to download.
* @return {Promise} Promise resolved with true when downloaded, resolved with false if user cancels, rejected if error.
* It will send a "progress" everytime a course is downloaded or fails to download.
*/
confirmAndPrefetchCourses(courses: any[], onProgress?: (data: CoreCourseCoursesProgress) => void) : Promise<boolean> {
const siteId = this.sitesProvider.getCurrentSiteId();
// Confirm the download without checking size because it could take a while.
return this.domUtils.showConfirm(this.translate.instant('core.areyousure')).then(() => {
let promises = [],
total = courses.length,
count = 0;
courses.forEach((course) => {
let subPromises = [],
sections,
handlers,
success = true;
// Get the sections and the handlers.
subPromises.push(this.courseProvider.getSections(course.id, false, true).then((courseSections) => {
sections = courseSections;
}));
subPromises.push(this.coursesDelegate.getHandlersToDisplay(course).then((cHandlers) => {
handlers = cHandlers;
}));
promises.push(Promise.all(subPromises).then(() => {
return this.prefetchCourse(course, sections, handlers, siteId);
}).catch((error) => {
success = false;
return Promise.reject(error);
}).finally(() => {
// Course downloaded or failed, notify the progress.
count++;
if (onProgress) {
onProgress({count: count, total: total, courseId: course.id, success: success});
}
}));
});
if (onProgress) {
// Notify the start of the download.
onProgress({count: 0, total: total, success: true});
}
return this.utils.allPromises(promises).then(() => {
return true;
});
}, () => {
// User cancelled.
return false;
});
};
/**
* Show confirmation dialog and then remove a module files.
*
* @param {any} module Module to remove the files.
* @param {number} courseId Course ID the module belongs to.
* @return {Promise<any>} Promise resolved when done.
*/
confirmAndRemoveFiles(module: any, courseId: number) : Promise<any> {
return this.domUtils.showConfirm(this.translate.instant('course.confirmdeletemodulefiles')).then(() => {
return this.prefetchDelegate.removeModuleFiles(module, courseId);
});
}
/**
* Calculate the size to download a section and show a confirm modal if needed.
*
* @param {number} courseId Course ID the section belongs to.
* @param {any} [section] Section. If not provided, all sections.
* @param {any[]} [sections] List of sections. Used when downloading all the sections.
* @param {boolean} [alwaysConfirm] True to show a confirm even if the size isn't high, false otherwise.
* @return {Promise<any>} Promise resolved if the user confirms or there's no need to confirm.
*/
confirmDownloadSizeSection(courseId: number, section?: any, sections?: any[], alwaysConfirm?: boolean) : Promise<any> {
let sizePromise;
// Calculate the size of the download.
if (section && section.id != CoreCourseProvider.ALL_SECTIONS_ID) {
sizePromise = this.prefetchDelegate.getDownloadSize(section.modules, courseId);
} else {
let promises = [],
results = {
size: 0,
total: true
};
sections.forEach((s) => {
if (s.id != CoreCourseProvider.ALL_SECTIONS_ID) {
promises.push(this.prefetchDelegate.getDownloadSize(s.modules, courseId).then((sectionSize) => {
results.total = results.total && sectionSize.total;
results.size += sectionSize.size;
}));
}
});
sizePromise = Promise.all(promises).then(() => {
return results;
});
}
return sizePromise.then((size) => {
// Show confirm modal if needed.
return this.domUtils.confirmDownloadSize(size, undefined, undefined, undefined, undefined, alwaysConfirm);
});
}
/**
* Determine the status of a list of courses.
*
* @param {any[]} courses Courses
* @return {Promise<string>} Promise resolved with the status.
*/
determineCoursesStatus(courses: any[]) : Promise<string> {
// Get the status of each course.
const promises = [],
siteId = this.sitesProvider.getCurrentSiteId();
courses.forEach((course) => {
promises.push(this.courseProvider.getCourseStatus(course.id, siteId));
});
return Promise.all(promises).then((statuses) => {
// Now determine the status of the whole list.
let status = statuses[0];
for (let i = 1; i < statuses.length; i++) {
status = this.filepoolProvider.determinePackagesStatus(status, statuses[i]);
}
return status;
});
}
/**
* Get a course download promise (if any).
*
* @param {number} courseId Course ID.
* @param {string} [siteId] Site ID. If not defined, current site.
* @return {Promise<any>} Download promise, undefined if not found.
*/
getCourseDownloadPromise(courseId: number, siteId?: string) : Promise<any> {
siteId = siteId || this.sitesProvider.getCurrentSiteId();
return this.courseDwnPromises[siteId] && this.courseDwnPromises[siteId][courseId];
}
/**
* Get a course status icon.
*
* @param {number} courseId Course ID.
* @param {string} [siteId] Site ID. If not defined, current site.
* @return {Promise<string>} Promise resolved with the icon name.
*/
getCourseStatusIcon(courseId: number, siteId?: string) : Promise<string> {
return this.courseProvider.getCourseStatus(courseId, siteId).then((status) => {
return this.getCourseStatusIconFromStatus(status);
});
}
/**
* Get a course status icon from status.
*
* @module mm.core.course
* @ngdoc method
* @name $mmCourseHelper#getCourseStatusIconFromStatus
* @param {String} status Course status.
* @return {String} Icon name.
*/
getCourseStatusIconFromStatus(status: string) : string {
if (status == CoreConstants.DOWNLOADED) {
// Always show refresh icon, we cannot knew if there's anything new in course options.
return 'refresh';
} else if (status == CoreConstants.DOWNLOADING) {
return 'spinner';
} else {
return 'cloud-download';
}
}
/**
* Get the course ID from a module instance ID, showing an error message if it can't be retrieved.
*
@ -82,6 +490,279 @@ export class CoreCourseHelperProvider {
});
}
/**
* Get prefetch info for a module.
*
* @param {any} module Module to get the info from.
* @param {number} courseId Course ID the section belongs to.
* @param {boolean} [invalidateCache] Invalidates the cache first.
* @param {string} [component] Component of the module.
* @return {Promise<CoreCourseModulePrefetchInfo>} Promise resolved with the info.
*/
getModulePrefetchInfo(module: any, courseId: number, invalidateCache?: boolean, component?: string)
: Promise<CoreCourseModulePrefetchInfo> {
let moduleInfo: CoreCourseModulePrefetchInfo = {},
siteId = this.sitesProvider.getCurrentSiteId(),
promises = [];
if (invalidateCache) {
this.prefetchDelegate.invalidateModuleStatusCache(module);
}
promises.push(this.prefetchDelegate.getModuleDownloadedSize(module, courseId).then((moduleSize) => {
moduleInfo.size = moduleSize;
moduleInfo.sizeReadable = this.textUtils.bytesToSize(moduleSize, 2);
}));
// @todo: Decide what to display instead of timemodified. Last check_updates?
// promises.push(this.prefetchDelegate.getModuleTimemodified(module, courseId).then(function(moduleModified) {
// moduleInfo.timemodified = moduleModified;
// if (moduleModified > 0) {
// var now = $mmUtil.timestamp();
// if (now - moduleModified < 7 * 86400) {
// moduleInfo.timemodifiedReadable = moment(moduleModified * 1000).fromNow();
// } else {
// moduleInfo.timemodifiedReadable = moment(moduleModified * 1000).calendar();
// }
// } else {
// moduleInfo.timemodifiedReadable = "";
// }
// }));
promises.push(this.prefetchDelegate.getModuleStatus(module, courseId).then((moduleStatus) => {
moduleInfo.status = moduleStatus;
switch (moduleStatus) {
case CoreConstants.NOT_DOWNLOADED:
moduleInfo.statusIcon = 'cloud-download';
break;
case CoreConstants.DOWNLOADING:
moduleInfo.statusIcon = 'spinner';
break;
case CoreConstants.OUTDATED:
moduleInfo.statusIcon = 'ion-android-refresh';
break;
default:
moduleInfo.statusIcon = '';
break;
}
}));
// Get the time it was downloaded (if it was downloaded).
promises.push(this.filepoolProvider.getPackageData(siteId, component, module.id).then((data) => {
if (data && data.downloadTime && (data.status == CoreConstants.OUTDATED || data.status == CoreConstants.DOWNLOADED)) {
const now = this.timeUtils.timestamp();
moduleInfo.downloadTime = data.downloadTime;
if (now - data.downloadTime < 7 * 86400) {
moduleInfo.downloadTimeReadable = moment(data.downloadTime * 1000).fromNow();
} else {
moduleInfo.downloadTimeReadable = moment(data.downloadTime * 1000).calendar();
}
}
}).catch(() => {
// Not downloaded.
moduleInfo.downloadTime = 0;
}));
return Promise.all(promises).then(() => {
return moduleInfo;
});
}
/**
* Get the download ID of a section. It's used to interact with CoreCourseModulePrefetchDelegate.
*
* @param {any} section Section.
* @return {string} Section download ID.
*/
getSectionDownloadId(section: any) : string {
return 'Section-' + section.id;
}
/**
* Prefetch all the activities in a course and also the course addons.
*
* @param {any} course The course to prefetch.
* @param {any[]} sections List of course sections.
* @param {CoreCoursesHandlerToDisplay[]} courseHandlers List of course handlers.
* @param {string} [siteId] Site ID. If not defined, current site.
* @return {Promise} Promise resolved when the download finishes.
*/
prefetchCourse(course: any, sections: any[], courseHandlers: CoreCoursesHandlerToDisplay[], siteId?: string) : Promise<any> {
siteId = siteId || this.sitesProvider.getCurrentSiteId();
if (this.courseDwnPromises[siteId] && this.courseDwnPromises[siteId][course.id]) {
// There's already a download ongoing for this course, return the promise.
return this.courseDwnPromises[siteId][course.id];
} else if (!this.courseDwnPromises[siteId]) {
this.courseDwnPromises[siteId] = {};
}
// First of all, mark the course as being downloaded.
this.courseDwnPromises[siteId][course.id] = this.courseProvider.setCourseStatus(course.id, CoreConstants.DOWNLOADING,
siteId).then(() => {
let promises = [],
allSectionsSection = sections[0];
// Prefetch all the sections. If the first section is "All sections", use it. Otherwise, use a fake "All sections".
if (sections[0].id != CoreCourseProvider.ALL_SECTIONS_ID) {
allSectionsSection = {id: CoreCourseProvider.ALL_SECTIONS_ID};
}
promises.push(this.prefetchSection(allSectionsSection, course.id, sections));
// Prefetch course options.
courseHandlers.forEach((handler) => {
if (handler.prefetch) {
promises.push(handler.prefetch(course));
}
});
return this.utils.allPromises(promises);
}).then(() => {
// Download success, mark the course as downloaded.
return this.courseProvider.setCourseStatus(course.id, CoreConstants.DOWNLOADED, siteId);
}).catch((error) => {
// Error, restore previous status.
return this.courseProvider.setCoursePreviousStatus(course.id, siteId).then(() => {
return Promise.reject(error);
});
}).finally(() => {
delete this.courseDwnPromises[siteId][course.id];
});
return this.courseDwnPromises[siteId][course.id];
}
/**
* Helper function to prefetch a module, showing a confirmation modal if the size is big
* and invalidating contents if refreshing.
*
* @param {handler} handler Prefetch handler to use. Must implement 'prefetch' and 'invalidateContent'.
* @param {any} module Module to download.
* @param {any} size Object containing size to download (in bytes) and a boolean to indicate if its totally calculated.
* @param {number} courseId Course ID of the module.
* @param {boolean} [refresh] True if refreshing, false otherwise.
* @return {Promise<any>} Promise resolved when downloaded.
*/
prefetchModule(handler: any, module: any, size: any, courseId: number, refresh?: boolean) : Promise<any> {
// Show confirmation if needed.
return this.domUtils.confirmDownloadSize(size).then(() => {
// Invalidate content if refreshing and download the data.
let promise = refresh ? handler.invalidateContent(module.id, courseId) : Promise.resolve();
return promise.catch(() => {
// Ignore errors.
}).then(() => {
return handler.prefetch(module, courseId, true);
});
});
}
/**
* Prefetch one section or all the sections.
* If the section is "All sections" it will prefetch all the sections.
*
* @param {any} section Section.
* @param {number} courseId Course ID the section belongs to.
* @param {any[]} [sections] List of sections. Used when downloading all the sections.
* @return {Promise<any>} Promise resolved when the prefetch is finished.
*/
prefetchSection(section: any, courseId: number, sections?: any[]) : Promise<any> {
if (section.id != CoreCourseProvider.ALL_SECTIONS_ID) {
// Download only this section.
return this.prefetchSingleSectionIfNeeded(section, courseId).then(() => {
// Calculate the status of the section that finished.
return this.calculateSectionStatus(section, courseId);
});
} else {
// Download all the sections except "All sections".
let promises = [],
allSectionsStatus;
section.isDownloading = true;
sections.forEach((section) => {
if (section.id != CoreCourseProvider.ALL_SECTIONS_ID) {
promises.push(this.prefetchSingleSectionIfNeeded(section, courseId).then(() => {
// Calculate the status of the section that finished.
return this.calculateSectionStatus(section, courseId).then((result) => {
// Calculate "All sections" status.
allSectionsStatus = this.filepoolProvider.determinePackagesStatus(allSectionsStatus, result.status);
});
}));
}
});
return this.utils.allPromises(promises).then(() => {
// Set "All sections" data.
section.showDownload = allSectionsStatus === CoreConstants.NOT_DOWNLOADED;
section.showRefresh = allSectionsStatus === CoreConstants.OUTDATED;
section.isDownloading = allSectionsStatus === CoreConstants.DOWNLOADING;
}).finally(() => {
section.isDownloading = false;
});
}
}
/**
* Prefetch a certain section if it needs to be prefetched.
* If the section is "All sections" it will be ignored.
*
* @param {any} section Section to prefetch.
* @param {number} courseId Course ID the section belongs to.
* @return {Promise<any>} Promise resolved when the section is prefetched.
*/
protected prefetchSingleSectionIfNeeded(section: any, courseId: number) : Promise<any> {
if (section.id == CoreCourseProvider.ALL_SECTIONS_ID) {
return Promise.resolve();
}
section.isDownloading = true;
// Validate the section needs to be downloaded and calculate amount of modules that need to be downloaded.
return this.prefetchDelegate.getModulesStatus(section.modules, courseId, section.id).then((result) => {
if (result.status == CoreConstants.DOWNLOADED || result.status == CoreConstants.NOT_DOWNLOADABLE) {
// Section is downloaded or not downloadable, nothing to do.
return;
}
return this.prefetchSingleSection(section, result, courseId);
}, (error) => {
section.isDownloading = false;
return Promise.reject(error);
});
}
/**
* Start or restore the prefetch of a section.
* If the section is "All sections" it will be ignored.
*
* @param {any} section Section to download.
* @param {any} result Result of CoreCourseModulePrefetchDelegate.getModulesStatus for this section.
* @param {number} courseId Course ID the section belongs to.
* @return {Promise<any>} Promise resolved when the section has been prefetched.
*/
protected prefetchSingleSection(section: any, result: any, courseId: number) {
if (section.id == CoreCourseProvider.ALL_SECTIONS_ID) {
return Promise.resolve();
}
if (section.total > 0) {
// Already being downloaded.
return Promise.resolve();
}
// We only download modules with status notdownloaded, downloading or outdated.
let modules = result[CoreConstants.OUTDATED].concat(result[CoreConstants.NOT_DOWNLOADED])
.concat(result[CoreConstants.DOWNLOADING]),
downloadId = this.getSectionDownloadId(section);
section.isDownloading = true;
// We prefetch all the modules to prevent incoeherences in the download count
// and also to download stale data that might not be marked as outdated.
return this.prefetchDelegate.prefetchModules(downloadId, modules, courseId, (data) => {
section.count = data.count;
section.total = data.total;
});
}
/**
* Check if a section has content.
*

147
src/core/course/providers/module-prefetch-delegate.ts
View File

@ -26,6 +26,31 @@ import { CoreCache } from '../../../classes/cache';
import { CoreSiteWSPreSets } from '../../../classes/site';
import { CoreConstants } from '../../constants';
import { Md5 } from 'ts-md5/dist/md5';
import { Subject, BehaviorSubject, Subscription } from 'rxjs';
/**
* Progress of downloading a list of modules.
*/
export type CoreCourseModulesProgress = {
/**
* Number of modules downloaded so far.
* @type {number}
*/
count: number;
/**
* Toal of modules to download.
* @type {number}
*/
total: number;
};
/**
* Progress function for downloading a list of modules.
*
* @param {CoreCourseModulesProgress} data Progress data.
*/
export type CoreCourseModulesProgressFunction = (data: CoreCourseModulesProgress) => void;
/**
* Interface that all course prefetch handlers must implement.
@ -203,9 +228,16 @@ export class CoreCourseModulePrefetchDelegate {
protected statusCache = new CoreCache();
protected lastUpdateHandlersStart: number;
// Promises for check updates and for prefetch.
// Promises for check updates, to prevent performing the same request twice at the same time.
protected courseUpdatesPromises: {[s: string]: {[s: string]: Promise<any>}} = {};
protected prefetchPromises: {[s: string]: {[s: string]: Promise<any>}} = {};
// Promises and observables for prefetching, to prevent downloading the same section twice at the same time
// and notify the progress of the download.
protected prefetchData: {[s: string]: {[s: string]: {
promise: Promise<any>,
observable: Subject<CoreCourseModulesProgress>,
subscriptions: Subscription[]
}}} = {};
constructor(logger: CoreLoggerProvider, private sitesProvider: CoreSitesProvider, private eventsProvider: CoreEventsProvider,
private courseProvider: CoreCourseProvider, private filepoolProvider: CoreFilepoolProvider,
@ -306,16 +338,15 @@ export class CoreCourseModulePrefetchDelegate {
*
* @param {any} module Module.
* @param {string} status Current status.
* @param {boolean} [restoreDownloads] True if it should restore downloads if needed.
* @param {boolean} [canCheck] True if updates can be checked using core_course_check_updates.
* @return {string} Module status.
*/
determineModuleStatus(module: any, status: string, restoreDownloads?: boolean, canCheck?: boolean) : string {
determineModuleStatus(module: any, status: string, canCheck?: boolean) : string {
const handler = this.getPrefetchHandlerFor(module),
siteId = this.sitesProvider.getCurrentSiteId();
if (handler) {
if (status == CoreConstants.DOWNLOADING && restoreDownloads) {
if (status == CoreConstants.DOWNLOADING) {
// Check if the download is being handled.
if (!this.filepoolProvider.getPackageDownloadPromise(siteId, handler.component, module.id)) {
// Not handled, the app was probably restarted or something weird happened.
@ -624,13 +655,10 @@ export class CoreCourseModulePrefetchDelegate {
* @param {any} [updates] Result of getCourseUpdates for all modules in the course. If not provided, it will be
* calculated (slower). If it's false it means the site doesn't support check updates.
* @param {boolean} [refresh] True if it should ignore the cache.
* @param {Boolean} [restoreDownloads] True if it should restore downloads. It's only used if refresh=false,
* if refresh=true then it always tries to restore downloads.
* @param {number} [sectionId] ID of the section the module belongs to.
* @return {Promise<string>} Promise resolved with the status.
*/
getModuleStatus(module: any, courseId: number, updates?: any, refresh?: boolean, restoreDownloads?: boolean, sectionId?: number)
: Promise<string> {
getModuleStatus(module: any, courseId: number, updates?: any, refresh?: boolean, sectionId?: number) : Promise<string> {
let handler = this.getPrefetchHandlerFor(module),
siteId = this.sitesProvider.getCurrentSiteId(),
canCheck = this.canCheckUpdates();
@ -644,7 +672,7 @@ export class CoreCourseModulePrefetchDelegate {
promise;
if (!refresh && typeof status != 'undefined') {
return Promise.resolve(this.determineModuleStatus(module, status, restoreDownloads, canCheck));
return Promise.resolve(this.determineModuleStatus(module, status, canCheck));
}
// Check if the module is downloadable.
@ -694,7 +722,7 @@ export class CoreCourseModulePrefetchDelegate {
}).catch(() => {
// Error checking if module has updates.
const status = this.statusCache.getValue(packageId, 'status', true);
return this.determineModuleStatus(module, status, restoreDownloads, canCheck);
return this.determineModuleStatus(module, status, canCheck);
});
}, () => {
// Error getting updates, show the stored status.
@ -704,9 +732,9 @@ export class CoreCourseModulePrefetchDelegate {
});
}).then((status) => {
if (updateStatus) {
this.updateStatusCache(component, module.id, status, sectionId);
this.updateStatusCache(status, courseId, component, module.id, sectionId);
}
return this.determineModuleStatus(module, status, restoreDownloads, canCheck);
return this.determineModuleStatus(module, status, canCheck);
});
}
@ -722,8 +750,6 @@ export class CoreCourseModulePrefetchDelegate {
* @param {number} courseId Course ID the modules belong to.
* @param {number} [sectionId] ID of the section the modules belong to.
* @param {boolean} [refresh] True if it should always check the DB (slower).
* @param {Boolean} [restoreDownloads] True if it should restore downloads. It's only used if refresh=false,
* if refresh=true then it always tries to restore downloads.
* @return {Promise<any>} Promise resolved with an object with the following properties:
* - status (string) Status of the module.
* - total (number) Number of modules.
@ -732,7 +758,7 @@ export class CoreCourseModulePrefetchDelegate {
* - CoreConstants.DOWNLOADING (any[]) Modules with state DOWNLOADING.
* - CoreConstants.OUTDATED (any[]) Modules with state OUTDATED.
*/
getModulesStatus(modules: any[], courseId: number, sectionId?: number, refresh?: boolean, restoreDownloads?: boolean) : any {
getModulesStatus(modules: any[], courseId: number, sectionId?: number, refresh?: boolean) : any {
let promises = [],
status = CoreConstants.NOT_DOWNLOADABLE,
result: any = {
@ -757,7 +783,7 @@ export class CoreCourseModulePrefetchDelegate {
if (handler) {
let packageId = this.filepoolProvider.getPackageId(handler.component, module.id);
promises.push(this.getModuleStatus(module, courseId, updates, refresh, restoreDownloads).then((modStatus) => {
promises.push(this.getModuleStatus(module, courseId, updates, refresh).then((modStatus) => {
if (modStatus != CoreConstants.NOT_DOWNLOADABLE) {
if (sectionId && sectionId > 0) {
// Store the section ID.
@ -906,7 +932,7 @@ export class CoreCourseModulePrefetchDelegate {
*/
isBeingDownloaded(id: string) : boolean {
const siteId = this.sitesProvider.getCurrentSiteId();
return !!(this.prefetchPromises[siteId] && this.prefetchPromises[siteId][id]);
return !!(this.prefetchData[siteId] && this.prefetchData[siteId][id]);
}
/**
@ -1017,19 +1043,39 @@ export class CoreCourseModulePrefetchDelegate {
* @param {string} id An ID to identify the download. It can be used to retrieve the download promise.
* @param {any[]} modules List of modules to prefetch.
* @param {number} courseId Course ID the modules belong to.
* @param {Function} [onProgress] Function to call everytime a module is downloaded.
* @param {CoreCourseModulesProgressFunction} [onProgress] Function to call everytime a module is downloaded.
* @return {Promise<any>} Promise resolved when all modules have been prefetched.
*/
prefetchModules(id: string, modules: any[], courseId: number, onProgress?: (moduleId: number) => any) : Promise<any> {
prefetchModules(id: string, modules: any[], courseId: number, onProgress?: CoreCourseModulesProgressFunction) : Promise<any> {
const siteId = this.sitesProvider.getCurrentSiteId();
const siteId = this.sitesProvider.getCurrentSiteId(),
currentData = this.prefetchData[siteId] && this.prefetchData[siteId][id];
if (this.prefetchPromises[siteId] && this.prefetchPromises[siteId][id]) {
if (currentData) {
// There's a prefetch ongoing, return the current promise.
return this.prefetchPromises[siteId][id];
if (onProgress) {
currentData.subscriptions.push(currentData.observable.subscribe(onProgress));
}
return currentData.promise;
}
let promises = [];
let promises = [],
count = 0,
total = modules.length,
moduleIds = modules.map((module) => {
return module.id;
});
// Initialize the prefetch data.
const prefetchData = {
observable: new BehaviorSubject<CoreCourseModulesProgress>({count: count, total: total}),
promise: undefined,
subscriptions: []
};
if (onProgress) {
prefetchData.observable.subscribe(onProgress);
}
modules.forEach((module) => {
// Check if the module has a prefetch handler.
@ -1041,23 +1087,34 @@ export class CoreCourseModulePrefetchDelegate {
}
return handler.prefetch(module, courseId).then(() => {
if (onProgress) {
onProgress(module.id);
let index = moduleIds.indexOf(id);
if (index > -1) {
// It's one of the modules we were expecting to download.
moduleIds.splice(index, 1);
count++;
prefetchData.observable.next({count: count, total: total});
}
});
}));
}
});
if (!this.prefetchPromises[siteId]) {
this.prefetchPromises[siteId] = {};
}
this.prefetchPromises[siteId][id] = Promise.all(promises).finally(() => {
delete this.prefetchPromises[siteId][id];
// Set the promise.
prefetchData.promise = Promise.all(promises).finally(() => {
// Unsubscribe all observers.
prefetchData.subscriptions.forEach((subscription: Subscription) => {
subscription.unsubscribe();
});
delete this.prefetchData[siteId][id];
});
return this.prefetchPromises[siteId][id];
// Store the prefetch data in the list.
if (!this.prefetchData[siteId]) {
this.prefetchData[siteId] = {};
}
this.prefetchData[siteId][id] = prefetchData;
return prefetchData.promise;
}
/**
@ -1115,6 +1172,22 @@ export class CoreCourseModulePrefetchDelegate {
});
}
/**
* Set an on progress function for the download of a list of modules.
*
* @param {string} id An ID to identify the download.
* @param {CoreCourseModulesProgressFunction} onProgress Function to call everytime a module is downloaded.
*/
setOnProgress(id: string, onProgress: CoreCourseModulesProgressFunction) : void {
const siteId = this.sitesProvider.getCurrentSiteId(),
currentData = this.prefetchData[siteId] && this.prefetchData[siteId][id];
if (currentData) {
// There's a prefetch ongoing, return the current promise.
currentData.subscriptions.push(currentData.observable.subscribe(onProgress));
}
}
/**
* Treat the result of the check updates WS call.
*
@ -1206,10 +1279,13 @@ export class CoreCourseModulePrefetchDelegate {
/**
* Update the status of a module in the "cache".
*
* @param {string} status New status.
* @param {number} courseId Course ID of the module.
* @param {string} component Package's component.
* @param {string|number} [componentId] An ID to use in conjunction with the component.
* @param {number} [sectionId] Section ID of the module.
*/
updateStatusCache(component: string, componentId: string|number, status: string, sectionId?: number) : void {
updateStatusCache(status: string, courseId: number, component: string, componentId?: string|number, sectionId?: number) : void {
let notify,
packageId = this.filepoolProvider.getPackageId(component, componentId),
cachedStatus = this.statusCache.getValue(packageId, 'status', true);
@ -1230,7 +1306,8 @@ export class CoreCourseModulePrefetchDelegate {
this.statusCache.setValue(packageId, 'sectionId', sectionId);
this.eventsProvider.trigger(CoreEventsProvider.SECTION_STATUS_CHANGED, {
sectionId: sectionId
sectionId: sectionId,
courseId: courseId
}, this.sitesProvider.getCurrentSiteId());
}
} else {

7
src/providers/utils/dom.ts
View File

@ -101,10 +101,11 @@ export class CoreDomUtilsProvider {
* @param {string} [unknownMessage] ID of the message to show if size is unknown.
* @param {number} [wifiThreshold] Threshold to show confirm in WiFi connection. Default: CoreWifiDownloadThreshold.
* @param {number} [limitedThreshold] Threshold to show confirm in limited connection. Default: CoreDownloadThreshold.
* @param {boolean} [alwaysConfirm] True to show a confirm even if the size isn't high, false otherwise.
* @return {Promise<void>} Promise resolved when the user confirms or if no confirm needed.
*/
confirmDownloadSize(size: any, message?: string, unknownMessage?: string, wifiThreshold?: number, limitedThreshold?: number)
: Promise<void> {
confirmDownloadSize(size: any, message?: string, unknownMessage?: string, wifiThreshold?: number, limitedThreshold?: number,
alwaysConfirm?: boolean) : Promise<void> {
wifiThreshold = typeof wifiThreshold == 'undefined' ? CoreConstants.WIFI_DOWNLOAD_THRESHOLD : wifiThreshold;
limitedThreshold = typeof limitedThreshold == 'undefined' ? CoreConstants.DOWNLOAD_THRESHOLD : limitedThreshold;
@ -120,6 +121,8 @@ export class CoreDomUtilsProvider {
message = message || 'core.course.confirmdownload';
let readableSize = this.textUtils.bytesToSize(size.size, 2);
return this.showConfirm(this.translate.instant(message, {size: readableSize}));
} else if (alwaysConfirm) {
return this.showConfirm(this.translate.instant('core.areyousure'));
}
return Promise.resolve();
}