393 lines
14 KiB
TypeScript
393 lines
14 KiB
TypeScript
// (C) Copyright 2015 Martin Dougiamas
|
|
//
|
|
// 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 { TranslateService } from '@ngx-translate/core';
|
|
import { CoreSitesProvider } from '@providers/sites';
|
|
import { CoreUserProvider } from '@core/user/providers/user';
|
|
import { CoreCourseLogHelperProvider } from '@core/course/providers/log-helper';
|
|
import { CoreUtilsProvider } from '@providers/utils/utils';
|
|
import { CoreSite, CoreSiteWSPreSets } from '@classes/site';
|
|
|
|
/**
|
|
* Service that provides some features for chats.
|
|
*/
|
|
@Injectable()
|
|
export class AddonModChatProvider {
|
|
static COMPONENT = 'mmaModChat';
|
|
static POLL_INTERVAL = 4000;
|
|
|
|
protected ROOT_CACHE_KEY = 'AddonModChat:';
|
|
|
|
constructor(private sitesProvider: CoreSitesProvider, private userProvider: CoreUserProvider,
|
|
private logHelper: CoreCourseLogHelperProvider, protected utils: CoreUtilsProvider, private translate: TranslateService) {}
|
|
|
|
/**
|
|
* Get a chat.
|
|
*
|
|
* @param {number} courseId Course ID.
|
|
* @param {number} cmId Course module ID.
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<any>} Promise resolved when the chat is retrieved.
|
|
*/
|
|
getChat(courseId: number, cmId: number, siteId?: string): Promise<any> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
const params = {
|
|
courseids: [courseId]
|
|
};
|
|
const preSets: CoreSiteWSPreSets = {
|
|
cacheKey: this.getChatsCacheKey(courseId),
|
|
updateFrequency: CoreSite.FREQUENCY_RARELY
|
|
};
|
|
|
|
return site.read('mod_chat_get_chats_by_courses', params, preSets).then((response) => {
|
|
if (response.chats) {
|
|
const chat = response.chats.find((chat) => chat.coursemodule == cmId);
|
|
if (chat) {
|
|
return chat;
|
|
}
|
|
}
|
|
|
|
return Promise.reject(null);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Log the user into a chat room.
|
|
*
|
|
* @param {number} chatId Chat instance ID.
|
|
* @return {Promise<any>} Promise resolved when the WS is executed.
|
|
*/
|
|
loginUser(chatId: number): Promise<any> {
|
|
const params = {
|
|
chatid: chatId
|
|
};
|
|
|
|
return this.sitesProvider.getCurrentSite().write('mod_chat_login_user', params).then((response) => {
|
|
if (response.chatsid) {
|
|
return response.chatsid;
|
|
}
|
|
|
|
return Promise.reject(null);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Report a chat as being viewed.
|
|
*
|
|
* @param {number} id Chat instance ID.
|
|
* @param {string} [name] Name of the chat.
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<any>} Promise resolved when the WS call is successful.
|
|
*/
|
|
logView(id: number, name?: string, siteId?: string): Promise<any> {
|
|
const params = {
|
|
chatid: id
|
|
};
|
|
|
|
return this.logHelper.logSingle('mod_chat_view_chat', params, AddonModChatProvider.COMPONENT, id, name, 'chat', {}, siteId);
|
|
}
|
|
|
|
/**
|
|
* Send a message to a chat.
|
|
*
|
|
* @param {number} sessionId Chat sessiond ID.
|
|
* @param {string} message Message text.
|
|
* @param {number} beepUserId Beep user ID.
|
|
* @return {Promise<any>} Promise resolved when the WS is executed.
|
|
*/
|
|
sendMessage(sessionId: number, message: string, beepUserId: number): Promise<any> {
|
|
const params = {
|
|
chatsid: sessionId,
|
|
messagetext: message,
|
|
beepid: beepUserId
|
|
};
|
|
|
|
return this.sitesProvider.getCurrentSite().write('mod_chat_send_chat_message', params).then((response) => {
|
|
if (response.messageid) {
|
|
return response.messageid;
|
|
}
|
|
|
|
return Promise.reject(null);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get the latest messages from a chat session.
|
|
*
|
|
* @param {number} sessionId Chat sessiond ID.
|
|
* @param {number} lastTime Last time when messages were retrieved.
|
|
* @return {Promise<any>} Promise resolved when the WS is executed.
|
|
*/
|
|
getLatestMessages(sessionId: number, lastTime: number): Promise<any> {
|
|
const params = {
|
|
chatsid: sessionId,
|
|
chatlasttime: lastTime
|
|
};
|
|
|
|
/* We use write to not use cache. It doesn't make sense to store the messages in cache
|
|
because we won't be able to retireve them if AddonModChatProvider.loginUser fails. */
|
|
return this.sitesProvider.getCurrentSite().write('mod_chat_get_chat_latest_messages', params);
|
|
}
|
|
|
|
/**
|
|
* Get user data for messages since they only have userid.
|
|
*
|
|
* @param {any[]} messages Messages to get the user data for.
|
|
* @param {number} courseId ID of the course the messages belong to.
|
|
* @return {Promise<any>} Promise always resolved with the formatted messages.
|
|
*/
|
|
getMessagesUserData(messages: any[], courseId: number): Promise<any> {
|
|
const promises = messages.map((message) => {
|
|
return this.userProvider.getProfile(message.userid, courseId, true).then((user) => {
|
|
message.userfullname = user.fullname;
|
|
message.userprofileimageurl = user.profileimageurl;
|
|
}).catch(() => {
|
|
// Error getting profile, most probably the user is deleted.
|
|
message.userfullname = this.translate.instant('core.deleteduser') + ' ' + message.userid;
|
|
});
|
|
});
|
|
|
|
return Promise.all(promises).then(() => {
|
|
return messages;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get the actives users of a current chat.
|
|
*
|
|
* @param {number} sessionId Chat sessiond ID.
|
|
* @return {Promise<any>} Promise resolved when the WS is executed.
|
|
*/
|
|
getChatUsers(sessionId: number): Promise<any> {
|
|
const params = {
|
|
chatsid: sessionId
|
|
};
|
|
const preSets = {
|
|
getFromCache: false
|
|
};
|
|
|
|
return this.sitesProvider.getCurrentSite().read('mod_chat_get_chat_users', params, preSets);
|
|
}
|
|
|
|
/**
|
|
* Return whether WS for passed sessions are available.
|
|
*
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<boolean>} Promise resolved with a boolean.
|
|
*/
|
|
areSessionsAvailable(siteId?: string): Promise<boolean> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
return site.wsAvailable('mod_chat_get_sessions') && site.wsAvailable('mod_chat_get_session_messages');
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get chat sessions.
|
|
*
|
|
* @param {number} chatId Chat ID.
|
|
* @param {number} [groupId=0] Group ID, 0 means that the function will determine the user group.
|
|
* @param {boolean} [showAll=false] Whether to include incomplete sessions or not.
|
|
* @param {boolean} [ignoreCache=false] True if it should ignore cached data (it will always fail in offline or server down).
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<any[]>} Promise resolved with the list of sessions.
|
|
* @since 3.5
|
|
*/
|
|
getSessions(chatId: number, groupId: number = 0, showAll: boolean = false, ignoreCache: boolean = false, siteId?: string):
|
|
Promise<any[]> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
const params = {
|
|
chatid: chatId,
|
|
groupid: groupId,
|
|
showall: showAll ? 1 : 0
|
|
};
|
|
const preSets: CoreSiteWSPreSets = {
|
|
cacheKey: this.getSessionsCacheKey(chatId, groupId, showAll),
|
|
updateFrequency: CoreSite.FREQUENCY_SOMETIMES
|
|
};
|
|
if (ignoreCache) {
|
|
preSets.getFromCache = false;
|
|
preSets.emergencyCache = false;
|
|
}
|
|
|
|
return site.read('mod_chat_get_sessions', params, preSets).then((response) => {
|
|
if (!response || !response.sessions) {
|
|
return Promise.reject(null);
|
|
}
|
|
|
|
return response.sessions;
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get chat session messages.
|
|
*
|
|
* @param {number} chatId Chat ID.
|
|
* @param {number} sessionStart Session start time.
|
|
* @param {number} sessionEnd Session end time.
|
|
* @param {number} [groupId=0] Group ID, 0 means that the function will determine the user group.
|
|
* @param {boolean} [ignoreCache=false] True if it should ignore cached data (it will always fail in offline or server down).
|
|
* @param {string} [siteId] Site ID. If not defined, current site.
|
|
* @return {Promise<any[]>} Promise resolved with the list of messages.
|
|
* @since 3.5
|
|
*/
|
|
getSessionMessages(chatId: number, sessionStart: number, sessionEnd: number, groupId: number = 0, ignoreCache: boolean = false,
|
|
siteId?: string): Promise<any[]> {
|
|
return this.sitesProvider.getSite(siteId).then((site) => {
|
|
const params = {
|
|
chatid: chatId,
|
|
sessionstart: sessionStart,
|
|
sessionend: sessionEnd,
|
|
groupid: groupId
|
|
};
|
|
const preSets: CoreSiteWSPreSets = {
|
|
cacheKey: this.getSessionMessagesCacheKey(chatId, sessionStart, groupId),
|
|
updateFrequency: CoreSite.FREQUENCY_RARELY
|
|
};
|
|
if (ignoreCache) {
|
|
preSets.getFromCache = false;
|
|
preSets.emergencyCache = false;
|
|
}
|
|
|
|
return site.read('mod_chat_get_session_messages', params, preSets).then((response) => {
|
|
if (!response || !response.messages) {
|
|
return Promise.reject(null);
|
|
}
|
|
|
|
return response.messages;
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Invalidate chats.
|
|
*
|
|
* @param {number} courseId Course ID.
|
|
* @return {Promise<any>} Promise resolved when the data is invalidated.
|
|
*/
|
|
invalidateChats(courseId: number): Promise<any> {
|
|
const site = this.sitesProvider.getCurrentSite();
|
|
|
|
return site.invalidateWsCacheForKey(this.getChatsCacheKey(courseId));
|
|
}
|
|
|
|
/**
|
|
* Invalidate chat sessions.
|
|
*
|
|
* @param {number} chatId Chat ID.
|
|
* @param {number} [groupId=0] Group ID, 0 means that the function will determine the user group.
|
|
* @param {boolean} [showAll=false] Whether to include incomplete sessions or not.
|
|
* @return {Promise<any>} Promise resolved when the data is invalidated.
|
|
*/
|
|
invalidateSessions(chatId: number, groupId: number = 0, showAll: boolean = false): Promise<any> {
|
|
const site = this.sitesProvider.getCurrentSite();
|
|
|
|
return site.invalidateWsCacheForKey(this.getSessionsCacheKey(chatId, groupId, showAll));
|
|
}
|
|
|
|
/**
|
|
* Invalidate all chat sessions.
|
|
*
|
|
* @param {number} chatId Chat ID.
|
|
* @return {Promise<any>} Promise resolved when the data is invalidated.
|
|
*/
|
|
invalidateAllSessions(chatId: number): Promise<any> {
|
|
const site = this.sitesProvider.getCurrentSite();
|
|
|
|
return site.invalidateWsCacheForKeyStartingWith(this.getSessionsCacheKeyPrefix(chatId));
|
|
}
|
|
|
|
/**
|
|
* Invalidate chat session messages.
|
|
*
|
|
* @param {number} chatId Chat ID.
|
|
* @param {number} sessionStart Session start time.
|
|
* @param {number} [groupId=0] Group ID, 0 means that the function will determine the user group.
|
|
* @return {Promise<any>} Promise resolved when the data is invalidated.
|
|
*/
|
|
invalidateSessionMessages(chatId: number, sessionStart: number, groupId: number = 0): Promise<any> {
|
|
const site = this.sitesProvider.getCurrentSite();
|
|
|
|
return site.invalidateWsCacheForKey(this.getSessionMessagesCacheKey(chatId, sessionStart, groupId));
|
|
}
|
|
|
|
/**
|
|
* Invalidate all chat session messages.
|
|
*
|
|
* @param {number} chatId Chat ID.
|
|
* @return {Promise<any>} Promise resolved when the data is invalidated.
|
|
*/
|
|
invalidateAllSessionMessages(chatId: number): Promise<any> {
|
|
const site = this.sitesProvider.getCurrentSite();
|
|
|
|
return site.invalidateWsCacheForKeyStartingWith(this.getSessionMessagesCacheKeyPrefix(chatId));
|
|
}
|
|
|
|
/**
|
|
* Get cache key for chats WS call.
|
|
*
|
|
* @param {number} courseId Course ID.
|
|
* @return {string} Cache key.
|
|
*/
|
|
protected getChatsCacheKey(courseId: number): string {
|
|
return this.ROOT_CACHE_KEY + 'chats:' + courseId;
|
|
}
|
|
|
|
/**
|
|
* Get cache key for sessions WS call.
|
|
*
|
|
* @param {number} chatId Chat ID.
|
|
* @param {number} groupId Goup ID, 0 means that the function will determine the user group.
|
|
* @param {boolean} showAll Whether to include incomplete sessions or not.
|
|
* @return {string} Cache key.
|
|
*/
|
|
protected getSessionsCacheKey(chatId: number, groupId: number, showAll: boolean): string {
|
|
return this.getSessionsCacheKeyPrefix(chatId) + groupId + ':' + (showAll ? 1 : 0);
|
|
}
|
|
|
|
/**
|
|
* Get cache key prefix for sessions WS call.
|
|
*
|
|
* @param {number} chatId Chat ID.
|
|
* @return {string} Cache key prefix.
|
|
*/
|
|
protected getSessionsCacheKeyPrefix(chatId: number): string {
|
|
return this.ROOT_CACHE_KEY + 'sessions:' + chatId + ':';
|
|
}
|
|
|
|
/**
|
|
* Get cache key for session messages WS call.
|
|
*
|
|
* @param {number} chatId Chat ID.
|
|
* @param {number} sessionStart Session start time.
|
|
* @param {number} groupId Group ID, 0 means that the function will determine the user group.
|
|
* @return {string} Cache key.
|
|
*/
|
|
protected getSessionMessagesCacheKey(chatId: number, sessionStart: number, groupId: number): string {
|
|
return this.getSessionMessagesCacheKeyPrefix(chatId) + sessionStart + ':' + groupId;
|
|
}
|
|
|
|
/**
|
|
* Get cache key prefix for session messages WS call.
|
|
*
|
|
* @param {number} chatId Chat ID.
|
|
* @return {string} Cache key prefix.
|
|
*/
|
|
protected getSessionMessagesCacheKeyPrefix(chatId: number): string {
|
|
return this.ROOT_CACHE_KEY + 'sessionsMessages:' + chatId + ':';
|
|
}
|
|
}
|