1097 lines
39 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 { Component, Optional, Input, OnInit, OnDestroy } from '@angular/core';
import { Params } from '@angular/router';
import { CoreError } from '@classes/errors/error';
import { CoreCourseModuleMainActivityComponent } from '@features/course/classes/main-activity-component';
import { CoreCourseContentsPage } from '@features/course/pages/contents/contents';
import { CoreCourse } from '@features/course/services/course';
import { CoreTag, CoreTagItem } from '@features/tag/services/tag';
import { CoreUser } from '@features/user/services/user';
import { IonContent } from '@ionic/angular';
import { CoreNetwork } from '@services/network';
import { CoreGroup, CoreGroups } from '@services/groups';
import { CoreNavigator } from '@services/navigator';
import { CoreSites } from '@services/sites';
import { CoreDomUtils } from '@services/utils/dom';
import { CoreUtils } from '@services/utils/utils';
import { Translate, NgZone } from '@singletons';
import { CoreEventObserver, CoreEvents } from '@singletons/events';
import { CorePath } from '@singletons/path';
import { Subscription } from 'rxjs';
import { Md5 } from 'ts-md5';
import { AddonModWikiPageDBRecord } from '../../services/database/wiki';
import { AddonModWikiModuleHandlerService } from '../../services/handlers/module';
import {
AddonModWiki,
AddonModWikiPageContents,
AddonModWikiProvider,
AddonModWikiSubwiki,
AddonModWikiSubwikiListData,
AddonModWikiSubwikiListGrouping,
AddonModWikiSubwikiListSubwiki,
AddonModWikiSubwikiPage,
AddonModWikiWiki,
} from '../../services/wiki';
import { AddonModWikiOffline } from '../../services/wiki-offline';
import {
AddonModWikiAutoSyncData,
AddonModWikiSync,
AddonModWikiSyncProvider,
AddonModWikiSyncWikiResult,
AddonModWikiSyncWikiSubwiki,
} from '../../services/wiki-sync';
import { AddonModWikiMapModalComponent, AddonModWikiMapModalReturn } from '../map/map';
import { AddonModWikiSubwikiPickerComponent } from '../subwiki-picker/subwiki-picker';
/**
* Component that displays a wiki entry page.
*/
@Component({
selector: 'addon-mod-wiki-index',
templateUrl: 'addon-mod-wiki-index.html',
styleUrls: ['index.scss'],
})
export class AddonModWikiIndexComponent extends CoreCourseModuleMainActivityComponent implements OnInit, OnDestroy {
@Input() action?: string;
@Input() pageId?: number;
@Input() pageTitle?: string;
@Input() subwikiId?: number;
@Input() userId?: number;
@Input() groupId?: number;
component = AddonModWikiProvider.COMPONENT;
componentId?: number;
moduleName = 'wiki';
groupWiki = false;
isOnline = false;
wiki?: AddonModWikiWiki; // The wiki instance.
isMainPage = false; // Whether the user is viewing wiki's main page (just entered the wiki).
canEdit = false; // Whether user can edit the page.
pageStr = '';
pageWarning?: string; // Message telling that the page was discarded.
loadedSubwikis: AddonModWikiSubwiki[] = []; // The loaded subwikis.
pageIsOffline = false; // Whether the loaded page is an offline page.
pageContent?: string; // Page content to display.
tagsEnabled = false;
currentPageObj?: AddonModWikiPageContents | AddonModWikiPageDBRecord; // Object of the current loaded page.
tags: CoreTagItem[] = [];
subwikiData: AddonModWikiSubwikiListData = { // Data for the subwiki selector.
subwikiSelected: 0,
userSelected: 0,
groupSelected: 0,
subwikis: [],
count: 0,
};
protected syncEventName = AddonModWikiSyncProvider.AUTO_SYNCED;
protected currentSubwiki?: AddonModWikiSubwiki; // Current selected subwiki.
protected currentPage?: number; // Current loaded page ID.
protected subwikiPages?: (AddonModWikiSubwikiPage | AddonModWikiPageDBRecord)[]; // List of subwiki pages.
protected newPageObserver?: CoreEventObserver; // Observer to check for new pages.
protected manualSyncObserver?: CoreEventObserver; // An observer to watch for manual sync events.
protected ignoreManualSyncEvent = false; // Whether manual sync event should be ignored.
protected currentUserId?: number; // Current user ID.
protected currentPath!: string;
protected onlineSubscription: Subscription; // It will observe the status of the network connection.
constructor(
protected content?: IonContent,
@Optional() courseContentsPage?: CoreCourseContentsPage,
) {
super('AddonModLessonIndexComponent', content, courseContentsPage);
this.isOnline = CoreNetwork.isOnline();
// Refresh online status when changes.
this.onlineSubscription = CoreNetwork.onChange().subscribe(() => {
// Execute the callback in the Angular zone, so change detection doesn't stop working.
NgZone.run(() => {
this.isOnline = CoreNetwork.isOnline();
});
});
}
/**
* @inheritdoc
*/
async ngOnInit(): Promise<void> {
super.ngOnInit();
this.pageStr = Translate.instant('addon.mod_wiki.wikipage');
this.tagsEnabled = CoreTag.areTagsAvailableInSite();
this.currentUserId = CoreSites.getCurrentSiteUserId();
this.isMainPage = !this.pageId && !this.pageTitle;
this.currentPage = this.pageId;
this.currentPath = CoreNavigator.getCurrentPath();
this.listenEvents();
try {
await this.loadContent(false, true);
} finally {
if (this.action == 'map') {
this.openMap();
}
}
}
/**
* Listen to events.
*/
protected listenEvents(): void {
// Listen for manual sync events.
this.manualSyncObserver = CoreEvents.on(AddonModWikiSyncProvider.MANUAL_SYNCED, (data) => {
if (!data || !this.wiki || data.wikiId != this.wiki.id) {
return;
}
if (this.ignoreManualSyncEvent) {
// Event needs to be ignored.
this.ignoreManualSyncEvent = false;
return;
}
if (this.currentSubwiki) {
this.checkPageCreatedOrDiscarded(data.subwikis[this.currentSubwiki.id]);
}
if (!this.pageWarning) {
this.showLoadingAndFetch(false, false);
}
}, this.siteId);
}
/**
* Check if the current page was created or discarded.
*
* @param data Data about created and deleted pages.
*/
protected checkPageCreatedOrDiscarded(data?: AddonModWikiSyncWikiSubwiki): void {
if (this.currentPage || !data) {
return;
}
// This is an offline page. Check if the page was created.
const page = data.created.find((page) => page.title == this.pageTitle);
if (page) {
// Page was created, set the ID so it's retrieved from server.
this.currentPage = page.pageId;
this.pageIsOffline = false;
} else {
// Page not found in created list, check if it was discarded.
const page = data.discarded.find((page) => page.title == this.pageTitle);
if (page) {
// Page discarded, show warning.
this.pageWarning = page.warning;
this.pageContent = '';
this.pageIsOffline = false;
this.hasOffline = false;
}
}
}
/**
* @inheritdoc
*/
protected async fetchContent(refresh?: boolean, sync = false, showErrors = false): Promise<void> {
try {
// Get the wiki instance.
this.wiki = await AddonModWiki.getWiki(this.courseId, this.module.id);
if (this.pageContent === undefined) {
// Page not loaded yet, emit the data to update the page title.
this.dataRetrieved.emit(this.wiki);
}
AddonModWiki.wikiPageOpened(this.wiki.id, this.currentPath);
if (sync) {
// Try to synchronize the wiki.
await CoreUtils.ignoreErrors(this.syncActivity(showErrors));
}
if (this.pageWarning) {
// Page discarded, stop getting data.
return;
}
// Get module instance if it's empty.
if (!this.module.id) {
this.module = await CoreCourse.getModule(this.wiki.coursemodule, this.wiki.course, undefined, true);
}
this.description = this.wiki.intro || this.module.description;
this.componentId = this.module.id;
await this.fetchSubwikis(this.wiki.id);
// Get the subwiki list data from the cache.
const subwikiList = AddonModWiki.getSubwikiList(this.wiki.id);
if (!subwikiList) {
// Not found in cache, create a new one.
// Get real groupmode, in case it's forced by the course.
const groupInfo = await CoreGroups.getActivityGroupInfo(this.wiki.coursemodule);
if (groupInfo.separateGroups && !groupInfo.groups.length) {
throw new CoreError(Translate.instant('addon.mod_wiki.cannotviewpage'));
}
await this.createSubwikiList(groupInfo.groups);
} else {
this.subwikiData.count = subwikiList.count;
this.setSelectedWiki(this.subwikiId, this.userId, this.groupId);
// If nothing was selected using nav params, use the selected from cache.
if (!this.isAnySubwikiSelected()) {
this.setSelectedWiki(subwikiList.subwikiSelected, subwikiList.userSelected, subwikiList.groupSelected);
}
this.subwikiData.subwikis = subwikiList.subwikis;
}
if (!this.isAnySubwikiSelected() || this.subwikiData.count <= 0) {
throw new CoreError(Translate.instant('addon.mod_wiki.errornowikiavailable'));
}
await this.fetchWikiPage();
} catch (error) {
if (this.pageWarning) {
// Warning is already shown in screen, no need to show a modal.
return;
}
throw error;
}
}
/**
* Get wiki page contents.
*
* @param pageId Page to get.
* @return Promise resolved with the page data.
*/
protected async fetchPageContents(pageId: number): Promise<AddonModWikiPageContents>;
protected async fetchPageContents(): Promise<AddonModWikiPageDBRecord | undefined>;
protected async fetchPageContents(pageId?: number): Promise<AddonModWikiPageContents | AddonModWikiPageDBRecord | undefined>;
protected async fetchPageContents(pageId?: number): Promise<AddonModWikiPageContents | AddonModWikiPageDBRecord | undefined> {
if (pageId) {
// Online page.
this.pageIsOffline = false;
return AddonModWiki.getPageContents(pageId, { cmId: this.module.id });
}
// No page ID but we received a title. This means we're trying to load an offline page.
try {
const title = this.pageTitle || this.wiki?.firstpagetitle || '';
const offlinePage = await AddonModWikiOffline.getNewPage(
title,
this.currentSubwiki?.id,
this.currentSubwiki?.wikiid,
this.currentSubwiki?.userid,
this.currentSubwiki?.groupid,
);
this.pageIsOffline = true;
if (!this.newPageObserver) {
// It's an offline page, listen for new pages event to detect if the user goes to Edit and submits the page.
this.newPageObserver = CoreEvents.on(AddonModWikiProvider.PAGE_CREATED_EVENT, async (data) => {
if (data.subwikiId != this.currentSubwiki?.id || data.pageTitle != title) {
return;
}
// The page has been submitted. Get the page from the server.
this.currentPage = data.pageId;
// Stop listening for new page events.
this.newPageObserver?.off();
this.newPageObserver = undefined;
await this.showLoadingAndFetch(true, false);
if (this.currentPage && this.wiki) {
CoreUtils.ignoreErrors(AddonModWiki.logPageView(this.currentPage, this.wiki.id, this.wiki.name));
}
}, CoreSites.getCurrentSiteId());
}
return offlinePage;
} catch {
// Page not found, ignore.
}
}
/**
* Fetch the list of pages of a subwiki.
*
* @param subwiki Subwiki.
*/
protected async fetchSubwikiPages(subwiki: AddonModWikiSubwiki): Promise<void> {
const subwikiPages = await AddonModWiki.getSubwikiPages(subwiki.wikiid, {
groupId: subwiki.groupid,
userId: subwiki.userid,
cmId: this.module.id,
});
if (!this.currentPage) {
if (!this.pageTitle) {
// No page specified, search first page.
const firstPage = subwikiPages.find((page) => page.firstpage );
if (firstPage) {
this.currentPage = firstPage.id;
this.pageTitle = firstPage.title;
}
} else {
// Got the page title but not its ID. Search the page.
const page = subwikiPages.find((page) => page.title === this.pageTitle );
if (page) {
this.currentPage = page.id;
}
}
}
// Now get the offline pages.
const dbPages = await AddonModWikiOffline.getSubwikiNewPages(subwiki.id, subwiki.wikiid, subwiki.userid, subwiki.groupid);
// If no page specified, search page title in the offline pages.
if (!this.currentPage) {
const searchTitle = this.pageTitle ? this.pageTitle : this.wiki?.firstpagetitle ?? '';
const pageExists = dbPages.some((page) => page.title == searchTitle);
if (pageExists) {
this.pageTitle = searchTitle;
}
}
this.subwikiPages = AddonModWiki.sortPagesByTitle(
(<(AddonModWikiSubwikiPage | AddonModWikiPageDBRecord)[]> subwikiPages).concat(dbPages),
);
// Reject if no currentPage selected from the subwikis given (if no subwikis available, do not reject).
if (!this.currentPage && !this.pageTitle && this.subwikiPages.length > 0) {
throw new CoreError();
}
}
/**
* Get the subwikis.
*
* @param wikiId Wiki ID.
*/
protected async fetchSubwikis(wikiId: number): Promise<void> {
this.loadedSubwikis = await AddonModWiki.getSubwikis(wikiId, { cmId: this.module.id });
this.hasOffline = await AddonModWikiOffline.subwikisHaveOfflineData(this.loadedSubwikis);
}
/**
* Fetch the page to be shown.
*
* @return Promise resolved when done.
*/
protected async fetchWikiPage(): Promise<void> {
// Search the current Subwiki.
this.currentSubwiki = this.loadedSubwikis.find((subwiki) => this.isSubwikiSelected(subwiki));
if (!this.currentSubwiki) {
throw new CoreError();
}
this.setSelectedWiki(this.currentSubwiki.id, this.currentSubwiki.userid, this.currentSubwiki.groupid);
await this.fetchSubwikiPages(this.currentSubwiki);
// Check can edit before to have the value if there's no valid page.
this.canEdit = this.currentSubwiki.canedit;
const pageContents = await this.fetchPageContents(this.currentPage);
if (pageContents) {
this.setSelectedWiki(pageContents.subwikiid, pageContents.userid, pageContents.groupid);
this.pageTitle = pageContents.title;
this.pageContent = this.replaceEditLinks(pageContents.cachedcontent);
this.canEdit = !!pageContents.caneditpage;
this.currentPageObj = pageContents;
this.tags = ('tags' in pageContents && pageContents.tags) || [];
}
}
/**
* @inheritdoc
*/
protected async logActivity(): Promise<void> {
if (!this.wiki) {
return; // Shouldn't happen.
}
if (!this.pageId) {
await AddonModWiki.logView(this.wiki.id, this.wiki.name);
} else {
this.checkCompletionAfterLog = false;
CoreUtils.ignoreErrors(AddonModWiki.logPageView(this.pageId, this.wiki.id, this.wiki.name));
}
}
/**
* @inheritdoc
*/
protected async storeModuleViewed(): Promise<void> {
// Only store module viewed when viewing the main page.
if (!this.pageId) {
await super.storeModuleViewed();
}
}
/**
* Get path to the wiki home view. If cannot determine or it's current view, return undefined.
*
* @return The path of the home view
*/
protected getWikiHomeView(): string | undefined {
if (!this.wiki) {
return;
}
return AddonModWiki.getFirstWikiPageOpened(this.wiki.id, this.currentPath);
}
/**
* Open the view to create the first page of the wiki.
*/
protected goToCreateFirstPage(): void {
CoreNavigator.navigateToSitePath(
`${AddonModWikiModuleHandlerService.PAGE_NAME}/${this.courseId}/${this.module.id}/edit`,
{
params: {
pageTitle: this.wiki?.firstpagetitle ?? '',
wikiId: this.currentSubwiki?.wikiid,
userId: this.currentSubwiki?.userid,
groupId: this.currentSubwiki?.groupid,
},
},
);
}
/**
* Open the view to edit the current page.
*/
goToEditPage(): void {
if (!this.canEdit) {
return;
}
if (this.currentPageObj) {
// Current page exists, go to edit it.
const pageParams: Params = {
pageTitle: this.currentPageObj.title,
subwikiId: this.currentPageObj.subwikiid,
};
if ('id' in this.currentPageObj) {
pageParams.pageId = this.currentPageObj.id;
}
if (this.currentSubwiki) {
pageParams.wikiId = this.currentSubwiki.wikiid;
pageParams.userId = this.currentSubwiki.userid;
pageParams.groupId = this.currentSubwiki.groupid;
}
CoreNavigator.navigateToSitePath(
`${AddonModWikiModuleHandlerService.PAGE_NAME}/${this.courseId}/${this.module.id}/edit`,
{ params: pageParams },
);
} else if (this.currentSubwiki) {
// No page loaded, the wiki doesn't have first page.
this.goToCreateFirstPage();
}
}
/**
* Go to the view to create a new page.
*/
goToNewPage(): void {
if (!this.canEdit) {
return;
}
if (this.currentPageObj) {
// Current page exists, go to edit it.
const pageParams: Params = {
subwikiId: this.currentPageObj.subwikiid,
};
if (this.currentSubwiki) {
pageParams.wikiId = this.currentSubwiki.wikiid;
pageParams.userId = this.currentSubwiki.userid;
pageParams.groupId = this.currentSubwiki.groupid;
}
CoreNavigator.navigateToSitePath(
`${AddonModWikiModuleHandlerService.PAGE_NAME}/${this.courseId}/${this.module.id}/edit`,
{ params: pageParams },
);
} else if (this.currentSubwiki) {
// No page loaded, the wiki doesn't have first page.
this.goToCreateFirstPage();
}
}
/**
* Go to view a certain page.
*
* @param page Page to view.
*/
protected async goToPage(page: AddonModWikiSubwikiPage | AddonModWikiPageDBRecord): Promise<void> {
if (!('id' in page)) {
// It's an offline page. Check if we are already in the same offline page.
if (this.currentPage || !this.pageTitle || page.title != this.pageTitle) {
this.openPageOrSubwiki({
pageTitle: page.title,
subwikiId: page.subwikiid,
});
}
} else if (this.currentPage != page.id) {
// Add a new State.
const pageContents = await this.fetchPageContents(page.id);
this.openPageOrSubwiki({
pageTitle: pageContents.title,
pageId: pageContents.id,
subwikiId: page.subwikiid,
});
}
}
/**
* Open a page or a subwiki in the current wiki.
*
* @param options Options
* @return Promise.
*/
protected async openPageOrSubwiki(options: AddonModWikiOpenPageOptions): Promise<void> {
const hash = <string> Md5.hashAsciiStr(JSON.stringify({
...options,
timestamp: Date.now(),
}));
CoreNavigator.navigateToSitePath(
`${AddonModWikiModuleHandlerService.PAGE_NAME}/${this.courseId}/${this.module.id}/page/${hash}`,
{
params: {
module: this.module,
...options,
},
},
);
}
/**
* Show the map.
*/
async openMap(): Promise<void> {
// Create the toc modal.
const modalData = await CoreDomUtils.openSideModal<AddonModWikiMapModalReturn>({
component: AddonModWikiMapModalComponent,
componentProps: {
pages: this.subwikiPages,
homeView: this.getWikiHomeView(),
moduleId: this.module.id,
courseId: this.courseId,
selectedTitle: this.currentPageObj && this.currentPageObj.title,
},
});
if (modalData) {
if (modalData.home) {
// Go back to the initial page of the wiki.
CoreNavigator.navigateToSitePath(modalData.home, { animationDirection: 'back' });
} else if (modalData.page) {
this.goToPage(modalData.page);
}
}
}
/**
* Go to the page to view a certain subwiki.
*
* @param subwikiId Subwiki ID.
* @param userId User ID of the subwiki.
* @param groupId Group ID of the subwiki.
*/
goToSubwiki(subwikiId: number, userId: number, groupId: number): void {
if (
subwikiId !== this.currentSubwiki?.id ||
userId !== this.currentSubwiki?.userid ||
groupId !== this.currentSubwiki?.groupid
) {
this.openPageOrSubwiki({
subwikiId: subwikiId,
userId: userId,
groupId: groupId,
});
}
}
/**
* Checks if there is any subwiki selected.
*
* @return Whether there is any subwiki selected.
*/
protected isAnySubwikiSelected(): boolean {
return this.subwikiData.subwikiSelected > 0 || this.subwikiData.userSelected > 0 || this.subwikiData.groupSelected > 0;
}
/**
* Checks if the given subwiki is the one picked on the subwiki picker.
*
* @param subwiki Subwiki to check.
* @return Whether it's the selected subwiki.
*/
protected isSubwikiSelected(subwiki: AddonModWikiSubwiki): boolean {
if (subwiki.id > 0 && this.subwikiData.subwikiSelected > 0) {
return subwiki.id == this.subwikiData.subwikiSelected;
}
return subwiki.userid == this.subwikiData.userSelected && subwiki.groupid == this.subwikiData.groupSelected;
}
/**
* Replace edit links to have full url.
*
* @param content Content to treat.
* @return Treated content.
*/
protected replaceEditLinks(content: string): string {
content = content.trim();
if (content.length > 0) {
const editUrl = CorePath.concatenatePaths(CoreSites.getRequiredCurrentSite().getURL(), '/mod/wiki/edit.php');
content = content.replace(/href="edit\.php/g, 'href="' + editUrl);
}
return content;
}
/**
* Sets the selected subwiki for the subwiki picker.
*
* @param subwikiId Subwiki ID to select.
* @param userId User ID of the subwiki to select.
* @param groupId Group ID of the subwiki to select.
*/
protected setSelectedWiki(subwikiId: number | undefined, userId: number | undefined, groupId: number | undefined): void {
this.subwikiData.subwikiSelected = AddonModWikiOffline.convertToPositiveNumber(subwikiId);
this.subwikiData.userSelected = AddonModWikiOffline.convertToPositiveNumber(userId);
this.subwikiData.groupSelected = AddonModWikiOffline.convertToPositiveNumber(groupId);
}
/**
* Checks if sync has succeed from result sync data.
*
* @param result Data returned on the sync function.
* @return If suceed or not.
*/
protected hasSyncSucceed(result: AddonModWikiSyncWikiResult | undefined): boolean {
if (!result) {
return false;
}
if (result.updated && this.wiki) {
// Trigger event.
this.ignoreManualSyncEvent = true;
CoreEvents.trigger(AddonModWikiSyncProvider.MANUAL_SYNCED, {
...result,
wikiId: this.wiki.id,
});
}
if (this.currentSubwiki) {
this.checkPageCreatedOrDiscarded(result.subwikis[this.currentSubwiki.id]);
}
return result.updated;
}
/**
* User entered the page that contains the component.
*/
ionViewDidEnter(): void {
super.ionViewDidEnter();
const editedPageData = AddonModWiki.consumeEditedPageData();
if (!editedPageData) {
return;
}
// User has just edited a page. Check if it's the current page.
if (this.pageId && editedPageData.pageId === this.pageId) {
this.showLoadingAndRefresh(true, false);
return;
}
const sameSubwiki = this.currentSubwiki &&
((this.currentSubwiki.id && this.currentSubwiki.id === editedPageData.subwikiId) ||
(this.currentSubwiki.userid === editedPageData.userId && this.currentSubwiki.groupid === editedPageData.groupId));
if (sameSubwiki && editedPageData.pageTitle === this.pageTitle) {
this.showLoadingAndRefresh(true, false);
return;
}
// Not same page or we cannot tell. Open the page.
this.openPageOrSubwiki({
pageId: editedPageData.pageId,
pageTitle: editedPageData.pageTitle,
subwikiId: editedPageData.subwikiId,
userId: editedPageData.wikiId,
groupId: editedPageData.groupId,
});
if (editedPageData.pageId && (!this.pageContent || this.pageContent.indexOf('/mod/wiki/create.php') != -1)) {
// Refresh current page anyway because the new page could have been created using the create link.
this.showLoadingAndRefresh(true, false);
}
}
/**
* @inheritdoc
*/
protected async invalidateContent(): Promise<void> {
const promises: Promise<void>[] = [];
promises.push(AddonModWiki.invalidateWikiData(this.courseId));
if (this.wiki) {
promises.push(AddonModWiki.invalidateSubwikis(this.wiki.id));
promises.push(CoreGroups.invalidateActivityAllowedGroups(this.wiki.coursemodule));
promises.push(CoreGroups.invalidateActivityGroupMode(this.wiki.coursemodule));
}
if (this.currentSubwiki) {
promises.push(AddonModWiki.invalidateSubwikiPages(this.currentSubwiki.wikiid));
promises.push(AddonModWiki.invalidateSubwikiFiles(this.currentSubwiki.wikiid));
}
if (this.currentPage) {
promises.push(AddonModWiki.invalidatePage(this.currentPage));
}
await Promise.all(promises);
}
/**
* @inheritdoc
*/
protected isRefreshSyncNeeded(syncEventData: AddonModWikiAutoSyncData): boolean {
if (this.currentSubwiki && syncEventData.subwikiId == this.currentSubwiki.id &&
syncEventData.wikiId == this.currentSubwiki.wikiid && syncEventData.userId == this.currentSubwiki.userid &&
syncEventData.groupId == this.currentSubwiki.groupid) {
if (this.isCurrentView && syncEventData.warnings && syncEventData.warnings.length) {
// Show warnings.
CoreDomUtils.showErrorModal(syncEventData.warnings[0]);
}
// Check if current page was created or discarded.
this.checkPageCreatedOrDiscarded(syncEventData);
}
return !this.pageWarning;
}
/**
* Show the TOC.
*
* @param event Event.
*/
async showSubwikiPicker(event: MouseEvent): Promise<void> {
const subwiki = await CoreDomUtils.openPopover<AddonModWikiSubwiki>({
component: AddonModWikiSubwikiPickerComponent,
componentProps: {
subwikis: this.subwikiData.subwikis,
currentSubwiki: this.currentSubwiki,
},
event,
});
if (subwiki) {
this.goToSubwiki(subwiki.id, subwiki.userid, subwiki.groupid);
}
}
/**
* Performs the sync of the activity.
*
* @return Promise resolved when done.
*/
protected async sync(): Promise<AddonModWikiSyncWikiResult | undefined> {
if (!this.wiki) {
return;
}
return AddonModWikiSync.syncWiki(this.wiki.id, this.courseId, this.wiki.coursemodule);
}
/**
* Component being destroyed.
*/
ngOnDestroy(): void {
super.ngOnDestroy();
this.manualSyncObserver?.off();
this.newPageObserver?.off();
this.onlineSubscription.unsubscribe();
if (this.wiki) {
AddonModWiki.wikiPageClosed(this.wiki.id, this.currentPath);
}
}
/**
* Create the subwiki list for the selector and store it in the cache.
*
* @param userGroups Groups.
* @return Promise resolved when done.
*/
protected async createSubwikiList(userGroups: CoreGroup[]): Promise<void> {
const subwikiList: AddonModWikiSubwikiListSubwiki[] = [];
let allParticipants = false;
let showMyGroupsLabel = false;
let multiLevelList = false;
this.subwikiData.subwikis = [];
this.setSelectedWiki(this.subwikiId, this.userId, this.groupId);
this.subwikiData.count = 0;
// Add the subwikis to the subwikiList.
await Promise.all(this.loadedSubwikis.map(async (subwiki) => {
let groupLabel = '';
if (subwiki.groupid == 0 && subwiki.userid == 0) {
// Add 'All participants' subwiki if needed at the start.
if (!allParticipants) {
subwikiList.unshift({
name: Translate.instant('core.allparticipants'),
id: subwiki.id,
userid: subwiki.userid,
groupid: subwiki.groupid,
groupLabel: '',
canedit: subwiki.canedit,
});
allParticipants = true;
}
} else {
if (subwiki.groupid != 0 && userGroups.length > 0) {
// Get groupLabel if it has groupId.
const group = userGroups.find(group => group.id == subwiki.groupid);
groupLabel = group?.name || '';
} else {
groupLabel = Translate.instant('addon.mod_wiki.notingroup');
}
if (subwiki.userid != 0) {
if (!multiLevelList && subwiki.groupid != 0) {
multiLevelList = true;
}
// Get user if it has userId.
const user = await CoreUser.getProfile(subwiki.userid, this.courseId, true);
subwikiList.push({
name: user.fullname,
id: subwiki.id,
userid: subwiki.userid,
groupid: subwiki.groupid,
groupLabel: groupLabel,
canedit: subwiki.canedit,
});
} else {
subwikiList.push({
name: groupLabel,
id: subwiki.id,
userid: subwiki.userid,
groupid: subwiki.groupid,
groupLabel: groupLabel,
canedit: subwiki.canedit,
});
showMyGroupsLabel = true;
}
}
}));
this.fillSubwikiData(subwikiList, showMyGroupsLabel, multiLevelList);
}
/**
* Fill the subwiki data.
*
* @param subwikiList List of subwikis.
* @param showMyGroupsLabel Whether subwikis should be grouped in "My groups" and "Other groups".
* @param multiLevelList Whether it's a multi level list.
*/
protected fillSubwikiData(
subwikiList: AddonModWikiSubwikiListSubwiki[],
showMyGroupsLabel: boolean,
multiLevelList: boolean,
): void {
subwikiList.sort((a, b) => a.groupid - b.groupid);
this.groupWiki = showMyGroupsLabel;
this.subwikiData.count = subwikiList.length;
// If no subwiki is received as view param, select always the most appropiate.
if ((!this.subwikiId || (!this.userId && !this.groupId)) && !this.isAnySubwikiSelected() && subwikiList.length > 0) {
let firstCanEdit: number | undefined;
let candidateNoFirstPage: number | undefined;
let candidateFirstPage: number | undefined;
for (const i in subwikiList) {
const subwiki = subwikiList[i];
if (subwiki.canedit) {
let candidateSubwikiId: number | undefined;
if (subwiki.userid > 0) {
// Check if it's the current user.
if (this.currentUserId == subwiki.userid) {
candidateSubwikiId = subwiki.id;
}
} else if (subwiki.groupid > 0) {
// Check if it's a current user' group.
if (showMyGroupsLabel) {
candidateSubwikiId = subwiki.id;
}
} else if (subwiki.id > 0) {
candidateSubwikiId = subwiki.id;
}
if (candidateSubwikiId !== undefined) {
if (candidateSubwikiId > 0) {
// Subwiki found and created, no need to keep looking.
candidateFirstPage = Number(i);
break;
} else if (candidateNoFirstPage === undefined) {
candidateNoFirstPage = Number(i);
}
} else if (firstCanEdit === undefined) {
firstCanEdit = Number(i);
}
}
}
let subWikiToTake: number;
if (candidateFirstPage !== undefined) {
// Take the candidate that already has the first page created.
subWikiToTake = candidateFirstPage;
} else if (candidateNoFirstPage !== undefined) {
// No first page created, take the first candidate.
subWikiToTake = candidateNoFirstPage;
} else if (firstCanEdit !== undefined) {
// None selected, take the first the user can edit.
subWikiToTake = firstCanEdit;
} else {
// Otherwise take the very first.
subWikiToTake = 0;
}
const subwiki = subwikiList[subWikiToTake];
if (subwiki !== undefined) {
this.setSelectedWiki(subwiki.id, subwiki.userid, subwiki.groupid);
}
}
if (multiLevelList) {
// As we loop over each subwiki, add it to the current group
let groupValue = -1;
let grouping: AddonModWikiSubwikiListGrouping;
subwikiList.forEach((subwiki) => {
// Should we create a new grouping?
if (subwiki.groupid !== groupValue) {
grouping = { label: subwiki.groupLabel, subwikis: [] };
groupValue = subwiki.groupid;
this.subwikiData.subwikis.push(grouping);
}
// Add the subwiki to the currently active grouping.
grouping.subwikis.push(subwiki);
});
} else if (showMyGroupsLabel) {
const noGrouping: AddonModWikiSubwikiListGrouping = { label: '', subwikis: [] };
const myGroupsGrouping: AddonModWikiSubwikiListGrouping = { label: Translate.instant('core.mygroups'), subwikis: [] };
const otherGroupsGrouping: AddonModWikiSubwikiListGrouping = {
label: Translate.instant('core.othergroups'),
subwikis: [],
};
// As we loop over each subwiki, add it to the current group
subwikiList.forEach((subwiki) => {
// Add the subwiki to the currently active grouping.
if (subwiki.canedit === undefined) {
noGrouping.subwikis.push(subwiki);
} else if (subwiki.canedit) {
myGroupsGrouping.subwikis.push(subwiki);
} else {
otherGroupsGrouping.subwikis.push(subwiki);
}
});
// Add each grouping to the subwikis
if (noGrouping.subwikis.length > 0) {
this.subwikiData.subwikis.push(noGrouping);
}
if (myGroupsGrouping.subwikis.length > 0) {
this.subwikiData.subwikis.push(myGroupsGrouping);
}
if (otherGroupsGrouping.subwikis.length > 0) {
this.subwikiData.subwikis.push(otherGroupsGrouping);
}
} else {
this.subwikiData.subwikis.push({ label: '', subwikis: subwikiList });
}
if (this.wiki) {
AddonModWiki.setSubwikiList(
this.wiki.id,
this.subwikiData.subwikis,
this.subwikiData.count,
this.subwikiData.subwikiSelected,
this.subwikiData.userSelected,
this.subwikiData.groupSelected,
);
}
}
}
type AddonModWikiOpenPageOptions = {
subwikiId?: number;
pageTitle?: string;
pageId?: number;
userId?: number;
groupId?: number;
};