doneit-web/src/app/services/chat/message.service.ts

import { Injectable } from '@angular/core';
import { Message } from 'src/app/models/chatMethod';
import { Storage } from '@ionic/storage';
import { SessionStore } from 'src/app/store/session.service';
import { capitalizeTxt } from 'src/plugin/text'
import { NfService } from 'src/app/services/chat/nf.service'
import { WsChatService } from 'src/app/services/chat/ws-chat.service';
import { showDateDuration } from 'src/plugin/showDateDuration';
import { ChatStorageService } from './chat-storage.service'
import { ChatMethodsService } from './chat-methods.service'
import { MessageModel, DeleteMessageModel } from '../../models/beast-orm'
import { AESEncrypt } from '../aesencrypt.service'

@Injectable({
  providedIn: 'root'
})
export class MessageService {

  customFields
  channels = []
  mentions = []
  msg = ''
  rid = ''
  ts = {}
  
  u = { 
    name: '', 
    username: '', 
    _id: ""
  }

  t = ''
  _id  = ''
  id = '' // table id
  _updatedAt
  file
  attachments
  offline = true
  displayType = ''
  temporaryData: any = {}
  hasFile = false
  hasSendAttachment = false
  sendAttempt = 0
  uploadingFile = false
  errorUploadingAttachment = false
  loadHistory = false
  duration = ''
  localReference = null
  viewed = []
  received = []
  addToDb = false

  messageSend = false
  delate = false
  delateRequest = false

  constructor(private storage: Storage,
    private NfService: NfService,
    private WsChatService: WsChatService,
    private ChatStorageService: ChatStorageService,
    private ChatMethodsService: ChatMethodsService,
    private AESEncrypt: AESEncrypt) {
  }

  setData({customFields = {}, channels, mentions, msg ,rid ,ts, u, t, _id, id, _updatedAt, file, attachments, temporaryData, localReference , viewed = [], received = [], delate = false, delateRequest =false, }:Message) {

    this.channels = channels || []
    this.mentions = mentions || []
    this.msg = msg || ""
    this.rid = rid
    this.ts = ts
    this.u = u || { name: this.usernameToDisplayName(SessionStore.user.RochetChatUser), username: SessionStore.user.RochetChatUser, _id: ""}
    this.t = t
    this._id = _id
    this._updatedAt = _updatedAt || new Date().getTime()
    this.file = file
    this.attachments = attachments
    this.temporaryData = temporaryData
    this.localReference = localReference || null
    this.id = id
    this.delate = delate
    this.delateRequest = delateRequest

    this.viewed =  [...new Set([...viewed,...this.viewed])];
    this.received =   [...new Set([...received,...this.received])];


    if(!this.ts) {
      this.offline = true
      this.messageSend = false
    } else {
      this.messageSend = true
      this.offline = false
    }

    if (this.file) {
      if(this.file.type) {
        if(typeof(this.file.type) == 'string') {
          this.hasFile = true
        }
      }
    }

    if(this.hasFile) {
      // this.getFileFromDb()
      if(this.file.type != 'application/webtrix') {
        this.displayType = this.file.type.replace('application/','').toUpperCase()
      }
    }

    this.calDateDuration()
  }

  private usernameToDisplayName(username) {

    const firstName = capitalizeTxt(username.split('.')[0])
    const lastName =  capitalizeTxt(username.split('.')[1])
    return firstName + ' ' + lastName
  }

  // getFileFromDb() {

  //   if(this.hasFile) {
  //     if (this.file.guid) {
  //       this.storage.get(this.file.guid).then((image) => {
  //         if(image != null) {
  //           this.file.image_url = image
  //         }
  //       });
  //     }
  //   }
  // }

  async send(): Promise<any> {

    this.sendAttempt++;

    if(!this.hasFile) {

      const params =  {roomId:this.rid, msg:this.msg, localReference: this.localReference}
      
      await this.sendRequest(params)

    } else {

      this.uploadingFile = true

      let  uploadSuccessfully = false
      if(this.hasSendAttachment == false) {
        uploadSuccessfully = await this.NfService.beforeSendAttachment(this)
      }

      this.uploadingFile = false

      if(uploadSuccessfully || this.hasSendAttachment == false) {
        this.hasSendAttachment = true
        this.errorUploadingAttachment = false
        this.temporaryData = {}


        const params =  {roomId:this.rid, msg: this.msg, attachments: this.attachments, file: this.file, localReference: this.localReference}
        await this.sendRequest(params)


      } else if(this.WsChatService.isLogin == false) {

        this.WsChatService.registerCallback({
          type: 'reConnect',
          funx: async ()=> {
            this.send()
            return true
          }
        })

      } else if(uploadSuccessfully == false) {
        this.errorUploadingAttachment = true

        return new Promise((resolve, reject)=>{
          reject(false)
        })
        
      }

    }

  }

  async sendRequest(params) {
    this.ChatMethodsService.send(params).subscribe(
      (response: any) => {
        const ChatMessage = response.message
        this.messageSend = true
        this.redefinedMessage(ChatMessage)

      },
      (error) => {
        this.WsChatService.registerCallback({
          type: 'reConnect',
          funx: async ()=> {
            
            this.WsChatService.send(params).then(({message, requestId}) => {
              let ChatMessage = message.result
              this.messageSend = true
              this.redefinedMessage(ChatMessage)
  
            })
            return true
          }
        })
      }
    )
  }

  async redefinedMessage(ChatMessage , update = true) {
    ChatMessage = this.NfService.fix_updatedAt(ChatMessage)
    
    const message = this.getChatObj()

    ChatMessage = Object.assign(message, ChatMessage)
    this.setData(ChatMessage)

    await this.save()
  }

  async downloadFileMsg() {
    const result =  await this.NfService.beforeSendAttachment(this)
    if(result) {

    }

  }

  private calDateDuration(date = null) {
    this.duration = showDateDuration(date || this._updatedAt);
  }


  async deleteFromDB() {
    this.delate = true
    this.save()
  }


  isSenderIsNotMe(ChatMessage) {
    return SessionStore.user.RochetChatUser != ChatMessage.u.username
  }

  messageOwnerById(id) {
    return SessionStore.user.RochetChatUser != this.u.username
  }

  private getChatObj() {
    return {
      channels: this.channels,
      mentions: this.mentions,
      //msg: this.AESEncrypt.encrypt(this.msg, SessionStore.user.RochetChatUser), 
      msg:this.msg, 
      rid: this.rid,
      ts: this.ts,
      u: this.u,
      _id: this._id,
      id: this.id,
      _updatedAt: this._updatedAt,
      messageSend: this.messageSend,
      offline: this.offline,
      viewed: this.viewed,
      received: this.received,
      localReference: this.localReference,
      attachments: this.attachments,
      file: this.file,
      delate: this.delate
    }
  }

  async addMessageDB() {
    if(!this.addToDb) {
      this.addToDb= true
      const message = this.getChatObj()

      delete message.id
      const createdMessage = await MessageModel.create(message)

      this.id = createdMessage.id
    }
  }

  async save() {
    const message = this.getChatObj()

    await MessageModel.update(message)

  }

	decryptMessage() {
    try {
      // this.msg = this.AESEncrypt.decrypt(this.msg, SessionStore.user.RochetChatUser)
    } catch (error) {}
	}

}