mirror of
https://code.equilibrium.co.ao/ITO/doneit-web.git
synced 2026-04-18 20:47:54 +00:00
Peter Maquiran
1297 lines
32 KiB
TypeScript
1297 lines
32 KiB
TypeScript
import { Injectable } from '@angular/core';
|
|
import { RochetChatConnectorService } from 'src/app/services/chat/rochet-chat-connector.service';
|
|
import { MessageService, MessageServiceDateLabel } from 'src/app/services/chat/message.service';
|
|
import { showDateDuration } from 'src/plugin/showDateDuration';
|
|
import { chatHistory } from 'src/app/models/chatMethod';
|
|
import { Storage } from '@ionic/storage';
|
|
import { Platform } from '@ionic/angular';
|
|
import { SqliteService } from 'src/app/services/sqlite.service';
|
|
import { NativeNotificationService } from 'src/app/services/native-notification.service';
|
|
import { SessionStore } from 'src/app/store/session.service';
|
|
import { capitalizeTxt } from 'src/plugin/text'
|
|
import { SortService } from '../functions/sort.service';
|
|
import { chatUser } from 'src/app/models/chatMethod';
|
|
import { environment } from 'src/environments/environment';
|
|
import { ChatService } from 'src/app/services/chat.service';
|
|
import { NfService } from 'src/app/services/chat/nf.service';
|
|
import { v4 as uuidv4 } from 'uuid'
|
|
import { ChatMethodsService } from './chat-methods.service';
|
|
import { DeleteMessageModel, MessageModel } from '../../models/beast-orm';
|
|
import { AESEncrypt } from '../aesencrypt.service';
|
|
import { IncomingChatMessage, ChatMessageInterface, falseTypingMethod } from 'src/app/models/message.model';
|
|
import { AttachmentsService } from 'src/app/services/attachments.service';
|
|
import { ConnectionStatus, NetworkServiceService } from 'src/app/services/network-service.service';
|
|
import { ChatSystemService } from './chat-system.service';
|
|
import { ViewedMessageService } from './viewed-message.service'
|
|
import * as FIFOProcessQueue from 'fifo-process-queue';
|
|
import { NotificationsService } from '../notifications.service';
|
|
import { ChangeDetectorRef } from '@angular/core';
|
|
|
|
@Injectable({
|
|
providedIn: 'root'
|
|
})
|
|
export class RoomService {
|
|
|
|
messages: MessageService[] = []
|
|
storageMessage: any[] = [];
|
|
lastMessage: MessageService;
|
|
messagesBeforeOfflineAPI: MessageService[] = []
|
|
|
|
customFields: any;
|
|
id = ''
|
|
t = ''
|
|
name = ''
|
|
_updatedAt = {}
|
|
hasLoadHistory = false
|
|
DoneLoadingHistory = false
|
|
restoreFromOffline = false
|
|
duration = ''
|
|
isTyping = false
|
|
otherUserType = false
|
|
lastTimeType = null
|
|
message = ''
|
|
lastMessageTxt = ''
|
|
userThatIsTyping = ''
|
|
messagesLocalReference: string[] = []
|
|
members: chatUser[] = []
|
|
membersExcludeMe: chatUser[] = []
|
|
u
|
|
sessionStore = SessionStore
|
|
countDownTime = ''
|
|
chatOpen = false
|
|
messageUnread = false
|
|
|
|
status = {
|
|
receive: {
|
|
message: false,
|
|
typing: false,
|
|
readMessage: false,
|
|
deleteMessage: false
|
|
}
|
|
}
|
|
|
|
isGroup: boolean
|
|
subscribeAttempt = false
|
|
|
|
scrollDown = () => { }
|
|
|
|
/**
|
|
* @description get user list from ws-chat-methods.service
|
|
* @returns chatUser[]
|
|
*/
|
|
getAllUsers = (): chatUser[] => {
|
|
return []
|
|
}
|
|
|
|
sortRoomList = () => { }
|
|
chatServiceDeleteRoom = (roomId) => { }
|
|
private changeDetector: Function = () => {}
|
|
|
|
constructor(
|
|
public RochetChatConnectorService: RochetChatConnectorService,
|
|
private MessageService: MessageService,
|
|
private storage: Storage,
|
|
private platform: Platform,
|
|
private sqlservice: SqliteService,
|
|
private NativeNotificationService: NativeNotificationService,
|
|
private sortService: SortService,
|
|
private chatService: ChatService,
|
|
private NfService: NfService,
|
|
private ChatMethodsService: ChatMethodsService,
|
|
private AESEncrypt: AESEncrypt,
|
|
private AttachmentsService: AttachmentsService,
|
|
private NetworkServiceService: NetworkServiceService,
|
|
private ChatSystemService: ChatSystemService,
|
|
private ViewedMessageService: ViewedMessageService,
|
|
private notificationService: NotificationsService
|
|
) {
|
|
/* this.NativeNotificationService.askForPermission() */
|
|
|
|
this.RochetChatConnectorService.getUserStatus((d) => {
|
|
|
|
const userId = d.fields.args[0][0]
|
|
const statusNum = d.fields.args[0][2]
|
|
const statusText = this.statusNumberToText(statusNum)
|
|
|
|
this.ViewedMessageService.request(this, userId, statusNum, statusText)
|
|
|
|
})
|
|
|
|
this.RochetChatConnectorService.registerCallback({
|
|
type: 'Offline',
|
|
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.resetStatus();
|
|
this.hasLoadHistory = false
|
|
this.subscribeAttempt = false
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
/**
|
|
* @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"
|
|
}
|
|
}
|
|
|
|
|
|
resetStatus() {
|
|
this.status = {
|
|
receive: {
|
|
message: false,
|
|
typing: false,
|
|
readMessage: false,
|
|
deleteMessage: false
|
|
}
|
|
}
|
|
}
|
|
|
|
setDataOnce = false
|
|
setData({ membersExcludeMe, members, u, customFields = {}, id, name, t, lastMessage = new MessageService(this.NfService, this.RochetChatConnectorService, this.ChatMethodsService, this.AESEncrypt, this.AttachmentsService, this.NetworkServiceService, this.ChatSystemService, this.notificationService), _updatedAt }) {
|
|
this.customFields = customFields
|
|
this.id = id
|
|
this.name = name
|
|
this.t = t
|
|
this.lastMessage = lastMessage
|
|
this._updatedAt = _updatedAt
|
|
this.u = u
|
|
this.calDateDuration();
|
|
|
|
|
|
if (this.customFields?.countDownDate) {
|
|
this.countDownDate(this.customFields.countDownDate);
|
|
}
|
|
|
|
if (this.setDataOnce == false) {
|
|
this.setDataOnce = true
|
|
this.updateContacts()
|
|
}
|
|
|
|
}
|
|
|
|
updateInfo() {
|
|
// this.chatService.getRoomInfo(this.id).toPromise();
|
|
|
|
}
|
|
|
|
setChangeDetector(x:Function) {
|
|
console.log("set change detector")
|
|
this.changeDetector = x
|
|
}
|
|
|
|
get online() {
|
|
|
|
if (!this.isGroup) {
|
|
for (let user of this.ChatSystemService.users) {
|
|
|
|
for (const members of this.membersExcludeMe) {
|
|
if (members._id == user._id) {
|
|
return user.status
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return 'offline'
|
|
}
|
|
|
|
countDownDate(date) {
|
|
let difference = new Date(date).getTime() - new Date().getTime();
|
|
let c_day = Math.floor(difference / (1000 * 60 * 60 * 24));
|
|
let c_hours = Math.floor((difference % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
|
|
let c_minutes = Math.floor((difference % (1000 * 60 * 60)) / (1000 * 60));
|
|
let c_seconds = Math.floor((difference % (1000 * 60)) / 1000);
|
|
|
|
this.countDownTime = this.addZero(c_day) + " : " + this.addZero(c_hours) + " : " + this.addZero(c_minutes) + " : " + this.addZero(c_seconds);
|
|
|
|
if (difference < 0) {
|
|
|
|
this.deleteRoom();
|
|
|
|
} else {
|
|
setTimeout(() => {
|
|
this.countDownDate(date)
|
|
}, 1000)
|
|
}
|
|
}
|
|
|
|
addZero(i) {
|
|
if (i < 10) {
|
|
i = "0" + i;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
deleteRoom() {
|
|
this.countDownTime = "Expired";
|
|
let body = { "roomId": this.id }
|
|
|
|
// this.chatService.getRoomInfo(this.id).subscribe( room =>{});
|
|
|
|
if (this.t === 'p') {
|
|
this.chatService.deleteGroup(body).subscribe(res => {
|
|
this.ChatSystemService.deleteRoom(this.id);
|
|
this.ChatSystemService.getAllRooms();
|
|
this.chatServiceDeleteRoom(this.id);
|
|
}, (error)=> {
|
|
if(error.status != 0) {
|
|
this.ChatSystemService.deleteRoom(this.id);
|
|
this.ChatSystemService.getAllRooms();
|
|
this.chatServiceDeleteRoom(this.id);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
this.chatService.deleteChannel(body).subscribe(res => {
|
|
this.ChatSystemService.deleteRoom(this.id);
|
|
this.ChatSystemService.getAllRooms();
|
|
this.chatServiceDeleteRoom(this.id);
|
|
}, (error)=> {
|
|
if(error.status != 0) {
|
|
this.ChatSystemService.deleteRoom(this.id);
|
|
this.ChatSystemService.getAllRooms();
|
|
this.chatServiceDeleteRoom(this.id);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
isSenderIsNotMe(ChatMessage) {
|
|
return SessionStore.user.UserName != ChatMessage.u.username
|
|
}
|
|
|
|
senderId(ChatMessage) {
|
|
return ChatMessage.u._id
|
|
}
|
|
|
|
receiveMessage() {
|
|
|
|
this.RochetChatConnectorService.updateRoomEventss(
|
|
this.id,
|
|
"stream-room-messages",
|
|
async (IncomingChatMessage: IncomingChatMessage) => {
|
|
|
|
this.appendReceiveMessage.push(IncomingChatMessage)
|
|
|
|
}
|
|
)
|
|
|
|
this.RochetChatConnectorService.receiveStreamNotifyRoom((message) => {
|
|
|
|
if (message.fields.eventName == this.id + '/' + 'typing') {
|
|
|
|
const args = message.fields.args
|
|
|
|
if (typeof args[1] != 'object') {
|
|
this.userThatIsTyping = this.usernameToDisplayName(args[0])
|
|
|
|
const user = args[0]
|
|
if (SessionStore.user.UserName != user) {
|
|
this.readAllMessage()
|
|
this.isTyping = args[1]
|
|
this.otherUserType = args[1]
|
|
}
|
|
|
|
} else if (args[0]?.method == 'viewMessage' || args[1]?.method == 'viewMessage') {
|
|
const user = args[0]
|
|
|
|
if (SessionStore.user.UserName != user) {
|
|
this.readAllMessage()
|
|
}
|
|
|
|
} else if (args[0]?.method == 'deleteMessage' || args[1]?.method == 'deleteMessage') {
|
|
|
|
this.deleteMessage(args[1]?.method?._id)
|
|
|
|
} else {
|
|
|
|
}
|
|
|
|
} else if (message.fields.eventName == this.id + '/' + 'deleteMessage') { }
|
|
|
|
})
|
|
}
|
|
|
|
appendReceiveMessage = FIFOProcessQueue(async (IncomingChatMessage: IncomingChatMessage, done) => {
|
|
|
|
let IncomingChatMessageArgs = IncomingChatMessage.fields.args[0]
|
|
let ChatMessage: ChatMessageInterface = this.fix_updatedAt(IncomingChatMessageArgs)
|
|
|
|
|
|
let found = this.findMessageBy_id(ChatMessage._id) ||
|
|
this.findMessageBy_localReference(ChatMessage?.localReference)
|
|
// || await this.findMessageInDBByData({_id:ChatMessage._id, localReference:ChatMessage.localReference })
|
|
|
|
if (!found) {
|
|
|
|
ChatMessage.origin = 'stream'
|
|
const message = await this.prepareCreate({ message: ChatMessage, save: false });
|
|
this.registerSendMessage(message)
|
|
|
|
message.from = 'stream'
|
|
message.loadHistory = this.DoneLoadingHistory
|
|
|
|
this.lastMessage = message;
|
|
|
|
try {
|
|
this.calDateDuration(ChatMessage._updatedAt);
|
|
} catch (error) {
|
|
console.log(error)
|
|
}
|
|
|
|
|
|
if (message.t == 'r') {
|
|
this.name = message.msg;
|
|
}
|
|
|
|
//if (this.isSenderIsNotMe(ChatMessage)) {
|
|
/* this.NativeNotificationService.sendNotificationChat({
|
|
message: message.msg,
|
|
title: this.name
|
|
}); */
|
|
//}
|
|
|
|
if (this.hasLoadHistory == true) {
|
|
this.messages.push(message)
|
|
message.addMessageDB()
|
|
} else {
|
|
this.messagesBeforeOfflineAPI.push(message)
|
|
}
|
|
|
|
this.messageUnread = true
|
|
setTimeout(() => {
|
|
this.scrollDown()
|
|
}, 50)
|
|
|
|
}
|
|
|
|
if (ChatMessage?.t == "au" || ChatMessage?.t == "ru" || ChatMessage?.t == "ul") {
|
|
this.updateContacts()
|
|
} else if (ChatMessage?.t == "r") {
|
|
this.name = ChatMessage.msg
|
|
}
|
|
|
|
this.changeDetector()
|
|
setTimeout(() => {
|
|
done()
|
|
}, 5)
|
|
})
|
|
|
|
|
|
async info() {
|
|
|
|
// set unread messages
|
|
const response: any = await this.chatService.GetSubscriptionRoomUnreadM(this.id).toPromise()
|
|
|
|
if(response?.subscription?.unread >= 1) {
|
|
this.messageUnread = true
|
|
}
|
|
}
|
|
|
|
getUsersByStatus(status: 'offline' | 'online') {
|
|
|
|
return this.getAllUsers().filter((user => {
|
|
for (const member of this.membersExcludeMe) {
|
|
if (user._id == member._id && user.status == status) {
|
|
return true
|
|
}
|
|
}
|
|
}))
|
|
|
|
}
|
|
|
|
getRoomMembersIds(): string[] {
|
|
try {
|
|
return this.membersExcludeMe.map((user) => user._id)
|
|
} catch (error) {
|
|
return []
|
|
}
|
|
|
|
}
|
|
|
|
getAllMemberThatIsNotOffline(): string[] {
|
|
|
|
const membersIds = this.getRoomMembersIds()
|
|
const allChatUsers = this.getAllUsers()
|
|
|
|
const AllMemberThatIsNotOffline = []
|
|
|
|
for (let user of allChatUsers) {
|
|
if (membersIds.includes(user._id)) {
|
|
|
|
if (user.status != 'offline') {
|
|
AllMemberThatIsNotOffline.push(user._id)
|
|
}
|
|
}
|
|
}
|
|
|
|
return AllMemberThatIsNotOffline
|
|
}
|
|
|
|
getAllMemberThatIsOffline(): string[] {
|
|
|
|
const membersIds = this.getRoomMembersIds()
|
|
const allChatUsers = this.getAllUsers()
|
|
|
|
const AllMemberThatIsNotOffline = []
|
|
|
|
for (let user of allChatUsers) {
|
|
if (membersIds.includes(user._id)) {
|
|
|
|
if (user.status == 'offline') {
|
|
AllMemberThatIsNotOffline.push(user._id)
|
|
}
|
|
}
|
|
}
|
|
|
|
return AllMemberThatIsNotOffline
|
|
}
|
|
|
|
|
|
async deleteMessageToReceive(userId) {
|
|
|
|
const allDeleteMessages = await DeleteMessageModel.filter({ rid: this.id }).execute()
|
|
|
|
for (let message_ of allDeleteMessages) {
|
|
|
|
if (message_.needToReceiveBy.includes(userId)) {
|
|
|
|
message_.needToReceiveBy = message_.needToReceiveBy.filter((e) => e != userId)
|
|
this.sendFalseTypingReadMessage('deleteMessage', { _id: message_.messageId })
|
|
|
|
if (message_.needToReceiveBy.length == 0) {
|
|
|
|
const deleteMessage = await DeleteMessageModel.get({ messageId: message_.messageId })
|
|
await deleteMessage.delete()
|
|
|
|
} else {
|
|
await DeleteMessageModel.update(message_)
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async receiveMessageDelete() {
|
|
|
|
this.RochetChatConnectorService.updateRoomEventss(
|
|
this.id,
|
|
"stream-notify-room",
|
|
async (ChatMessage) => {
|
|
const DeletedMessageId = ChatMessage.fields.args[0]._id;
|
|
|
|
const message = this.messages.find((e) => e._id == DeletedMessageId)
|
|
|
|
if (message) {
|
|
if (message.delate == false) {
|
|
this.deleteMessage(DeletedMessageId)
|
|
}
|
|
} else {
|
|
const message = await MessageModel.get({ _id: DeletedMessageId })
|
|
if (message) {
|
|
(message as MessageModel).delete()
|
|
|
|
DeleteMessageModel.create({
|
|
messageId: DeletedMessageId,
|
|
rid: this.id,
|
|
ts: "",
|
|
u: {},
|
|
needToReceiveBy: []
|
|
})
|
|
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
)
|
|
}
|
|
|
|
/**
|
|
* @description delete message in the view
|
|
* @param id message ID
|
|
*/
|
|
async deleteMessage(_id) {
|
|
|
|
const id = _id
|
|
|
|
for (let i = 0; i <= this.messages.length; i++) {
|
|
|
|
if (this.messages[i]?._id == id) {
|
|
|
|
|
|
if (SessionStore.user.UserName == this.messages[i]?.u?.username) {
|
|
const allMemberThatIsOffline = this.getAllMemberThatIsOffline()
|
|
|
|
DeleteMessageModel.create({
|
|
messageId: this.messages[i]._id,
|
|
rid: this.messages[i].rid,
|
|
ts: this.messages[i].ts,
|
|
u: this.messages[i].u,
|
|
needToReceiveBy: allMemberThatIsOffline
|
|
})
|
|
}
|
|
|
|
this.messages[i]?.delateDB()
|
|
this.messages.splice(i, 1)
|
|
|
|
//Get previous last message from room
|
|
const previousLastMessage = this.messages.slice(-1)[0];
|
|
|
|
if (previousLastMessage.dateLabel == false) {
|
|
if (previousLastMessage) {
|
|
this.lastMessage = previousLastMessage;
|
|
this.calDateDuration(previousLastMessage._updatedAt)
|
|
this.sortRoomList()
|
|
}
|
|
} else {
|
|
const previousLastMessage = this.messages.slice(-2)[0];
|
|
|
|
if (previousLastMessage) {
|
|
this.lastMessage = previousLastMessage;
|
|
this.calDateDuration(previousLastMessage._updatedAt)
|
|
this.sortRoomList()
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true
|
|
|
|
} else {
|
|
//
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* @description delete message in the view
|
|
* @param id message ID
|
|
*/
|
|
async deleteMessageFromArray(_id) {
|
|
|
|
const id = _id
|
|
|
|
for (let i = 0; i <= this.messages.length; i++) {
|
|
|
|
if (this.messages[i]?._id == id) {
|
|
|
|
this.messages.splice(i, 1)
|
|
|
|
return true
|
|
|
|
} else {
|
|
//
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
deleteAll() {
|
|
this.messages.forEach((message) => {
|
|
if (message?._id) {
|
|
this.sendDeleteRequest(message._id)
|
|
}
|
|
})
|
|
}
|
|
|
|
async delateMessageToSendToOthers(userId) {
|
|
|
|
const deleteMessage = await DeleteMessageModel.all();
|
|
|
|
const toSend = deleteMessage.filter((DeleteMessage: string[]) => !DeleteMessage.includes(userId))
|
|
|
|
}
|
|
|
|
|
|
async sendDeleteRequest(msgId) {
|
|
|
|
const message = this.messages.find((e) => e._id == msgId)
|
|
await message.delateStatusFalse()
|
|
|
|
if (this.NetworkServiceService.getCurrentNetworkStatus() == ConnectionStatus.Online) {
|
|
|
|
this.RochetChatConnectorService.deleteMessage(msgId).then(async () => {
|
|
message.delateRequest = true
|
|
await message.saveChanges();
|
|
this.deleteMessage(msgId);
|
|
})
|
|
|
|
} else {
|
|
this.RochetChatConnectorService.registerCallback({
|
|
type: 'reConnect',
|
|
funx: async () => {
|
|
|
|
this.sendDeleteRequest(msgId)
|
|
return true
|
|
}
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* @description sen text message
|
|
*/
|
|
async send({ file = null, attachments = null, temporaryData = {}, attachmentsModelData = {} }) {
|
|
|
|
this.message = this.message.replace(/(\n$)/, '')
|
|
|
|
if (file && this.message) {
|
|
this.send({})
|
|
}
|
|
|
|
const localReference = uuidv4();
|
|
|
|
let offlineChatMessage = {
|
|
rid: this.id,
|
|
msg: this.message,
|
|
attachments,
|
|
file,
|
|
temporaryData,
|
|
localReference,
|
|
origin: 'local',
|
|
attachmentsModelData
|
|
}
|
|
|
|
|
|
//console.log('offlineChatMessage', offlineChatMessage)
|
|
|
|
this.message = ''
|
|
|
|
this.hojeLabel({ ...offlineChatMessage })
|
|
|
|
const message: MessageService = await this.prepareCreate({ message: offlineChatMessage, save: environment.chatOffline })
|
|
this.registerSendMessage(message)
|
|
|
|
if (this.hasLoadHistory == true) {
|
|
await message.addMessageDB()
|
|
}
|
|
|
|
message.send()
|
|
message.from = 'send'
|
|
message.loadHistory = this.hasLoadHistory
|
|
|
|
if (environment.chatOffline) {
|
|
|
|
setTimeout(() => {
|
|
this.scrollDown()
|
|
}, 150)
|
|
|
|
this.lastMessage = message
|
|
this.calDateDuration(message._updatedAt)
|
|
this.sortRoomList()
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Register all send message so that
|
|
* the incoming message wont be confuse to
|
|
* other user the localReference is the identifier
|
|
*/
|
|
registerSendMessage(message: MessageService) {
|
|
this.messagesLocalReference.push(message.localReference)
|
|
}
|
|
|
|
|
|
localReferenceExist(message: MessageService) {
|
|
for (const localReference of this.messagesLocalReference) {
|
|
if (localReference == message?.localReference) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
sendTyping(text: string = this.message) {
|
|
|
|
if (this.lastMessageTxt == text) { return false }
|
|
this.lastTimeType = new Date().getTime()
|
|
|
|
const lastIsTyping = this.isTyping
|
|
if (text.length >= 1) {
|
|
this.isTyping = true
|
|
} else {
|
|
this.isTyping = false
|
|
}
|
|
|
|
if (lastIsTyping != this.isTyping) {
|
|
this.RochetChatConnectorService.sendStreamNotifyRoom(this.id, SessionStore.user.UserName, 'typing', this.isTyping).catch((error) => console.error(error));
|
|
}
|
|
|
|
this.lastMessageTxt = this.message
|
|
this.typingWatch()
|
|
}
|
|
|
|
sendFalseTypingReadMessage(method, param: object) {
|
|
this.RochetChatConnectorService.sendStreamNotifyRoom(this.id, SessionStore.user.UserName, 'typing', { method: method, params: param } as falseTypingMethod).catch((error) => console.error(error))
|
|
this.setTypingOff()
|
|
}
|
|
|
|
private typingWatch() {
|
|
setTimeout(() => {
|
|
const now = new Date().getTime()
|
|
|
|
if ((now - this.lastTimeType) >= 2888) {
|
|
|
|
if (this.isTyping == true) {
|
|
this.isTyping = false
|
|
this.RochetChatConnectorService.sendStreamNotifyRoom(this.id, SessionStore.user.UserName, 'typing', this.isTyping).catch((error) => console.error(error))
|
|
}
|
|
}
|
|
|
|
}, 3000)
|
|
}
|
|
|
|
private setTypingOff() {
|
|
this.sendTyping('')
|
|
}
|
|
|
|
roomLeave() {
|
|
this.setTypingOff()
|
|
this.chatOpen = false
|
|
}
|
|
|
|
open() {
|
|
// this.typing(this.message)
|
|
this.chatOpen = true
|
|
this.messageUnread = false
|
|
this.sendReadMessage()
|
|
}
|
|
|
|
|
|
leave(rid?) {
|
|
this.RochetChatConnectorService.leaveRoom(this.id).catch((error) => console.error(error))
|
|
}
|
|
|
|
isJson(str) {
|
|
try {
|
|
JSON.parse(str);
|
|
} catch (e) {
|
|
return "";
|
|
}
|
|
return JSON.parse(str);
|
|
}
|
|
|
|
formatDateToDDMMYYYY(dateStamp) {
|
|
const date = new Date(dateStamp);
|
|
|
|
const day = date.getDate().toString().padStart(2, '0');
|
|
const month = (date.getMonth() + 1).toString().padStart(2, '0'); // Month is zero-based
|
|
const year = date.getFullYear();
|
|
|
|
return `${day}-${month}-${year}`;
|
|
}
|
|
|
|
sortArrayISODate(messages: any): any[] {
|
|
|
|
return messages.sort((a, b) =>
|
|
new Date(b._updatedAt).getTime()
|
|
-
|
|
new Date(a._updatedAt).getTime())
|
|
}
|
|
|
|
restoreOnce = false
|
|
labelDates = []
|
|
|
|
|
|
goshPush(ChatMessage) {
|
|
let currentDateMessage = new Date(ChatMessage._updatedAt).toLocaleDateString()
|
|
|
|
if (currentDateMessage) {
|
|
if (!this.labelDates.find(e => e == currentDateMessage)) {
|
|
this.labelDates.push(currentDateMessage)
|
|
|
|
const newMessage = this.fix_updatedAt({ ...ChatMessage })
|
|
newMessage.msg = currentDateMessage
|
|
const cloneMessage = new MessageServiceDateLabel()
|
|
|
|
cloneMessage.ChatSystemService = this.ChatSystemService
|
|
cloneMessage.setData({ ...newMessage } as any)
|
|
//
|
|
cloneMessage._id = ""
|
|
cloneMessage._updatedAt = ""
|
|
cloneMessage.duration = ""
|
|
cloneMessage.msg = currentDateMessage
|
|
cloneMessage.dateLabel = true
|
|
cloneMessage.delate = false
|
|
cloneMessage.file = undefined
|
|
cloneMessage.attachments = undefined
|
|
|
|
if (new Date().toLocaleDateString() == currentDateMessage) {
|
|
|
|
cloneMessage.msg = "hoje"
|
|
} else {
|
|
cloneMessage.msg = currentDateMessage
|
|
}
|
|
|
|
this.messages.push(cloneMessage as any)
|
|
|
|
// console.log(currentDateMessage)
|
|
}
|
|
}
|
|
}
|
|
|
|
async deleteMessageDate(MessageService: MessageService) {
|
|
|
|
let currentDateMessageToDelete = new Date(MessageService._updatedAt).toLocaleDateString()
|
|
|
|
for (let i = 0; i <= this.messages.length; i++) {
|
|
|
|
let currentDateMessage = new Date(this.messages[i]._updatedAt).toLocaleDateString()
|
|
|
|
if (currentDateMessageToDelete == currentDateMessage) {
|
|
return
|
|
}
|
|
}
|
|
|
|
for (let i = 0; i <= this.messages.length; i++) {
|
|
if (this.messages[i].dateLabel) {
|
|
if (this.messages[i].msg == currentDateMessageToDelete) {
|
|
this.messages.splice(i, 1)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
hojeLabel(offlineChatMessage: any) {
|
|
let currentDateMessage = new Date().toLocaleDateString()
|
|
if (!this.labelDates.find(e => e == currentDateMessage)) {
|
|
|
|
this.labelDates.push(currentDateMessage)
|
|
|
|
const cloneMessage = new MessageServiceDateLabel()
|
|
|
|
cloneMessage.ChatSystemService = this.ChatSystemService
|
|
cloneMessage.setData({ ...offlineChatMessage } as any)
|
|
|
|
cloneMessage.msg = "hoje"
|
|
cloneMessage._id = ""
|
|
cloneMessage._updatedAt = ""
|
|
cloneMessage.duration = ""
|
|
cloneMessage.dateLabel = true
|
|
cloneMessage.delate = false
|
|
cloneMessage.attachments = undefined
|
|
cloneMessage.file = undefined
|
|
|
|
this.messages.push(cloneMessage as any)
|
|
}
|
|
}
|
|
|
|
async restoreMessageFromDB() {
|
|
if (environment.chatOffline && this.restoreOnce == false) {
|
|
this.restoreOnce = true
|
|
|
|
const messages = this.sortArrayISODate(await MessageModel.filter({ rid: this.id }).execute()).reverse()
|
|
|
|
for (let ChatMessage of messages) {
|
|
|
|
|
|
this.goshPush(ChatMessage)
|
|
|
|
|
|
const wewMessage = await this.simplePrepareMessage(ChatMessage)
|
|
|
|
wewMessage.from = 'Offline'
|
|
wewMessage.loadHistory = this.hasLoadHistory
|
|
wewMessage.messageModelInstance = ChatMessage
|
|
|
|
if (wewMessage.offline == false) {
|
|
|
|
const message = await this.prepareCreate({ message: ChatMessage })
|
|
|
|
|
|
message.from = 'Offline'
|
|
message.loadHistory = this.hasLoadHistory
|
|
wewMessage.messageModelInstance = ChatMessage
|
|
message?.decryptMessage()
|
|
|
|
} else {
|
|
|
|
const offlineMessage = await this.prepareCreate({ message: ChatMessage })
|
|
|
|
offlineMessage.from = 'Offline'
|
|
offlineMessage.loadHistory = this.hasLoadHistory
|
|
wewMessage.messageModelInstance = ChatMessage
|
|
this.registerSendMessage(offlineMessage)
|
|
offlineMessage?.decryptMessage()
|
|
offlineMessage.send()
|
|
|
|
}
|
|
|
|
if (wewMessage.delate && !wewMessage.offline && !wewMessage.delateRequest) {
|
|
this.sendDeleteRequest(wewMessage._id)
|
|
}
|
|
}
|
|
|
|
if (!this.lastMessage) {
|
|
this.lastMessage = messages.pop();
|
|
}
|
|
|
|
|
|
setTimeout(() => {
|
|
this.scrollDown()
|
|
}, 50)
|
|
}
|
|
}
|
|
|
|
// runs onces only
|
|
loadHistoryCount = 0
|
|
localMessages = []
|
|
async loadHistory({ limit = 1000, forceUpdate = false }) {
|
|
|
|
if (forceUpdate == false) {
|
|
if (this.hasLoadHistory) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
this.hasLoadHistory = true
|
|
|
|
await this.restoreMessageFromDB()
|
|
const chatHistory: chatHistory = await this.RochetChatConnectorService.loadHistory(this.id, limit)
|
|
|
|
this.localMessages = this.messages.map(e => e._id)
|
|
|
|
if (Array.isArray(chatHistory?.result?.messages)) {
|
|
|
|
const users = this.getUsersByStatus('online')
|
|
|
|
if(chatHistory.result.unreadNotLoaded >= 1) {
|
|
this.messageUnread = true
|
|
}
|
|
|
|
for (let message of chatHistory.result.messages.reverse()) {
|
|
|
|
message.origin = 'history'
|
|
message.from = 'History'
|
|
const messagesToSave = await this.prepareMessageCreateIfNotExist({ message: message });
|
|
if (messagesToSave != null) {
|
|
|
|
messagesToSave.received = users.map((user) => user._id)
|
|
messagesToSave.addMessageDB()
|
|
}
|
|
|
|
}
|
|
|
|
|
|
for (const message of this.messagesBeforeOfflineAPI) {
|
|
const messagesToSave = await this.prepareMessageCreateIfNotExist({ message: message });
|
|
if (messagesToSave != null) {
|
|
|
|
messagesToSave.received = users.map((user) => user._id)
|
|
|
|
this.addMessageDB.push(messagesToSave)
|
|
}
|
|
}
|
|
this.messagesBeforeOfflineAPI = []
|
|
|
|
setTimeout(() => {
|
|
this.scrollDown()
|
|
}, 50)
|
|
|
|
}
|
|
|
|
this.DoneLoadingHistory = true
|
|
|
|
if (chatHistory?.result?.messages) {
|
|
|
|
if (!this.lastMessage) {
|
|
this.lastMessage = chatHistory?.result?.messages.pop() as any
|
|
}
|
|
}
|
|
|
|
this.deletedMessages(chatHistory)
|
|
}
|
|
|
|
|
|
deletedMessages(chatHistory: chatHistory) {
|
|
|
|
const messagesToDelete = this.localMessages.filter(id => {
|
|
const found = chatHistory.result.messages.find(e => {
|
|
return e._id == id
|
|
})
|
|
if (!found) {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
})
|
|
|
|
|
|
for (const id of messagesToDelete) {
|
|
if (id != '') {
|
|
this.deleteMessage(id)
|
|
}
|
|
}
|
|
}
|
|
|
|
addMessageDB = FIFOProcessQueue(async ({ messagesToSave }, callback) => {
|
|
|
|
await messagesToSave.addMessageDB()
|
|
callback()
|
|
})
|
|
|
|
async readAllMessage() {
|
|
|
|
this.ViewedMessageService.requestReadAll(this)
|
|
|
|
}
|
|
|
|
|
|
|
|
async ChatMessageIsPresentInTheView(ChatMessage: ChatMessageInterface) {
|
|
let foundIndex;
|
|
|
|
const found = this.messages.find((MessageService, index) => {
|
|
if (MessageService._id == ChatMessage._id) {
|
|
foundIndex = index
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
})
|
|
|
|
if (foundIndex) {
|
|
return { found, foundIndex }
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
async prepareCreate({ message, save = true }): Promise<MessageService> {
|
|
message = this.fix_updatedAt(message)
|
|
|
|
const wewMessage = new MessageService(this.NfService, this.RochetChatConnectorService, this.ChatMethodsService, this.AESEncrypt, this.AttachmentsService, this.NetworkServiceService, this.ChatSystemService, this.notificationService)
|
|
wewMessage.setData(message)
|
|
wewMessage.loadHistory = this.hasLoadHistory
|
|
|
|
if (save) {
|
|
this.messages.push(wewMessage)
|
|
}
|
|
|
|
return wewMessage
|
|
}
|
|
|
|
|
|
simplePrepareMessage(message) {
|
|
message = this.fix_updatedAt(message)
|
|
const wewMessage = new MessageService(this.NfService, this.RochetChatConnectorService, this.ChatMethodsService, this.AESEncrypt, this.AttachmentsService, this.NetworkServiceService, this.ChatSystemService, this.notificationService)
|
|
wewMessage.setData(message)
|
|
wewMessage.loadHistory = this.hasLoadHistory
|
|
|
|
return wewMessage
|
|
}
|
|
|
|
|
|
private findMessageBy_id(id) {
|
|
for (let m of this.messages) {
|
|
if (m?._id == id) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
private findMessageBy_localReference(localReference) {
|
|
for (let m of this.messages) {
|
|
if (m?.localReference == localReference) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
private async findMessageInDBByLocalReference({ localReference }) {
|
|
const a = await MessageModel.get({ localReference: localReference })
|
|
|
|
return typeof a.id == 'number'
|
|
}
|
|
|
|
private async findMessageInDBByLocalId({ _id }) {
|
|
const a = await MessageModel.get({ _id: _id })
|
|
return typeof a.id == 'number'
|
|
}
|
|
|
|
private async findMessageInDBByData({ localReference, _id }) {
|
|
|
|
const a = await MessageModel.filter({ localReference: localReference }).execute()
|
|
if (a.length >= 1) {
|
|
|
|
return true
|
|
}
|
|
|
|
const c = await MessageModel.filter({ _id: _id }).execute()
|
|
if (c.length >= 1) {
|
|
|
|
return true
|
|
}
|
|
|
|
|
|
return false
|
|
}
|
|
|
|
async prepareMessageCreateIfNotExist({ message }) {
|
|
message = this.fix_updatedAt(message)
|
|
|
|
let found = await this.findMessageBy_id(message._id) || await this.findMessageBy_localReference(message.localReference)
|
|
// || await this.findMessageInDBByData({_id:message._id, localReference:message.localReference })
|
|
|
|
if (!found) {
|
|
const wewMessage = this.simplePrepareMessage(message)
|
|
this.goshPush(wewMessage)
|
|
this.messages.push(wewMessage)
|
|
return wewMessage
|
|
} else {
|
|
return null
|
|
}
|
|
}
|
|
|
|
private calDateDuration(date = null) {
|
|
this.duration = showDateDuration(date || this._updatedAt);
|
|
this._updatedAt = date || this._updatedAt
|
|
}
|
|
|
|
private fix_updatedAt(message): ChatMessageInterface {
|
|
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
|
|
}
|
|
|
|
usernameToDisplayName(username) {
|
|
|
|
try {
|
|
const firstName = capitalizeTxt(username.split('.')[0])
|
|
const lastName = capitalizeTxt(username.split('.')[1])
|
|
return firstName + ' ' + lastName
|
|
} catch (error) {
|
|
return username
|
|
}
|
|
|
|
}
|
|
|
|
sendReadMessage() {
|
|
this.RochetChatConnectorService.readMessage(this.id).catch((error) => {
|
|
console.error(error)
|
|
})
|
|
this.sendFalseTypingReadMessage('viewMessage', {})
|
|
this.messageUnread = false
|
|
}
|
|
|
|
async addContacts(userId: any) {
|
|
|
|
let body = {
|
|
"roomId": this.id,
|
|
"userId": userId,
|
|
}
|
|
|
|
await this.chatService.addUserToGroup(body).toPromise();
|
|
this.ChatSystemService.getGroupRoom(this.id).updateContacts()
|
|
}
|
|
|
|
|
|
async updateContacts() {
|
|
|
|
let res
|
|
let error = false
|
|
|
|
if (this.t == 'd') {
|
|
|
|
try {
|
|
res = await this.chatService.getMembers(this.id).toPromise();
|
|
} catch (e) {
|
|
await this.chatService.refreshtoken();
|
|
error = true
|
|
}
|
|
|
|
if (error) {
|
|
res = await this.chatService.getMembers(this.id).toPromise();
|
|
}
|
|
|
|
} else {
|
|
if (this.t === 'p') {
|
|
|
|
try {
|
|
res = await this.chatService.getGroupMembers(this.id).toPromise()
|
|
} catch (e) {
|
|
await this.chatService.refreshtoken();
|
|
error = true
|
|
}
|
|
|
|
if (error) {
|
|
res = await this.chatService.getGroupMembers(this.id).toPromise()
|
|
}
|
|
|
|
|
|
setTimeout(() => {
|
|
// console.log("getGroupMembers", this.membersExcludeMe)
|
|
}, 500)
|
|
|
|
}
|
|
else {
|
|
|
|
try {
|
|
res = await this.chatService.getChannelMembers(this.id).toPromise()
|
|
|
|
} catch (e) {
|
|
await this.chatService.refreshtoken();
|
|
error = true
|
|
}
|
|
|
|
if (error) {
|
|
res = await this.chatService.getChannelMembers(this.id).toPromise()
|
|
}
|
|
|
|
setTimeout(() => {
|
|
console.log("getChannelMembers", this.membersExcludeMe)
|
|
}, 500)
|
|
}
|
|
}
|
|
|
|
const members = res['members'];
|
|
const users = members.filter(data => data.username != this.sessionStore.user.UserName);
|
|
this.members = members
|
|
this.membersExcludeMe = users
|
|
}
|
|
}
|