mirror of
https://code.equilibrium.co.ao/ITO/doneit-web.git
synced 2026-04-18 20:47:54 +00:00
Peter Maquiran
419 lines
9.9 KiB
TypeScript
419 lines
9.9 KiB
TypeScript
import { Injectable } from '@angular/core';
|
|
import { RoomService } from './room.service';
|
|
import { WsChatService } from 'src/app/services/chat/ws-chat.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 { Rooms, 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'
|
|
|
|
@Injectable({
|
|
providedIn: 'root'
|
|
})
|
|
export class WsChatMethodsService {
|
|
|
|
dm: {[key: string]: RoomService} = {}
|
|
group: {[key: string]: RoomService} = {}
|
|
|
|
_dm = []
|
|
_group = []
|
|
|
|
loadingWholeList = false
|
|
|
|
dmCount = 0;
|
|
groupCount = 0;
|
|
|
|
currentRoom: RoomService = null
|
|
users: chatUser[] = []
|
|
|
|
constructor(
|
|
private WsChatService: WsChatService,
|
|
private storage: Storage,
|
|
private platform: Platform,
|
|
private sqlservice: SqliteService,
|
|
private NativeNotificationService: NativeNotificationService,
|
|
private sortService: SortService,
|
|
private ChatService: ChatService,
|
|
private NfService: NfService,
|
|
) {
|
|
(async()=>{
|
|
await this.restoreRooms()
|
|
await this.getAllRooms();
|
|
this.subscribeToRoom()
|
|
|
|
|
|
//
|
|
await this.getUser()
|
|
this.getUserStatus()
|
|
|
|
})()
|
|
|
|
this.WsChatService.registerCallback({
|
|
type: 'reConnect',
|
|
funx: ()=>{
|
|
/**
|
|
* @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.subscribeToRoom()
|
|
|
|
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
|
|
}
|
|
|
|
}
|
|
})
|
|
|
|
|
|
// this.WsChatService.registerCallback({
|
|
// type:'Onmessage',
|
|
// funx:(message) => {
|
|
|
|
// if(message.msg =='changed' && message.collection == "stream-room-messages") {
|
|
// if(message.fields.args[0].rid) {
|
|
// // new message
|
|
// const ChatMessage = message.fields.args[0]
|
|
// const messageId = ChatMessage.rid
|
|
|
|
// setTimeout(()=>{
|
|
// this.sortRoomList()
|
|
// }, 100)
|
|
|
|
// }
|
|
// } else if(message.msg =='changed' && message.collection == "stream-notify-room") {
|
|
// if(message.fields.eventName.includes('deleteMessage')) {
|
|
// // delete message
|
|
// const DeletedMessageId = message.fields.args[0]._id;
|
|
|
|
// setTimeout(()=>{
|
|
// this.sortRoomList()
|
|
// }, 100)
|
|
|
|
// } else if(message.fields.eventName.includes('typing')) {
|
|
|
|
// }
|
|
// }
|
|
// }
|
|
// })
|
|
|
|
|
|
}
|
|
|
|
getRoomFromDb() {
|
|
this.storage.get('Rooms').then((rooms) => {
|
|
rooms.result.update.forEach((roomData: room) => {
|
|
this.prepareRoom(roomData);
|
|
});
|
|
})
|
|
}
|
|
|
|
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()
|
|
|
|
}
|
|
|
|
|
|
async restoreRooms() {
|
|
|
|
try {
|
|
const rooms = await this.storage.get('Rooms');
|
|
|
|
if(rooms) {
|
|
await rooms.result.update.forEach( async (roomData: room) => {
|
|
await this.prepareRoom(roomData);
|
|
});
|
|
|
|
}
|
|
|
|
} catch(e){}
|
|
|
|
this.sortRoomList()
|
|
}
|
|
|
|
async getAllRooms () {
|
|
this.loadingWholeList = true
|
|
//this.getRoomFromDb();
|
|
const rooms = await this.WsChatService.getRooms();
|
|
await this.storage.remove('Rooms');
|
|
await this.storage.set('Rooms', rooms);
|
|
|
|
console.log('rooms', rooms)
|
|
|
|
this.dm = {}
|
|
this.group = {}
|
|
this._dm = []
|
|
this._group = []
|
|
|
|
await rooms.result.update.forEach( async (roomData: room) => {
|
|
await this.prepareRoom(roomData);
|
|
});
|
|
|
|
this.sortRoomList()
|
|
this.loadingWholeList = false
|
|
}
|
|
|
|
/**
|
|
* @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() {
|
|
|
|
for (const id in this.dm) {
|
|
this.defaultSubtribe(id)
|
|
}
|
|
|
|
for (const id in this.group) {
|
|
this.defaultSubtribe(id)
|
|
}
|
|
|
|
this.WsChatService.streamNotifyLogged().then((subscription=>{
|
|
console.log('streamRoomMessages', subscription)
|
|
}))
|
|
}
|
|
|
|
/**
|
|
* @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) {
|
|
this.WsChatService.streamRoomMessages(id).then((subscription)=>{
|
|
//console.log('streamRoomMessages', subscription)
|
|
})
|
|
|
|
this.WsChatService.subStreamNotifyRoom(id, 'typing', false)
|
|
this.WsChatService.streamNotifyRoomDeleteMessage(id).then((subscription)=>{
|
|
//console.log('streamNotifyRoomDeleteMessage', subscription);
|
|
})
|
|
}
|
|
|
|
|
|
/**
|
|
* @description create a representation of an room in these instance this.dm, this.group ...
|
|
* @param roomData
|
|
*/
|
|
prepareRoom(roomData) {
|
|
let room:RoomService;
|
|
|
|
room = new RoomService(this.WsChatService, new MessageService(this.storage, this.NfService, this.WsChatService), this.storage, this.platform, this.sqlservice, this.NativeNotificationService, this.sortService, this.ChatService, this.NfService)
|
|
|
|
room.setData({
|
|
customFields: roomData.customFields,
|
|
id: this.getRoomId(roomData),
|
|
name: this.getRoomName(roomData),
|
|
t: roomData.t,
|
|
lastMessage: this.getRoomLastMessage(roomData),
|
|
_updatedAt: new Date(roomData._updatedAt['$date'])
|
|
})
|
|
|
|
room.receiveMessage()
|
|
room.getAllUsers = this.getUsers
|
|
room.receiveMessageDelete();
|
|
room.sortRoomList = this.sortRoomList
|
|
|
|
let roomId = this.getRoomId(roomData)
|
|
|
|
if(this.isIndividual(roomData)) {
|
|
this.dm[roomId] = room
|
|
this._dm.push(room)
|
|
this.dmCount++
|
|
} else {
|
|
this.group[roomId] = room
|
|
this._group.push(room)
|
|
this.groupCount++
|
|
}
|
|
}
|
|
|
|
|
|
|
|
getReceptorName(roomData) {
|
|
try {
|
|
return roomData.usernames.find((e)=> e != SessionStore.user.RochetChatUser)
|
|
} catch(e) {
|
|
return '*'
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @description update user status. this method is called once only
|
|
* @param id user ID
|
|
*/
|
|
private getUserStatus(id?:string) {
|
|
|
|
// this.WsChatService.getUserStatus((d) => {
|
|
|
|
// const username = d.fields.args[0][1]
|
|
// const statusNum = d.fields.args[0][2]
|
|
|
|
// const statusText = this.statusNumberToText(statusNum)
|
|
|
|
// const user = this.getUserByName(username)
|
|
|
|
// if(user) {
|
|
// user.status = statusText
|
|
// }
|
|
|
|
// })
|
|
|
|
}
|
|
|
|
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.WsChatService.deleteMessage(id);
|
|
}
|
|
|
|
leaveRoom(id?) {
|
|
return this.WsChatService.leaveRoom(id);
|
|
}
|
|
|
|
hidingRoom(id?) {
|
|
return this.WsChatService.hidingRoom(id);
|
|
}
|
|
|
|
addRoomOwner(roomid, userId){
|
|
return this.WsChatService.addRoomOwner(roomid, userId);
|
|
}
|
|
|
|
createPrivateRoom(groupName, username, customFields){
|
|
return this.WsChatService.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) {
|
|
if(this.isIndividual(roomData)) {
|
|
const names: String[] = roomData.usernames
|
|
const roomName = names.filter((name)=>{
|
|
return name != SessionStore.user.RochetChatUser
|
|
})[0]
|
|
|
|
const firstName = capitalizeTxt(roomName.split('.')[0])
|
|
const lastName = capitalizeTxt(roomName.split('.')[1])
|
|
return firstName + ' ' + lastName
|
|
} 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() {
|
|
|
|
let _res = await this.ChatService.getAllUsers().toPromise()
|
|
|
|
let user = _res['users'].filter(data => data.username != SessionStore.user.RochetChatUser);
|
|
|
|
user = user.sort((a,b) => {
|
|
if(a.name < b.name) {
|
|
return -1;
|
|
}
|
|
if(a.name > b.name) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
});
|
|
|
|
this.users = user
|
|
}
|
|
|
|
getUserOfRoom(roomId){
|
|
return this.WsChatService.getUserOfRoom(roomId);
|
|
}
|
|
|
|
|
|
}
|