gs_graph 2.6.5

data/lib/gs_graph/exception.rb

@@ -0,0 +1,139 @@
+module GSGraph
+  class Exception < StandardError
+    attr_accessor :code, :type
+
+    ERROR_HEADER_MATCHERS = {
+      /invalid_token/ => "InvalidToken",
+      /invalid_request/ => "InvalidRequest"
+    }
+
+    ERROR_EXCEPTION_MATCHERS = {
+      /Could\snot\ssave\screative/          => "CreativeNotSaved",
+      /QueryLockTimeoutException/           => "QueryLockTimeout",
+      /Could\snot\screate\stargeting\sspec/ => "TargetingSpecNotSaved",
+      /Could\snot\sfetch\sadgroups/         => "AdgroupFetchFailure",
+      /Failed\sto\sopen\sprocess/           => "OpenProcessFailure",
+      /Could\snot\scommit\stransaction/     => "TransactionCommitFailure",
+      /QueryErrorException/                 => "QueryError",
+      /QueryConnectionException/            => "QueryConnection",
+      /QueryDuplicateKeyException/          => "QueryDuplicateKey"
+    }
+
+    def self.handle_httpclient_error(response, headers)
+      return nil unless (response[:error] || response[:error_code] || response[:error_msg])
+
+      # Sometimes we see an error that does not have the "error" field, but instead has both "error_code" and "error_msg"
+      # example: {"error_code":1,"error_msg":"An unknown error occurred"}
+      if (response[:error_code] && response[:error_msg] && !response[:error])
+        raise InternalServerError.new("#{response[:error_code]} :: #{response[:error_msg]}")
+      end
+
+      # Check the WWW-Authenticate header, since it seems to be more standardized than the response
+      # body error information.
+      # The complex lookup is needed to follow the HTTP spec - headers should be looked up
+      # without regard to case.
+      www_authenticate = headers.select do |name, value|
+        name.upcase == "WWW-Authenticate".upcase
+      end.to_a.flatten.second
+      if www_authenticate
+        # Session expiration/invalidation is very common. Check for that first.
+        if www_authenticate =~ /invalid_token/ && response[:error][:message] =~ /session has been invalidated/
+          raise InvalidSession.new("#{response[:error][:type]} :: #{response[:error][:message]}")
+        end
+
+        ERROR_HEADER_MATCHERS.keys.each do |matcher|
+          if matcher =~ www_authenticate
+            exception_class = GSGraph::const_get(ERROR_HEADER_MATCHERS[matcher])
+            raise exception_class.new("#{response[:error][:type]} :: #{response[:error][:message]}")
+          end
+        end
+      end
+
+      # If we can't match on WWW-Authenticate, use the type
+      case response[:error][:type]
+      when /OAuth/
+        raise Unauthorized.new("#{response[:error][:type]} :: #{response[:error][:message]}")
+      else
+        exception_class = nil
+        ERROR_EXCEPTION_MATCHERS.keys.each do |matcher|
+          exception_class = GSGraph::const_get(ERROR_EXCEPTION_MATCHERS[matcher]) if matcher =~ response[:error][:message]
+        end
+        if exception_class
+          raise exception_class.new("#{response[:error][:type]} :: #{response[:error][:message]}")
+        else
+          raise BadRequest.new("#{response[:error][:type]} :: #{response[:error][:message]}")
+        end
+      end
+    end
+
+    def self.handle_rack_oauth2_error(e)
+      exception = case e.status
+      when 400
+        BadRequest.new(e.message)
+      when 401
+        Unauthorized.new(e.message)
+      else
+        Exception.new(e.status, e.message)
+      end
+      raise exception
+    end
+
+    def initialize(code, message, body = '')
+      @code = code
+      if body.present?
+        response = MultiJson.load(body).with_indifferent_access
+        message = response[:error][:message]
+        @type = response[:error][:type]
+      end
+      super message
+    end
+  end
+
+  class BadRequest < Exception
+    def initialize(message, body = '')
+      super 400, message, body
+    end
+  end
+
+  class Unauthorized < Exception
+    def initialize(message, body = '')
+      super 401, message, body
+    end
+  end
+
+  class NotFound < Exception
+    def initialize(message, body = '')
+      super 404, message, body
+    end
+  end
+
+  class InternalServerError < Exception
+    def initialize(message, body = '')
+      super 500, message, body
+    end
+  end
+
+  class InvalidToken < Unauthorized; end
+
+  class InvalidSession < InvalidToken; end
+
+  class InvalidRequest < BadRequest; end
+
+  class CreativeNotSaved < InternalServerError; end
+
+  class QueryLockTimeout < InternalServerError; end
+
+  class TargetingSpecNotSaved < InternalServerError; end
+
+  class AdgroupFetchFailure < InternalServerError; end
+
+  class OpenProcessFailure < InternalServerError; end
+
+  class TransactionCommitFailure < InternalServerError; end
+
+  class QueryError < InternalServerError; end
+
+  class QueryConnection < InternalServerError; end
+
+  class QueryDuplicateKey < InternalServerError; end
+end

