466 lines
16 KiB
TypeScript
466 lines
16 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 { Http, Response } from '@angular/http';
|
|
import { CoreFileProvider } from '@providers/file';
|
|
import { CoreFilepoolProvider } from '@providers/filepool';
|
|
import { CoreLoggerProvider } from '@providers/logger';
|
|
import { CoreSitesProvider } from '@providers/sites';
|
|
import { CoreDomUtilsProvider } from '@providers/utils/dom';
|
|
import { CoreTextUtilsProvider } from '@providers/utils/text';
|
|
import { CoreUtilsProvider } from '@providers/utils/utils';
|
|
import { CoreCourseProvider } from '@core/course/providers/course';
|
|
import { CoreCourseLogHelperProvider } from '@core/course/providers/log-helper';
|
|
import { CoreSite } from '@classes/site';
|
|
import { CoreTagItem } from '@core/tag/providers/tag';
|
|
import { CoreWSExternalWarning, CoreWSExternalFile } from '@providers/ws';
|
|
|
|
/**
|
|
* Service that provides some features for books.
|
|
*/
|
|
@Injectable()
|
|
export class AddonModBookProvider {
|
|
static COMPONENT = 'mmaModBook';
|
|
|
|
protected ROOT_CACHE_KEY = 'mmaModBook:';
|
|
protected logger;
|
|
|
|
constructor(logger: CoreLoggerProvider, private sitesProvider: CoreSitesProvider, private textUtils: CoreTextUtilsProvider,
|
|
private fileProvider: CoreFileProvider, private filepoolProvider: CoreFilepoolProvider, private http: Http,
|
|
private utils: CoreUtilsProvider, private courseProvider: CoreCourseProvider, private domUtils: CoreDomUtilsProvider,
|
|
private logHelper: CoreCourseLogHelperProvider) {
|
|
this.logger = logger.getInstance('AddonModBookProvider');
|
|
}
|
|
|
|
/**
|
|
* Get a book by course module ID.
|
|
*
|
|
* @param courseId Course ID.
|
|
* @param cmId Course module ID.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the book is retrieved.
|
|
*/
|
|
getBook(courseId: number, cmId: number, siteId?: string): Promise<AddonModBookBook> {
|
|
return this.getBookByField(courseId, 'coursemodule', cmId, siteId);
|
|
}
|
|
|
|
/**
|
|
* Get a book 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 siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the book is retrieved.
|
|
*/
|
|
protected getBookByField(courseId: number, key: string, value: any, siteId?: string): Promise<AddonModBookBook> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
const params = {
|
|
courseids: [courseId]
|
|
},
|
|
preSets = {
|
|
cacheKey: this.getBookDataCacheKey(courseId),
|
|
updateFrequency: CoreSite.FREQUENCY_RARELY
|
|
};
|
|
|
|
return site.read('mod_book_get_books_by_courses', params, preSets)
|
|
.then((response: AddonModBookGetBooksByCoursesResult): any => {
|
|
|
|
// Search the book.
|
|
if (response && response.books) {
|
|
const book = response.books.find((book) => book[key] == value);
|
|
if (book) {
|
|
return book;
|
|
}
|
|
}
|
|
|
|
return Promise.reject(null);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get cache key for get book data WS calls.
|
|
*
|
|
* @param courseId Course ID.
|
|
* @return Cache key.
|
|
*/
|
|
protected getBookDataCacheKey(courseId: number): string {
|
|
return this.ROOT_CACHE_KEY + 'book:' + courseId;
|
|
}
|
|
|
|
/**
|
|
* Gets a chapter contents.
|
|
*
|
|
* @param contentsMap Contents map returned by getContentsMap.
|
|
* @param chapterId Chapter to retrieve.
|
|
* @param moduleId The module ID.
|
|
* @return Promise resolved with the contents.
|
|
*/
|
|
getChapterContent(contentsMap: AddonModBookContentsMap, chapterId: string, moduleId: number): Promise<string> {
|
|
const indexUrl = contentsMap[chapterId] ? contentsMap[chapterId].indexUrl : undefined,
|
|
siteId = this.sitesProvider.getCurrentSiteId();
|
|
let promise;
|
|
|
|
if (!indexUrl) {
|
|
// It shouldn't happen.
|
|
this.logger.debug('Could not locate the index chapter');
|
|
|
|
return Promise.reject(null);
|
|
}
|
|
|
|
if (this.fileProvider.isAvailable()) {
|
|
promise = this.filepoolProvider.downloadUrl(siteId, indexUrl, false, AddonModBookProvider.COMPONENT, moduleId);
|
|
} else {
|
|
// We return the live URL.
|
|
return this.sitesProvider.getCurrentSite().checkAndFixPluginfileURL(indexUrl);
|
|
}
|
|
|
|
return promise.then((url) => {
|
|
// Fetch the URL content.
|
|
const promise = this.http.get(url).toPromise();
|
|
|
|
return promise.then((response: Response): any => {
|
|
const content = response.text();
|
|
if (typeof content !== 'string') {
|
|
return Promise.reject(null);
|
|
} else {
|
|
// Now that we have the content, we update the SRC to point back to the external resource.
|
|
return this.domUtils.restoreSourcesInHtml(content, contentsMap[chapterId].paths);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Convert an array of book contents into an object where contents are organized in chapters.
|
|
* Each chapter has an indexUrl and the list of contents in that chapter.
|
|
*
|
|
* @param contents The module contents.
|
|
* @return Contents map.
|
|
*/
|
|
getContentsMap(contents: any[]): AddonModBookContentsMap {
|
|
const map: AddonModBookContentsMap = {};
|
|
|
|
if (!contents) {
|
|
return map;
|
|
}
|
|
|
|
contents.forEach((content) => {
|
|
if (this.isFileDownloadable(content)) {
|
|
let chapter,
|
|
matches,
|
|
split,
|
|
filepathIsChapter,
|
|
key;
|
|
|
|
// Search the chapter number in the filepath.
|
|
matches = content.filepath.match(/\/(\d+)\//);
|
|
if (matches && matches[1]) {
|
|
chapter = matches[1];
|
|
filepathIsChapter = content.filepath == '/' + chapter + '/';
|
|
|
|
// Init the chapter if it's not defined yet.
|
|
map[chapter] = map[chapter] || { paths: {} };
|
|
|
|
if (content.filename == 'index.html' && filepathIsChapter) {
|
|
// Index of the chapter, set indexUrl and tags of the chapter.
|
|
map[chapter].indexUrl = content.fileurl;
|
|
map[chapter].tags = content.tags;
|
|
} else {
|
|
if (filepathIsChapter) {
|
|
// It's a file in the root folder OR the WS isn't returning the filepath as it should (MDL-53671).
|
|
// Try to get the path to the file from the URL.
|
|
split = content.fileurl.split('mod_book/chapter' + content.filepath);
|
|
key = split[1] || content.filename; // Use filename if we couldn't find the path.
|
|
} else {
|
|
// Remove the chapter folder from the path and add the filename.
|
|
key = content.filepath.replace('/' + chapter + '/', '') + content.filename;
|
|
}
|
|
|
|
map[chapter].paths[this.textUtils.decodeURIComponent(key)] = content.fileurl;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
return map;
|
|
}
|
|
|
|
/**
|
|
* Get the first chapter of a book.
|
|
*
|
|
* @param chapters The chapters list.
|
|
* @return The chapter id.
|
|
*/
|
|
getFirstChapter(chapters: AddonModBookTocChapter[]): string {
|
|
if (!chapters || !chapters.length) {
|
|
return;
|
|
}
|
|
|
|
return chapters[0].id;
|
|
}
|
|
|
|
/**
|
|
* Get the next chapter to the given one.
|
|
*
|
|
* @param chapters The chapters list.
|
|
* @param chapterId The current chapter.
|
|
* @return The next chapter id.
|
|
*/
|
|
getNextChapter(chapters: AddonModBookTocChapter[], chapterId: string): string {
|
|
let next = '0';
|
|
|
|
for (let i = 0; i < chapters.length; i++) {
|
|
if (chapters[i].id == chapterId) {
|
|
if (typeof chapters[i + 1] != 'undefined') {
|
|
next = chapters[i + 1].id;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return next;
|
|
}
|
|
|
|
/**
|
|
* Get the previous chapter to the given one.
|
|
*
|
|
* @param chapters The chapters list.
|
|
* @param chapterId The current chapter.
|
|
* @return The next chapter id.
|
|
*/
|
|
getPreviousChapter(chapters: AddonModBookTocChapter[], chapterId: string): string {
|
|
let previous = '0';
|
|
|
|
for (let i = 0; i < chapters.length; i++) {
|
|
if (chapters[i].id == chapterId) {
|
|
break;
|
|
}
|
|
previous = chapters[i].id;
|
|
}
|
|
|
|
return previous;
|
|
}
|
|
|
|
/**
|
|
* Get the book toc as an array.
|
|
*
|
|
* @param contents The module contents.
|
|
* @return The toc.
|
|
*/
|
|
getToc(contents: any[]): any[] {
|
|
if (!contents || !contents.length) {
|
|
return [];
|
|
}
|
|
|
|
return this.textUtils.parseJSON(contents[0].content, []);
|
|
}
|
|
|
|
/**
|
|
* Get the book toc as an array of chapters (not nested).
|
|
*
|
|
* @param contents The module contents.
|
|
* @return The toc as a list.
|
|
*/
|
|
getTocList(contents: any[]): AddonModBookTocChapter[] {
|
|
// Convenience function to get chapter info.
|
|
const getChapterInfo = (chapter: any, chapterNumber: number, previousNumber: string = ''): AddonModBookTocChapter => {
|
|
chapter.hidden = !!parseInt(chapter.hidden, 10);
|
|
|
|
const fullChapterNumber = previousNumber + (chapter.hidden ? 'x.' : chapterNumber + '.');
|
|
|
|
return {
|
|
id: chapter.href.replace('/index.html', ''),
|
|
title: chapter.title,
|
|
level: chapter.level,
|
|
number: fullChapterNumber,
|
|
hidden: chapter.hidden
|
|
};
|
|
};
|
|
|
|
const chapters = [],
|
|
toc = this.getToc(contents);
|
|
|
|
let chapterNumber = 1;
|
|
toc.forEach((chapter) => {
|
|
const tocChapter = getChapterInfo(chapter, chapterNumber);
|
|
|
|
// Add the chapter to the list.
|
|
chapters.push(tocChapter);
|
|
|
|
if (chapter.subitems) {
|
|
let subChapterNumber = 1;
|
|
// Add all the subchapters to the list.
|
|
chapter.subitems.forEach((subChapter) => {
|
|
chapters.push(getChapterInfo(subChapter, subChapterNumber, tocChapter.number));
|
|
subChapterNumber++;
|
|
});
|
|
}
|
|
|
|
chapterNumber++;
|
|
});
|
|
|
|
return chapters;
|
|
}
|
|
|
|
/**
|
|
* Invalidates book data.
|
|
*
|
|
* @param courseId Course ID.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the data is invalidated.
|
|
*/
|
|
invalidateBookData(courseId: number, siteId?: string): Promise<any> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
return site.invalidateWsCacheForKey(this.getBookDataCacheKey(courseId));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Invalidate the prefetched content.
|
|
*
|
|
* @param moduleId The module ID.
|
|
* @param courseId Course ID of the module.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the data is invalidated.
|
|
*/
|
|
invalidateContent(moduleId: number, courseId: number, siteId?: string): Promise<any> {
|
|
siteId = siteId || this.sitesProvider.getCurrentSiteId();
|
|
|
|
const promises = [];
|
|
|
|
promises.push(this.invalidateBookData(courseId, siteId));
|
|
promises.push(this.filepoolProvider.invalidateFilesByComponent(siteId, AddonModBookProvider.COMPONENT, moduleId));
|
|
promises.push(this.courseProvider.invalidateModule(moduleId, siteId));
|
|
|
|
return this.utils.allPromises(promises);
|
|
}
|
|
|
|
/**
|
|
* Check if a file is downloadable. The file param must have a 'type' attribute like in core_course_get_contents response.
|
|
*
|
|
* @param file File to check.
|
|
* @return Whether it's downloadable.
|
|
*/
|
|
isFileDownloadable(file: any): boolean {
|
|
return file.type === 'file';
|
|
}
|
|
|
|
/**
|
|
* Return whether or not the plugin is enabled.
|
|
*
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved with true if plugin is enabled, rejected or resolved with false otherwise.
|
|
*/
|
|
isPluginEnabled(siteId?: string): Promise<boolean> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
return site.canDownloadFiles();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Report a book as being viewed.
|
|
*
|
|
* @param id Module ID.
|
|
* @param chapterId Chapter ID.
|
|
* @param name Name of the book.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the WS call is successful.
|
|
*/
|
|
logView(id: number, chapterId: string, name?: string, siteId?: string): Promise<any> {
|
|
const params = {
|
|
bookid: id,
|
|
chapterid: chapterId
|
|
};
|
|
|
|
return this.logHelper.logSingle('mod_book_view_book', params, AddonModBookProvider.COMPONENT, id, name, 'book',
|
|
{chapterid: chapterId}, siteId);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A book chapter inside the toc list.
|
|
*/
|
|
export interface AddonModBookTocChapter {
|
|
/**
|
|
* ID to identify the chapter.
|
|
*/
|
|
id: string;
|
|
|
|
/**
|
|
* Chapter's title.
|
|
*/
|
|
title: string;
|
|
|
|
/**
|
|
* The chapter's level.
|
|
*/
|
|
level: number;
|
|
|
|
/**
|
|
* The chapter is hidden.
|
|
*/
|
|
hidden: boolean;
|
|
|
|
/**
|
|
* The chapter's number'.
|
|
*/
|
|
number: string;
|
|
}
|
|
|
|
/**
|
|
* Map of book contents. For each chapter it has its index URL and the list of paths of the files the chapter has. Each path
|
|
* is identified by the relative path in the book, and the value is the URL of the file.
|
|
*/
|
|
export type AddonModBookContentsMap = {
|
|
[chapter: string]: {
|
|
indexUrl?: string,
|
|
paths: {[path: string]: string},
|
|
tags?: CoreTagItem[]
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Book returned by mod_book_get_books_by_courses.
|
|
*/
|
|
export type AddonModBookBook = {
|
|
id: number; // Book id.
|
|
coursemodule: number; // Course module id.
|
|
course: number; // Course id.
|
|
name: string; // Book name.
|
|
intro: string; // The Book intro.
|
|
introformat: number; // Intro format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
|
|
introfiles?: CoreWSExternalFile[]; // @since 3.2.
|
|
numbering: number; // Book numbering configuration.
|
|
navstyle: number; // Book navigation style configuration.
|
|
customtitles: number; // Book custom titles type.
|
|
revision?: number; // Book revision.
|
|
timecreated?: number; // Time of creation.
|
|
timemodified?: number; // Time of last modification.
|
|
section?: number; // Course section id.
|
|
visible?: boolean; // Visible.
|
|
groupmode?: number; // Group mode.
|
|
groupingid?: number; // Group id.
|
|
};
|
|
|
|
/**
|
|
* Result of WS mod_book_get_books_by_courses.
|
|
*/
|
|
export type AddonModBookGetBooksByCoursesResult = {
|
|
books: AddonModBookBook[];
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|