Expose ChatName objects to slash commands

Instead of only exposing a User to slash commands we now also expose the
ChatName object that the User object is retrieved from. This is
necessary for GitLab Chatops as we need for example the user ID of the
chat user.

app/models/chat_name.rb

 class ChatName < ActiveRecord::Base
+  LAST_USED_AT_INTERVAL = 1.hour
+
   belongs_to :service
   belongs_to :user
@@ -9,4 +11,23 @@ class ChatName < ActiveRecord::Base
   validates :user_id, uniqueness: { scope: [:service_id] }
   validates :chat_id, uniqueness: { scope: [:service_id, :team_id] }
+
+  # Updates the "last_used_timestamp" but only if it wasn't already updated
+  # recently.
+  #
+  # The throttling this method uses is put in place to ensure that high chat
+  # traffic doesn't result in many UPDATE queries being performed.
+  def update_last_used_at
+    return unless update_last_used_at?
+
+    obtained = Gitlab::ExclusiveLease
+      .new("chat_name/last_used_at/#{id}", timeout: LAST_USED_AT_INTERVAL.to_i)
+      .try_obtain
+
+    touch(:last_used_at) if obtained
+  end
+
+  def update_last_used_at?
+    last_used_at.nil? || last_used_at > LAST_USED_AT_INTERVAL.ago
+  end
 end

app/models/project_services/slash_commands_service.rb

@@ -30,10 +30,10 @@ class SlashCommandsService < Service
   def trigger(params)
     return unless valid_token?(params[:token])
-    user = find_chat_user(params)
-    if user
-      Gitlab::SlashCommands::Command.new(project, user, params).execute
+    chat_user = find_chat_user(params)
+    if chat_user&.user
+      Gitlab::SlashCommands::Command.new(project, chat_user, params).execute
     else
       url = authorize_chat_name_url(params)
       Gitlab::SlashCommands::Presenters::Access.new(url).authorize

app/services/chat_names/find_user_service.rb

@@ -9,8 +9,8 @@ module ChatNames
       chat_name = find_chat_name
       return unless chat_name
-      chat_name.touch(:last_used_at)
-      chat_name.user
+      chat_name.update_last_used_at
+      chat_name
     end
     private

lib/gitlab/slash_commands/base_command.rb

@@ -31,10 +31,11 @@ module Gitlab
         raise NotImplementedError
       end
-      attr_accessor :project, :current_user, :params
-      def initialize(project, user, params = {})
-        @project, @current_user, @params = project, user, params.dup
+      attr_accessor :project, :current_user, :params, :chat_name
+      def initialize(project, chat_name, params = {})
+        @project, @current_user, @params = project, chat_name.user, params.dup
+        @chat_name = chat_name
       end
       private

lib/gitlab/slash_commands/command.rb

@@ -13,12 +13,13 @@ module Gitlab
         if command
           if command.allowed?(project, current_user)
-            command.new(project, current_user, params).execute(match)
+            command.new(project, chat_name, params).execute(match)
           else
             Gitlab::SlashCommands::Presenters::Access.new.access_denied
           end
         else
-          Gitlab::SlashCommands::Help.new(project, current_user, params).execute(available_commands, params[:text])
+          Gitlab::SlashCommands::Help.new(project, chat_name, params)
+            .execute(available_commands, params[:text])
         end
       end

spec/lib/gitlab/slash_commands/command_spec.rb

@@ -3,10 +3,11 @@ require 'spec_helper'
 describe Gitlab::SlashCommands::Command do
   let(:project) { create(:project) }
   let(:user) { create(:user) }
+  let(:chat_name) { double(:chat_name, user: user) }
   describe '#execute' do
     subject do
-      described_class.new(project, user, params).execute
+      described_class.new(project, chat_name, params).execute
     end
     context 'when no command is available' do
@@ -88,7 +89,7 @@ describe Gitlab::SlashCommands::Command do
   end
   describe '#match_command' do
-    subject { described_class.new(project, user, params).match_command.first }
+    subject { described_class.new(project, chat_name, params).match_command.first }
     context 'IssueShow is triggered' do
       let(:params) { { text: 'issue show 123' } }

spec/lib/gitlab/slash_commands/deploy_spec.rb

@@ -4,6 +4,7 @@ describe Gitlab::SlashCommands::Deploy do
   describe '#execute' do
     let(:project) { create(:project) }
     let(:user) { create(:user) }
+    let(:chat_name) { double(:chat_name, user: user) }
     let(:regex_match) { described_class.match('deploy staging to production') }
     before do
