Progress on dms, code cleanup

Progress on dms, code cleanup

app/controllers/api/base_controller.rb

@@ -3,12 +3,15 @@
 class Api::BaseController < ApplicationController
   DEFAULT_STATUSES_LIMIT = 20
   DEFAULT_ACCOUNTS_LIMIT = 20
+  DEFAULT_CHAT_CONVERSATION_LIMIT = 12
+  DEFAULT_CHAT_CONVERSATION_MESSAGE_LIMIT = 10
 
   include RateLimitHeaders
 
   skip_before_action :store_current_location
   skip_before_action :check_user_permissions
 
+  before_action :block_if_doorkeeper
   before_action :set_cache_headers
 
   protect_from_forgery with: :null_session
@@ -90,6 +93,14 @@ class Api::BaseController < ApplicationController
     doorkeeper_authorize!(*scopes) if doorkeeper_token
   end
 
+  def superapp?
+    doorkeeper_token && doorkeeper_token.application.superapp? || false
+  end
+
+  def block_if_doorkeeper
+    raise GabSocial::NotPermittedError unless superapp?
+  end
+
   def set_cache_headers
     response.headers['Cache-Control'] = 'no-cache, no-store, max-age=0, must-revalidate'
   end

app/controllers/api/v1/accounts/search_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Api::V1::Accounts::SearchController < Api::BaseController
+  before_action -> { doorkeeper_authorize! :read, :'read:accounts' }
+  before_action :require_user!
+
+  def show
+    @accounts = account_search
+    render json: @accounts, each_serializer: REST::AccountSerializer
+  end
+
+  private
+
+  def account_search
+    AccountSearchService.new.call(
+      params[:q],
+      current_account,
+      limit: limit_param(DEFAULT_ACCOUNTS_LIMIT),
+      resolve: truthy_param?(:resolve),
+      following: truthy_param?(:following),
+      offset: params[:offset]
+    )
+  end
+end

app/controllers/api/v1/chat_conversation_accounts/blocked_accounts_controller.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class Api::V1::ChatConversationAccounts::BlockedAccountsController < Api::BaseController
+  before_action -> { doorkeeper_authorize! :follow, :'read:blocks' }
+  before_action :require_user!
+  after_action :insert_pagination_headers
+
+  def index
+    @accounts = load_accounts
+    render json: @accounts, each_serializer: REST::AccountSerializer
+  end
+
+  private
+
+  def load_accounts
+    paginated_blocks.map(&:target_account)
+  end
+
+  def paginated_blocks
+    @paginated_blocks ||= ChatBlock.eager_load(target_account: :account_stat)
+                               .where(account: current_account)
+                               .paginate_by_max_id(
+                                 limit_param(DEFAULT_ACCOUNTS_LIMIT),
+                                 params[:max_id],
+                                 params[:since_id]
+                               )
+  end
+
+  def insert_pagination_headers
+    set_pagination_headers(next_path, prev_path)
+  end
+
+  def next_path
+    if records_continue?
+      api_v1_chat_conversation_accounts_blocked_accounts_url pagination_params(max_id: pagination_max_id)
+    end
+  end
+
+  def prev_path
+    unless paginated_blocks.empty?
+      api_v1_chat_conversation_accounts_blocked_accounts_url pagination_params(since_id: pagination_since_id)
+    end
+  end
+
+  def pagination_max_id
+    paginated_blocks.last.id
+  end
+
+  def pagination_since_id
+    paginated_blocks.first.id
+  end
+
+  def records_continue?
+    paginated_blocks.size == limit_param(DEFAULT_ACCOUNTS_LIMIT)
+  end
+
+  def pagination_params(core_params)
+    params.slice(:limit).permit(:limit).merge(core_params)
+  end
+end

