270 lines
9.9 KiB
Ruby
270 lines
9.9 KiB
Ruby
class ChatChannelsController < ApplicationController
|
|
before_action :authenticate_user!, only: %i[moderate]
|
|
before_action :set_channel, only: %i[show update update_channel open moderate]
|
|
after_action :verify_authorized
|
|
|
|
CHANNEL_ATTRIBUTES_FOR_SERIALIZATION = %i[id description channel_name].freeze
|
|
private_constant :CHANNEL_ATTRIBUTES_FOR_SERIALIZATION
|
|
|
|
def index
|
|
case params[:state]
|
|
when "unopened"
|
|
authorize ChatChannel
|
|
render_unopened_json_response
|
|
when "unopened_ids"
|
|
authorize ChatChannel
|
|
render_unopened_ids_response
|
|
when "pending"
|
|
authorize ChatChannel
|
|
render_pending_json_response
|
|
when "joining_request"
|
|
authorize ChatChannel
|
|
render_joining_request_json_response
|
|
else
|
|
skip_authorization
|
|
render_channels_html
|
|
end
|
|
end
|
|
|
|
def show
|
|
@chat_messages = @chat_channel.messages
|
|
.includes(:user)
|
|
.order(created_at: :desc)
|
|
.offset(params[:message_offset])
|
|
.limit(50)
|
|
end
|
|
|
|
def create
|
|
authorize ChatChannel
|
|
@chat_channel = current_user.chat_channels.create(
|
|
channel_type: "invite_only",
|
|
channel_name: chat_channel_params[:channel_name],
|
|
slug: chat_channel_params[:slug],
|
|
)
|
|
render_chat_channel
|
|
end
|
|
|
|
def update
|
|
@chat_channel.update(chat_channel_params)
|
|
if @chat_channel.errors.any?
|
|
flash[:error] = @chat_channel.errors.full_messages.to_sentence
|
|
else
|
|
if chat_channel_params[:discoverable].to_i.zero?
|
|
ChatChannelMembership.create(user_id: SiteConfig.mascot_user_id, chat_channel_id: @chat_channel.id,
|
|
role: "member", status: "active")
|
|
else
|
|
ChatChannelMembership.find_by(user_id: SiteConfig.mascot_user_id)&.destroy
|
|
end
|
|
flash[:settings_notice] = "Channel settings updated."
|
|
end
|
|
current_user_membership = @chat_channel.mod_memberships.find_by!(user: current_user)
|
|
|
|
redirect_to edit_chat_channel_membership_path(current_user_membership)
|
|
end
|
|
|
|
def update_channel
|
|
@chat_channel.update(chat_channel_params)
|
|
if @chat_channel.errors.any?
|
|
render json: { success: false, errors: @chat_channel.errors.full_messages,
|
|
message: "Channel settings updation failed. Try again later." }, success: :bad_request
|
|
else
|
|
if chat_channel_params[:discoverable]
|
|
ChatChannelMembership.create(user_id: SiteConfig.mascot_user_id, chat_channel_id: @chat_channel.id,
|
|
role: "member", status: "active")
|
|
else
|
|
ChatChannelMembership.find_by(user_id: SiteConfig.mascot_user_id)&.destroy
|
|
end
|
|
render json: { success: true, message: "Channel settings updated.", data: {} }, success: :ok
|
|
end
|
|
end
|
|
|
|
def open
|
|
membership = @chat_channel.chat_channel_memberships.where(user_id: current_user.id).first
|
|
membership.update(last_opened_at: 1.second.from_now, has_unopened_messages: false)
|
|
send_open_notification
|
|
render json: { status: "success", channel: params[:id] }, status: :ok
|
|
end
|
|
|
|
def moderate
|
|
chat_channel = ChatChannel.find_by(id: params[:id])
|
|
authorize chat_channel
|
|
command, username = chat_channel_params[:command].split
|
|
case command
|
|
when "/ban"
|
|
user = User.find_by(username: username)
|
|
membership = user&.chat_channel_memberships&.find_by(chat_channel: chat_channel)
|
|
if user && membership
|
|
user.add_role :banned
|
|
user.messages.where(chat_channel: chat_channel).delete_all
|
|
membership.update(status: "removed_from_channel")
|
|
Pusher.trigger(chat_channel.pusher_channels, "user-banned", { userId: user.id }.to_json)
|
|
render json: { status: "moderation-success", message: "#{username} was suspended.", userId: user.id,
|
|
chatChannelId: chat_channel.id }, status: :ok
|
|
else
|
|
render json: {
|
|
status: "error",
|
|
message: "Ban failed. user with username '#{username}' not found in this channel."
|
|
}, status: :bad_request
|
|
end
|
|
when "/unban"
|
|
user = User.find_by(username: username)
|
|
if user
|
|
user.remove_role :banned
|
|
render json: { status: "moderation-success", message: "#{username} was unsuspended." }, status: :ok
|
|
else
|
|
render json: {
|
|
status: "error",
|
|
message: "Unban failed. User with username '#{username}' not found in this channel."
|
|
}, status: :bad_request
|
|
end
|
|
when "/clearchannel"
|
|
@chat_channel.clear_channel
|
|
render json: { status: "success", message: "cleared!" }, status: :ok
|
|
else
|
|
render json: { status: "error", message: "invalid command" }, status: :bad_request
|
|
end
|
|
end
|
|
|
|
def create_chat
|
|
chat_recipient = User.find(params[:user_id])
|
|
valid_listing = Listing.where(user_id: params[:user_id], contact_via_connect: true).limit(1)
|
|
authorize ChatChannel
|
|
|
|
if chat_recipient.inbox_type == "open" || valid_listing.length == 1
|
|
chat = ChatChannels::CreateWithUsers.call(users: [current_user, chat_recipient], channel_type: "direct")
|
|
message_markdown = params[:message]
|
|
message = Message.new(
|
|
chat_channel: chat,
|
|
message_markdown: message_markdown,
|
|
user: current_user,
|
|
)
|
|
chat.messages.append(message)
|
|
render json: { status: "success", message: "chat channel created!" }, status: :ok
|
|
else
|
|
render json: { status: "error", message: "not allowed!" }, status: :bad_request
|
|
end
|
|
rescue StandardError => e
|
|
render json: { status: "error", message: e.message }, status: :bad_request
|
|
end
|
|
|
|
def block_chat
|
|
chat_channel = ChatChannel.find(params[:chat_id])
|
|
authorize chat_channel
|
|
chat_channel.status = "blocked"
|
|
chat_channel.save
|
|
chat_channel.chat_channel_memberships.map(&:index_to_elasticsearch)
|
|
render json: { status: "success", message: "chat channel blocked" }, status: :ok
|
|
end
|
|
|
|
# Note: this is part of an effort of moving some things from the external to
|
|
# the internal API. No behavior was changes as part of this refactoring, so
|
|
# this action is a bit unusual.
|
|
def channel_info
|
|
skip_authorization
|
|
|
|
@chat_channel =
|
|
ChatChannel
|
|
.select(CHANNEL_ATTRIBUTES_FOR_SERIALIZATION)
|
|
.find_by(id: params[:id])
|
|
|
|
return if @chat_channel&.has_member?(current_user)
|
|
|
|
render json: { error: "not found", status: 404 }, status: :not_found
|
|
end
|
|
|
|
private
|
|
|
|
def set_channel
|
|
@chat_channel = ChatChannel.find_by(id: params[:id]) || not_found
|
|
authorize @chat_channel
|
|
end
|
|
|
|
def chat_channel_params
|
|
params.require(:chat_channel).permit(policy(ChatChannel).permitted_attributes)
|
|
end
|
|
|
|
def render_unopened_json_response
|
|
@chat_channels_memberships = if session_current_user_id
|
|
ChatChannelMembership.where(user_id: session_current_user_id)
|
|
.where(has_unopened_messages: true)
|
|
.where(show_global_badge_notification: true)
|
|
.where.not(status: %w[removed_from_channel left_channel])
|
|
.includes(%i[chat_channel user])
|
|
.order("chat_channel_memberships.updated_at" => :desc)
|
|
else
|
|
[]
|
|
end
|
|
render "index.json"
|
|
end
|
|
|
|
def render_pending_json_response
|
|
@chat_channels_memberships = if current_user
|
|
current_user
|
|
.chat_channel_memberships.includes(:chat_channel)
|
|
.where(status: "pending")
|
|
.order("chat_channel_memberships.updated_at" => :desc)
|
|
else
|
|
[]
|
|
end
|
|
render "index.json"
|
|
end
|
|
|
|
def render_unopened_ids_response
|
|
@unopened_ids = ChatChannelMembership.where(user_id: session_current_user_id).includes(:chat_channel)
|
|
.where(has_unopened_messages: true).where.not(status: %w[removed_from_channel
|
|
left_channel]).pluck(:chat_channel_id)
|
|
render json: { unopened_ids: @unopened_ids }
|
|
end
|
|
|
|
def render_joining_request_json_response
|
|
requested_memberships_id = current_user
|
|
.chat_channel_memberships
|
|
.includes(:chat_channel)
|
|
.where(chat_channels: { discoverable: true }, role: "mod")
|
|
.pluck(:chat_channel_id)
|
|
.map { |membership_id| ChatChannel.find_by(id: membership_id).requested_memberships }
|
|
.flatten
|
|
.map(&:id)
|
|
|
|
@chat_channels_memberships = ChatChannelMembership
|
|
.includes(%i[user chat_channel])
|
|
.where(id: requested_memberships_id)
|
|
|
|
render "index.json"
|
|
end
|
|
|
|
def render_channels_html
|
|
return unless current_user && params[:slug]
|
|
|
|
slug = if params[:slug]&.start_with?("@")
|
|
[current_user.username, params[:slug].delete("@")].sort.join("/")
|
|
else
|
|
params[:slug]
|
|
end
|
|
chat_channel = ChatChannel.find_by(slug: slug)
|
|
return unless chat_channel
|
|
|
|
membership = chat_channel.chat_channel_memberships.find_by(user_id: current_user.id)
|
|
@active_channel = membership&.status == "active" ? chat_channel : nil
|
|
end
|
|
|
|
def render_chat_channel
|
|
if @chat_channel.valid?
|
|
render json: { status: "success",
|
|
chat_channel: @chat_channel.to_json(only: %i[channel_name slug]) },
|
|
status: :ok
|
|
else
|
|
render json: { errors: @chat_channel.errors.full_messages }
|
|
end
|
|
end
|
|
|
|
def send_open_notification
|
|
adjusted_slug = if @chat_channel.group?
|
|
@chat_channel.adjusted_slug
|
|
else
|
|
@chat_channel.adjusted_slug(current_user)
|
|
end
|
|
Pusher.trigger("private-message-notifications-#{session_current_user_id}", "message-opened",
|
|
{ channel_type: @chat_channel.channel_type, adjusted_slug: adjusted_slug }.to_json)
|
|
end
|
|
end
|