1236 lines
40 KiB
TypeScript
1236 lines
40 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 { CoreError } from '@classes/errors/error';
|
|
import { CoreSite, CoreSiteWSPreSets } from '@classes/site';
|
|
import { CoreCourseCommonModWSOptions } from '@features/course/services/course';
|
|
import { CoreCourseLogHelper } from '@features/course/services/log-helper';
|
|
import { CoreTagItem } from '@features/tag/services/tag';
|
|
import { CoreApp } from '@services/app';
|
|
import { CoreNavigator } from '@services/navigator';
|
|
import { CoreSites, CoreSitesCommonWSOptions, CoreSitesReadingStrategy } from '@services/sites';
|
|
import { CoreUtils } from '@services/utils/utils';
|
|
import { CoreWSExternalFile, CoreWSExternalWarning, CoreWSFile } from '@services/ws';
|
|
import { makeSingleton, Translate } from '@singletons';
|
|
import { CoreEvents } from '@singletons/events';
|
|
import { AddonModWikiPageDBRecord } from './database/wiki';
|
|
import { AddonModWikiOffline } from './wiki-offline';
|
|
import { AddonModWikiAutoSyncData, AddonModWikiManualSyncData, AddonModWikiSyncProvider } from './wiki-sync';
|
|
|
|
const ROOT_CACHE_KEY = 'mmaModWiki:';
|
|
|
|
/**
|
|
* Service that provides some features for wikis.
|
|
*/
|
|
@Injectable({ providedIn: 'root' })
|
|
export class AddonModWikiProvider {
|
|
|
|
static readonly COMPONENT = 'mmaModWiki';
|
|
static readonly PAGE_CREATED_EVENT = 'addon_mod_wiki_page_created';
|
|
static readonly RENEW_LOCK_TIME = 30000; // Milliseconds.
|
|
|
|
protected subwikiListsCache: {[wikiId: number]: AddonModWikiSubwikiListData} = {};
|
|
protected wikiFirstViewedPage: Record<string, Record<number, string>> = {};
|
|
protected editedPage?: AddonModWikiEditedPageData;
|
|
|
|
constructor() {
|
|
// Clear subwiki lists cache on logout.
|
|
CoreEvents.on(CoreEvents.LOGIN, () => {
|
|
this.clearSubwikiList();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Clear subwiki list cache for a certain wiki or all of them.
|
|
*
|
|
* @param wikiId wiki Id, if not provided all will be cleared.
|
|
*/
|
|
clearSubwikiList(wikiId?: number): void {
|
|
if (typeof wikiId == 'undefined') {
|
|
this.subwikiListsCache = {};
|
|
} else {
|
|
delete this.subwikiListsCache[wikiId];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete and return the edited page data if any.
|
|
*
|
|
* @return Edited page data, undefined if no data.
|
|
*/
|
|
consumeEditedPageData(): AddonModWikiEditedPageData | undefined {
|
|
const editedPage = this.editedPage;
|
|
delete this.editedPage;
|
|
|
|
return editedPage;
|
|
}
|
|
|
|
/**
|
|
* Save wiki contents on a page or section.
|
|
*
|
|
* @param pageId Page ID.
|
|
* @param content content to be saved.
|
|
* @param section section to get.
|
|
* @return Promise resolved with the page ID.
|
|
*/
|
|
async editPage(pageId: number, content: string, section?: string, siteId?: string): Promise<number> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
const params: AddonModWikiEditPageWSParams = {
|
|
pageid: pageId,
|
|
content: content,
|
|
};
|
|
|
|
if (section) {
|
|
params.section = section;
|
|
}
|
|
|
|
const response = await site.write<AddonModWikiEditPageWSResponse>('mod_wiki_edit_page', params);
|
|
|
|
return response.pageid;
|
|
}
|
|
|
|
/**
|
|
* Get the first page opened for a wiki in the app if it isn't the current one.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param path Path.
|
|
*/
|
|
getFirstWikiPageOpened(wikiId: number, path: string): string | undefined {
|
|
const tab = CoreNavigator.getMainMenuTabFromPath(path);
|
|
if (!tab) {
|
|
return;
|
|
}
|
|
|
|
if (this.wikiFirstViewedPage[tab] && this.wikiFirstViewedPage[tab][wikiId] !== path) {
|
|
return this.wikiFirstViewedPage[tab][wikiId];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a wiki page contents.
|
|
*
|
|
* @param pageId Page ID.
|
|
* @param options Other options.
|
|
* @return Promise resolved with the page data.
|
|
*/
|
|
async getPageContents(pageId: number, options: CoreCourseCommonModWSOptions = {}): Promise<AddonModWikiPageContents> {
|
|
const site = await CoreSites.getSite(options.siteId);
|
|
|
|
const params: AddonModWikiGetPageContentsWSParams = {
|
|
pageid: pageId,
|
|
};
|
|
const preSets: CoreSiteWSPreSets = {
|
|
cacheKey: this.getPageContentsCacheKey(pageId),
|
|
updateFrequency: CoreSite.FREQUENCY_SOMETIMES,
|
|
component: AddonModWikiProvider.COMPONENT,
|
|
componentId: options.cmId,
|
|
...CoreSites.getReadingStrategyPreSets(options.readingStrategy), // Include reading strategy preSets.
|
|
};
|
|
|
|
const response = await site.read<AddonModWikiGetPageContentsWSResponse>('mod_wiki_get_page_contents', params, preSets);
|
|
|
|
return response.page;
|
|
}
|
|
|
|
/**
|
|
* Get cache key for wiki Pages Contents WS calls.
|
|
*
|
|
* @param pageId Wiki Page ID.
|
|
* @return Cache key.
|
|
*/
|
|
protected getPageContentsCacheKey(pageId: number): string {
|
|
return ROOT_CACHE_KEY + 'page:' + pageId;
|
|
}
|
|
|
|
/**
|
|
* Get a wiki page contents for editing. It does not cache calls.
|
|
*
|
|
* @param pageId Page ID.
|
|
* @param section Section to get.
|
|
* @param lockOnly Just renew lock and not return content.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved with page contents.
|
|
*/
|
|
async getPageForEditing(
|
|
pageId: number,
|
|
section?: string,
|
|
lockOnly?: boolean,
|
|
siteId?: string,
|
|
): Promise<AddonModWikiWSEditPageSection> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
const params: AddonModWikiGetPageForEditingWSParams = {
|
|
pageid: pageId,
|
|
};
|
|
if (section) {
|
|
params.section = section;
|
|
}
|
|
if (lockOnly) {
|
|
params.lockonly = true;
|
|
}
|
|
|
|
const response = await site.write<AddonModWikiGetPageForEditingWSResponse>('mod_wiki_get_page_for_editing', params);
|
|
|
|
return response.pagesection;
|
|
}
|
|
|
|
/**
|
|
* Gets the list of files from a specific subwiki.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param options Other options.
|
|
* @return Promise resolved with subwiki files.
|
|
*/
|
|
async getSubwikiFiles(wikiId: number, options: AddonModWikiGetSubwikiFilesOptions = {}): Promise<CoreWSFile[]> {
|
|
const site = await CoreSites.getSite(options.siteId);
|
|
|
|
const groupId = options.groupId || -1;
|
|
const userId = options.userId || 0;
|
|
|
|
const params: AddonModWikiGetSubwikiFilesWSParams = {
|
|
wikiid: wikiId,
|
|
groupid: groupId,
|
|
userid: userId,
|
|
};
|
|
const preSets: CoreSiteWSPreSets = {
|
|
cacheKey: this.getSubwikiFilesCacheKey(wikiId, groupId, userId),
|
|
updateFrequency: CoreSite.FREQUENCY_SOMETIMES,
|
|
component: AddonModWikiProvider.COMPONENT,
|
|
componentId: options.cmId,
|
|
...CoreSites.getReadingStrategyPreSets(options.readingStrategy), // Include reading strategy preSets.
|
|
};
|
|
|
|
const response = await site.read<AddonModWikiGetSubwikiFilesWSResponse>('mod_wiki_get_subwiki_files', params, preSets);
|
|
|
|
return response.files;
|
|
}
|
|
|
|
/**
|
|
* Get cache key for wiki Subwiki Files WS calls.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param groupId Group ID.
|
|
* @param userId User ID.
|
|
* @return Cache key.
|
|
*/
|
|
protected getSubwikiFilesCacheKey(wikiId: number, groupId: number, userId: number): string {
|
|
return this.getSubwikiFilesCacheKeyPrefix(wikiId) + ':' + groupId + ':' + userId;
|
|
}
|
|
|
|
/**
|
|
* Get cache key for all wiki Subwiki Files WS calls.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @return Cache key.
|
|
*/
|
|
protected getSubwikiFilesCacheKeyPrefix(wikiId: number): string {
|
|
return ROOT_CACHE_KEY + 'subwikifiles:' + wikiId;
|
|
}
|
|
|
|
/**
|
|
* Get a list of subwikis and related data for a certain wiki from the cache.
|
|
*
|
|
* @param wikiId wiki Id
|
|
* @return Subwiki list and related data.
|
|
*/
|
|
getSubwikiList(wikiId: number): AddonModWikiSubwikiListData {
|
|
return this.subwikiListsCache[wikiId];
|
|
}
|
|
|
|
/**
|
|
* Get the list of Pages of a SubWiki.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param options Other options.
|
|
* @return Promise resolved with wiki subwiki pages.
|
|
*/
|
|
async getSubwikiPages(wikiId: number, options: AddonModWikiGetSubwikiPagesOptions = {}): Promise<AddonModWikiSubwikiPage[]> {
|
|
const site = await CoreSites.getSite(options.siteId);
|
|
|
|
const groupId = options.groupId || -1;
|
|
const userId = options.userId || 0;
|
|
const sortBy = options.sortBy || 'title';
|
|
const sortDirection = options.sortDirection || 'ASC';
|
|
|
|
const params: AddonModWikiGetSubwikiPagesWSParams = {
|
|
wikiid: wikiId,
|
|
groupid: groupId,
|
|
userid: userId,
|
|
options: {
|
|
sortby: sortBy,
|
|
sortdirection: sortDirection,
|
|
includecontent: options.includeContent ? 1 : 0,
|
|
},
|
|
};
|
|
const preSets: CoreSiteWSPreSets = {
|
|
cacheKey: this.getSubwikiPagesCacheKey(wikiId, groupId, userId),
|
|
updateFrequency: CoreSite.FREQUENCY_SOMETIMES,
|
|
component: AddonModWikiProvider.COMPONENT,
|
|
componentId: options.cmId,
|
|
...CoreSites.getReadingStrategyPreSets(options.readingStrategy), // Include reading strategy preSets.
|
|
};
|
|
|
|
const response = await site.read<AddonModWikiGetSubwikiPagesWSResponse>('mod_wiki_get_subwiki_pages', params, preSets);
|
|
|
|
return response.pages;
|
|
}
|
|
|
|
/**
|
|
* Get cache key for wiki Subwiki Pages WS calls.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param groupId Group ID.
|
|
* @param userId User ID.
|
|
* @return Cache key.
|
|
*/
|
|
protected getSubwikiPagesCacheKey(wikiId: number, groupId: number, userId: number): string {
|
|
return this.getSubwikiPagesCacheKeyPrefix(wikiId) + ':' + groupId + ':' + userId;
|
|
}
|
|
|
|
/**
|
|
* Get cache key for all wiki Subwiki Pages WS calls.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @return Cache key.
|
|
*/
|
|
protected getSubwikiPagesCacheKeyPrefix(wikiId: number): string {
|
|
return ROOT_CACHE_KEY + 'subwikipages:' + wikiId;
|
|
}
|
|
|
|
/**
|
|
* Get all the subwikis of a wiki.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param options Other options.
|
|
* @return Promise resolved with subwikis.
|
|
*/
|
|
async getSubwikis(wikiId: number, options: CoreCourseCommonModWSOptions = {}): Promise<AddonModWikiSubwiki[]> {
|
|
const site = await CoreSites.getSite(options.siteId);
|
|
|
|
const params: AddonModWikiGetSubwikisWSParams = {
|
|
wikiid: wikiId,
|
|
};
|
|
const preSets = {
|
|
cacheKey: this.getSubwikisCacheKey(wikiId),
|
|
updateFrequency: CoreSite.FREQUENCY_RARELY,
|
|
component: AddonModWikiProvider.COMPONENT,
|
|
componentId: options.cmId,
|
|
...CoreSites.getReadingStrategyPreSets(options.readingStrategy), // Include reading strategy preSets.
|
|
};
|
|
|
|
const response = await site.read<AddonModWikiGetSubwikisWSResponse>('mod_wiki_get_subwikis', params, preSets);
|
|
|
|
return response.subwikis.map(subwiki => ({
|
|
...subwiki,
|
|
groupid: Number(subwiki.groupid), // Convert groupid to number.
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* Get cache key for get wiki subWikis WS calls.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @return Cache key.
|
|
*/
|
|
protected getSubwikisCacheKey(wikiId: number): string {
|
|
return ROOT_CACHE_KEY + 'subwikis:' + wikiId;
|
|
}
|
|
|
|
/**
|
|
* Get a wiki by module ID.
|
|
*
|
|
* @param courseId Course ID.
|
|
* @param cmId Course module ID.
|
|
* @param options Other options.
|
|
* @return Promise resolved when the wiki is retrieved.
|
|
*/
|
|
getWiki(courseId: number, cmId: number, options: CoreSitesCommonWSOptions = {}): Promise<AddonModWikiWiki> {
|
|
return this.getWikiByField(courseId, 'coursemodule', cmId, options);
|
|
}
|
|
|
|
/**
|
|
* Get a wiki 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 wiki is retrieved.
|
|
*/
|
|
protected async getWikiByField(
|
|
courseId: number,
|
|
key: string,
|
|
value: unknown,
|
|
options: CoreSitesCommonWSOptions = {},
|
|
): Promise<AddonModWikiWiki> {
|
|
const site = await CoreSites.getSite(options.siteId);
|
|
|
|
const params: AddonModWikiGetWikisByCoursesWSParams = {
|
|
courseids: [courseId],
|
|
};
|
|
const preSets: CoreSiteWSPreSets = {
|
|
cacheKey: this.getWikiDataCacheKey(courseId),
|
|
updateFrequency: CoreSite.FREQUENCY_RARELY,
|
|
component: AddonModWikiProvider.COMPONENT,
|
|
...CoreSites.getReadingStrategyPreSets(options.readingStrategy), // Include reading strategy preSets.
|
|
};
|
|
|
|
const response = await site.read<AddonModWikiGetWikisByCoursesWSResponse>('mod_wiki_get_wikis_by_courses', params, preSets);
|
|
|
|
const currentWiki = response.wikis.find((wiki) => wiki[key] == value);
|
|
if (currentWiki) {
|
|
return currentWiki;
|
|
}
|
|
|
|
throw new CoreError(Translate.instant('core.course.modulenotfound'));
|
|
}
|
|
|
|
/**
|
|
* Get a wiki by wiki ID.
|
|
*
|
|
* @param courseId Course ID.
|
|
* @param id Wiki ID.
|
|
* @param options Other options.
|
|
* @return Promise resolved when the wiki is retrieved.
|
|
*/
|
|
getWikiById(courseId: number, id: number, options: CoreSitesCommonWSOptions = {}): Promise<AddonModWikiWiki> {
|
|
return this.getWikiByField(courseId, 'id', id, options);
|
|
}
|
|
|
|
/**
|
|
* Get cache key for wiki data WS calls.
|
|
*
|
|
* @param courseId Course ID.
|
|
* @return Cache key.
|
|
*/
|
|
protected getWikiDataCacheKey(courseId: number): string {
|
|
return ROOT_CACHE_KEY + 'wiki:' + courseId;
|
|
}
|
|
|
|
/**
|
|
* Gets a list of files to download for a wiki, using a format similar to module.contents from get_course_contents.
|
|
*
|
|
* @param wiki Wiki.
|
|
* @param options Other options.
|
|
* @return Promise resolved with the list of files.
|
|
*/
|
|
async getWikiFileList(wiki: AddonModWikiWiki, options: CoreSitesCommonWSOptions = {}): Promise<CoreWSFile[]> {
|
|
options.siteId = options.siteId || CoreSites.getCurrentSiteId();
|
|
|
|
let files: CoreWSFile[] = [];
|
|
const modOptions = {
|
|
cmId: wiki.coursemodule,
|
|
...options, // Include all options.
|
|
};
|
|
|
|
const subwikis = await this.getSubwikis(wiki.id, modOptions);
|
|
|
|
await Promise.all(subwikis.map(async (subwiki) => {
|
|
const subwikiOptions = {
|
|
groupId: subwiki.groupid,
|
|
userId: subwiki.userid,
|
|
...modOptions, // Include all options.
|
|
};
|
|
|
|
const subwikiFiles = await this.getSubwikiFiles(subwiki.wikiid, subwikiOptions);
|
|
|
|
files = files.concat(subwikiFiles);
|
|
}));
|
|
|
|
return files;
|
|
}
|
|
|
|
/**
|
|
* Gets a list of all pages for a Wiki.
|
|
*
|
|
* @param wiki Wiki.
|
|
* @param options Other options.
|
|
* @return Page list.
|
|
*/
|
|
async getWikiPageList(wiki: AddonModWikiWiki, options: CoreSitesCommonWSOptions = {}): Promise<AddonModWikiSubwikiPage[]> {
|
|
options.siteId = options.siteId || CoreSites.getCurrentSiteId();
|
|
|
|
let pages: AddonModWikiSubwikiPage[] = [];
|
|
const modOptions = {
|
|
cmId: wiki.coursemodule,
|
|
...options, // Include all options.
|
|
};
|
|
|
|
const subwikis = await this.getSubwikis(wiki.id, modOptions);
|
|
|
|
await Promise.all(subwikis.map(async (subwiki) => {
|
|
const subwikiPages = await this.getSubwikiPages(subwiki.wikiid, {
|
|
groupId: subwiki.groupid,
|
|
userId: subwiki.userid,
|
|
...modOptions, // Include all options.
|
|
});
|
|
|
|
pages = pages.concat(subwikiPages);
|
|
}));
|
|
|
|
return pages;
|
|
}
|
|
|
|
/**
|
|
* Invalidate the prefetched content except files.
|
|
* To invalidate files, use invalidateFiles.
|
|
*
|
|
* @param moduleId The module ID.
|
|
* @param courseId Course ID.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when done.
|
|
*/
|
|
async invalidateContent(moduleId: number, courseId: number, siteId?: string): Promise<void> {
|
|
siteId = siteId || CoreSites.getCurrentSiteId();
|
|
|
|
const wiki = await this.getWiki(courseId, moduleId, { siteId });
|
|
|
|
await Promise.all([
|
|
this.invalidateWikiData(courseId, siteId),
|
|
this.invalidateSubwikis(wiki.id, siteId),
|
|
this.invalidateSubwikiPages(wiki.id, siteId),
|
|
this.invalidateSubwikiFiles(wiki.id, siteId),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Invalidates page content WS call for a certain page.
|
|
*
|
|
* @param pageId Wiki Page ID.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the data is invalidated.
|
|
*/
|
|
async invalidatePage(pageId: number, siteId?: string): Promise<void> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
await site.invalidateWsCacheForKey(this.getPageContentsCacheKey(pageId));
|
|
}
|
|
|
|
/**
|
|
* Invalidates all the subwiki files WS calls for a certain wiki.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the data is invalidated.
|
|
*/
|
|
async invalidateSubwikiFiles(wikiId: number, siteId?: string): Promise<void> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
await site.invalidateWsCacheForKeyStartingWith(this.getSubwikiFilesCacheKeyPrefix(wikiId));
|
|
}
|
|
|
|
/**
|
|
* Invalidates all the subwiki pages WS calls for a certain wiki.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the data is invalidated.
|
|
*/
|
|
async invalidateSubwikiPages(wikiId: number, siteId?: string): Promise<void> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
await site.invalidateWsCacheForKeyStartingWith(this.getSubwikiPagesCacheKeyPrefix(wikiId));
|
|
}
|
|
|
|
/**
|
|
* Invalidates all the get subwikis WS calls for a certain wiki.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the data is invalidated.
|
|
*/
|
|
async invalidateSubwikis(wikiId: number, siteId?: string): Promise<void> {
|
|
this.clearSubwikiList(wikiId);
|
|
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
await site.invalidateWsCacheForKey(this.getSubwikisCacheKey(wikiId));
|
|
}
|
|
|
|
/**
|
|
* Invalidates wiki data.
|
|
*
|
|
* @param courseId Course ID.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the data is invalidated.
|
|
*/
|
|
async invalidateWikiData(courseId: number, siteId?: string): Promise<void> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
await site.invalidateWsCacheForKey(this.getWikiDataCacheKey(courseId));
|
|
}
|
|
|
|
/**
|
|
* Check if a page title is already used.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param subwikiId Subwiki ID.
|
|
* @param title Page title.
|
|
* @param options Other options.
|
|
* @return Promise resolved with true if used, resolved with false if not used or cannot determine.
|
|
*/
|
|
async isTitleUsed(
|
|
wikiId: number,
|
|
subwikiId: number,
|
|
title: string,
|
|
options: CoreCourseCommonModWSOptions = {},
|
|
): Promise<boolean> {
|
|
try {
|
|
// First get the subwiki.
|
|
const subwikis = await this.getSubwikis(wikiId, options);
|
|
|
|
// Search the subwiki.
|
|
const subwiki = subwikis.find((subwiki) => subwiki.id == subwikiId);
|
|
|
|
if (!subwiki) {
|
|
return false;
|
|
}
|
|
|
|
// Now get all the pages of the subwiki.
|
|
const pages = await this.getSubwikiPages(wikiId, {
|
|
groupId: subwiki.groupid,
|
|
userId: subwiki.userid,
|
|
...options, // Include all options.
|
|
});
|
|
|
|
// Check if there's any page with the same title.
|
|
const page = pages.find((page) => page.title == title);
|
|
|
|
return !!page;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Report a wiki page as being viewed.
|
|
*
|
|
* @param id Page ID.
|
|
* @param wikiId Wiki ID.
|
|
* @param name Name of the wiki.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the WS call is successful.
|
|
*/
|
|
logPageView(id: number, wikiId: number, name?: string, siteId?: string): Promise<void> {
|
|
const params: AddonModWikiViewPageWSParams = {
|
|
pageid: id,
|
|
};
|
|
|
|
return CoreCourseLogHelper.logSingle(
|
|
'mod_wiki_view_page',
|
|
params,
|
|
AddonModWikiProvider.COMPONENT,
|
|
wikiId,
|
|
name,
|
|
'wiki',
|
|
params,
|
|
siteId,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Report the wiki as being viewed.
|
|
*
|
|
* @param id Wiki ID.
|
|
* @param name Name of the wiki.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the WS call is successful.
|
|
*/
|
|
logView(id: number, name?: string, siteId?: string): Promise<void> {
|
|
const params: AddonModWikiViewWikiWSParams = {
|
|
wikiid: id,
|
|
};
|
|
|
|
return CoreCourseLogHelper.logSingle(
|
|
'mod_wiki_view_wiki',
|
|
params,
|
|
AddonModWikiProvider.COMPONENT,
|
|
id,
|
|
name,
|
|
'wiki',
|
|
{},
|
|
siteId,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Create a new page on a subwiki.
|
|
*
|
|
* @param title Title to create the page.
|
|
* @param content Content to save on the page.
|
|
* @param options Other options.
|
|
* @return Promise resolved with page ID if page was created in server, -1 if stored in device.
|
|
*/
|
|
async newPage(title: string, content: string, options: AddonModWikiNewPageOptions = {}): Promise<number> {
|
|
|
|
options.siteId = options.siteId || CoreSites.getCurrentSiteId();
|
|
|
|
// Convenience function to store a new page to be synchronized later.
|
|
const storeOffline = async (): Promise<number> => {
|
|
if (options.wikiId && options.subwikiId) {
|
|
// We have wiki ID, check if there's already an online page with this title and subwiki.
|
|
const used = await CoreUtils.ignoreErrors(this.isTitleUsed(options.wikiId, options.subwikiId, title, {
|
|
cmId: options.cmId,
|
|
readingStrategy: CoreSitesReadingStrategy.PREFER_CACHE,
|
|
siteId: options.siteId,
|
|
}));
|
|
|
|
if (used) {
|
|
throw new CoreError(Translate.instant('addon.mod_wiki.pageexists'));
|
|
}
|
|
}
|
|
|
|
await AddonModWikiOffline.saveNewPage(
|
|
title,
|
|
content,
|
|
options.subwikiId,
|
|
options.wikiId,
|
|
options.userId,
|
|
options.groupId,
|
|
options.siteId,
|
|
);
|
|
|
|
return -1;
|
|
};
|
|
|
|
if (!CoreApp.isOnline()) {
|
|
// App is offline, store the action.
|
|
return storeOffline();
|
|
}
|
|
|
|
// Discard stored content for this page. If it exists it means the user is editing it.
|
|
await AddonModWikiOffline.deleteNewPage(
|
|
title,
|
|
options.subwikiId,
|
|
options.wikiId,
|
|
options.userId,
|
|
options.groupId,
|
|
options.siteId,
|
|
);
|
|
|
|
try {
|
|
// Try to create it in online.
|
|
return this.newPageOnline(title, content, options);
|
|
} catch (error) {
|
|
if (CoreUtils.isWebServiceError(error)) {
|
|
// The WebService has thrown an error, this means that the page cannot be added.
|
|
throw error;
|
|
}
|
|
|
|
// Couldn't connect to server, store in offline.
|
|
return storeOffline();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a new page on a subwiki. It will fail if offline or cannot connect.
|
|
*
|
|
* @param title Title to create the page.
|
|
* @param content Content to save on the page.
|
|
* @param options Other options.
|
|
* @return Promise resolved with the page ID if created, rejected otherwise.
|
|
*/
|
|
async newPageOnline(title: string, content: string, options: AddonModWikiNewPageOnlineOptions = {}): Promise<number> {
|
|
const site = await CoreSites.getSite(options.siteId);
|
|
|
|
const params: AddonModWikiNewPageWSParams = {
|
|
title: title,
|
|
content: content,
|
|
contentformat: 'html',
|
|
};
|
|
|
|
const subwikiId = AddonModWikiOffline.convertToPositiveNumber(options.subwikiId);
|
|
const wikiId = AddonModWikiOffline.convertToPositiveNumber(options.wikiId);
|
|
|
|
if (subwikiId && subwikiId > 0) {
|
|
params.subwikiid = subwikiId;
|
|
} else if (wikiId) {
|
|
params.wikiid = wikiId;
|
|
params.userid = AddonModWikiOffline.convertToPositiveNumber(options.userId);
|
|
params.groupid = AddonModWikiOffline.convertToPositiveNumber(options.groupId);
|
|
}
|
|
|
|
const response = await site.write<AddonModWikiNewPageWSResponse>('mod_wiki_new_page', params);
|
|
|
|
return response.pageid;
|
|
}
|
|
|
|
/**
|
|
* Set edited page data.
|
|
*
|
|
* @param data Data.
|
|
*/
|
|
setEditedPageData(data: AddonModWikiEditedPageData): void {
|
|
this.editedPage = data;
|
|
}
|
|
|
|
/**
|
|
* Save subwiki list for a wiki to the cache.
|
|
*
|
|
* @param wikiId Wiki Id.
|
|
* @param subwikis List of subwikis.
|
|
* @param count Number of subwikis in the subwikis list.
|
|
* @param subwikiId Subwiki Id currently selected.
|
|
* @param userId User Id currently selected.
|
|
* @param groupId Group Id currently selected.
|
|
*/
|
|
setSubwikiList(
|
|
wikiId: number,
|
|
subwikis: AddonModWikiSubwikiListGrouping[],
|
|
count: number,
|
|
subwikiId: number,
|
|
userId: number,
|
|
groupId: number,
|
|
): void {
|
|
this.subwikiListsCache[wikiId] = {
|
|
count: count,
|
|
subwikiSelected: subwikiId,
|
|
userSelected: userId,
|
|
groupSelected: groupId,
|
|
subwikis: subwikis,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Sort an array of wiki pages by title.
|
|
*
|
|
* @param pages Pages to sort.
|
|
* @param desc True to sort in descendent order, false to sort in ascendent order. Defaults to false.
|
|
* @return Sorted pages.
|
|
*/
|
|
sortPagesByTitle<T extends AddonModWikiSubwikiPage | AddonModWikiPageDBRecord>(
|
|
pages: T[],
|
|
desc?: boolean,
|
|
): T[] {
|
|
return pages.sort((a, b) => {
|
|
let result = a.title >= b.title ? 1 : -1;
|
|
|
|
if (desc) {
|
|
result = -result;
|
|
}
|
|
|
|
return result;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Check if a wiki has a certain subwiki.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param subwikiId Subwiki ID to search.
|
|
* @param options Other options.
|
|
* @return Promise resolved with true if it has subwiki, resolved with false otherwise.
|
|
*/
|
|
async wikiHasSubwiki(wikiId: number, subwikiId: number, options: CoreCourseCommonModWSOptions = {}): Promise<boolean> {
|
|
try {
|
|
// Get the subwikis to check if any of them matches the one passed as param.
|
|
const subwikis = await this.getSubwikis(wikiId, options);
|
|
|
|
const subwiki = subwikis.find((subwiki) => subwiki.id == subwikiId);
|
|
|
|
return !!subwiki;
|
|
} catch {
|
|
// Not found, return false.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If this page is the first opened page for a wiki, remove the stored path so it's no longer the first viewed page.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param path Path.
|
|
*/
|
|
wikiPageClosed(wikiId: number, path: string): void {
|
|
const tab = CoreNavigator.getMainMenuTabFromPath(path);
|
|
if (!tab) {
|
|
return;
|
|
}
|
|
|
|
this.wikiFirstViewedPage[tab] = this.wikiFirstViewedPage[tab] || {};
|
|
|
|
if (this.wikiFirstViewedPage[tab][wikiId] === path) {
|
|
delete this.wikiFirstViewedPage[tab][wikiId];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If this page is the first opened page for a wiki, save its path so we can go back to it.
|
|
*
|
|
* @param wikiId Wiki ID.
|
|
* @param path Path.
|
|
*/
|
|
wikiPageOpened(wikiId: number, path: string): void {
|
|
const tab = CoreNavigator.getMainMenuTabFromPath(path);
|
|
if (!tab) {
|
|
return;
|
|
}
|
|
|
|
this.wikiFirstViewedPage[tab] = this.wikiFirstViewedPage[tab] || {};
|
|
|
|
if (this.wikiFirstViewedPage[tab][wikiId]) {
|
|
// There's already an opened page for this wiki.
|
|
return;
|
|
}
|
|
|
|
this.wikiFirstViewedPage[tab][wikiId] = path;
|
|
}
|
|
|
|
}
|
|
|
|
export const AddonModWiki = makeSingleton(AddonModWikiProvider);
|
|
|
|
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 {
|
|
[AddonModWikiProvider.PAGE_CREATED_EVENT]: AddonModWikiPageCreatedData;
|
|
[AddonModWikiSyncProvider.AUTO_SYNCED]: AddonModWikiAutoSyncData;
|
|
[AddonModWikiSyncProvider.MANUAL_SYNCED]: AddonModWikiManualSyncData;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Options to pass to getSubwikiFiles.
|
|
*/
|
|
export type AddonModWikiGetSubwikiFilesOptions = CoreCourseCommonModWSOptions & {
|
|
userId?: number; // User to get files from.
|
|
groupId?: number; // Group to get files from.
|
|
};
|
|
|
|
/**
|
|
* Options to pass to getSubwikiPages.
|
|
*/
|
|
export type AddonModWikiGetSubwikiPagesOptions = CoreCourseCommonModWSOptions & {
|
|
userId?: number; // User to get pages from.
|
|
groupId?: number; // Group to get pages from.
|
|
sortBy?: string; // The attribute to sort the returned list. Defaults to 'title'.
|
|
sortDirection?: string; // Direction to sort the returned list (ASC | DESC). Defaults to 'ASC'.
|
|
includeContent?: boolean; // Whether the pages have to include their content.
|
|
};
|
|
|
|
/**
|
|
* Options to pass to newPageOnline.
|
|
*/
|
|
export type AddonModWikiNewPageOnlineOptions = {
|
|
subwikiId?: number; // Subwiki ID. If not defined, wikiId, userId and groupId should be defined.
|
|
wikiId?: number; // Wiki ID. Optional, will be used to create a new subwiki if subwikiId not supplied.
|
|
userId?: number; // User ID. Optional, will be used to create a new subwiki if subwikiId not supplied.
|
|
groupId?: number; // Group ID. Optional, will be used to create a new subwiki if subwikiId not supplied.
|
|
siteId?: string; // Site ID. If not defined, current site.
|
|
};
|
|
|
|
/**
|
|
* Options to pass to newPage.
|
|
*/
|
|
export type AddonModWikiNewPageOptions = AddonModWikiNewPageOnlineOptions & {
|
|
cmId?: number; // Module ID.
|
|
};
|
|
|
|
export type AddonModWikiSubwikiListData = {
|
|
count: number; // Number of subwikis.
|
|
subwikiSelected: number; // Subwiki ID currently selected.
|
|
userSelected: number; // User of the subwiki currently selected.
|
|
groupSelected: number; // Group of the subwiki currently selected.
|
|
subwikis: AddonModWikiSubwikiListGrouping[]; // List of subwikis, grouped by a certain label.
|
|
};
|
|
|
|
export type AddonModWikiSubwikiListGrouping = {
|
|
label: string;
|
|
subwikis: AddonModWikiSubwikiListSubwiki[];
|
|
};
|
|
|
|
export type AddonModWikiSubwikiListSubwiki = {
|
|
name: string;
|
|
id: number;
|
|
userid: number;
|
|
groupid: number;
|
|
groupLabel: string;
|
|
canedit: boolean;
|
|
};
|
|
|
|
/**
|
|
* Params of mod_wiki_edit_page WS.
|
|
*/
|
|
export type AddonModWikiEditPageWSParams = {
|
|
pageid: number; // Page ID.
|
|
content: string; // Page contents.
|
|
section?: string; // Section page title.
|
|
};
|
|
|
|
/**
|
|
* Data returned by mod_wiki_edit_page WS.
|
|
*/
|
|
export type AddonModWikiEditPageWSResponse = {
|
|
pageid: number; // Edited page id.
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Params of mod_wiki_get_page_contents WS.
|
|
*/
|
|
export type AddonModWikiGetPageContentsWSParams = {
|
|
pageid: number; // Page ID.
|
|
};
|
|
|
|
/**
|
|
* Data returned by mod_wiki_get_page_contents WS.
|
|
*/
|
|
export type AddonModWikiGetPageContentsWSResponse = {
|
|
page: AddonModWikiPageContents; // Page.
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Page data returned by mod_wiki_get_page_contents WS.
|
|
*/
|
|
export type AddonModWikiPageContents = {
|
|
id: number; // Page ID.
|
|
wikiid: number; // Page's wiki ID.
|
|
subwikiid: number; // Page's subwiki ID.
|
|
groupid: number; // Page's group ID.
|
|
userid: number; // Page's user ID.
|
|
title: string; // Page title.
|
|
cachedcontent: string; // Page contents.
|
|
contentformat?: number; // Cachedcontent format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
|
|
caneditpage: boolean; // True if user can edit the page.
|
|
version?: number; // Latest version of the page.
|
|
tags?: CoreTagItem[]; // Tags.
|
|
};
|
|
|
|
/**
|
|
* Params of mod_wiki_get_page_for_editing WS.
|
|
*/
|
|
export type AddonModWikiGetPageForEditingWSParams = {
|
|
pageid: number; // Page ID to edit.
|
|
section?: string; // Section page title.
|
|
lockonly?: boolean; // Just renew lock and not return content.
|
|
};
|
|
|
|
/**
|
|
* Data returned by mod_wiki_get_page_for_editing WS.
|
|
*/
|
|
export type AddonModWikiGetPageForEditingWSResponse = {
|
|
pagesection: AddonModWikiWSEditPageSection;
|
|
};
|
|
|
|
/**
|
|
* Page section data returned by mod_wiki_get_page_for_editing WS.
|
|
*/
|
|
export type AddonModWikiWSEditPageSection = {
|
|
content?: string; // The contents of the page-section to be edited.
|
|
contentformat?: string; // Format of the original content of the page.
|
|
version: number; // Latest version of the page.
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Params of mod_wiki_get_subwiki_files WS.
|
|
*/
|
|
export type AddonModWikiGetSubwikiFilesWSParams = {
|
|
wikiid: number; // Wiki instance ID.
|
|
groupid?: number; // Subwiki's group ID, -1 means current group. It will be ignored if the wiki doesn't use groups.
|
|
userid?: number; // Subwiki's user ID, 0 means current user. It will be ignored in collaborative wikis.
|
|
};
|
|
|
|
/**
|
|
* Data returned by mod_wiki_get_subwiki_files WS.
|
|
*/
|
|
export type AddonModWikiGetSubwikiFilesWSResponse = {
|
|
files: CoreWSExternalFile[];
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Params of mod_wiki_get_subwiki_pages WS.
|
|
*/
|
|
export type AddonModWikiGetSubwikiPagesWSParams = {
|
|
wikiid: number; // Wiki instance ID.
|
|
groupid?: number; // Subwiki's group ID, -1 means current group. It will be ignored if the wiki doesn't use groups.
|
|
userid?: number; // Subwiki's user ID, 0 means current user. It will be ignored in collaborative wikis.
|
|
options?: {
|
|
sortby?: string; // Field to sort by (id, title, ...).
|
|
sortdirection?: string; // Sort direction: ASC or DESC.
|
|
includecontent?: number; // Include each page contents or just the contents size.
|
|
}; // Options.
|
|
};
|
|
|
|
/**
|
|
* Data returned by mod_wiki_get_subwiki_pages WS.
|
|
*/
|
|
export type AddonModWikiGetSubwikiPagesWSResponse = {
|
|
pages: AddonModWikiSubwikiPage[];
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Page data returned by mod_wiki_get_subwiki_pages WS.
|
|
*/
|
|
export type AddonModWikiSubwikiPage = {
|
|
id: number; // Page ID.
|
|
subwikiid: number; // Page's subwiki ID.
|
|
title: string; // Page title.
|
|
timecreated: number; // Time of creation.
|
|
timemodified: number; // Time of last modification.
|
|
timerendered: number; // Time of last renderization.
|
|
userid: number; // ID of the user that last modified the page.
|
|
pageviews: number; // Number of times the page has been viewed.
|
|
readonly: number; // 1 if readonly, 0 otherwise.
|
|
caneditpage: boolean; // True if user can edit the page.
|
|
firstpage: boolean; // True if it's the first page.
|
|
cachedcontent?: string; // Page contents.
|
|
contentformat?: number; // Cachedcontent format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
|
|
contentsize?: number; // Size of page contents in bytes (doesn't include size of attached files).
|
|
tags?: CoreTagItem[]; // Tags.
|
|
};
|
|
|
|
/**
|
|
* Params of mod_wiki_get_subwikis WS.
|
|
*/
|
|
export type AddonModWikiGetSubwikisWSParams = {
|
|
wikiid: number; // Wiki instance ID.
|
|
};
|
|
|
|
/**
|
|
* Data returned by mod_wiki_get_subwikis WS.
|
|
*/
|
|
export type AddonModWikiGetSubwikisWSResponse = {
|
|
subwikis: AddonModWikiSubwikiWSData[];
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Subwiki data returned by mod_wiki_get_subwikis WS.
|
|
*/
|
|
export type AddonModWikiSubwikiWSData = {
|
|
id: number; // Subwiki ID.
|
|
wikiid: number; // Wiki ID.
|
|
groupid: string; // Group ID.
|
|
userid: number; // User ID.
|
|
canedit: boolean; // True if user can edit the subwiki.
|
|
};
|
|
|
|
/**
|
|
* Subwiki data with some calculated data.
|
|
*/
|
|
export type AddonModWikiSubwiki = Omit<AddonModWikiSubwikiWSData, 'groupid'> & {
|
|
groupid: number; // Group ID.
|
|
};
|
|
|
|
/**
|
|
* Params of mod_wiki_get_wikis_by_courses WS.
|
|
*/
|
|
export type AddonModWikiGetWikisByCoursesWSParams = {
|
|
courseids?: number[]; // Array of course ids.
|
|
};
|
|
|
|
/**
|
|
* Data returned by mod_wiki_get_wikis_by_courses WS.
|
|
*/
|
|
export type AddonModWikiGetWikisByCoursesWSResponse = {
|
|
wikis: AddonModWikiWiki[];
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Wiki data returned by mod_wiki_get_wikis_by_courses WS.
|
|
*/
|
|
export type AddonModWikiWiki = {
|
|
id: number; // Wiki ID.
|
|
coursemodule: number; // Course module ID.
|
|
course: number; // Course ID.
|
|
name: string; // Wiki name.
|
|
intro?: string; // Wiki intro.
|
|
introformat?: number; // Wiki intro format. format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
|
|
introfiles?: CoreWSExternalFile[];
|
|
timecreated?: number; // Time of creation.
|
|
timemodified?: number; // Time of last modification.
|
|
firstpagetitle?: string; // First page title.
|
|
wikimode?: string; // Wiki mode (individual, collaborative).
|
|
defaultformat?: string; // Wiki's default format (html, creole, nwiki).
|
|
forceformat?: number; // 1 if format is forced, 0 otherwise.
|
|
editbegin?: number; // Edit begin.
|
|
editend?: number; // Edit end.
|
|
section?: number; // Course section ID.
|
|
visible?: number; // 1 if visible, 0 otherwise.
|
|
groupmode?: number; // Group mode.
|
|
groupingid?: number; // Group ID.
|
|
cancreatepages: boolean; // True if user can create pages.
|
|
};
|
|
|
|
/**
|
|
* Params of mod_wiki_view_page WS.
|
|
*/
|
|
export type AddonModWikiViewPageWSParams = {
|
|
pageid: number; // Wiki page ID.
|
|
};
|
|
|
|
/**
|
|
* Params of mod_wiki_view_wiki WS.
|
|
*/
|
|
export type AddonModWikiViewWikiWSParams = {
|
|
wikiid: number; // Wiki instance ID.
|
|
};
|
|
|
|
/**
|
|
* Params of mod_wiki_new_page WS.
|
|
*/
|
|
export type AddonModWikiNewPageWSParams = {
|
|
title: string; // New page title.
|
|
content: string; // Page contents.
|
|
contentformat?: string; // Page contents format. If an invalid format is provided, default wiki format is used.
|
|
subwikiid?: number; // Page's subwiki ID.
|
|
wikiid?: number; // Page's wiki ID. Used if subwiki does not exists.
|
|
userid?: number; // Subwiki's user ID. Used if subwiki does not exists.
|
|
groupid?: number; // Subwiki's group ID. Used if subwiki does not exists.
|
|
};
|
|
|
|
/**
|
|
* Data returned by mod_wiki_new_page WS.
|
|
*/
|
|
export type AddonModWikiNewPageWSResponse = {
|
|
pageid: number; // New page id.
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Data passed to PAGE_CREATED event.
|
|
*/
|
|
export type AddonModWikiPageCreatedData = {
|
|
pageId: number;
|
|
subwikiId: number;
|
|
pageTitle: string;
|
|
};
|
|
|
|
/**
|
|
* Data about a page that was just edited.
|
|
*/
|
|
export type AddonModWikiEditedPageData = {
|
|
cmId?: number;
|
|
courseId?: number;
|
|
wikiId: number;
|
|
pageTitle: string;
|
|
subwikiId?: number;
|
|
userId?: number;
|
|
groupId?: number;
|
|
pageId?: number;
|
|
};
|