@@ -16,7 +17,7 @@ describe Gitlab::SlashCommands::Deploy do
     end
     subject do
-      described_class.new(project, user).execute(regex_match)
+      described_class.new(project, chat_name).execute(regex_match)
     end
     context 'if no environment is defined' do

spec/lib/gitlab/slash_commands/issue_new_spec.rb

@@ -4,6 +4,7 @@ describe Gitlab::SlashCommands::IssueNew do
   describe '#execute' do
     let(:project) { create(:project) }
     let(:user) { create(:user) }
+    let(:chat_name) { double(:chat_name, user: user) }
     let(:regex_match) { described_class.match("issue create bird is the word") }
     before do
@@ -11,7 +12,7 @@ describe Gitlab::SlashCommands::IssueNew do
     end
     subject do
-      described_class.new(project, user).execute(regex_match)
+      described_class.new(project, chat_name).execute(regex_match)
     end
     context 'without description' do

spec/lib/gitlab/slash_commands/issue_search_spec.rb

@@ -6,10 +6,11 @@ describe Gitlab::SlashCommands::IssueSearch do
     let!(:confidential) { create(:issue, :confidential, project: project, title: 'mepmep find') }
     let(:project) { create(:project) }
     let(:user) { create(:user) }
+    let(:chat_name) { double(:chat_name, user: user) }
     let(:regex_match) { described_class.match("issue search find") }
     subject do
-      described_class.new(project, user).execute(regex_match)
+      described_class.new(project, chat_name).execute(regex_match)
     end
     context 'when the user has no access' do

spec/lib/gitlab/slash_commands/issue_show_spec.rb

@@ -5,6 +5,7 @@ describe Gitlab::SlashCommands::IssueShow do
     let(:issue) { create(:issue, project: project) }
     let(:project) { create(:project) }
     let(:user) { issue.author }
+    let(:chat_name) { double(:chat_name, user: user) }
     let(:regex_match) { described_class.match("issue show #{issue.iid}") }
     before do
@@ -12,7 +13,7 @@ describe Gitlab::SlashCommands::IssueShow do
     end
     subject do
-      described_class.new(project, user).execute(regex_match)
+      described_class.new(project, chat_name).execute(regex_match)
     end
     context 'the issue exists' do

spec/models/chat_name_spec.rb

@@ -14,4 +14,24 @@ describe ChatName do
   it { is_expected.to validate_uniqueness_of(:user_id).scoped_to(:service_id) }
   it { is_expected.to validate_uniqueness_of(:chat_id).scoped_to(:service_id, :team_id) }
+
+  describe '#update_last_used_at', :clean_gitlab_redis_shared_state do
+    it 'updates the last_used_at timestamp' do
+      expect(subject.last_used_at).to be_nil
+
+      subject.update_last_used_at
+
+      expect(subject.last_used_at).to be_present
+    end
+
+    it 'does not update last_used_at if it was recently updated' do
+      subject.update_last_used_at
+
+      time = subject.last_used_at
+
+      subject.update_last_used_at
+
+      expect(subject.last_used_at).to eq(time)
+    end
+  end
 end

spec/services/chat_names/find_user_service_spec.rb

 require 'spec_helper'
-describe ChatNames::FindUserService do
+describe ChatNames::FindUserService, :clean_gitlab_redis_shared_state do
   describe '#execute' do
     let(:service) { create(:service) }
@@ -13,21 +13,30 @@ describe ChatNames::FindUserService do
       context 'when existing user is requested' do
         let(:params) { { team_id: chat_name.team_id, user_id: chat_name.chat_id } }
-        it 'returns the existing user' do
-          is_expected.to eq(user)
+        it 'returns the existing chat_name' do
+          is_expected.to eq(chat_name)
         end
-        it 'updates when last time chat name was used' do
+        it 'updates the last used timestamp if one is not already set' do
           expect(chat_name.last_used_at).to be_nil
           subject
-          initial_last_used = chat_name.reload.last_used_at
-          expect(initial_last_used).to be_present
-          Timecop.travel(2.days.from_now) { described_class.new(service, params).execute }
-          expect(chat_name.reload.last_used_at).to be > initial_last_used
+          expect(chat_name.reload.last_used_at).to be_present
+        end
+
+        it 'only updates an existing timestamp once within a certain time frame' do
+          service = described_class.new(service, params)
+
+          expect(chat_name.last_used_at).to be_nil
+
+          service.execute
+
+          time = chat_name.reload.last_used_at
+          service.execute
+          expect(chat_name.reload.last_used_at).to eq(time)
         end
       end