foundryvtt-reve-de-dragon/module/chat-utility.js

import { Misc } from "./misc.js";
import { SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";

export const MESSAGE_DATA = 'message-data';

/**
 * Class providing helper methods to get the list of users, and 
 */
export class ChatUtility {

  /* -------------------------------------------- */
  static onSocketMessage(sockmsg) {
    switch (sockmsg.msg) {
      case "msg_delete_chat_message": return ChatUtility.onRemoveMessages(sockmsg.data);
      case "msg_user_ui_notifications": return ChatUtility.onNotifyUser(sockmsg.data);
    }
  }
  
  
  /* -------------------------------------------- */
  static notifyUser(userId, level = 'info', message) {
    const data = {
      userId: userId, level: level, message: message
    };
    if (game.user.id == userId) {
      ChatUtility.onNotifyUser(data);
    }
    else {
      game.socket.emit(SYSTEM_SOCKET_ID, {
        msg: "msg_user_ui_notifications", data: data
      });
    }
  }

  static onNotifyUser(data) {
    if (game.user.id == data.userId) {
      switch (data.level) {
        case 'warn': ui.notifications.warn(data.message); break;
        case 'error': ui.notifications.error(data.message); break;
        default: ui.notifications.info(data.message); break;
      }
    }
  }

  /* -------------------------------------------- */
  static onRemoveMessages(data) {
    if (Misc.isUniqueConnectedGM()) {
      if (data.part) {
        const toDelete = game.messages.filter(it => it.data.content.includes(data.part));
        toDelete.forEach(it => it.delete());
      }
      if (data.messageId) {
        game.messages.get(data.messageId)?.delete();
      }
    }
  }

  static onRemoveMessages(data) {
    if (Misc.isUniqueConnectedGM()) {
      if (data.part) {
        const toDelete = game.messages.filter(it => it.content.includes(data.part));
        toDelete.forEach(it => it.delete());
      }
      if (data.messageId) {
        game.messages.get(data.messageId)?.delete();
      }
    }
  }
  /* -------------------------------------------- */

  static removeMessages(data) {
    if (Misc.isUniqueConnectedGM()) {
      ChatUtility.onRemoveMessages(data);
    }
    else {
      game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_delete_chat_message", data: data });
    }
  }

  /* -------------------------------------------- */
  static removeChatMessageContaining(part) {
    ChatUtility.removeMessages({ part: part });
  }

  static removeChatMessageId(messageId) {
    if (messageId){
      ChatUtility.removeMessages({ messageId: messageId });
    }
  }

  /* -------------------------------------------- */
  static async createChatWithRollMode(name, chatOptions) {
    return await ChatUtility.createChatMessage(name, game.settings.get("core", "rollMode"), chatOptions);
  }

  /* -------------------------------------------- */
  static async createChatMessage(name, rollMode, chatOptions) {
    switch (rollMode) {
      case "blindroll": // GM only
        if (!game.user.isGM) {
          ChatUtility.blindMessageToGM(chatOptions);

          chatOptions.whisper = [game.user.id];
          chatOptions.content = "Message envoyé en aveugle au Gardien";
        }
        else {
          chatOptions.whisper = ChatUtility.getUsers(user => user.isGM);
        }
        break;
      default:
        chatOptions.whisper = ChatUtility.getWhisperRecipients(rollMode, name);
        break;
    }
    chatOptions.alias = chatOptions.alias || name;
    return await ChatMessage.create(chatOptions);
  }

  /* -------------------------------------------- */
  static prepareChatMessage(rollMode, name) {
    return {
      user: game.user.id,
      whisper: ChatUtility.getWhisperRecipients(rollMode, name)
    }
  }

  /* -------------------------------------------- */
  static getWhisperRecipients(rollMode, name) {
    switch (rollMode) {
      case "blindroll": return ChatUtility.getUsers(user => user.isGM);
      case "gmroll": return ChatUtility.getWhisperRecipientsAndGMs(name);
      case "selfroll": return [game.user.id];
    }
    return undefined;
  }

  /* -------------------------------------------- */
  static getWhisperRecipientsAndGMs(name) {
    let recep1 = ChatMessage.getWhisperRecipients(name) || [];
    return recep1.concat(ChatMessage.getWhisperRecipients('GM'));
  }

  /* -------------------------------------------- */
  static getUsers(filter) {
    return Misc.getUsers().filter(filter).map(user => user.data._id);
  }

  /* -------------------------------------------- */
  static blindMessageToGM(chatOptions) {
    let chatGM = duplicate(chatOptions);
    chatGM.whisper = ChatUtility.getUsers(user => user.isGM);
    chatGM.content = "Message aveugle de " + game.user.name + "<br>" + chatOptions.content;
    console.log("blindMessageToGM", chatGM);
    game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_gm_chat_message", data: chatGM });
  }

  /* -------------------------------------------- */
  static handleGMChatMessage(data) {
    console.log("blindMessageToGM", data);
    if (game.user.isGM) { // message privé pour GM only
      data.user = game.user.id;
      ChatMessage.create(data);
    }
  }

  static async setMessageData(chatMessage, key, data) {
    if (data) {
      await chatMessage.setFlag(SYSTEM_RDD, key, JSON.stringify(data));
    }
  }

  static getMessageData(chatMessage, key) {
    const json = chatMessage.getFlag(SYSTEM_RDD, key);
    return json ? JSON.parse(json) : undefined;
  }

  static getChatMessage(event) {
    const chatMessageId = $(event.currentTarget).closest('.chat-message').attr('data-message-id');
    return game.messages.get(chatMessageId);
  }

}