data/lib/gs_graph/friend_list.rb

@@ -0,0 +1,13 @@
+module GSGraph
+  class FriendList < Node
+    include Connections::Members
+
+    attr_accessor :name, :list_type
+
+    def initialize(identifier, attributes = {})
+      super
+      @name = attributes[:name]
+      @list_type = attributes[:list_type]
+    end
+  end
+end

data/lib/gs_graph/friend_request.rb

@@ -0,0 +1,14 @@
+module GSGraph
+  class FriendRequest
+    include Comparison
+    attr_accessor :from, :to, :created_time, :message, :unread
+
+    def initialize(attributes = {})
+      @from = User.new attributes[:from]
+      @to = User.new attributes[:to]
+      @created_time = Time.parse attributes[:created_time]
+      @message = attributes[:message]
+      @unread = attributes[:unread]
+    end
+  end
+end

data/lib/gs_graph/group.rb

@@ -0,0 +1,29 @@
+module GSGraph
+  class Group < Node
+    include Connections::Docs
+    include Connections::Feed
+    include Connections::Members
+    include Connections::Picture
+    include Connections::Videos
+    extend Searchable
+
+    attr_accessor :owner, :name, :email, :description, :link, :icon, :privacy, :version, :updated_time
+
+    def initialize(identifier, attributes = {})
+      super
+      if (owner = attributes[:owner])
+        @owner = User.new(owner[:id], owner)
+      end
+      @name         = attributes[:name]
+      @email        = attributes[:email]
+      @description  = attributes[:description]
+      @link         = attributes[:link]
+      @icon         = attributes[:icon]
+      @privacy      = attributes[:privacy]
+      @version      = attributes[:version]
+      if attributes[:updated_time]
+        @updated_time = Time.parse(attributes[:updated_time]).utc
+      end
+    end
+  end
+end

data/lib/gs_graph/image.rb

@@ -0,0 +1,11 @@
+module GSGraph
+  class Image
+    include Comparison
+    attr_accessor :source, :height, :width
+    def initialize(attributes = {})
+      @source = attributes[:source]
+      @height = attributes[:height]
+      @width  = attributes[:width]
+    end
+  end
+end

data/lib/gs_graph/insight.rb

@@ -0,0 +1,13 @@
+module GSGraph
+  class Insight < Node
+    attr_accessor :name, :period, :values, :description
+
+    def initialize(identifier, attributes = {})
+      super
+      @name   = attributes[:name]
+      @period = attributes[:period]
+      @values = attributes[:values].collect(&:with_indifferent_access)
+      @description = attributes[:description]
+    end
+  end
+end

data/lib/gs_graph/klass.rb

@@ -0,0 +1,31 @@
+module GSGraph
+  class Klass < Page
+    attr_accessor :with, :start_date, :end_date
+
+    def initialize(identifier, attributes = {})
+      super
+      @with = []
+      if attributes[:with]
+        attributes[:with].each do |user|
+          @with << User.new(user[:id], user)
+        end
+      end
+      if attributes[:start_date]
+        year, month = attributes[:start_date].split('-').collect(&:to_i)
+        @start_date = if month.blank? || month == 0
+          Date.new(year)
+        else
+          Date.new(year, month)
+        end
+      end
+      if attributes[:end_date]
+        year, month = attributes[:end_date].split('-').collect(&:to_i)
+        @end_date = if month.blank? || month == 0
+          Date.new(year)
+        else
+          Date.new(year, month)
+        end
+      end
+    end
+  end
+end

