337 lines
12 KiB
TypeScript
337 lines
12 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 { CoreSyncBaseProvider } from '@classes/base-sync';
|
|
import { CoreComments, CoreCommentsProvider } from './comments';
|
|
import { CoreEvents } from '@singletons/events';
|
|
import { makeSingleton, Translate } from '@singletons';
|
|
import { CoreCommentsOffline } from './comments-offline';
|
|
import { CoreSites } from '@services/sites';
|
|
import { CoreNetwork } from '@services/network';
|
|
import { CoreUtils } from '@services/utils/utils';
|
|
import { CoreNetworkError } from '@classes/errors/network-error';
|
|
import { CoreCommentsDBRecord, CoreCommentsDeletedDBRecord } from './database/comments';
|
|
|
|
/**
|
|
* Service to sync omments.
|
|
*/
|
|
@Injectable( { providedIn: 'root' })
|
|
export class CoreCommentsSyncProvider extends CoreSyncBaseProvider<CoreCommentsSyncResult> {
|
|
|
|
static readonly AUTO_SYNCED = 'core_comments_autom_synced';
|
|
|
|
constructor() {
|
|
super('CoreCommentsSync');
|
|
}
|
|
|
|
/**
|
|
* Try to synchronize all the comments in a certain site or in all sites.
|
|
*
|
|
* @param siteId Site ID to sync. If not defined, sync all sites.
|
|
* @param force Wether to force sync not depending on last execution.
|
|
* @return Promise resolved if sync is successful, rejected if sync fails.
|
|
*/
|
|
syncAllComments(siteId?: string, force?: boolean): Promise<void> {
|
|
return this.syncOnSites('all comments', this.syncAllCommentsFunc.bind(this, !!force), siteId);
|
|
}
|
|
|
|
/**
|
|
* Synchronize all the comments in a certain site
|
|
*
|
|
* @param force Wether to force sync not depending on last execution.
|
|
* @param siteId Site ID to sync.
|
|
* @return Promise resolved if sync is successful, rejected if sync fails.
|
|
*/
|
|
private async syncAllCommentsFunc(force: boolean, siteId: string): Promise<void> {
|
|
const comments = await CoreCommentsOffline.getAllComments(siteId);
|
|
|
|
const commentsUnique: { [syncId: string]: (CoreCommentsDBRecord | CoreCommentsDeletedDBRecord) } = {};
|
|
// Get Unique array.
|
|
comments.forEach((comment) => {
|
|
const syncId = this.getSyncId(
|
|
comment.contextlevel,
|
|
comment.instanceid,
|
|
comment.component,
|
|
comment.itemid,
|
|
comment.area,
|
|
);
|
|
commentsUnique[syncId] = comment;
|
|
});
|
|
|
|
// Sync all courses.
|
|
const promises = Object.keys(commentsUnique).map(async (key) => {
|
|
const comment = commentsUnique[key];
|
|
|
|
const result = await (force
|
|
? this.syncComments(
|
|
comment.contextlevel,
|
|
comment.instanceid,
|
|
comment.component,
|
|
comment.itemid,
|
|
comment.area,
|
|
siteId,
|
|
)
|
|
: this.syncCommentsIfNeeded(
|
|
comment.contextlevel,
|
|
comment.instanceid,
|
|
comment.component,
|
|
comment.itemid,
|
|
comment.area,
|
|
siteId,
|
|
));
|
|
|
|
if (result !== undefined) {
|
|
// Sync successful, send event.
|
|
CoreEvents.trigger(CoreCommentsSyncProvider.AUTO_SYNCED, {
|
|
contextLevel: comment.contextlevel,
|
|
instanceId: comment.instanceid,
|
|
componentName: comment.component,
|
|
itemId: comment.itemid,
|
|
area: comment.area,
|
|
warnings: result.warnings,
|
|
}, siteId);
|
|
}
|
|
});
|
|
|
|
await Promise.all(promises);
|
|
}
|
|
|
|
/**
|
|
* Sync course comments only if a certain time has passed since the last time.
|
|
*
|
|
* @param contextLevel Contextlevel system, course, user...
|
|
* @param instanceId The Instance id of item associated with the context level.
|
|
* @param component Component name.
|
|
* @param itemId Associated id.
|
|
* @param area String comment area. Default empty.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved when the comments are synced or if they don't need to be synced.
|
|
*/
|
|
private async syncCommentsIfNeeded(
|
|
contextLevel: string,
|
|
instanceId: number,
|
|
component: string,
|
|
itemId: number,
|
|
area: string = '',
|
|
siteId?: string,
|
|
): Promise<CoreCommentsSyncResult | undefined> {
|
|
const syncId = this.getSyncId(contextLevel, instanceId, component, itemId, area);
|
|
|
|
const needed = await this.isSyncNeeded(syncId, siteId);
|
|
|
|
if (needed) {
|
|
return this.syncComments(contextLevel, instanceId, component, itemId, area, siteId);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Synchronize comments in a particular area.
|
|
*
|
|
* @param contextLevel Contextlevel system, course, user...
|
|
* @param instanceId The Instance id of item associated with the context level.
|
|
* @param component Component name.
|
|
* @param itemId Associated id.
|
|
* @param area String comment area. Default empty.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved if sync is successful, rejected otherwise.
|
|
*/
|
|
syncComments(
|
|
contextLevel: string,
|
|
instanceId: number,
|
|
component: string,
|
|
itemId: number,
|
|
area: string = '',
|
|
siteId?: string,
|
|
): Promise<CoreCommentsSyncResult> {
|
|
siteId = siteId || CoreSites.getCurrentSiteId();
|
|
|
|
const syncId = this.getSyncId(contextLevel, instanceId, component, itemId, area);
|
|
const currentSyncPromise = this.getOngoingSync(syncId, siteId);
|
|
|
|
if (currentSyncPromise) {
|
|
// There's already a sync ongoing for comments, return the promise.
|
|
return currentSyncPromise;
|
|
}
|
|
|
|
this.logger.debug('Try to sync comments ' + syncId + ' in site ' + siteId);
|
|
|
|
const syncPromise = this.performSyncComments(contextLevel, instanceId, component, itemId, area, siteId);
|
|
|
|
return this.addOngoingSync(syncId, syncPromise, siteId);
|
|
}
|
|
|
|
/**
|
|
* Performs the syncronization of comments in a particular area.
|
|
*
|
|
* @param contextLevel Contextlevel system, course, user...
|
|
* @param instanceId The Instance id of item associated with the context level.
|
|
* @param component Component name.
|
|
* @param itemId Associated id.
|
|
* @param area String comment area. Default empty.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @return Promise resolved if sync is successful, rejected otherwise.
|
|
*/
|
|
private async performSyncComments(
|
|
contextLevel: string,
|
|
instanceId: number,
|
|
component: string,
|
|
itemId: number,
|
|
area: string = '',
|
|
siteId: string,
|
|
): Promise<CoreCommentsSyncResult> {
|
|
|
|
const result: CoreCommentsSyncResult = {
|
|
warnings: [],
|
|
updated: false,
|
|
};
|
|
|
|
// Get offline comments to be sent.
|
|
const comments = await CoreCommentsOffline.getComments(contextLevel, instanceId, component, itemId, area, siteId);
|
|
if (!comments.length) {
|
|
// Nothing to sync.
|
|
return result;
|
|
}
|
|
|
|
if (!CoreNetwork.isOnline()) {
|
|
// Cannot sync in offline.
|
|
throw new CoreNetworkError();
|
|
}
|
|
|
|
const errors: string[] = [];
|
|
const promises: Promise<void>[] = [];
|
|
const deleteCommentIds: number[] = [];
|
|
let countChange = 0;
|
|
|
|
comments.forEach((comment) => {
|
|
if ('deleted' in comment) {
|
|
deleteCommentIds.push(comment.commentid);
|
|
} else {
|
|
promises.push(CoreComments.addCommentOnline(
|
|
comment.content,
|
|
contextLevel,
|
|
instanceId,
|
|
component,
|
|
itemId,
|
|
area,
|
|
siteId,
|
|
).then(() => {
|
|
countChange++;
|
|
|
|
return CoreCommentsOffline.removeComment(contextLevel, instanceId, component, itemId, area, siteId);
|
|
}));
|
|
}
|
|
});
|
|
|
|
if (deleteCommentIds.length > 0) {
|
|
promises.push(CoreComments.deleteCommentsOnline(
|
|
deleteCommentIds,
|
|
contextLevel,
|
|
instanceId,
|
|
component,
|
|
itemId,
|
|
area,
|
|
siteId,
|
|
).then(() => {
|
|
countChange--;
|
|
|
|
return CoreCommentsOffline.removeDeletedComments(
|
|
contextLevel,
|
|
instanceId,
|
|
component,
|
|
itemId,
|
|
area,
|
|
siteId,
|
|
);
|
|
}));
|
|
}
|
|
|
|
// Send the comments.
|
|
try {
|
|
await Promise.all(promises);
|
|
|
|
result.updated = true;
|
|
|
|
CoreEvents.trigger(CoreCommentsProvider.COMMENTS_COUNT_CHANGED_EVENT, {
|
|
contextLevel: contextLevel,
|
|
instanceId: instanceId,
|
|
component,
|
|
itemId: itemId,
|
|
area: area,
|
|
countChange: countChange,
|
|
}, CoreSites.getCurrentSiteId());
|
|
|
|
// Fetch the comments from server to be sure they're up to date.
|
|
await CoreUtils.ignoreErrors(
|
|
CoreComments.invalidateCommentsData(contextLevel, instanceId, component, itemId, area, siteId),
|
|
);
|
|
await CoreUtils.ignoreErrors(
|
|
CoreComments.getComments(contextLevel, instanceId, component, itemId, area, 0, siteId),
|
|
);
|
|
} catch (error) {
|
|
if (CoreUtils.isWebServiceError(error)) {
|
|
// It's a WebService error, this means the user cannot send comments.
|
|
errors.push(error.message);
|
|
} else {
|
|
// Not a WebService error, reject the synchronization to try again.
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
if (errors && errors.length) {
|
|
errors.forEach((error) => {
|
|
result.warnings.push(Translate.instant('core.comments.warningcommentsnotsent', {
|
|
error: error,
|
|
}));
|
|
});
|
|
}
|
|
|
|
// All done, return the warnings.
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get the ID of a comments sync.
|
|
*
|
|
* @param contextLevel Contextlevel system, course, user...
|
|
* @param instanceId The Instance id of item associated with the context level.
|
|
* @param component Component name.
|
|
* @param itemId Associated id.
|
|
* @param area String comment area. Default empty.
|
|
* @return Sync ID.
|
|
*/
|
|
protected getSyncId(contextLevel: string, instanceId: number, component: string, itemId: number, area: string = ''): string {
|
|
return contextLevel + '#' + instanceId + '#' + component + '#' + itemId + '#' + area;
|
|
}
|
|
|
|
}
|
|
export const CoreCommentsSync = makeSingleton(CoreCommentsSyncProvider);
|
|
|
|
export type CoreCommentsSyncResult = {
|
|
warnings: string[]; // List of warnings.
|
|
updated: boolean; // Whether some data was sent to the server or offline data was updated.
|
|
};
|
|
|
|
/**
|
|
* Data passed to AUTO_SYNCED event.
|
|
*/
|
|
export type CoreCommentsSyncAutoSyncData = {
|
|
contextLevel: string;
|
|
instanceId: number;
|
|
componentName: string;
|
|
itemId: number;
|
|
area: string;
|
|
warnings: string[];
|
|
};
|