hiptail 0.0.1

data/lib/hiptail/authority/sqlite3_provider.rb

@@ -0,0 +1,85 @@
+require 'hiptail/authority/provider'
+require 'sqlite3'
+
+class HipTail::SQLite3AuthorityProvider < HipTail::AuthorityProvider
+  # @return [HipTail::SQLite3AuthorityProvider]
+  def initialize(db)
+    @authorities = {}
+    @db = db
+
+    build
+  end
+
+  # @return [void]
+  def build
+    @db.execute_batch <<-'END_SQL'
+      CREATE TABLE IF NOT EXISTS hiptail_authority (
+          oauth_id          VARCHAR(255) NOT NULL PRIMARY KEY,
+          oauth_secret      VARCHAR(255) NOT NULL,
+          authorization_url VARCHAR(255) NOT NULL,
+          token_url         VARCHAR(255) NOT NULL,
+          room_id           INT UNSIGNED,
+          group_id          INT UNSIGNED NOT NULL,
+          api_base          VARCHAR(255) NOT NULL,
+          created_at        INTEGER NOT NULL
+      );
+    END_SQL
+  end
+
+  SQL_GET = <<-'END_SQL'
+    SELECT * FROM hiptail_authority WHERE oauth_id = ? LIMIT 1
+  END_SQL
+
+  # @abstract
+  # @param [String] oauth_id
+  # @return [HipTail::Authority]
+  def get(oauth_id)
+    unless @authorities.include?(oauth_id)
+      begin
+        last_rah = @db.results_as_hash
+        @db.results_as_hash = true
+        @db.execute(SQL_GET, oauth_id) do |row|
+          data = row.to_a.select { |f| f[0].is_a?(String) }.map { |f| [ f[0].to_sym, f[1] ] }
+          @authorities[oauth_id] = HipTail::Authority.new(Hash[*data.flatten(1)])
+          break
+        end
+      ensure
+        @db.results_as_hash = last_rah
+      end
+    end
+
+    @authorities[oauth_id]
+  end
+
+  SQL_REGISTER = <<-'END_SQL'
+    REPLACE INTO hiptail_authority
+      ( oauth_id, oauth_secret, authorization_url, token_url, room_id, group_id, api_base, created_at )
+      VALUES ( :oauth_id, :oauth_secret, :authorization_url, :token_url, :room_id, :group_id, :api_base, :created_at )
+  END_SQL
+
+  # @param [String] oauth_id
+  # @param [HipTail::Authority] authority
+  # @return [HipTail::Authority]
+  def register(oauth_id, authority)
+    @authorities[oauth_id] = authority
+
+    row_data = authority.as_hash
+    [ :api_base, :authorization_url, :token_url ].each do |key|
+      row_data[key] = row_data[key].to_s
+    end
+    row_data[:created_at] = Time.now.to_i
+    @db.execute(SQL_REGISTER, row_data)
+  end
+
+  SQL_UNREGISTER = <<-'END_SQL'
+    DELETE FROM hiptail_authority WHERE oauth_id = ?
+  END_SQL
+
+  # @param [String] oauth_id
+  # @return [void]
+  def unregister(oauth_id)
+    @authorities.delete(oauth_id)
+
+    @db.execute(SQL_UNREGISTER, oauth_id)
+  end
+end

data/lib/hiptail/authority.rb

