mirror of
https://code.equilibrium.co.ao/ITO/doneit-web.git
synced 2026-04-18 20:47:54 +00:00
Peter Maquiran
814 lines
19 KiB
TypeScript
814 lines
19 KiB
TypeScript
import { Injectable } from '@angular/core';
|
|
import { RoomService } from './room.service';
|
|
import { RochetChatConnectorService } from 'src/app/services/chat/rochet-chat-connector.service';
|
|
import { MessageService } from 'src/app/services/chat/message.service';
|
|
import { SessionStore } from 'src/app/store/session.service';
|
|
import { capitalizeTxt } from 'src/plugin/text';
|
|
import { Update as room } from 'src/app/models/chatMethod';
|
|
import { Storage } from '@ionic/storage';
|
|
import { Platform } from '@ionic/angular';
|
|
import { SqliteService } from 'src/app/services/sqlite.service';
|
|
import { ChatService } from 'src/app/services/chat.service';
|
|
import { NativeNotificationService } from 'src/app/services/native-notification.service';
|
|
import { SortService } from '../functions/sort.service';
|
|
import { chatUser } from 'src/app/models/chatMethod';
|
|
import { NfService } from 'src/app/services/chat/nf.service'
|
|
import { ChangeProfileService } from '../change-profile.service';
|
|
import { ChatMethodsService } from './chat-methods.service';
|
|
import { AESEncrypt } from '../aesencrypt.service'
|
|
import { AttachmentsService } from 'src/app/services/attachments.service';
|
|
import { NetworkServiceService } from 'src/app/services/network-service.service';
|
|
import { ViewedMessageService } from './viewed-message.service'
|
|
import { NotificationsService } from '../notifications.service';
|
|
import { Subscribe } from '../subcribe';
|
|
import { Plugins } from '@capacitor/core';
|
|
|
|
const { App } = Plugins;
|
|
|
|
@Injectable({
|
|
providedIn: 'root'
|
|
})
|
|
export class ChatSystemService {
|
|
|
|
dm: { [key: string]: RoomService } = {}
|
|
group: { [key: string]: RoomService } = {}
|
|
|
|
_dm: RoomService[] = []
|
|
_group: RoomService[] = []
|
|
|
|
loadingWholeList = false;
|
|
|
|
dmCount = 0;
|
|
groupCount = 0;
|
|
|
|
currentRoom: RoomService = null
|
|
users: chatUser[] = []
|
|
sessionStore = SessionStore
|
|
delete = []
|
|
loadingUsers = false
|
|
|
|
onRoomsLoad = new Subscribe({ execute: false, deleteOnExecute: true })
|
|
|
|
|
|
constructor(
|
|
private RochetChatConnectorService: RochetChatConnectorService,
|
|
private storage: Storage,
|
|
private platform: Platform,
|
|
private sqlservice: SqliteService,
|
|
private NativeNotificationService: NativeNotificationService,
|
|
private sortService: SortService,
|
|
private ChatService: ChatService,
|
|
private NfService: NfService,
|
|
private changeProfileService: ChangeProfileService,
|
|
private chatService: ChatService,
|
|
private ChatMethodsService: ChatMethodsService,
|
|
private AESEncrypt: AESEncrypt,
|
|
private AttachmentsService: AttachmentsService,
|
|
private NetworkServiceService: NetworkServiceService,
|
|
private ViewedMessageService: ViewedMessageService,
|
|
private notificationService: NotificationsService
|
|
) {
|
|
|
|
|
|
this.RochetChatConnectorService.registerCallback({
|
|
type: 'reConnect',
|
|
funx: async () => {
|
|
/**
|
|
* @description when the phone is in the background for a long time it could disconnects from the socket then the socket reconnects automatically,
|
|
* when the connection is lost the subscribe is also lost, so we have to subscribe again when reconnection is establish.
|
|
*/
|
|
|
|
this.RochetChatConnectorService.setStatus('online')
|
|
this.getUserStatus();
|
|
await this.chatService.refreshtoken();
|
|
this.getUser();
|
|
this.getAllRooms();
|
|
this.subscribeToRoom();
|
|
//
|
|
|
|
|
|
if (this.currentRoom) {
|
|
this.currentRoom.loadHistory({ forceUpdate: true })
|
|
}
|
|
|
|
for (const id in this.dm) {
|
|
this.dm[id].hasLoadHistory = false
|
|
}
|
|
|
|
for (const id in this.group) {
|
|
this.group[id].hasLoadHistory = false
|
|
}
|
|
|
|
}
|
|
})
|
|
|
|
if (this.sessionStore.user.Inactivity) {
|
|
this.loadChat();
|
|
}
|
|
|
|
|
|
if (SessionStore.user?.ChatData?.data) {
|
|
this.restoreRooms();
|
|
}
|
|
|
|
document.addEventListener('resume', () => {
|
|
this.RochetChatConnectorService.setStatus('online')
|
|
if (this._dm?.length == 0 && this._group?.length == 0) {
|
|
if (SessionStore.user?.ChatData?.data) {
|
|
this.getAllRooms();
|
|
}
|
|
|
|
}
|
|
});
|
|
|
|
try {
|
|
if (!this.platform.is('desktop')) {
|
|
App.addListener('appStateChange', ({ isActive }) => {
|
|
if (isActive) {
|
|
// The app is in the foreground.
|
|
console.log('App is in the foreground');
|
|
|
|
if (SessionStore.user?.ChatData?.data) {
|
|
this.currentRoom?.loadHistory({ forceUpdate: true })
|
|
}
|
|
|
|
setTimeout(() => {
|
|
if (SessionStore.user?.ChatData?.data) {
|
|
this.subscribeToRoom()
|
|
this.RochetChatConnectorService.setStatus('online')
|
|
}
|
|
}, 1000);
|
|
|
|
/* this.reloadComponent(true) */
|
|
} else {
|
|
// The app is in the background.
|
|
console.log('App is in the background');
|
|
// You can perform actions specific to the background state here.
|
|
}
|
|
});
|
|
}
|
|
} catch(error) {}
|
|
|
|
|
|
|
|
}
|
|
|
|
loadChat() {
|
|
if (SessionStore.user?.ChatData?.data) {
|
|
this.ReLoadChat()
|
|
}
|
|
}
|
|
|
|
private async ReLoadChat() {
|
|
|
|
if (SessionStore.user?.ChatData?.data) {
|
|
this.getUserStatus();
|
|
await this.chatService.refreshtoken();
|
|
|
|
this.restoreUsers();
|
|
await this.getUser();
|
|
await this.restoreRooms();
|
|
await this.getAllRooms();
|
|
this.subscribeToRoom();
|
|
}
|
|
//
|
|
|
|
}
|
|
|
|
clearChat() {
|
|
this.dm = {}
|
|
this.group = {}
|
|
this._dm = []
|
|
this._group = []
|
|
|
|
this.loadingWholeList = false;
|
|
|
|
this.dmCount = 0;
|
|
this.groupCount = 0;
|
|
|
|
this.currentRoom = null
|
|
this.users = []
|
|
this.storage.remove('Users');
|
|
}
|
|
|
|
openRoom(roomId) {
|
|
|
|
if (this.currentRoom) {
|
|
this.currentRoom.roomLeave()
|
|
}
|
|
|
|
if (this.getDmRoom(roomId)) {
|
|
this.currentRoom = this.getDmRoom(roomId)
|
|
} else if (this.getGroupRoom(roomId)) {
|
|
this.currentRoom = this.getGroupRoom(roomId)
|
|
}
|
|
|
|
this.currentRoom.open()
|
|
|
|
}
|
|
|
|
getRoomById(roomId) {
|
|
if (this.getDmRoom(roomId)) {
|
|
return this.getDmRoom(roomId)
|
|
} else if (this.getGroupRoom(roomId)) {
|
|
return this.getGroupRoom(roomId)
|
|
}
|
|
}
|
|
|
|
async restoreRooms() {
|
|
|
|
try {
|
|
const _rooms = await this.storage.get('Rooms');
|
|
|
|
if (_rooms) {
|
|
for (let roomData of this.sortArrayISODate(_rooms)) {
|
|
await this.prepareRoom(roomData);
|
|
}
|
|
}
|
|
} catch (e) { }
|
|
|
|
}
|
|
|
|
async restoreUsers() {
|
|
const users = await this.storage.get('Users');
|
|
|
|
if (users) {
|
|
this.users = users
|
|
|
|
}
|
|
}
|
|
|
|
sortArrayISODate(messages: any): any[] {
|
|
|
|
return messages.sort((a, b) =>
|
|
new Date(b._updatedAt).getTime()
|
|
-
|
|
new Date(a._updatedAt).getTime())
|
|
}
|
|
|
|
async getAllRooms(callback: Function = () => { }, roomIdCallback = "") {
|
|
this.loadingWholeList = true
|
|
var rooms;
|
|
|
|
if (this.RochetChatConnectorService.isLogin) {
|
|
try {
|
|
rooms = await this.RochetChatConnectorService.getRooms();
|
|
} catch (error) {
|
|
this.loadingWholeList = false
|
|
console.error('chatgetrooms', error)
|
|
}
|
|
try {
|
|
await this.storage.remove('Rooms');
|
|
} catch (e) { }
|
|
}
|
|
|
|
let index = 0
|
|
|
|
let _rooms = rooms?.result?.update
|
|
|
|
if (_rooms) {
|
|
|
|
_rooms = _rooms.map(e => {
|
|
e["_updatedAt"] = e._updatedAt || e._updatedAt['$date']
|
|
return e
|
|
})
|
|
|
|
for (let roomData of this.sortArrayISODate(_rooms)) {
|
|
|
|
const roomId = this.getRoomId(roomData);
|
|
|
|
if (roomData.t == 'd') {
|
|
await this.prepareRoom(roomData);
|
|
} else {
|
|
if (roomData.t === 'p') {
|
|
await this.prepareRoom(roomData);
|
|
}
|
|
else {
|
|
await this.prepareRoom(roomData);
|
|
}
|
|
}
|
|
|
|
if (roomId == roomIdCallback) {
|
|
callback()
|
|
}
|
|
|
|
index++;
|
|
}
|
|
}
|
|
|
|
this.loadingWholeList = false
|
|
this.sortRoomList()
|
|
await this.storage.set('Rooms', _rooms);
|
|
|
|
this.onRoomsLoad.executor()
|
|
}
|
|
|
|
|
|
async getRoom(_rooms: any) {
|
|
this.loadingWholeList = true
|
|
|
|
let index = 0
|
|
|
|
if (_rooms) {
|
|
|
|
_rooms = _rooms.map(e => {
|
|
e["_updatedAt"] = e._updatedAt || e._updatedAt['$date']
|
|
return e
|
|
})
|
|
|
|
for (let roomData of this.sortArrayISODate(_rooms)) {
|
|
|
|
if (roomData.t == 'd') {
|
|
|
|
await this.prepareRoom(roomData);
|
|
} else {
|
|
if (roomData.t === 'p') {
|
|
|
|
await this.prepareRoom(roomData);
|
|
|
|
}
|
|
else {
|
|
|
|
await this.prepareRoom(roomData);
|
|
}
|
|
|
|
}
|
|
|
|
index++;
|
|
}
|
|
}
|
|
|
|
this.loadingWholeList = false
|
|
this.sortRoomList()
|
|
|
|
this.onRoomsLoad.executor()
|
|
}
|
|
|
|
/**
|
|
* @description sort room list by last message date
|
|
*/
|
|
sortRoomList = () => {
|
|
|
|
this._dm = this.sortService.sortDate(this._dm, '_updatedAt').reverse()
|
|
this._group = this.sortService.sortDate(this._group, '_updatedAt').reverse()
|
|
}
|
|
|
|
/**
|
|
* @description subscribe all room
|
|
*/
|
|
subscribeToRoom() {
|
|
|
|
if (SessionStore.user?.ChatData?.data) {
|
|
|
|
for (const id in this.dm) {
|
|
this.defaultSubtribe(id)
|
|
}
|
|
|
|
for (const id in this.group) {
|
|
this.defaultSubtribe(id)
|
|
}
|
|
|
|
this.RochetChatConnectorService.streamNotifyLogged().then((subscription => { }))
|
|
|
|
this.RochetChatConnectorService.subStreamMessageUser().then((subscription => {
|
|
console.log({subscription})
|
|
}))
|
|
} else {
|
|
|
|
setTimeout(() => {
|
|
throw ('No chat data');
|
|
}, 1000)
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* @description when a new room is create, needs to subtribe in order to receive updates
|
|
* @param id
|
|
* @param roomData
|
|
*/
|
|
subscribeToRoomUpdate(id, roomData) {
|
|
|
|
this.defaultSubtribe(id);
|
|
|
|
this.prepareRoom(roomData);
|
|
|
|
this.getGroupRoom(id).loadHistory({});
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* @deprecated things a room need to subscribe on
|
|
* @param id room id
|
|
*/
|
|
private defaultSubtribe(id: any) {
|
|
|
|
const room = this.getRoomById(id);
|
|
|
|
if (!room.subscribeAttempt) {
|
|
|
|
try {
|
|
|
|
room.subscribeAttempt = true;
|
|
} catch (error) {
|
|
console.log("error")
|
|
}
|
|
|
|
|
|
this.RochetChatConnectorService.streamRoomMessages(id).then((subscription) => {
|
|
room.status.receive.message = true;
|
|
})
|
|
|
|
this.RochetChatConnectorService.subStreamNotifyRoom(id, 'typing', false).then((subscription) => {
|
|
room.status.receive.typing = true;
|
|
//
|
|
})
|
|
|
|
this.RochetChatConnectorService.subStreamNotifyRoom(id, 'readMessage', false).then((subscription) => {
|
|
room.status.receive.readMessage = true;
|
|
})
|
|
|
|
this.RochetChatConnectorService.streamNotifyRoomDeleteMessage(id).then((subscription) => {
|
|
room.status.receive.deleteMessage = true;
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
private fix_updatedAt(message) {
|
|
if (message.result) {
|
|
message.result._updatedAt = message.result._updatedAt['$date']
|
|
} else if (message._updatedAt) {
|
|
if (message._updatedAt.hasOwnProperty('$date')) {
|
|
message._updatedAt = message._updatedAt['$date']
|
|
}
|
|
}
|
|
return message
|
|
}
|
|
|
|
/**
|
|
* @description create a representation of an room in these instance this.dm, this.group ...
|
|
* @param roomData
|
|
*/
|
|
prepareRoom(roomData) {
|
|
|
|
|
|
/**
|
|
* @description data used to define or create room
|
|
*/
|
|
|
|
|
|
roomData = this.fix_updatedAt(roomData)
|
|
const setData = {
|
|
customFields: roomData.customFields,
|
|
id: this.getRoomId(roomData),
|
|
name: this.getRoomName(roomData),
|
|
t: roomData.t,
|
|
lastMessage: this.getRoomLastMessage(roomData),
|
|
_updatedAt: new Date(roomData._updatedAt || roomData._updatedAt['$date']),
|
|
u: roomData.u || {},
|
|
members: [],
|
|
membersExcludeMe: []
|
|
}
|
|
|
|
let roomId = this.getRoomId(roomData);
|
|
|
|
let chat = false
|
|
if (roomData?.usernames) {
|
|
if (roomData?.usernames?.includes("chat.admin")) {
|
|
chat = true
|
|
}
|
|
}
|
|
|
|
if (setData.name != 'Rocket Cat' && setData.name != 'general' && chat == false) {
|
|
// create room
|
|
if (!this.roomExist(roomId)) {
|
|
let room: RoomService = new RoomService(this.RochetChatConnectorService, new MessageService(this.NfService, this.RochetChatConnectorService, this.ChatMethodsService, this.AESEncrypt, this.AttachmentsService, this.NetworkServiceService, this, this.notificationService), this.storage, this.platform, this.sqlservice, this.NativeNotificationService, this.sortService, this.ChatService, this.NfService, this.ChatMethodsService, this.AESEncrypt, this.AttachmentsService, this.NetworkServiceService, this, this.ViewedMessageService, this.notificationService)
|
|
room.setData(setData)
|
|
room.receiveMessage()
|
|
room.getAllUsers = this.getUsers
|
|
room.receiveMessageDelete();
|
|
room.sortRoomList = this.sortRoomList
|
|
room.chatServiceDeleteRoom = this.deleteRoom
|
|
room.isGroup = !this.isIndividual(roomData)
|
|
room.info()
|
|
|
|
|
|
// create individual room
|
|
if (this.isIndividual(roomData)) {
|
|
|
|
this.dm[roomId] = room
|
|
this._dm.push(room)
|
|
this.dmCount++
|
|
|
|
} else {
|
|
// create group room
|
|
|
|
this.group[roomId] = room
|
|
this._group.push(room)
|
|
this.groupCount++
|
|
|
|
}
|
|
|
|
this.defaultSubtribe(roomId)
|
|
} else {
|
|
// in this case room is already present, therefor it will only be necessary,
|
|
// to redefine
|
|
|
|
if (this.dm[roomId]) {
|
|
this.dm[roomId].setData(setData)
|
|
} else if (this.group[roomId]) {
|
|
this.group[roomId].setData(setData)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
deleteRoom = (roomId) => {
|
|
|
|
this.delete.push(roomId)
|
|
delete this.group[roomId];
|
|
this._group = this._group.filter((e) => e.id != roomId);
|
|
}
|
|
|
|
deleteRecently(roomId) {
|
|
return this.delete.includes(roomId)
|
|
}
|
|
|
|
roomExist(roomId) {
|
|
return this.dm[roomId]?.id || this.group[roomId]?.id
|
|
}
|
|
|
|
getReceptorName(roomData) {
|
|
try {
|
|
return roomData.usernames.find((e) => e != SessionStore.user.UserName)
|
|
} catch (e) {
|
|
return '*'
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @description update user status. this method is called once only
|
|
* @param id user ID
|
|
*/
|
|
private getUserStatus(id?: string) {
|
|
|
|
this.RochetChatConnectorService.getUserStatus(async (d) => {
|
|
|
|
const userId = d.fields.args[0][0]
|
|
const username = d.fields.args[0][1]
|
|
let statusNum = d.fields.args[0][2]
|
|
|
|
const statusText = this.statusNumberToText(statusNum)
|
|
|
|
for (const user in this.users) {
|
|
if (this.users[user]._id == userId) {
|
|
this.users[user].status = statusText
|
|
}
|
|
}
|
|
|
|
this.getUser()
|
|
|
|
})
|
|
}
|
|
|
|
getUserByName(username) {
|
|
return this.users.find((user) => user.username == username)
|
|
}
|
|
|
|
/**
|
|
* @description convert rocketchat statues num to readable string
|
|
* @param text
|
|
* @returns
|
|
*/
|
|
statusNumberToText(text) {
|
|
if (text == '0') {
|
|
return "offline"
|
|
}
|
|
else if (text == '1') {
|
|
return "online"
|
|
}
|
|
else if (text == '2') {
|
|
return "away"
|
|
}
|
|
else if (text == '3') {
|
|
return "busy"
|
|
}
|
|
}
|
|
|
|
|
|
deleteMessage(id?) {
|
|
return this.RochetChatConnectorService.deleteMessage(id);
|
|
}
|
|
|
|
leaveRoom(id?) {
|
|
return this.RochetChatConnectorService.leaveRoom(id);
|
|
}
|
|
|
|
async hideRoom(id) {
|
|
this._dm.forEach((md, index) => {
|
|
if (md.id == id) {
|
|
this._dm.splice(index, 1)
|
|
delete this.dm[id]
|
|
}
|
|
});
|
|
|
|
this._group.forEach((group, index) => {
|
|
if (group.id == id) {
|
|
this._group.splice(index, 1)
|
|
delete this.group[id]
|
|
}
|
|
})
|
|
}
|
|
|
|
hidingRoom(id?) {
|
|
|
|
return this.RochetChatConnectorService.hidingRoom(id).then(() => {
|
|
// this.hideRoom(id)
|
|
})
|
|
|
|
}
|
|
|
|
addRoomOwner(roomid, userId) {
|
|
return this.RochetChatConnectorService.addRoomOwner(roomid, userId);
|
|
}
|
|
|
|
createPrivateRoom(groupName, username, customFields) {
|
|
return this.RochetChatConnectorService.createPrivateRoom(groupName, username, customFields);
|
|
}
|
|
|
|
getDmRoom(id): RoomService {
|
|
try {
|
|
return this.dm[id]
|
|
} catch (e) { }
|
|
}
|
|
|
|
getGroupRoom(id): RoomService {
|
|
try {
|
|
return this.group[id]
|
|
} catch (e) { }
|
|
}
|
|
|
|
getRoomName(roomData: room): string {
|
|
if (this.isIndividual(roomData)) {
|
|
const names: String[] = roomData.usernames
|
|
|
|
|
|
if (roomData.t == 'd') {
|
|
|
|
const username = roomData.usernames.find(e => e != SessionStore.user.UserName)
|
|
|
|
try {
|
|
const firstName = capitalizeTxt(username.split('.')[0])
|
|
const lastName = capitalizeTxt(username.split('.')[1])
|
|
|
|
return firstName + ' ' + lastName
|
|
} catch (error) {
|
|
const username = roomData.usernames.find(e => e != SessionStore.user.UserName)
|
|
|
|
const firstName = capitalizeTxt(username.split('.')[0])
|
|
return firstName
|
|
}
|
|
|
|
} else {
|
|
if (roomData.t === 'p') {
|
|
return 'Loading'
|
|
}
|
|
else {
|
|
return 'Loading'
|
|
}
|
|
}
|
|
|
|
} else {
|
|
return roomData.fname
|
|
}
|
|
}
|
|
|
|
getRoomId(roomData: room) {
|
|
return roomData._id
|
|
}
|
|
|
|
getRoomLastMessage(roomData: room): any {
|
|
return roomData.lastMessage
|
|
}
|
|
|
|
private isIndividual(roomData: room) {
|
|
return !roomData.fname
|
|
}
|
|
|
|
getUsers = () => {
|
|
return this.users
|
|
}
|
|
|
|
async getUser() {
|
|
|
|
this.loadingUsers = true
|
|
let _res
|
|
|
|
try {
|
|
_res = await this.ChatService.getAllUsers().toPromise();
|
|
} catch (error) {
|
|
await this.chatService.refreshtoken();
|
|
_res = await this.ChatService.getAllUsers().toPromise();
|
|
}
|
|
|
|
let users: chatUser[] = _res['users'].filter(data => data.username != SessionStore.user.UserName);
|
|
|
|
users = users.filter((data) => !(data.name == 'Rocket.Cat' || data.name == 'Administrator'))
|
|
|
|
const userIds = this.users.map((user) => user._id)
|
|
|
|
for (let UserUpdate of users) {
|
|
if (userIds.includes(UserUpdate._id)) {
|
|
for (var index = 0; index < this.users.length; index++) {
|
|
if (UserUpdate._id == this.users[index]._id) {
|
|
this.users[index] = UserUpdate
|
|
}
|
|
}
|
|
} else {
|
|
this.users.push(UserUpdate)
|
|
}
|
|
}
|
|
|
|
this.users = this.users.sort((a, b) => {
|
|
if (a.name < b.name) {
|
|
return -1;
|
|
}
|
|
if (a.name > b.name) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
});
|
|
|
|
await this.storage.set('Users', this.users);
|
|
|
|
this.loadingUsers = false
|
|
|
|
}
|
|
|
|
getUserOfRoom(roomId) {
|
|
return this.RochetChatConnectorService.getUserOfRoom(roomId);
|
|
}
|
|
|
|
|
|
async createGroup(name) {
|
|
const res: any = await this.createPrivateRoom(name, SessionStore.user.UserName, {});
|
|
if (res?.result?.rid) {
|
|
try {
|
|
await this.getAllRooms();
|
|
} catch (e) { }
|
|
return res
|
|
} else {
|
|
return res
|
|
}
|
|
}
|
|
|
|
|
|
async createGroup__(name, customFields = {}) {
|
|
const res: any = await this.createPrivateRoom(name, SessionStore.user.UserName, customFields);
|
|
console.log('room is created', res)
|
|
if (res?.result?.rid) {
|
|
try {
|
|
await this.getAllRooms();
|
|
return res
|
|
} catch (e) { }
|
|
console.log('room is loaded')
|
|
return res
|
|
} else {
|
|
return res
|
|
}
|
|
}
|
|
|
|
getGroupByName(name) {
|
|
return this._group.find(e => e.name == name)
|
|
}
|
|
|
|
async waitRoomToCreate(rid): Promise<RoomService> {
|
|
return new Promise(async (resolve, reject) => {
|
|
let sub;
|
|
|
|
sub = this.onRoomsLoad.subscribe(() => {
|
|
const room = this.getRoomById(rid)
|
|
if (room) {
|
|
resolve(room)
|
|
sub.unSubscribe()
|
|
}
|
|
})
|
|
|
|
try {
|
|
await this.getAllRooms();
|
|
} catch (e) { }
|
|
|
|
})
|
|
}
|
|
|
|
searchContact(name, username) {
|
|
return this.users.find(e => e.name == name || e.username == username)
|
|
}
|
|
|
|
}
|