519 lines
18 KiB
TypeScript
519 lines
18 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 { CoreWSError } from '@classes/errors/wserror';
|
|
import { CoreSite } from '@classes/sites/site';
|
|
import { CoreUser } from '@features/user/services/user';
|
|
import { CoreNetwork } from '@services/network';
|
|
import { CoreSites } from '@services/sites';
|
|
import { CoreUtils } from '@services/utils/utils';
|
|
import { CoreWSExternalWarning } from '@services/ws';
|
|
import { makeSingleton, Translate } from '@singletons';
|
|
import { AddonNotesOffline } from './notes-offline';
|
|
import { CoreSiteWSPreSets } from '@classes/sites/candidate-site';
|
|
|
|
const ROOT_CACHE_KEY = 'mmaNotes:';
|
|
|
|
/**
|
|
* Service to handle notes.
|
|
*/
|
|
@Injectable( { providedIn: 'root' } )
|
|
export class AddonNotesProvider {
|
|
|
|
/**
|
|
* Add a note.
|
|
*
|
|
* @param userId User ID of the person to add the note.
|
|
* @param courseId Course ID where the note belongs.
|
|
* @param publishState Personal, Site or Course.
|
|
* @param noteText The note text.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved with boolean: true if note was sent to server, false if stored in device.
|
|
*/
|
|
async addNote(
|
|
userId: number,
|
|
courseId: number,
|
|
publishState: AddonNotesPublishState,
|
|
noteText: string,
|
|
siteId?: string,
|
|
): Promise<boolean> {
|
|
siteId = siteId || CoreSites.getCurrentSiteId();
|
|
|
|
// Convenience function to store a note to be synchronized later.
|
|
const storeOffline = async (): Promise<boolean> => {
|
|
await AddonNotesOffline.saveNote(userId, courseId, publishState, noteText, siteId);
|
|
|
|
return false;
|
|
};
|
|
|
|
if (!CoreNetwork.isOnline()) {
|
|
// App is offline, store the note.
|
|
return storeOffline();
|
|
}
|
|
|
|
// Send note to server.
|
|
try {
|
|
await this.addNoteOnline(userId, courseId, publishState, noteText, siteId);
|
|
|
|
return true;
|
|
} catch (error) {
|
|
if (CoreUtils.isWebServiceError(error)) {
|
|
// It's a WebService error, the user cannot send the message so don't store it.
|
|
throw error;
|
|
}
|
|
|
|
return storeOffline();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a note. It will fail if offline or cannot connect.
|
|
*
|
|
* @param userId User ID of the person to add the note.
|
|
* @param courseId Course ID where the note belongs.
|
|
* @param publishState Personal, Site or Course.
|
|
* @param noteText The note text.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved when added, rejected otherwise.
|
|
*/
|
|
async addNoteOnline(
|
|
userId: number,
|
|
courseId: number,
|
|
publishState: AddonNotesPublishState,
|
|
noteText: string,
|
|
siteId?: string,
|
|
): Promise<void> {
|
|
const notes: AddonNotesCreateNoteData[] = [
|
|
{
|
|
courseid: courseId,
|
|
format: 1,
|
|
publishstate: publishState,
|
|
text: noteText,
|
|
userid: userId,
|
|
},
|
|
];
|
|
|
|
const response = await this.addNotesOnline(notes, siteId);
|
|
if (response && response[0] && response[0].noteid === -1) {
|
|
// There was an error, and it should be translated already.
|
|
throw new CoreWSError({ message: response[0].errormessage });
|
|
}
|
|
|
|
await CoreUtils.ignoreErrors(this.invalidateNotes(courseId, undefined, siteId));
|
|
}
|
|
|
|
/**
|
|
* Add several notes. It will fail if offline or cannot connect.
|
|
*
|
|
* @param notes Notes to save.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved when added, rejected otherwise. Promise resolved doesn't mean that notes
|
|
* have been added, the resolve param can contain errors for notes not sent.
|
|
*/
|
|
async addNotesOnline(notes: AddonNotesCreateNoteData[], siteId?: string): Promise<AddonNotesCreateNotesWSResponse> {
|
|
if (!notes || !notes.length) {
|
|
return [];
|
|
}
|
|
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
const data: AddonNotesCreateNotesWSParams = {
|
|
notes: notes,
|
|
};
|
|
|
|
return site.write('core_notes_create_notes', data);
|
|
}
|
|
|
|
/**
|
|
* Delete a note.
|
|
*
|
|
* @param note Note object to delete.
|
|
* @param courseId Course ID where the note belongs.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved when deleted, rejected otherwise. Promise resolved doesn't mean that notes
|
|
* have been deleted, the resolve param can contain errors for notes not deleted.
|
|
*/
|
|
async deleteNote(note: AddonNotesNoteFormatted, courseId: number, siteId?: string): Promise<boolean> {
|
|
siteId = siteId || CoreSites.getCurrentSiteId();
|
|
|
|
if (note.offline) {
|
|
await AddonNotesOffline.deleteOfflineNote(note.userid, note.content, note.created, siteId);
|
|
|
|
return true;
|
|
}
|
|
|
|
// Convenience function to store the action to be synchronized later.
|
|
const storeOffline = async (): Promise<boolean> => {
|
|
await AddonNotesOffline.deleteNote(note.id, courseId, siteId);
|
|
|
|
return false;
|
|
};
|
|
|
|
if (!CoreNetwork.isOnline()) {
|
|
// App is offline, store the note.
|
|
return storeOffline();
|
|
}
|
|
|
|
// Send note to server.
|
|
try {
|
|
await this.deleteNotesOnline([note.id], courseId, siteId);
|
|
|
|
return true;
|
|
} catch (error) {
|
|
if (CoreUtils.isWebServiceError(error)) {
|
|
// It's a WebService error, the user cannot send the note so don't store it.
|
|
throw error;
|
|
}
|
|
|
|
return storeOffline();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete a note. It will fail if offline or cannot connect.
|
|
*
|
|
* @param noteIds Note IDs to delete.
|
|
* @param courseId Course ID where the note belongs.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved when deleted, rejected otherwise. Promise resolved doesn't mean that notes
|
|
* have been deleted, the resolve param can contain errors for notes not deleted.
|
|
*/
|
|
async deleteNotesOnline(noteIds: number[], courseId: number, siteId?: string): Promise<void> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
const params: AddonNotesDeleteNotesWSParams = {
|
|
notes: noteIds,
|
|
};
|
|
|
|
await site.write('core_notes_delete_notes', params);
|
|
|
|
CoreUtils.ignoreErrors(this.invalidateNotes(courseId, undefined, siteId));
|
|
}
|
|
|
|
/**
|
|
* Returns whether or not the notes plugin is enabled for a certain site.
|
|
*
|
|
* This method is called quite often and thus should only perform a quick
|
|
* check, we should not be calling WS from here.
|
|
*
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved with true if enabled, resolved with false or rejected otherwise.
|
|
*/
|
|
async isPluginEnabled(siteId?: string): Promise<boolean> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
return site.canUseAdvancedFeature('enablenotes');
|
|
}
|
|
|
|
/**
|
|
* Returns whether or not the add note plugin is enabled for a certain course.
|
|
*
|
|
* @param courseId ID of the course.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved with true if enabled, resolved with false or rejected otherwise.
|
|
*/
|
|
async isPluginAddNoteEnabledForCourse(courseId: number, siteId?: string): Promise<boolean> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
// The only way to detect if it's enabled is to perform a WS call.
|
|
// We use an invalid user ID (-1) to avoid saving the note if the user has permissions.
|
|
const params: AddonNotesCreateNotesWSParams = {
|
|
notes: [
|
|
{
|
|
userid: -1,
|
|
publishstate: 'personal',
|
|
courseid: courseId,
|
|
text: '',
|
|
format: 1,
|
|
},
|
|
],
|
|
};
|
|
const preSets: CoreSiteWSPreSets = {
|
|
updateFrequency: CoreSite.FREQUENCY_RARELY,
|
|
};
|
|
|
|
// Use .read to cache data and be able to check it in offline. This means that, if a user loses the capabilities
|
|
// to add notes, he'll still see the option in the app.
|
|
return CoreUtils.promiseWorks(site.read('core_notes_create_notes', params, preSets));
|
|
}
|
|
|
|
/**
|
|
* Returns whether or not the read notes plugin is enabled for a certain course.
|
|
*
|
|
* @param courseId ID of the course.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved with true if enabled, resolved with false or rejected otherwise.
|
|
*/
|
|
isPluginViewNotesEnabledForCourse(courseId: number, siteId?: string): Promise<boolean> {
|
|
return CoreUtils.promiseWorks(this.getNotes(courseId, undefined, false, true, siteId));
|
|
}
|
|
|
|
/**
|
|
* Get prefix cache key for course notes.
|
|
*
|
|
* @param courseId ID of the course to get the notes from.
|
|
* @returns Cache key.
|
|
*/
|
|
getNotesPrefixCacheKey(courseId: number): string {
|
|
return ROOT_CACHE_KEY + 'notes:' + courseId + ':';
|
|
}
|
|
|
|
/**
|
|
* Get the cache key for the get notes call.
|
|
*
|
|
* @param courseId ID of the course to get the notes from.
|
|
* @param userId ID of the user to get the notes from if requested.
|
|
* @returns Cache key.
|
|
*/
|
|
getNotesCacheKey(courseId: number, userId?: number): string {
|
|
return this.getNotesPrefixCacheKey(courseId) + (userId ? userId : '');
|
|
}
|
|
|
|
/**
|
|
* Get users notes for a certain site, course and personal notes.
|
|
*
|
|
* @param courseId ID of the course to get the notes from.
|
|
* @param userId ID of the user to get the notes from if requested.
|
|
* @param ignoreCache True when we should not get the value from the cache.
|
|
* @param onlyOnline True to return only online notes, false to return both online and offline.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise to be resolved when the notes are retrieved.
|
|
*/
|
|
async getNotes(
|
|
courseId: number,
|
|
userId?: number,
|
|
ignoreCache = false,
|
|
onlyOnline = false,
|
|
siteId?: string,
|
|
): Promise<AddonNotesGetCourseNotesWSResponse> {
|
|
|
|
const site = await CoreSites.getSite(siteId);
|
|
const params: AddonNotesGetCourseNotesWSParams = {
|
|
courseid: courseId,
|
|
};
|
|
if (userId) {
|
|
params.userid = userId;
|
|
}
|
|
|
|
const preSets: CoreSiteWSPreSets = {
|
|
cacheKey: this.getNotesCacheKey(courseId, userId),
|
|
updateFrequency: CoreSite.FREQUENCY_SOMETIMES,
|
|
};
|
|
|
|
if (ignoreCache) {
|
|
preSets.getFromCache = false;
|
|
preSets.emergencyCache = false;
|
|
}
|
|
const notes = await site.read<AddonNotesGetCourseNotesWSResponse>('core_notes_get_course_notes', params, preSets);
|
|
if (onlyOnline) {
|
|
return notes;
|
|
}
|
|
|
|
const offlineNotes = await AddonNotesOffline.getNotesForCourseAndUser(courseId, userId, siteId);
|
|
offlineNotes.forEach((note: AddonNotesNote) => {
|
|
const fieldName = note.publishstate + 'notes';
|
|
if (!notes[fieldName]) {
|
|
notes[fieldName] = [];
|
|
}
|
|
note.offline = true;
|
|
// Add note to the start of array since last notes are shown first.
|
|
notes[fieldName].unshift(note);
|
|
});
|
|
|
|
return notes;
|
|
}
|
|
|
|
/**
|
|
* Get offline deleted notes and set the state.
|
|
*
|
|
* @param notes Array of notes.
|
|
* @param courseId ID of the course the notes belong to.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved when done.
|
|
*/
|
|
async setOfflineDeletedNotes(
|
|
notes: AddonNotesNoteFormatted[],
|
|
courseId: number,
|
|
siteId?: string,
|
|
): Promise<void> {
|
|
const deletedNotes = await AddonNotesOffline.getCourseDeletedNotes(courseId, siteId);
|
|
|
|
notes.forEach((note) => {
|
|
note.deleted = deletedNotes.some((n) => n.noteid == note.id);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get user data for notes since they only have userid.
|
|
*
|
|
* @param notes Notes to get the data for.
|
|
* @returns Promise always resolved. Resolve param is the formatted notes.
|
|
*/
|
|
async getNotesUserData(notes: AddonNotesNoteFormatted[]): Promise<AddonNotesNoteFormatted[]> {
|
|
const promises = notes.map((note) =>
|
|
// Get the user profile to retrieve the user image.
|
|
CoreUser.getProfile(note.userid, note.courseid, true).then((user) => {
|
|
note.userfullname = user.fullname;
|
|
note.userprofileimageurl = user.profileimageurl;
|
|
|
|
return;
|
|
}).catch(() => {
|
|
note.userfullname = Translate.instant('core.user.userwithid', { id: note.userid });
|
|
}));
|
|
|
|
await Promise.all(promises);
|
|
|
|
return notes;
|
|
}
|
|
|
|
/**
|
|
* Invalidate get notes WS call.
|
|
*
|
|
* @param courseId Course ID.
|
|
* @param userId User ID if needed.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved when data is invalidated.
|
|
*/
|
|
async invalidateNotes(courseId: number, userId?: number, siteId?: string): Promise<void> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
if (userId) {
|
|
await site.invalidateWsCacheForKey(this.getNotesCacheKey(courseId, userId));
|
|
|
|
return;
|
|
}
|
|
|
|
await site.invalidateWsCacheForKeyStartingWith(this.getNotesPrefixCacheKey(courseId));
|
|
}
|
|
|
|
/**
|
|
* Report notes as being viewed.
|
|
*
|
|
* @param courseId ID of the course.
|
|
* @param userId User ID if needed.
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @returns Promise resolved when the WS call is successful.
|
|
*/
|
|
async logView(courseId: number, userId?: number, siteId?: string): Promise<void> {
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
const params: AddonNotesViewNotesWSParams = {
|
|
courseid: courseId,
|
|
userid: userId || 0,
|
|
};
|
|
|
|
await site.write('core_notes_view_notes', params);
|
|
}
|
|
|
|
}
|
|
export const AddonNotes = makeSingleton(AddonNotesProvider);
|
|
|
|
/**
|
|
* Params of core_notes_view_notes WS.
|
|
*/
|
|
type AddonNotesViewNotesWSParams = {
|
|
courseid: number; // Course id, 0 for notes at system level.
|
|
userid?: number; // User id, 0 means view all the user notes.
|
|
};
|
|
|
|
/**
|
|
* Params of core_notes_get_course_notes WS.
|
|
*/
|
|
export type AddonNotesGetCourseNotesWSParams = {
|
|
courseid: number; // Course id, 0 for SITE.
|
|
userid?: number; // User id.
|
|
};
|
|
|
|
/**
|
|
* Note data returned by core_notes_get_course_notes.
|
|
*/
|
|
export type AddonNotesNote = {
|
|
id: number; // Id of this note.
|
|
courseid: number; // Id of the course.
|
|
userid: number; // User id.
|
|
content: string; // The content text formated.
|
|
format: number; // Content format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
|
|
created: number; // Time created (timestamp).
|
|
lastmodified: number; // Time of last modification (timestamp).
|
|
usermodified: number; // User id of the creator of this note.
|
|
publishstate: AddonNotesPublishState; // State of the note (i.e. draft, public, site).
|
|
offline?: boolean;
|
|
};
|
|
|
|
/**
|
|
* Result of WS core_notes_get_course_notes.
|
|
*/
|
|
export type AddonNotesGetCourseNotesWSResponse = {
|
|
sitenotes?: AddonNotesNote[]; // Site notes.
|
|
coursenotes?: AddonNotesNote[]; // Couse notes.
|
|
personalnotes?: AddonNotesNote[]; // Personal notes.
|
|
canmanagesystemnotes?: boolean; // @since 3.7. Whether the user can manage notes at system level.
|
|
canmanagecoursenotes?: boolean; // @since 3.7. Whether the user can manage notes at the given course.
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Result of WS core_notes_view_notes.
|
|
*/
|
|
export type AddonNotesViewNotesResult = {
|
|
status: boolean; // Status: true if success.
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
/**
|
|
* Notes with some calculated data.
|
|
*/
|
|
export type AddonNotesNoteFormatted = AddonNotesNote & {
|
|
offline?: boolean; // Calculated in the app. Whether it's an offline note.
|
|
deleted?: boolean; // Calculated in the app. Whether the note was deleted in offline.
|
|
userfullname?: string; // Calculated in the app. Full name of the user the note refers to.
|
|
userprofileimageurl?: string; // Calculated in the app. Avatar url of the user the note refers to.
|
|
};
|
|
|
|
export type AddonNotesCreateNoteData = {
|
|
userid: number; // Id of the user the note is about.
|
|
publishstate: AddonNotesPublishState; // 'personal', 'course' or 'site'.
|
|
courseid: number; // Course id of the note (in Moodle a note can only be created into a course,
|
|
// even for site and personal notes).
|
|
text: string; // The text of the message - text or HTML.
|
|
format?: number; // Text format (1 = HTML, 0 = MOODLE, 2 = PLAIN or 4 = MARKDOWN).
|
|
clientnoteid?: string; // Your own client id for the note. If this id is provided, the fail message id will be returned to you.
|
|
};
|
|
|
|
/**
|
|
* Params of core_notes_create_notes WS.
|
|
*/
|
|
type AddonNotesCreateNotesWSParams = {
|
|
notes: AddonNotesCreateNoteData[];
|
|
};
|
|
|
|
/**
|
|
* Note returned by WS core_notes_create_notes.
|
|
*/
|
|
export type AddonNotesCreateNotesWSResponse = {
|
|
clientnoteid?: string; // Your own id for the note.
|
|
noteid: number; // ID of the created note when successful, -1 when failed.
|
|
errormessage?: string; // Error message - if failed.
|
|
}[];
|
|
|
|
/**
|
|
* Params of core_notes_delete_notes WS.
|
|
*/
|
|
type AddonNotesDeleteNotesWSParams = {
|
|
notes: number[]; // Array of Note Ids to be deleted.
|
|
};
|
|
|
|
export type AddonNotesPublishState = 'personal' | 'site' | 'course';
|