@@ -0,0 +1,258 @@
+require 'json'
+require 'uri'
+require 'open-uri'
+require 'net/http'
+require 'oauth2'
+
+module HipTail
+  class Authority
+    # @return [String] Returns OAuth ID.
+    attr_reader :oauth_id
+    # Returns room_id for room authority.
+    # Nil for global authority.
+    # @return [String]
+    # @return [nil]
+    attr_reader :room_id
+    # Returns group_id for authority.
+    # @return [String]
+    attr_reader :group_id
+
+    # @return [Boolean] Represents whether the authority is for global or not.
+    def for_global?
+      ! @room_id
+    end
+    alias global? for_global?
+
+    # @return [Boolean] Represents whether the authority is for a room or not.
+    def for_room?
+      ! for_global?
+    end
+    alias room? for_room?
+
+    # A new instance of HipTail::Authority.
+    # @param [Hash] params
+    # @option params [String] :oauth_id
+    # @option params [String] :oauth_secret
+    # @option params [String] :authorization_url
+    # @option params [String] :token_url
+    # @option params [String] :room_id
+    # @option params [String] :group_id
+    # @option params [String] :api_base
+    # @return [HipTail::Authority]
+    def initialize(params)
+      @oauth_id          = params[:oauth_id]
+      @oauth_secret      = params[:oauth_secret]
+      @authorization_url = params[:authorization_url]
+      @token_url         = params[:token_url]
+
+      @room_id           = params[:room_id]
+      @group_id          = params[:group_id]
+
+      @room_id  = @room_id.to_i  if ! @room_id.nil?
+      @group_id = @group_id.to_i if ! @group_id.nil?
+
+      api_base_uri = params[:api_base].to_s
+      unless api_base_uri.end_with?('/')
+        api_base_uri += '/';
+      end
+      @api_base = URI.parse(api_base_uri)
+    end
+
+    # @return [Hash] Hash representation.  Convenient for persistency.
+    def as_hash
+      {
+        :oauth_id          => @oauth_id,
+        :oauth_secret      => @oauth_secret,
+        :authorization_url => @authorization_url,
+        :token_url         => @token_url,
+        :room_id           => @room_id,
+        :group_id          => @group_id,
+        :api_base          => @api_base,
+      }
+    end
+
+    # Issues send notification API.
+    # @param [Hash] params Parameters for notification API with :room_id.
+    # @option params [String] :room_id Room ID. Optional but mandatory for global authority.
+    # @return [Hash] Resulting response of API.
+    def send_notification(params)
+      room_id = self.room_id || params.delete(:room_id)
+      raise ArgumentError.new("room_id required") unless room_id
+      call_api(:method => :post, :uri => @api_base.merge("room/#{room_id}/notification"), :body_params => params)
+    end
+
+    # Issues reply message API.
+    # @param [Hash] params Parameters for reply message API with :room_id.
+    # @option params [String] :room_id Room ID. Optional but mandatory for global authority.
+    # @return [Hash] Resulting response of API.
+    def reply_message(params)
+      room_id = self.room_id || params.delete(:room_id)
+      raise ArgumentError.new("room_id required") unless room_id
+      call_api(:method => :post, :uri => @api_base.merge("room/#{room_id}/reply"), :body_params => params)
+    end
+
+    # Issues get all rooms API.
+    # @param [Hash] params Parameters for get all rooms API.
+    # @return [HipTail::Rooms]
+    def get_all_rooms(params = {})
+      res = call_api(:method => :get, :uri => @api_base.merge("room"), :query_params => params)
+      Rooms.new(res)
+    end
+
+    # Issues get room API.
+    # @param [Hash] params Parameters for get all room API.
+    # @option params [String] :room_id Room ID. Optional but mandatory for global authority.
+    # @return [HipTail::Room::Detail]
+    def get_room(params)
+      room_id = self.room_id || params.delete(:room_id)
+      raise ArgumentError.new("room_id required") unless room_id
+      res = call_api(:method => :get, :uri => @api_base.merge("room/#{room_id}"), :query_params => params)
+      Room::Detail.new(res)
+    end
+
+    # Issues get all members API.
+    # @param [Hash] params Parameters for get all members API.
+    # @return [HipTail::Users]
+    def get_all_members(params)
+      room_id = self.room_id || params.delete(:room_id)
+      raise ArgumentError.new("room_id required") unless room_id
+      res = call_api(:method => :get, :uri => @api_base.merge("room/#{room_id}/member"), :query_params => params)
+      Users.new(res)
+    end
+
+    # Issues get all participants API.
+    # @param [Hash] params Parameters for get all participants API.
+    # @return [HipTail::Users]
+    def get_all_participants(params)
+      room_id = self.room_id || params.delete(:room_id)
+      raise ArgumentError.new("room_id required") unless room_id
+      res = call_api(:method => :get, :uri => @api_base.merge("room/#{room_id}/participant"), :query_params => params)
+      Users.new(res)
+    end
+
+    # Issues add member API.
+    # @param [Hash] params Parameters for add member API with :room_id.
+    # @option params [String] :room_id Room ID. Optional but mandatory for global authority.
+    # @option params [String] :user_id One of :user_id, :user_mention, :user_email is required.
+    # @option params [String] :user_mention
+    # @option params [String] :user_email
+    # @return [Hash] Resulting response of API.
+    def add_member(params)
+      room_id = self.room_id || params.delete(:room_id)
+      raise ArgumentError.new("room_id required") unless room_id
+
+      user_name = user_name_from_params(params)
+      raise ArgumentError.new("user_id or user_mention or user_email required") unless user_name
+
+      call_api(:method => :put, :uri => @api_base.merge("room/#{room_id}/member/#{user_name}"), :body_params => params)
+    end
+
+    # Issues remove member API.
+    # @param [Hash] params Parameters for remove member API with :room_id.
+    # @option params [String] :room_id Room ID. Optional but mandatory for global authority.
+    # @option params [String] :user_id One of :user_id, :user_mention, :user_email is required.
+    # @option params [String] :user_mention
+    # @option params [String] :user_email
+    # @return [Hash] Resulting response of API.
+    def remove_member(params)
+      room_id = self.room_id || params.delete(:room_id)
+      raise ArgumentError.new("room_id required") unless room_id
+
+      user_name = user_name_from_params(params)
+      raise ArgumentError.new("user_id or user_mention or user_email required") unless user_name
+
+      call_api(:method => :delete, :uri => @api_base.merge("room/#{room_id}/member/#{user_name}"), :body_params => params)
+    end
+
+    private
+
+    def user_name_from_params(params)
+      user_id      = params.delete(:user_id)
+      user_mention = params.delete(:user_mention)
+      user_email   = params.delete(:user_email)
+
+      return user_id if user_id
+      return "@" + user_mention if user_mention
+      return user_email if user_email
+      return
+    end
+
+    def call_api(args)
+      uri = URI.parse(args[:uri].to_s)
+      queries = URI.decode_www_form(uri.query || '').map { |pair| [ pair[0].to_sym, pair[1] ] }
+      # XXX Array or Hash, which is better?
+      query = Hash[*queries.flatten(1)].merge(args[:query_params] || {})
+      query[:auth_token] = token
+      uri.query = query.size > 0 ? URI.encode_www_form(query) : nil
+
+      headers = {
+        'Content-Type' => 'application/json; charset=UTF-8',
+      }
+
+      if args[:body_params]
+        body = JSON.generate(args[:body_params] || {})
+        headers['Content-Length'] = body.bytesize.to_s
+      else
+        body = nil
+      end
+
+      case args[:method].to_s.downcase
+      when 'get'
+        req = Net::HTTP::Get.new(uri.request_uri, headers)
+      when 'post'
+        req = Net::HTTP::Post.new(uri.request_uri, headers)
+      when 'put'
+        req = Net::HTTP::Put.new(uri.request_uri, headers)
+      when 'delete'
+        req = Net::HTTP::Delete.new(uri.request_uri, headers)
+      else
+        raise
+      end
+
+      req.body = body if body
+
+      res = http.start do |http|
+        http.request(req)
+      end
+
+      if res.content_type =~ %r{\A application/json}x
+        return JSON.parse(res.body)
+      else
+        return {}
+      end
+    end
+
+    def token
+      if !@token || @token.expired?
+        @token = oauth2_client.client_credentials.get_token( :scope => "send_notification send_message admin_room view_group" )
+      end
+
+      @token.token
+    end
+
+    def oauth2_client
+      unless @client
+        @client = OAuth2::Client.new(
+          @oauth_id, @oauth_secret,
+          :authorize_url => @authorization_url,
+          :token_url     => @token_url,
+        )
+      end
+
+      @client
+    end
+
+    def http
+      unless @http
+        @http = Net::HTTP.new(@api_base.host, @api_base.port)
+        @http.use_ssl = true if @api_base.scheme == 'https'
+        @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        if ENV["DEBUG_HTTP"]
+          @http.set_debug_output($stderr)
+        end
+      end
+
+      @http.clone
+    end
+  end
+end