app/controllers/api/v1/chat_conversation_accounts/muted_accounts_controller.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class Api::V1::ChatConversationAccounts::MutedAccountsController < Api::BaseController
+  before_action -> { doorkeeper_authorize! :follow, :'read:mutes' }
+  before_action :require_user!
+  after_action :insert_pagination_headers
+
+  def index
+    @accounts = load_accounts
+    render json: @accounts, each_serializer: REST::AccountSerializer
+  end
+
+  private
+
+  def load_accounts
+    paginated_mutes.map(&:target_account)
+  end
+
+  def paginated_mutes
+    @paginated_mutes ||= ChatMute.eager_load(target_account: :account_stat)
+                               .where(account: current_account)
+                               .paginate_by_max_id(
+                                 limit_param(DEFAULT_ACCOUNTS_LIMIT),
+                                 params[:max_id],
+                                 params[:since_id]
+                               )
+  end
+
+  def insert_pagination_headers
+    set_pagination_headers(next_path, prev_path)
+  end
+
+  def next_path
+    if records_continue?
+      api_v1_chat_conversation_accounts_muted_accounts_url pagination_params(max_id: pagination_max_id)
+    end
+  end
+
+  def prev_path
+    unless paginated_mutes.empty?
+      api_v1_chat_conversation_accounts_muted_accounts_url pagination_params(since_id: pagination_since_id)
+    end
+  end
+
+  def pagination_max_id
+    paginated_mutes.last.id
+  end
+
+  def pagination_since_id
+    paginated_mutes.first.id
+  end
+
+  def records_continue?
+    paginated_mutes.size == limit_param(DEFAULT_ACCOUNTS_LIMIT)
+  end
+
+  def pagination_params(core_params)
+    params.slice(:limit).permit(:limit).merge(core_params)
+  end
+end

app/controllers/api/v1/chat_conversation_accounts_controller.rb

@@ -1,24 +1,16 @@
 # frozen_string_literal: true
 
-class Api::V1::AccountsController < Api::BaseController
-  before_action -> { authorize_if_got_token! :read, :'read:accounts' }, except: [:create, :follow, :unfollow, :block, :unblock, :mute, :unmute]
-  before_action -> { doorkeeper_authorize! :follow, :'write:follows' }, only: [:follow, :unfollow]
-  before_action -> { doorkeeper_authorize! :follow, :'write:mutes' }, only: [:mute, :unmute]
-  before_action -> { doorkeeper_authorize! :follow, :'write:blocks' }, only: [:block, :unblock]
-  before_action -> { doorkeeper_authorize! :write, :'write:accounts' }, only: [:create]
+class Api::V1::ChatConversationAccountsController < Api::BaseController
+  before_action -> { authorize_if_got_token! :read, :'read:chats' }, except: [:create, :follow, :unfollow, :block, :unblock, :mute, :unmute]
+  before_action -> { doorkeeper_authorize! :write, :'write:chats' }, only: [:create]
 
-  before_action :require_user!, except: [:show, :create]
+  before_action :require_user!
   before_action :set_account, except: [:create]
-  before_action :check_account_suspension, only: [:show]
 
   def show
     # 
   end
 
-  def create
-    # 
-  end
-
   def block
     BlockMessengerService.new.call(current_user.account, @account)
     render json: @account, serializer: REST::RelationshipSerializer, relationships: relationships
@@ -42,18 +34,19 @@ class Api::V1::AccountsController < Api::BaseController
   private
 
   def set_account
-    @account = Account.find(params[:id])
+  #   @account = Account.find(params[:id])
   end
 
-  def relationships(**options)
-    AccountRelationshipsPresenter.new([@account.id], current_user.account_id, options)
-  end
+  # def relationships(**options)
+  #   AccountRelationshipsPresenter.new([@account.id], current_user.account_id, options)
+  # end
 
   def check_account_suspension
     gone if @account.suspended?
   end
 
-  def account_params
-    params.permit(:username, :email, :password, :agreement, :locale)
-  end
+  # def account_params
+  #   params.permit(:username, :email, :password, :agreement, :locale)
+  # end
+
 end