data/lib/gs_graph/link.rb

@@ -0,0 +1,32 @@
+module GSGraph
+  class Link < Node
+    include Connections::Comments
+    include Connections::Likes
+    include Connections::Likes::Likable
+
+    attr_accessor :from, :link, :name, :description, :icon, :picture, :message, :created_time
+
+    def initialize(identifier, attributes = {})
+      super
+      if (from = attributes[:from])
+        @from = if from[:category]
+          Page.new(from[:id], from)
+        else
+          User.new(from[:id], from)
+        end
+      end
+      @name        = attributes[:name]
+      @link        = attributes[:link]
+      @description = attributes[:description]
+      @icon        = attributes[:icon]
+      @picture     = attributes[:picture] # NOTE: this is external image, so isn't connection.
+      @message     = attributes[:message]
+      if attributes[:created_time]
+        @created_time = Time.parse(attributes[:created_time]).utc
+      end
+
+      # cached connection
+      cache_collection attributes, :comments
+    end
+  end
+end

data/lib/gs_graph/location.rb

@@ -0,0 +1,20 @@
+module GSGraph
+  class Location
+    include Comparison
+    include Serialization
+
+    attr_accessor :latitude, :longitude
+
+    def initialize(attributes = {})
+      @latitude  = attributes[:latitude]
+      @longitude = attributes[:longitude]
+    end
+
+    def to_hash(options = {})
+      {
+        :latitude  => self.latitude,
+        :longitude => self.longitude
+      }
+    end
+  end
+end

data/lib/gs_graph/message.rb

@@ -0,0 +1,30 @@
+module GSGraph
+  class Message < Node
+    # TODO:
+    # include Connections::Attachments
+    # include Connections::Shares
+    include Connections::Tags
+
+    attr_accessor :message, :from, :to, :created_time
+
+    def initialize(identifier, attributes = {})
+      super
+      @message = attributes[:message]
+      if (from = attributes[:from])
+        @from = User.new(from[:id], from)
+      end
+      @to = []
+      if attributes[:to]
+        Collection.new(attributes[:to]).each do |to|
+          @to << User.new(to[:id], to)
+        end
+      end
+      if attributes[:created_time]
+        @created_time = Time.parse(attributes[:created_time]).utc
+      end
+
+      # cached connection
+      cache_collection attributes, :tags
+    end
+  end
+end

data/lib/gs_graph/milestone.rb

@@ -0,0 +1,26 @@
+module GSGraph
+  class Milestone < Node
+    attr_accessor :from, :title, :description, :created_time, :updated_time, :start_time, :end_time
+
+    def initialize(identifier, attributes = {})
+      super
+      if (from = attributes[:from])
+        @from = Page.new from[:id], from
+      end
+      [:title, :description].each do |key|
+        self.send :"#{key}=", attributes[key]
+      end
+      [:created_time, :updated_time, :start_time, :end_time].each do |key|
+        if (value = attributes[key])
+          time = case value
+          when String
+            Time.parse(value)
+          else
+            value
+          end
+          self.send :"#{key}=", time
+        end
+      end
+    end
+  end
+end

data/lib/gs_graph/node.rb