data/lib/hiptail/event.rb

@@ -0,0 +1,108 @@
+require 'hiptail/atom'
+
+module HipTail
+  class Event
+    attr_accessor :authority
+    attr_reader :raw
+
+    # @return [HipTail::Event]
+    def initialize(params)
+      @raw = params.dup
+    end
+
+    # @attribute [r] type
+    # @return [String]
+    def type
+      @raw['event']
+    end
+
+    # @attribute [r] oauth_client_id
+    # @return [String]
+    def oauth_client_id
+      @raw['oauth_client_id']
+    end
+
+    # @attribute [r] webhook_id
+    # @return [String]
+    def webhook_id
+      @raw['webhook_id']
+    end
+
+    class << self
+      # @param [Hash] params
+      # @return [HipTail::Event]
+      def parse(params)
+        type = params['event']
+
+        case params['event']
+        when 'room_message'
+          return Event::RoomMessage.new(params)
+        when 'room_notification'
+          return Event::RoomNotification.new(params)
+        when 'room_enter'
+          return Event::RoomEnter.new(params)
+        when 'room_exit'
+          return Event::RoomExit.new(params)
+        else
+          return Event.new(params)
+        end
+      end
+    end
+  end
+
+  class Event::RoomMessaging < Event
+    # @abstract
+    # @attribute [r] message
+    # @return [HipTail::Messsage]
+    def message
+      raise
+    end
+
+    # @attribute [r] room
+    # @return [HipTail::Room]
+    def room
+      @room ||= Room.new(@raw['item']['room'])
+      @room
+    end
+  end
+
+  class Event::RoomMessage < Event::RoomMessaging
+    # @attribute [r] message
+    # @return [HipTail::Messsage::Talk]
+    def message
+      @message ||= Message::Talk.new(@raw['item']['message'])
+      @message
+    end
+  end
+
+  class Event::RoomNotification < Event::RoomMessaging
+    # @attribute [r] message
+    # @return [HipTail::Messsage::Notification]
+    def message
+      @message ||= Message::Notification.new(@raw['item']['message'])
+      @message
+    end
+  end
+
+  class Event::RoomVisiting < Event
+    # @attribute [r] sender
+    # @return [HipTail::User]
+    def sender
+      @sender ||= User.create(@raw['item']['sender'])
+      @sender
+    end
+
+    # @attribute [r] room
+    # @return [HipTail::Room]
+    def room
+      @room ||= Room.new(@raw['item']['room'])
+      @room
+    end
+  end
+
+  class Event::RoomEnter < Event::RoomVisiting
+  end
+
+  class Event::RoomExit < Event::RoomVisiting
+  end
+end

