# frozen_string_literal: true module ChatPublisher def self.new_messages_message_bus_channel(chat_channel_id) "/chat/#{chat_channel_id}/new-messages" end def self.publish_new!(chat_channel, chat_message, staged_id) content = ChatMessageSerializer.new( chat_message, { scope: anonymous_guardian, root: :chat_message }, ).as_json content[:type] = :sent content[:stagedId] = staged_id permissions = permissions(chat_channel) MessageBus.publish("/chat/#{chat_channel.id}", content.as_json, permissions) MessageBus.publish( self.new_messages_message_bus_channel(chat_channel.id), { channel_id: chat_channel.id, message_id: chat_message.id, user_id: chat_message.user.id, username: chat_message.user.username, }, permissions, ) end def self.publish_processed!(chat_message) chat_channel = chat_message.chat_channel content = { type: :processed, chat_message: { id: chat_message.id, cooked: chat_message.cooked, }, } MessageBus.publish("/chat/#{chat_channel.id}", content.as_json, permissions(chat_channel)) end def self.publish_edit!(chat_channel, chat_message) content = ChatMessageSerializer.new( chat_message, { scope: anonymous_guardian, root: :chat_message }, ).as_json content[:type] = :edit MessageBus.publish("/chat/#{chat_channel.id}", content.as_json, permissions(chat_channel)) end def self.publish_refresh!(chat_channel, chat_message) content = ChatMessageSerializer.new( chat_message, { scope: anonymous_guardian, root: :chat_message }, ).as_json content[:type] = :refresh MessageBus.publish("/chat/#{chat_channel.id}", content.as_json, permissions(chat_channel)) end def self.publish_reaction!(chat_channel, chat_message, action, user, emoji) content = { action: action, user: BasicUserSerializer.new(user, root: false).as_json, emoji: emoji, type: :reaction, chat_message_id: chat_message.id, } MessageBus.publish( "/chat/message-reactions/#{chat_message.id}", content.as_json, permissions(chat_channel), ) MessageBus.publish("/chat/#{chat_channel.id}", content.as_json, permissions(chat_channel)) end def self.publish_presence!(chat_channel, user, typ) raise NotImplementedError end def self.publish_delete!(chat_channel, chat_message) MessageBus.publish( "/chat/#{chat_channel.id}", { type: "delete", deleted_id: chat_message.id, deleted_at: chat_message.deleted_at }, permissions(chat_channel), ) end def self.publish_bulk_delete!(chat_channel, deleted_message_ids) MessageBus.publish( "/chat/#{chat_channel.id}", { typ: "bulk_delete", deleted_ids: deleted_message_ids, deleted_at: Time.zone.now }, permissions(chat_channel), ) end def self.publish_restore!(chat_channel, chat_message) content = ChatMessageSerializer.new( chat_message, { scope: anonymous_guardian, root: :chat_message }, ).as_json content[:type] = :restore MessageBus.publish("/chat/#{chat_channel.id}", content.as_json, permissions(chat_channel)) end def self.publish_flag!(chat_message, user, reviewable, score) # Publish to user who created flag MessageBus.publish( "/chat/#{chat_message.chat_channel_id}", { type: "self_flagged", user_flag_status: score.status_for_database, chat_message_id: chat_message.id, }.as_json, user_ids: [user.id], ) # Publish flag with link to reviewable to staff MessageBus.publish( "/chat/#{chat_message.chat_channel_id}", { type: "flag", chat_message_id: chat_message.id, reviewable_id: reviewable.id }.as_json, group_ids: [Group::AUTO_GROUPS[:staff]], ) end def self.user_tracking_state_message_bus_channel(user_id) "/chat/user-tracking-state/#{user_id}" end def self.publish_user_tracking_state(user, chat_channel_id, chat_message_id) MessageBus.publish( self.user_tracking_state_message_bus_channel(user.id), { chat_channel_id: chat_channel_id, chat_message_id: chat_message_id.to_i }.as_json, user_ids: [user.id], ) end def self.new_mentions_message_bus_channel(chat_channel_id) "/chat/#{chat_channel_id}/new-mentions" end def self.publish_new_mention(user_id, chat_channel_id, chat_message_id) MessageBus.publish( self.new_mentions_message_bus_channel(chat_channel_id), { message_id: chat_message_id, channel_id: chat_channel_id }.as_json, user_ids: [user_id], ) end NEW_CHANNEL_MESSAGE_BUS_CHANNEL = "/chat/new-channel" def self.publish_new_channel(chat_channel, users) users.each do |user| # FIXME: This could generate a lot of queries depending on the amount of users membership = chat_channel.membership_for(user) # TODO: this event is problematic as some code will update the membership before calling it # and other code will update it after calling it # it means frontend must handle logic for both cases serialized_channel = ChatChannelSerializer.new( chat_channel, scope: Guardian.new(user), # We need a guardian here for direct messages root: :channel, membership: membership, ).as_json MessageBus.publish(NEW_CHANNEL_MESSAGE_BUS_CHANNEL, serialized_channel, user_ids: [user.id]) end end def self.publish_inaccessible_mentions( user_id, chat_message, cannot_chat_users, without_membership, too_many_members, mentions_disabled ) MessageBus.publish( "/chat/#{chat_message.chat_channel_id}", { type: :mention_warning, chat_message_id: chat_message.id, cannot_see: cannot_chat_users.map { |u| { username: u.username, id: u.id } }.as_json, without_membership: without_membership.map { |u| { username: u.username, id: u.id } }.as_json, groups_with_too_many_members: too_many_members.map(&:name).as_json, group_mentions_disabled: mentions_disabled.map(&:name).as_json, }, user_ids: [user_id], ) end CHANNEL_EDITS_MESSAGE_BUS_CHANNEL = "/chat/channel-edits" def self.publish_chat_channel_edit(chat_channel, acting_user) MessageBus.publish( CHANNEL_EDITS_MESSAGE_BUS_CHANNEL, { chat_channel_id: chat_channel.id, name: chat_channel.title(acting_user), description: chat_channel.description, }, permissions(chat_channel), ) end CHANNEL_STATUS_MESSAGE_BUS_CHANNEL = "/chat/channel-status" def self.publish_channel_status(chat_channel) MessageBus.publish( CHANNEL_STATUS_MESSAGE_BUS_CHANNEL, { chat_channel_id: chat_channel.id, status: chat_channel.status }, permissions(chat_channel), ) end CHANNEL_METADATA_MESSAGE_BUS_CHANNEL = "/chat/channel-metadata" def self.publish_chat_channel_metadata(chat_channel) MessageBus.publish( CHANNEL_METADATA_MESSAGE_BUS_CHANNEL, { chat_channel_id: chat_channel.id, memberships_count: chat_channel.user_count }, permissions(chat_channel), ) end def self.publish_archive_status( chat_channel, archive_status:, archived_messages:, archive_topic_id:, total_messages: ) MessageBus.publish( "/chat/channel-archive-status", { chat_channel_id: chat_channel.id, archive_failed: archive_status == :failed, archive_completed: archive_status == :success, archived_messages: archived_messages, total_messages: total_messages, archive_topic_id: archive_topic_id, }, permissions(chat_channel), ) end private def self.permissions(chat_channel) { user_ids: chat_channel.allowed_user_ids, group_ids: chat_channel.allowed_group_ids } end def self.anonymous_guardian Guardian.new(nil) end end