@@ -0,0 +1,149 @@
+require 'tempfile'
+
+module GSGraph
+  class Node
+    include Comparison
+
+    attr_accessor :identifier, :endpoint, :access_token, :raw_attributes
+
+    def initialize(identifier, attributes = {})
+      @identifier         = identifier
+      @endpoint           = File.join(GSGraph::graph_url, identifier.to_s)
+      @access_token       = attributes[:access_token]
+      @raw_attributes     = attributes
+      @cached_collections = {}
+    end
+
+    def fetch(options = {})
+      options[:access_token] ||= self.access_token if self.access_token
+      _fetched_ = get options
+      _fetched_[:access_token] ||= options[:access_token]
+      self.class.new(_fetched_[:id], _fetched_)
+    end
+
+    def self.fetch(identifier, options = {})
+      new(identifier).fetch(options)
+    end
+
+    def connection(connection, options = {})
+      Connection.new(
+        self,
+        connection,
+        options.merge(
+          :collection => collection_for(connection, options)
+        )
+      )
+    end
+
+    def update(options = {})
+      post options
+    end
+
+    def destroy(options = {})
+      delete options
+    end
+
+    protected
+
+    def get(params = {})
+      handle_response do
+        http_client.get build_endpoint(params), build_params(params)
+      end
+    end
+
+    def post(params = {})
+      handle_response do
+        http_client.post build_endpoint(params), build_params(params)
+      end
+    end
+
+    def delete(params = {})
+      _endpoint_, _params_ = build_endpoint(params), build_params(params)
+      _endpoint_ = [_endpoint_, _params_.try(:to_query)].compact.join('?')
+      handle_response do
+        http_client.delete _endpoint_
+      end
+    end
+
+    def http_client
+      GSGraph.http_client
+    end
+
+    private
+
+    def collection_for(connection, options = {})
+      collection = if @cached_collections.has_key?(connection) && options.blank?
+        @cached_collections[connection]
+      else
+        get options.merge(:connection => connection)
+      end
+      Collection.new collection
+    end
+
+    def cache_collections(attributes, *connections)
+      if (attributes.keys - [:access_token]).present?
+        connections.each do |connection|
+          @cached_collections[connection] = attributes[connection]
+        end
+      end
+    end
+    alias_method :cache_collection, :cache_collections
+
+    def build_endpoint(params = {})
+      File.join([self.endpoint, params.delete(:connection), params.delete(:connection_scope)].compact.collect(&:to_s))
+    end
+
+    def build_params(params)
+      _params_ = params.dup
+      _params_[:access_token] ||= self.access_token
+      _params_.delete_if do |k, v|
+        v.blank? &&
+        # NOTE: allow "key=false" in params (ex. for test user creation, it supports "installed=false")
+        v != false
+      end
+      _params_.each do |key, value|
+        next if value.blank?
+        _params_[key] = case value
+        when String, Symbol, Numeric, Date, Time, Rack::OAuth2::AccessToken::Legacy
+          value.to_s
+        when IO, Tempfile
+          value
+        when defined?(ActionDispatch::Http::UploadedFile) && ActionDispatch::Http::UploadedFile
+          # NOTE: for Rails 3.0.6+
+          # ref) http://blog.livedoor.jp/idea_and_players/archives/5184702.html
+          value.tempfile
+        else
+          value.to_json
+        end
+      end
+      _params_.blank? ? nil : _params_
+    end
+
+    def handle_response
+      response = yield
+      case response.body
+      when 'true'
+        true
+      when 'false'
+        # NOTE: When the object is not found, Graph API returns
+        #  - error response (JSON) when the identifier contains alphabet (ex. graph.gamestamper.com/iamnotfound)
+        #  - false when the identifier is only integer + underbar (ex. graph.gamestamper.com/1234567890, graph.gamestamper.com/12345_67890)
+        # This is an undocumented behaviour, so facebook might chaange it without any announcement.
+        # I've posted this issue on their forum, so hopefully I'll get a document about Graph API error responses.
+        # ref) http://forum.developers.gamestamper.com/viewtopic.php?pid=228256#p228256
+        raise NotFound.new('Graph API returned false, so probably it means your requested object is not found.')
+      when 'null'
+        nil
+      else
+        _response_ = MultiJson.load(response.body).with_indifferent_access
+        if (200...300).include?(response.status)
+          _response_
+        else
+          Exception.handle_httpclient_error(_response_, response.headers)
+        end
+      end
+    rescue MultiJson::DecodeError
+      raise Exception.new(response.status, "Unparsable Response: #{response.body}")
+    end
+  end
+end