grape-slack-bot 1.0.0

data/lib/slack_bot/callback.rb

@@ -0,0 +1,109 @@
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/numeric/time'
+
+module SlackBot
+  class Callback
+    CALLBACK_CACHE_KEY = "slack-bot-callback".freeze
+
+    def self.find(id, config: nil)
+      callback = new(id: id, config: config)
+      callback.reload
+    end
+
+    def self.create(class_name:, method_name:, user:, channel_id: nil, config: nil)
+      callback =
+        new(class_name: class_name, method_name: method_name, user: user, channel_id: channel_id, config: config)
+      callback.save
+      callback
+    end
+
+    attr_reader :id, :data, :args, :config
+    def initialize(id: nil, class_name: nil, method_name: nil, user: nil, channel_id: nil, extra: nil, config: nil)
+      @id = id
+      @data = {
+        class_name: class_name,
+        method_name: method_name,
+        user_id: user&.id,
+        channel_id: channel_id,
+        extra: extra
+      }
+      @args = SlackBot::Args.new
+      @config = config || SlackBot::Config.current_instance
+    end
+
+    def reload
+      @data = read_data
+      SlackBot::DevConsole.log_check("SlackBot::Callback#read_data: #{id} | #{data}")
+
+      parse_args
+      self
+    end
+
+    def save
+      @id = generate_id if id.blank?
+      serialize_args
+
+      SlackBot::DevConsole.log_check("SlackBot::Callback#write_data: #{id} | #{data}")
+      write_data(data)
+    end
+
+    def update(payload)
+      return if id.blank?
+      return if data.blank?
+
+      @data = data.merge(payload)
+      save
+    end
+
+    def destroy
+      return if id.blank?
+
+      delete_data
+    end
+
+    def user
+      @user ||= begin
+        user_id = data&.dig(:user_id)
+        config.callback_user_finder_method.call(user_id) if user_id.present?
+      end
+    end
+
+    def handler_class
+      return if class_name.blank?
+
+      config.find_handler_class(class_name)
+    end
+
+    def method_missing(method_name, *args, &block)
+      return data[method_name.to_sym] if data.key?(method_name.to_sym)
+
+      super
+    end
+
+    private
+
+    def parse_args
+      args.raw_args = data&.dig(:args)
+    end
+
+    def serialize_args
+      data[:args] = args.to_s
+    end
+
+    def generate_id
+      SecureRandom.uuid
+    end
+
+    def read_data
+      config.callback_storage_instance.read("#{CALLBACK_CACHE_KEY}:#{id}")
+    end
+
+    def write_data(data)
+      config.callback_storage_instance.write("#{CALLBACK_CACHE_KEY}:#{id}", data, expires_in: 1.hour)
+    end
+
+    def delete_data
+      config.callback_storage_instance.delete("#{CALLBACK_CACHE_KEY}:#{id}")
+    end
+  end
+end

data/lib/slack_bot/callback_storage.rb

@@ -0,0 +1,15 @@
+module SlackBot
+  class CallbackStorage
+    def read(*_args, **_kwargs)
+      raise "Not implemented"
+    end
+
+    def write(*_args, **_kwargs)
+      raise "Not implemented"
+    end
+
+    def delete(*_args, **_kwargs)
+      raise "Not implemented"
+    end
+  end
+end

data/lib/slack_bot/command.rb

@@ -0,0 +1,72 @@
+module SlackBot
+  class Command
+    def self.interaction(klass)
+      define_singleton_method(:interaction_klass) { klass }
+    end
+
+    def self.view(klass)
+      define_singleton_method(:view_klass) { klass }
+    end
+
+    attr_reader :current_user, :params, :args, :config
+    def initialize(current_user:, params:, args:, config: nil)
+      @current_user = current_user
+      @params = params
+      @config = config || SlackBot::Config.current_instance
+
+      @args = SlackBot::Args.new
+      @args.raw_args = args
+    end
+
+    def command
+      params[:command]
+    end
+
+    def text
+      params[:text]
+    end
+
+    def only_user?
+      true
+    end
+
+    def only_direct_message?
+      true
+    end
+
+    def only_slack_team?
+      true
+    end
+
+    def render_response(response_type = nil, **kwargs)
+      return if !response_type
+
+      {
+        response_type: response_type
+      }.merge(kwargs)
+    end
+
+    private
+
+    def open_modal(view_name, method_name: nil, context: nil)
+      view = self.class.view_klass.new(
+        args: args,
+        current_user: @current_user,
+        params: params,
+        context: context,
+        config: config
+      )
+      payload = view.send(view_name)
+      self.class.interaction_klass.open_modal(
+        trigger_id: params[:trigger_id],
+        channel_id: params[:channel_id],
+        class_name: self.class.name,
+        method_name: method_name,
+        user: @current_user,
+        payload: payload,
+        config: config
+      )
+      render_response
+    end
+  end
+end