data/lib/hiptail/manager.rb

@@ -0,0 +1,234 @@
+require 'json'
+require 'uri'
+require 'open-uri'
+
+require 'hiptail/event'
+require 'hiptail/authority'
+require 'hiptail/authority/provider'
+
+module HipTail
+  class Manager
+    # A new instance of HipTail::Manager.
+    # @param [Hash] params ({})
+    # @option params [HipTail::AuthorityProvider] :authority_provider (new instance of HipTail::MemoryAuthorityProvider)
+    # @return [HipTail::Manager]
+    def initialize(params = {})
+      @authority_provider = params[:authority_provider] || MemoryAuthorityProvider.new
+
+      @authority_manager = AuthorityManager.new(@authority_provider)
+
+      @hook = {}
+      [
+        :install, :uninstall,
+        :event,
+        :room_messaging, :room_message, :room_notification,
+        :room_visiting,  :room_enter, :room_exit,
+      ].each do |hook_type|
+        @hook[hook_type] = {}
+      end
+    end
+
+    # @return [HipTail::AuthorityProvider]
+    attr_reader :authority_provider
+
+    # @param [HipTail::AuthorityProvider] provider
+    # @return [HipTail::AuthorityProvider]
+    def authority_provider=(provider)
+      @authority_provider = @authority_manager.authority_provider = provider
+    end
+
+    # Retrieves authority from oauth_id
+    # @attribute [r] authority
+    # @example
+    #   authority = manager.authority[oauth_id]
+    # @return [HipTail::Manager::AuthorityManager]
+    def authority
+      @authority_manager
+    end
+
+    # Registers hook on installation.
+    # @return [String] Hook ID
+    # @yield [authority]
+    # @yield [HipTail::Authority] authority
+    def on_install(&block)
+      register_hook :install, block
+    end
+
+    # Registers hook on uninstallation.
+    # @return [String] Hook ID
+    # @yield [oauth_id]
+    # @yield [String] oauth_id
+    def on_uninstall(&block)
+      register_hook :uninstall, block
+    end
+
+    # Registers hook on events.
+    # @return [String] Hook ID
+    # @yield [event]
+    # @yield [HipTail::Event] event
+    def on_event(&block)
+      register_hook :event, block
+    end
+
+    # Registers hook on messaging events (room_message and room_notification).
+    # @return [String] Hook ID
+    # @yield [event]
+    # @yield [HipTail::Event::RoomMessaging] event
+    def on_room_messaging(&block)
+      register_hook :room_messaging, block
+    end
+
+    # Registers hook on room_message event.
+    # @return [String] Hook ID
+    # @yield [event]
+    # @yield [HipTail::Event::RoomMessage] event
+    def on_room_message(&block)
+      register_hook :room_message, block
+    end
+
+    # Registers hook on room_notification event.
+    # @return [String] Hook ID
+    # @yield [event]
+    # @yield [HipTail::Event::RoomNotification] event
+    def on_room_notification(&block)
+      register_hook :room_notification, block
+    end
+
+    # Registers hook on room visiting event (room_enter and room_exit).
+    # @return [String] Hook ID
+    # @yield [event]
+    # @yield [HipTail::Event::RoomVisiting] event
+    def on_room_visiting(&block)
+      register_hook :room_visiting, block
+    end
+
+    # Registers hook on room_enter event.
+    # @return [String] Hook ID
+    # @yield [event]
+    # @yield [HipTail::Event::RoomEnter] event
+    def on_room_enter(&block)
+      register_hook :room_enter, block
+    end
+
+    # Registers hook on room_exit event.
+    # @return [String] Hook ID
+    # @yield [event]
+    # @yield [HipTail::Event::RoomExit] event
+    def on_room_exit(&block)
+      register_hook :room_exit, block
+    end
+
+    # Handles installing request.
+    # @param [Hash] params Request object (originally represented in JSON) from HipChat Server on installation.
+    # @return [void]
+    def handle_install(params)
+      authority = build_authority(params)
+
+      @authority_provider.register(authority.oauth_id, authority)
+
+      call_hooks :install, authority
+    end
+
+    # Handles uninstalling request.
+    # @note Uninstall event will be fired after uninstallation on the server.
+    #       So you cannot use oauth information to do something (e.g. sending notification) on uninstallation phase.
+    # @param [String] oauth_id Corresponding OAuth ID
+    # @return [void]
+    def handle_uninstall(oauth_id)
+      call_hooks :uninstall, oauth_id
+
+      @authority_provider.unregister(oauth_id)
+    end
+
+    # Handles events (room_message, room_enter, etc.).
+    # @param [Hash] params Request object (originally represented in JSON) from HipChat Server on installation.
+    # @return [void]
+    def handle_event(params)
+      event = Event.parse(params)
+      event.authority = self.authority[event.oauth_client_id]
+
+      call_hooks :event, event
+
+      if event.is_a?(Event::RoomMessaging)
+        call_hooks :room_messaging, event
+
+        case event
+        when Event::RoomMessage
+          call_hooks :room_message, event
+        when Event::RoomNotification
+          call_hooks :room_notification, event
+        end
+      elsif event.is_a?(Event::RoomVisiting)
+        call_hooks :room_visiting, event
+
+        case event
+        when Event::RoomEnter
+          call_hooks :room_enter, event
+        when Event::RoomExit
+          call_hooks :room_exit, event
+        end
+      end
+    end
+
+    # Registers a hook.
+    # @param [Symbol] hook_type
+    # @param [Proc] block
+    # @param [String] hook_id
+    # @return [String] Hook ID
+    def register_hook(hook_type, block, hook_id = nil)
+      hook_id ||= block.object_id.to_s
+      @hook[hook_type][hook_id] = block
+      return hook_id
+    end
+
+    # Unregisters a hook.
+    # @param [Symbol] hook_type
+    # @param [String] hook_id
+    # @return [Proc] Unregistered procedure
+    def unregister_hook(hook_type, hook_id = nil)
+      @hook[hook_type].delete(hook_id.to_s)
+    end
+
+    private
+
+    def call_hooks(hook_type, *args)
+      @hook[hook_type].values.each do |block|
+        block.call(*args)
+      end
+    end
+
+    def build_authority(params)
+      server_cap = JSON.parse(URI.parse(params['capabilitiesUrl']).read)
+      oauth2_info = server_cap['capabilities']['oauth2Provider']
+      api_base    = server_cap['links']['api']
+
+      HipTail::Authority.new(
+        :oauth_id          => params['oauthId'],
+        :oauth_secret      => params['oauthSecret'],
+        :room_id           => params['roomId'],
+        :group_id          => params['groupId'],
+        :authorization_url => oauth2_info['authorizationUrl'],
+        :token_url         => oauth2_info['tokenUrl'],
+        :api_base          => server_cap['links']['api'],
+      )
+    end
+
+    # @private
+    class AuthorityManager
+      # @return [HipTail::AuthorityProvider]
+      attr_accessor :authority_provider
+
+      # @param [HipTail::AuthorityProvider] authority_provider
+      # @return [HipTail::Manager::AuthorityManager]
+      def initialize(authority_provider)
+        @authority_provider = authority_provider
+      end
+
+      # @param [String] oauth_id
+      # @return [HipTail::Authority]
+      def [](oauth_id)
+        @authority_provider.get(oauth_id)
+      end
+    end
+  end
+end