app/controllers/api/v1/chat_conversation_controller.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class Api::V1::ChatConversationController < Api::BaseController
+  before_action -> { authorize_if_got_token! :read, :'read:chats' }
+  before_action -> { doorkeeper_authorize! :write, :'write:chats' }
+
+  before_action :require_user!
+  before_action :set_account, only: :create
+  before_action :set_chat_conversation, only: [:show, :mark_chat_conversation_approved, :mark_chat_conversation_hidden, :mark_chat_conversation_unread]
+
+  def show
+    puts "tilly ChatConversationsController-0"
+    render json: {}, each_serializer: REST::ChatConversationAccountSerializer
+  end
+
+  def create
+    puts "tilly ChatConversationsController-1"
+    # : todo :
+    # check if already created
+    # check if blocked
+    # check if chat blocked
+    # check if allow anyone to message then create with approved:true
+    # unique account id, participants
+    chat_conversation_account = find_or_create_conversation
+    render json: chat_conversation_account, each_serializer: REST::ChatConversationAccountSerializer
+  end
+
+  def mark_chat_conversation_unread
+    @chat_conversation_account.update!(is_unread: true)
+    render json: @chat_conversation_account, serializer: REST::ChatConversationAccountSerializer
+  end
+
+  def mark_chat_conversation_hidden
+    @chat_conversation_account.update!(is_hidden: true)
+    render json: @chat_conversation_account, serializer: REST::ChatConversationAccountSerializer
+  end
+
+  def mark_chat_conversation_approved
+    @chat_conversation_account.update!(is_approved: true)
+    render json: @chat_conversation_account, serializer: REST::ChatConversationAccountSerializer
+  end
+
+  private
+
+  def find_or_create_conversation
+    chat = ChatConversationAccount.find_by(account: current_account, participant_account_ids: [@account.id.to_s])
+
+    return chat unless chat.nil?
+
+    chat_conversation = ChatConversation.create
+    
+    my_chat = ChatConversationAccount.create!(
+                account: current_account,
+                participant_account_ids: [@account.id.to_s],
+                chat_conversation: chat_conversation,
+                is_approved: true
+              )
+
+    # : todo : if multiple ids
+    their_chat = ChatConversationAccount.create!(
+                  account: @account,
+                  participant_account_ids: [current_account.id.to_s],
+                  chat_conversation: chat_conversation,
+                  is_approved: false # default as request
+                )
+
+    return my_chat
+  end
+
+  def set_account
+    @account = Account.find(params[:account_id])
+  end
+
+  def set_chat_conversation
+    @chat_conversation = ChatConversation.find(params[:id])
+    @chat_conversation_account = ChatConversationAccount.where(
+      account: current_account,
+      chat_conversation: @chat_conversation
+    ).first
+  end
+
+end

app/controllers/api/v1/chat_conversations/approved_conversations_controller.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class Api::V1::ChatConversations::ApprovedConversationsController < Api::BaseController
+  before_action -> { authorize_if_got_token! :read, :'read:chats' }
+
+  before_action :require_user!
+  after_action :insert_pagination_headers
+
+  def index
+    puts "tilly ApprovedConversationsController-0"
+    @chat_conversations = load_chat_conversations
+    render json: @chat_conversations, each_serializer: REST::ChatConversationAccountSerializer
+  end
+
+  def show
+    puts "tilly ApprovedConversationsController-1"
+    @chat_conversations = load_chat_conversations
+    render json: @chat_conversations, each_serializer: REST::ChatConversationAccountSerializer
+  end
+
+  private
+
+  def load_chat_conversations
+    paginated_chat_conversations
+  end
+
+  def paginated_chat_conversations
+    ChatConversationAccount.where(
+      account: current_account,
+      is_hidden: false,
+      is_approved: true
+    ).paginate_by_max_id(
+      limit_param(DEFAULT_CHAT_CONVERSATION_LIMIT),
+      params[:max_id],
+      params[:since_id]
+    )
+  end
+
+  def insert_pagination_headers
+    set_pagination_headers(next_path, prev_path)
+  end
+
+  def next_path
+    if records_continue?
+      api_v1_chat_conversations_approved_conversations_url pagination_params(max_id: pagination_max_id)
+    end
+  end
+
+  def prev_path
+    unless paginated_chat_conversations.empty?
+      api_v1_chat_conversations_approved_conversations_url pagination_params(since_id: pagination_since_id)
+    end
+  end
+
+  def pagination_max_id
+    paginated_chat_conversations.last.id
+  end
+
+  def pagination_since_id
+    paginated_chat_conversations.first.id
+  end
+
+  def records_continue?
+    paginated_chat_conversations.size == limit_param(DEFAULT_CHAT_CONVERSATION_LIMIT)
+  end
+
+  def pagination_params(core_params)
+    params.slice(:limit).permit(:limit).merge(core_params)
+  end
+
+end