data/lib/slack_bot/config.rb

@@ -0,0 +1,168 @@
+require 'active_support/core_ext/object'
+
+module SlackBot
+  class Config
+    def self.current_instance
+      @@current_instances ||= {}
+      @@current_instances[self.name] ||= self.new
+    end
+
+    def self.configure(&block)
+      current_instance.instance_eval(&block)
+    end
+
+    attr_reader :callback_storage_instance
+    def callback_storage(klass)
+      @callback_storage_instance = klass
+    end
+
+    attr_reader :callback_user_finder_method
+    def callback_user_finder(method_lambda)
+      @callback_user_finder_method = method_lambda
+    end
+
+    def event_handlers
+      @event_handlers ||= {}
+    end
+
+    def event(event_type, event_klass)
+      event_handlers[event_type.to_sym] = event_klass
+    end
+
+    def find_event_handler(event_type)
+      event_handlers[event_type.to_sym]
+    end
+
+    def slash_command_endpoint(url_token, command_klass = nil, &block)
+      @slash_command_endpoints ||= {}
+      @slash_command_endpoints[url_token.to_sym] ||=
+        begin
+          endpoint =
+            SlashCommandEndpointConfig.new(url_token, command_klass: command_klass, config: self)
+          endpoint.instance_eval(&block) if block_given?
+          endpoint
+        end
+    end
+
+    def slash_command_endpoints
+      @slash_command_endpoints ||= {}
+    end
+
+    def find_slash_command_config(url_token, command, text)
+      endpoint_config = slash_command_endpoints[url_token.to_sym]
+      return if endpoint_config.blank?
+
+      endpoint_config.find_command_config(text) || endpoint_config
+    end
+
+    def menu_options(action_id, klass)
+      @menu_options ||= {}
+      @menu_options[action_id.to_sym] = klass
+    end
+
+    def find_menu_options(action_id)
+      @menu_options ||= {}
+      @menu_options[action_id.to_sym]
+    end
+
+    def handler_class(class_name, klass)
+      @handler_classes ||= {}
+      @handler_classes[class_name.to_sym] = klass
+    end
+
+    def find_handler_class(class_name)
+      @handler_classes ||= {}
+      @handler_classes[class_name.to_sym]
+    end
+  end
+
+  class SlashCommandEndpointConfig
+    attr_reader :url_token, :command_klass, :routes, :config
+    def initialize(url_token, config:, command_klass: nil, routes: {})
+      @url_token = url_token
+      @command_klass = command_klass
+      @routes = routes
+      @config = config
+
+      config.handler_class(command_klass.name, command_klass) if command_klass.present?
+    end
+
+    def command(command_token, command_klass, &block)
+      @command_configs ||= {}
+      @command_configs[command_token.to_sym] ||=
+        begin
+          command =
+            SlashCommandConfig.new(
+              command_klass: command_klass,
+              token: command_token,
+              endpoint: self
+            )
+          command.instance_eval(&block) if block_given?
+          command
+        end
+    end
+
+    def command_configs
+      @command_configs ||= {}
+    end
+
+    def find_command_config(text)
+      route_key = text.scan(/^(#{routes.keys.join("|")})(?:\s|$)/).flatten.first
+      return if route_key.blank?
+
+      routes[route_key]
+    end
+
+    def full_token
+      ""
+    end
+  end
+
+  class SlashCommandConfig
+    def self.delimiter
+      " "
+    end
+
+    attr_accessor :command_klass, :token, :parent_configs, :endpoint
+    def initialize(command_klass:, token:, endpoint:, parent_configs: [])
+      @command_klass = command_klass
+      @token = token
+      @parent_configs = parent_configs || []
+      @endpoint = endpoint
+
+      endpoint.routes[full_token] = self
+      endpoint.config.handler_class(command_klass.name, command_klass)
+    end
+
+    def argument_command(argument_token, klass = nil, &block)
+      @argument_command_configs ||= {}
+      @argument_command_configs[argument_token.to_sym] ||=
+        SlashCommandConfig.new(
+          command_klass: command_klass,
+          token: argument_token,
+          parent_configs: [self] + (parent_configs || []),
+          endpoint: endpoint
+        )
+
+      command_config = @argument_command_configs[argument_token.to_sym]
+      command_config.instance_eval(&block) if block_given?
+
+      command_config
+    end
+
+    def find_argument_command_config(argument_token)
+      @argument_command_configs ||= {}
+      @argument_command_configs[argument_token.to_sym]
+    end
+
+    def full_token
+      [parent_configs.map(&:token), token].flatten.compact.join(
+        self.class.delimiter
+      )
+    end
+
+    def url_token
+      endpoint.url_token
+    end
+  end
+end

data/lib/slack_bot/dev_console.rb

@@ -0,0 +1,33 @@
+module SlackBot
+  class DevConsole
+    def self.enabled=(value)
+      @enabled = value
+    end
+
+    def self.enabled?
+      @enabled
+    end
+
+    def self.log(message = nil, &)
+      return unless enabled?
+
+      message = yield if block_given?
+      Rails.logger.info(message)
+    end
+
+    def self.log_input(message = nil, &)
+      message = yield if block_given?
+      log(">>> #{message}")
+    end
+
+    def self.log_output(message = nil, &)
+      message = yield if block_given?
+      log("<<< #{message}")
+    end
+
+    def self.log_check(message = nil, &)
+      message = yield if block_given?
+      log("!!! #{message}")
+    end
+  end
+end

data/lib/slack_bot/errors.rb

@@ -0,0 +1,39 @@
+module SlackBot
+  module Errors
+    class SignatureAuthenticationError < StandardError
+    end
+
+    class TeamAuthenticationError < StandardError
+    end
+
+    class ChannelAuthenticationError < StandardError
+    end
+
+    class UserAuthenticationError < StandardError
+    end
+
+    class SlashCommandNotImplemented < StandardError
+    end
+
+    class MenuOptionsNotImplemented < StandardError
+    end
+
+    class SlackResponseError < StandardError
+      attr_reader :error, :data, :payload
+      def initialize(error, data: nil, payload: nil)
+        @error = error
+        @data = data
+        @payload = payload
+      end
+    end
+
+    class OpenModalError < SlackResponseError
+    end
+
+    class UpdateModalError < SlackResponseError
+    end
+
+    class PublishViewError < SlackResponseError
+    end
+  end
+end

data/lib/slack_bot/event.rb

@@ -0,0 +1,41 @@
+module SlackBot
+  class Event
+    def self.view(klass)
+      define_singleton_method(:view_klass) { klass }
+    end
+
+    attr_reader :current_user, :params, :callback, :config
+    def initialize(current_user: nil, params: nil, callback: nil, config: nil)
+      @current_user = current_user
+      @params = params
+      @callback = callback
+      @config = config || SlackBot::Config.current_instance
+    end
+
+    def call
+      nil
+    end
+
+    private
+
+    def event_type
+      params["event"]["type"]
+    end
+
+    def publish_view(view_method_name)
+      user_id = params["event"]["user"]
+      view =
+        self.class.view_klass
+          .new(current_user: current_user, params: params)
+          .send(view_method_name)
+      response =
+        SlackBot::ApiClient.new.views_publish(user_id: user_id, view: view)
+
+      if !response.ok?
+        raise SlackBot::Errors::PublishViewError.new(response.error, data: response.data, payload: view)
+      end
+
+      nil
+    end
+  end
+end

data/lib/slack_bot/grape_extension.rb

@@ -0,0 +1,198 @@
+require 'active_support/core_ext/object'
+
+module SlackBot
+  module GrapeExtension
+    def self.included(base)
+      base.format :json
+      base.content_type :json, "application/json"
+      base.use ActionDispatch::RemoteIp
+      base.helpers do
+        def fetch_team_id
+          params.dig("team_id") || params.dig("team", "id")
+        end
+
+        def fetch_user_id
+          params.dig("user_id") || params.dig("user", "id") ||
+            params.dig("event", "user")
+        end
+
+        def verify_slack_signature!
+          slack_signing_secret = ENV.fetch("SLACK_SIGNING_SECRET")
+          timestamp = request.headers["X-Slack-Request-Timestamp"]
+          request_body = request.body.read
+          sig_basestring = "v0:#{timestamp}:#{request_body}"
+          my_signature =
+            "v0=" +
+              OpenSSL::HMAC.hexdigest(
+                OpenSSL::Digest.new("sha256"),
+                slack_signing_secret,
+                sig_basestring
+              )
+          slack_signature = request.headers["X-Slack-Signature"]
+          if ActiveSupport::SecurityUtils.secure_compare(
+               my_signature,
+               slack_signature
+             )
+            true
+          else
+            raise SlackBot::SignatureAuthenticationError.new("Signature mismatch")
+          end
+        end
+
+        def verify_slack_team!
+          slack_team_id = ENV.fetch("SLACK_TEAM_ID")
+          if slack_team_id == fetch_team_id
+            true
+          else
+            raise SlackBot::TeamAuthenticationError.new("Team is not authorized")
+          end
+        end
+
+        def verify_direct_message_channel!
+          if params[:channel_name] == "directmessage"
+            true
+          else
+            raise SlackBot::ChannelAuthenticationError.new(
+                    "This command is only available in direct messages"
+                  )
+          end
+        end
+
+        def verify_current_user!
+          if current_user
+            true
+          else
+            raise SlackBot::UserAuthenticationError.new("User is not authorized")
+          end
+        end
+
+        def events_callback(params)
+          verify_slack_team!
+
+          SlackBot::DevConsole.log_input "SlackApi::Events#events_callback: #{params.inspect}"
+          handler = config.find_event_handler(params[:event][:type].to_sym)
+          return if handler.blank?
+
+          event = handler.new(params: params, current_user: current_user)
+          event.call
+        end
+
+        def url_verification(params)
+          SlackBot::DevConsole.log_input "SlackApi::Events#url_verification: #{params.inspect}"
+          { challenge: params[:challenge] }
+        end
+
+        def handle_block_actions_view(view:, user:, params:)
+          callback_id = view&.dig("callback_id")
+          callback = SlackBot::Callback.find(callback_id, config: config)
+
+          if callback.blank?
+            raise "Callback not found"
+          end
+
+          SlackBot::DevConsole.log_check "SlackApi::Interactions##{__method__}: #{callback.id} #{callback.extra} #{callback.user_id} #{user&.id}"
+
+          if callback.user_id != user.id
+            raise "Callback user is not equal to action user"
+          end
+
+          interaction_klass = callback.handler_class&.interaction_klass
+          return if interaction_klass.blank?
+
+          interaction_klass.new(current_user: user, params: params, callback: callback, config: config).call
+        end
+      end
+
+      base.before do
+        verify_slack_signature!
+      end
+
+      base.resource :commands do
+        post ":url_token" do
+          command_config = config.find_slash_command_config(params[:url_token], params[:command], params[:text])
+          command_klass = command_config&.command_klass
+          raise SlackBot::Errors::SlashCommandNotImplemented.new if command_klass.blank?
+
+          args = params[:text].gsub(/^#{command_config.full_token}\s?/, "")
+          SlackBot::DevConsole.log_input "SlackApi::SlashCommands#post: #{command_config.url_token} | #{command_config.full_token} | #{args}"
+
+          action =
+            command_klass.new(
+              current_user: current_user,
+              params: params,
+              args: args,
+              config: config
+            )
+          verify_slack_team! if action.only_slack_team?
+          verify_direct_message_channel! if action.only_direct_message?
+          verify_current_user! if action.only_user?
+
+          result = action.call
+          return body false if !result
+
+          result
+        end
+      end
+
+      base.resource :interactions do
+        post do
+          payload = JSON.parse(params[:payload])
+
+          action_user_session =
+            resolve_user_session(
+              payload.dig("user", "team_id"),
+              payload.dig("user", "id")
+            )
+          action_user = action_user_session&.user
+
+          action_type = payload["type"]
+          result = case action_type
+          when "block_actions", "view_submission"
+            handle_block_actions_view(
+              view: payload["view"],
+              user: action_user,
+              params: params
+            )
+          else
+            raise "Unknown action type: #{action_type}"
+          end
+
+          return body false if result.blank?
+
+          result
+        end
+      end
+
+      base.resource :events do
+        post do
+          result =
+            case params[:type]
+            when "url_verification"
+              url_verification(params)
+            when "event_callback"
+              events_callback(params)
+            end
+
+          return body false if result.blank?
+
+          result
+        end
+      end
+
+      base.resource :menu_options do
+        get do
+          SlackBot::DevConsole.log_input "SlackApi::MenuOptions#get: #{params.inspect}"
+
+          action_id = params[:action_id]
+          menu_options_klass = config.find_menu_options(action_id)
+          raise SlackBot::Errors::MenuOptionsNotImplemented.new if menu_options_klass.blank?
+
+          menu_options = menu_options_klass.new(current_user: current_user, params: params, config: config).call
+          return body false if menu_options.blank?
+
+          menu_options
+        end
+      end
+    end
+  end
+end