ets/service/ConversationListService.ets

/**
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * 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 HiLog from '../utils/HiLog';
import common from '../data/commonData';
import ConversationListModel from '../model/ConversationListModel';
import ConversationService from './ConversationService';
import ContactService from './ContactsService';
import commonService from './CommonService';
import telephoneUtils from '../utils/TelephoneUtil';
import LooseObject from '../data/LooseObject'

const TAG = "ConversationListService";

export default class ConversationListService {
  private static instance: ConversationListService;
  private conversationListModel: ConversationListModel = new ConversationListModel();

  private constructor() {
  }

  public static getInstance(): ConversationListService {
    if (ConversationListService.instance == null) {
      ConversationListService.instance = new ConversationListService();
    }
    return ConversationListService.instance;
  }

  public insertSession(valueBucket, callback, context): void {
    let mmsContext = context ? context : globalThis.mmsContext;
    if (globalThis.DataWorker != null) {
      globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.insertSession, {
        valueBucket: valueBucket,
        context: mmsContext
      }, res => {
        if (callback) {
          callback(res);
        }
      });
    } else {
      this.conversationListModel.insertSession(valueBucket, callback, mmsContext);
    }
    globalThis.needToUpdate = true;
  }

  public deleteSessionByCondition(actionData, callback, context): void {
    let mmsContext = context ? context : globalThis.mmsContext;
    if (globalThis.DataWorker != null) {
      globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.deleteSessionByCondition, {
        actionData: actionData,
        context: mmsContext
      }, res => {
        if (callback) {
          callback(res);
        }
      });
    } else {
      this.conversationListModel.deleteSessionByCondition(actionData, callback, mmsContext);
    }
    globalThis.needToUpdate = true;
  }

  public updateSessionByCondition(actionData, valueBucket, callback, context): void {
    let mmsContext = context ? context : globalThis.mmsContext;
    if (globalThis.DataWorker != null) {
      globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.updateSessionByCondition, {
        actionData: actionData,
        valueBucket: valueBucket,
        context: mmsContext
      }, res => {
        if (callback) {
          callback(res);
        }
      });
    } else {
      this.conversationListModel.updateSessionByCondition(actionData, valueBucket, callback, mmsContext);
    }
    globalThis.needToUpdate = true;
  }

  public querySessionByCondition(actionData, callback, context): void {
    let mmsContext = context ? context : globalThis.mmsContext;
    if (globalThis.DataWorker != null) {
      globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.querySessionByCondition, {
        actionData: actionData,
        context: mmsContext
      }, res => {
        callback(res);
      });
    } else {
      this.conversationListModel.querySessionByCondition(actionData, callback, mmsContext);
    }
  }

  public querySessionSizeByCondition(actionData, callback, context): void {
    let mmsContext = context ? context : globalThis.mmsContext;
    if (globalThis.DataWorker != null) {
      globalThis.DataWorker.sendRequest(common.RUN_IN_WORKER_METHOD.querySessionSizeByCondition, {
        actionData: actionData,
        context: mmsContext
      }, res => {
        callback(res);
      });
    } else {
      this.conversationListModel.querySessionSizeByCondition(actionData, callback, mmsContext);
    }
  }

  public async getSessionListSize(actionData, context): Promise<number> {
    let condition: LooseObject = {};
    condition.smsType = actionData.smsType;
    let result: Promise<number> = new Promise((resolve) => {
      this.querySessionSizeByCondition(condition, res => {
        let size: number = 0;
        if (res.code == common.int.SUCCESS && res.abilityResult != null) {
          size = res.abilityResult;
        }
        resolve(size);
      }, context);
    });
    return result;
  }

  public getSessionListResult(actionData, context): Promise<LooseObject> {
    let result: Promise<LooseObject> = new Promise((resolve) => {
      this.querySessionByCondition(actionData, res => {
        let result: LooseObject = {
          "messageList": [],
          "telephones": []
        };
        if (res.code == common.int.SUCCESS && res.abilityResult != null) {
          result = this.getConvertSessionListResult(res.abilityResult);
        }
        resolve(result);
      }, context)
    });
    return result;
  }

  public isExistNoticeMessage(context): Promise<boolean> {
    let result: Promise<boolean> = new Promise((resolve) => {
      let actionData: LooseObject = {};
      actionData.smsType = common.sms_type.NOTICE;
      this.querySessionSizeByCondition(actionData, res => {
        let isExistNoticeMessage: boolean = false;
        if (res.code == common.int.SUCCESS && res.abilityResult != null && res.abilityResult > 0) {
          isExistNoticeMessage = true;
        }
        resolve(isExistNoticeMessage);
      }, context);
    });
    return result;
  }

  public querySessionList(actionData, callback, context): void {
    let result: LooseObject = {};
    let queryPromise: Promise<LooseObject> = this.getSessionListResult(actionData, context);
    let countPromise: Promise<number> = this.getSessionListSize(actionData, context);
    let noticePromise: Promise<boolean> = this.isExistNoticeMessage(context);
    Promise.all([queryPromise, countPromise, noticePromise]).then(res => {
      result.code = common.int.SUCCESS;
      result.total = res[1];
      result.hasInfoMsg = res[2];
      result.response = [];
      HiLog.i(TAG, "querySessionList, sessionList.length: " + res[0].messageList.length + ", total=" + result.total
      + ", hasInfoMsg=" + result.hasInfoMsg);
      if (result.total > 0) {
        this.dealContactsName(res[0].telephones, actionData, res[0].messageList, res => {
          result.response = res;
          callback(result);
        }, context);
      } else {
        callback(result);
      }
    }).catch(error => {
      HiLog.e(TAG, "querySessionList, error: " + JSON.stringify(error));
      result.code = common.int.FAILURE;
      callback(result);
    });
  }

  private getConvertSessionListResult(sessionList): LooseObject {
    let result: LooseObject = {
      "messageList": [],
      "telephones": []
    };
    if (sessionList == null) {
      return result;
    }
    let messageList: Array<LooseObject> = [];
    let telephones: Array<LooseObject> = [];
    for (let session of sessionList) {
      let item: LooseObject = {};
      item.name = common.string.EMPTY_STR;
      item.contactsNum = session.contactsNum;
      item.content = session.content;
      item.countOfUnread = session.unreadCount;
      if (session.smsType == common.sms_type.COMMON) {
        item.icon = "icon/user_avatar_full_fill.svg";
      } else {
        item.icon = "icon/entrance_icon01.svg";
      }
      item.smsType = session.smsType;
      item.isCbChecked = false;
      item.isLock = false;
      item.sendingFailed = session.sendStatus == common.int.SEND_MESSAGE_FAILED ? true : false;
      item.telephone = session.telephone;
      if (item.contactsNum > 1) {
        let telephoneSplit = item.telephone.split(common.string.COMMA);
        for (let item of telephoneSplit) {
          telephones.push(item);
        }
      } else {
        telephones.push(item.telephone);
      }
      item.telephoneFormat = session.telephoneFormat;
      item.threadId = session.id;
      item.timeMillisecond = session.time;
      item.isDraft = session.hasDraft == 1 ? true : false;
      item.isLock = session.hasLock == 1 ? true : false;
      item.time = common.string.EMPTY_STR;
      item.messageCount = session.messageCount;
      item.hasMms = session.hasMms == 1 ? true : false;
      item.hasAttachment = session.hasAttachment == 1 ? true : false;
      messageList.push(item);
    }
    result.messageList = messageList;
    result.telephones = telephones;
    return result;
  }

  private dealContactsName(telephones, actionData, sessionLists, callback, context) {
    if (telephones.length == 0) {
      HiLog.w(TAG, "dealContactsName, has no telephones");
      callback(sessionLists);
      return;
    }
    actionData.telephones = telephones;
    actionData.hasDelete = "0";
    ContactService.getInstance().queryContactDataByCondition(actionData, res => {
      if (res.code == common.int.FAILURE || res.abilityResult.length == 0) {
        HiLog.w(TAG, "dealContactsName, has no contacts");
        callback(sessionLists);
      } else {
        callback(this.buildSessionNames(res.abilityResult, sessionLists));
      }
    }, context);
  }

  private buildSessionNames(contacts, sessionLists) {
    let telephoneMap = new Map();
    for (let item of contacts) {
      if (item.displayName == common.string.EMPTY_STR) {
        telephoneMap.set(item.detailInfo, item.detailInfo);
      } else {
        telephoneMap.set(item.detailInfo, item.displayName);
      }
    }
    for (let session of sessionLists) {
      if (session.contactsNum > 1) {
        this.dealMultiName(session, telephoneMap);
      } else if (telephoneMap.has(session.telephone)) {
        session.name = telephoneMap.get(session.telephone);
      }
    }
    return sessionLists;
  }

  private dealMultiName(session, telephoneMap): void {
    let telephones: Array<string> = session.telephone.split(common.string.COMMA);
    let name: string = common.string.EMPTY_STR;
    for (let telephone of telephones) {
      if (telephoneMap.has(telephone)) {
        name = name + telephoneMap.get(telephone) + common.string.COMMA;
      } else {
        name = name + telephone + common.string.COMMA;
      }
    }
    session.name = name.substring(0, name.length - 1);
  }

  public statisticalData(callBack, context): void {
    let normalPromise = new Promise<LooseObject>((resolve) => {
      ConversationService.getInstance().statisticalData(res => {
        if (res.code == common.int.SUCCESS) {
          resolve(res.abilityResult);
        } else {
          HiLog.w(TAG, "statisticalData, failed");
        }
      }, context);
    });
    let notifyPromise = new Promise<number>((resolve) => {
      ConversationService.getInstance().statisticsUnreadNotify(res => {
        resolve(res);
      }, context);
    });
    let result: LooseObject = {};
    Promise.all([normalPromise, notifyPromise]).then(res => {
      let normalResult: LooseObject = res[0];
      let notifyResult: number = res[1];
      result.code = common.int.SUCCESS;
      let response: LooseObject = {};
      response.totalListCount = normalResult.totalListCount;
      response.unreadCount = normalResult.totalListCount - notifyResult;
      response.unreadTotalOfInfo = notifyResult;
      result.response = response;
      callBack(result);
    }).catch(error => {
      HiLog.e(TAG, "statisticalData, failed: " + JSON.stringify(error));
      result.code = common.int.FAILURE;
      callBack(result);
    });
  }

  public deleteMessageById(actionData, callback, context): void {
    // Deletes data from the session list.
    this.deleteSessionByCondition(actionData, callback, context);
    // Deletes data from the information list.
    ConversationService.getInstance().deleteSmsMmsInfoByCondition(actionData, null, null);
  }

  public markAllToRead(actionData) {
    actionData.unreadCount_greaterThan = 0;
    let sessionValueBucket: LooseObject = {
      "unread_count": 0
    };
    this.updateSessionByCondition(actionData, sessionValueBucket, null, null);

    actionData.hasRead = common.is_read.UN_READ;
    let smsMmsInfoValueBucket: LooseObject = {
      "is_read": common.is_read.READ
    };
    ConversationService.getInstance().updateSmsMmsInfoByCondition(actionData, smsMmsInfoValueBucket, null, null);
  }

  /**
   * Adding a session draft list
   *
   * @param valueBucket New Data
   * @callback callback
   */
  public insertSessionDraft(actionData, callback, context): void {
    let param: LooseObject = this.dealSendResults(actionData);
    // Check whether a session list has been created
    this.querySessionByTelephone(param.telephone, res => {
      if (res.code == common.int.SUCCESS && res.response.id <= 0) {
        // If you modify the recipient in draft state and save the modification again, you need to delete the
        // unnecessary session draft before modification.
        if (actionData.threadId != 0 && actionData.isDraft) {
          this.deleteSessionByCondition(actionData, null, null);
        }
        this.dealInsertSession(param, actionData, callback, context);
      } else {
        this.deleteDraftDataOrUpdate(actionData, res.response, param, callback, context);
      }
      globalThis.needToUpdate = true;
    }, context);
  }

  public dealInsertSession(param, actionData, callback, context): void {
    let valueBucket: LooseObject = {
      "telephone": param.telephone,
      "content": param.content,
      "contacts_num": param.contactsNum,
      "sms_type": param.smsType,
      "unread_count": 0,
      "sending_status": common.int.SEND_MESSAGE_SENDING,
      "has_draft": common.has_draft.HAVE,
      "time": param.timestamp,
      "has_mms": param.hasMms,
      "has_attachment": param.hasAttachment,
    }
    this.insertSession(valueBucket, sessionResult => {
      // Invoke the SMS database to insert SMS messages.
      let sessionId: number = sessionResult.abilityResult;
      ConversationService.getInstance().dealInsertMessageDetail(param, actionData, sessionId, res => {
        callback();
      }, context);
    }, context);
  }

  public deleteDraftDataOrUpdate(actionData, response, param, callback, context): void {
    if (actionData.groupId > 0) {
      ConversationService.getInstance().deleteSmsMmsInfoByCondition(actionData, null, null);
    }
    if (actionData.content != common.string.EMPTY_STR || actionData.mmsSource.length > 0) {
      // Save New Draft
      this.updateDraftData(response, param, actionData, callback, context);
    } else {
      if (callback) {
        callback();
      }
    }
  }

  public updateDraftData(response, param, actionData, callback, context): void {
    let valueBucket: LooseObject = {
      "content": param.content,
      "has_draft": common.has_draft.HAVE,
      "time": new Date().getTime(),
      "has_attachment": param.hasAttachment,
      "has_mms": param.hasMms,
    }
    if (response == undefined || response == null) {
      return
    }
    let sessionId: number = response.id;
    let condition: LooseObject = {};
    condition.threadId = sessionId;
    this.updateSessionByCondition(condition, valueBucket, null, null);
    ConversationService.getInstance().dealInsertMessageDetail(param, actionData, sessionId, res => {
      if (callback) {
        callback();
      }
    }, context);
  }

  public dealSendResults(actionData): LooseObject {
    let contactsNum: number = 1;
    let telephone: string = common.string.EMPTY_STR;
    if (actionData.isNewMsg) {
      let selectContacts = actionData.selectContacts;
      if (selectContacts.length > 1) {
        for (let contact of selectContacts) {
          telephone = telephone + contact.telephone + common.string.COMMA;
        }
        // If it fails, then the session list turns out to be a failure.
        telephone = telephone.substring(0, telephone.length - 1);
        contactsNum = selectContacts.length;
      } else if (selectContacts.length == 1) {
        telephone = selectContacts[0]?.telephone;
      }
      let receiveContactValue = actionData.receiveContactValue;
      if (receiveContactValue != common.string.EMPTY_STR) {
        telephone = actionData.receiveContactValue;
      }
    } else {
      telephone = actionData.telephone;
    }
    let smsType: number = common.sms_type.COMMON;
    if (contactsNum == 1 && telephoneUtils.judgeIsInfoMsg(telephone)) {
      smsType = common.sms_type.NOTICE;
    }
    let sendResult: LooseObject = {
      telephone: telephone,
      content: actionData.content,
      sendStatus: common.int.SEND_DRAFT
    }
    actionData.sendResults = [sendResult];
    let timestamp = new Date().getTime();
    let result: LooseObject = {};
    result.contactsNum = contactsNum;
    result.telephone = telephoneUtils.dealTelephoneSort(telephone);
    result.content = actionData.content;
    if (actionData.isMms) {
      result.content = commonService.getMmsContent(actionData.mmsSource);
    }
    result.sendStatus = common.int.SEND_MESSAGE_SENDING;
    result.smsType = smsType;
    result.timestamp = timestamp;
    result.hasMms = actionData.isMms ? 1 : 0;
    result.hasAttachment = actionData.hasAttachment ? 1 : 0;

    return result;
  }

  public querySessionByTelephone(telephone, callback, context): void {
    let result: LooseObject = {};
    if (telephone == null) {
      HiLog.w(TAG, "querySessionByTelephone, telephone is null!");
      result.code = common.int.FAILURE;
      callback(result);
    } else {
      HiLog.i(TAG, "querySessionByTelephone, telephone != null");
      let actionData: LooseObject = {};
      actionData.telephone = telephone;
      this.querySessionByCondition(actionData, res => {
        if (res.code == common.int.FAILURE) {
          callback(res);
        } else {
          result.code = common.int.SUCCESS;
          result.response = res.abilityResult[0];
          callback(result);
        }
      }, context);
    }
  }

  public dealMessageLockContent(actionData, callback, context): void {
    let threadIds = actionData.threadIds;
    let length: number = threadIds.length;
    let count: number = 0;
    for (let id of threadIds) {
      actionData.threadId = id;
      if (!actionData.isMessageDetail) {
        actionData.hasLock = 1;
      }
      ConversationService.getInstance().queryMessageDetail(actionData, res => {
        if (res.code == common.int.SUCCESS && res.response.length > 0) {
          count++;
          actionData.mmsList = res.response;
          this.updateLastItemContent(actionData, null, null);
        }
        if (count == length) {
          callback(common.int.SUCCESS);
        }
      }, context);
    }
  }

  public updateLastItemContent(actionData, callback, context): void {
    let valueBucket: LooseObject = {
      "content": common.string.EMPTY_STR,
      "sending_status": common.int.SEND_MESSAGE_FAILED,
      "has_mms": common.has_mms.NO,
      "has_attachment": common.has_attachment.NO,
      "message_count": 0,
      "unread_count": 0
    };
    let length: number = actionData.mmsList.length;
    if (length > 0) {
      let item: LooseObject = actionData.mmsList[length - 1];
      valueBucket.content = item.isMsm ? commonService.getMmsContent(item.mms) : item.content;
      valueBucket.sending_status = item.sendStatus;
      valueBucket.has_mms = item.isMsm ? common.has_mms.HAVE : common.has_mms.NO;
      valueBucket.has_attachment = item.isMsm ? common.has_attachment.HAVE : common.has_attachment.NO;
      valueBucket.message_count = length;
    }
    let condition: LooseObject = {
      threadId: actionData.threadId
    };
    this.updateSessionByCondition(condition, valueBucket, callback, context);
  }
}