app/controllers/api/v1/chat_conversations/messages_controller.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class Api::V1::ChatConversations::MessagesController < Api::BaseController
+  before_action -> { authorize_if_got_token! :read, :'read:chats' }
+  before_action -> { doorkeeper_authorize! :write, :'write:chats' }
+  
+  before_action :require_user!
+  before_action :set_chat_conversation
+  before_action :set_chat_messages
+
+  after_action :insert_pagination_headers, unless: -> { @chats.empty? }
+
+  def show
+    puts "tilly chat_message_conversations - 1: " + @chats.count.inspect
+    render json: @chats, each_serializer: REST::ChatMessageSerializer
+  end
+
+  private
+
+  def set_chat_conversation
+    @chat_conversation = ChatConversation.find(params[:id])
+  end
+
+  def set_chat_messages
+    @chats = cached_conversation_chats
+  end
+
+  def cached_conversation_chats
+    cache_collection conversation_chats, ChatMessage
+  end
+
+  def conversation_chats
+    chats = ChatMessage.where(
+      chat_conversation: @chat_conversation
+    ).paginate_by_id(
+      limit_param(DEFAULT_CHAT_CONVERSATION_MESSAGE_LIMIT),
+      params_slice(:max_id, :since_id, :min_id)
+    )
+  end
+
+  def insert_pagination_headers
+    set_pagination_headers(next_path, nil)
+  end
+
+  def pagination_params(core_params)
+    params.slice(:limit).permit(:limit).merge(core_params)
+  end
+
+  def next_path
+    api_v1_chat_conversations_message_url params[:id], pagination_params(since_id: pagination_since_id)
+  end
+
+  def pagination_since_id
+    @chats.first.id
+  end
+end

app/controllers/api/v1/chat_conversations/requested_conversations_controller.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+class Api::V1::ChatConversations::RequestedConversationsController < Api::BaseController
+  before_action -> { authorize_if_got_token! :read, :'read:chats' }
+
+  before_action :require_user!
+  after_action :insert_pagination_headers
+
+  def index
+    @chat_conversations = load_chat_conversations
+    render json: @chat_conversations, each_serializer: REST::ChatConversationAccountSerializer
+  end
+
+  def count
+    count = ChatConversationAccount.where(account: current_account, is_hidden: false, is_approved: false).count
+    render json: count
+  end
+
+  private
+
+  def load_chat_conversations
+    paginated_chat_conversations
+  end
+
+  def paginated_chat_conversations
+    ChatConversationAccount.where(
+      account: current_account,
+      is_hidden: false,
+      is_approved: false
+    ).paginate_by_max_id(
+      limit_param(DEFAULT_CHAT_CONVERSATION_LIMIT),
+      params[:max_id],
+      params[:since_id]
+    )
+  end
+
+  def insert_pagination_headers
+    set_pagination_headers(next_path, prev_path)
+  end
+
+  def next_path
+    if records_continue?
+      api_v1_chat_conversations_requested_conversations_url pagination_params(max_id: pagination_max_id)
+    end
+  end
+
+  def prev_path
+    unless paginated_chat_conversations.empty?
+      api_v1_chat_conversations_requested_conversations_url pagination_params(since_id: pagination_since_id)
+    end
+  end
+
+  def pagination_max_id
+    paginated_chat_conversations.last.id
+  end
+
+  def pagination_since_id
+    paginated_chat_conversations.first.id
+  end
+
+  def records_continue?
+    paginated_chat_conversations.size == limit_param(DEFAULT_CHAT_CONVERSATION_LIMIT)
+  end
+
+  def pagination_params(core_params)
+    params.slice(:limit).permit(:limit).merge(core_params)
+  end
+
+end

app/controllers/api/v1/chat_messages_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Api::V1::ChatMessagesController < Api::BaseController
+  before_action -> { authorize_if_got_token! :read, :'read:chats' }
+  before_action -> { doorkeeper_authorize! :write, :'write:chats' }
+
+  before_action :require_user!
+  before_action :set_chat_conversation
+
+  def create
+    @chat = ChatMessage.create!(
+      from_account: current_account,
+      chat_conversation: @chat_conversation,
+      text: params[:text]
+    )
+    
+    # : todo :
+    # Redis.current.publish("chat_messages:10", 'hi')
+    Redis.current.publish("chat_messages:10", Oj.dump(event: :chat_message, payload: InlineRenderer.render(@chat, current_user.account, :chat_message)))
+
+    render json: @chat, serializer: REST::ChatMessageSerializer
+  end
+
+  def destroy
+    @chat = ChatMessage.where(account: current_user.account).find(params[:id])
+    authorize @chat, :destroy?
+
+    # : todo :
+    # make sure last_chat_message_id in chat_account_conversation gets set to last
+
+    @chat.destroy!
+
+    render json: @chat, serializer: REST::ChatMessageSerializer
+  end
+
+  private
+
+  def set_chat_conversation
+    @chat_conversation = ChatConversation.find(params[:chat_conversation_id])
+  end
+
+  def chat_params
+    params.permit(:text, :chat_conversation_id)
+  end
+
+end