brienw-linkedin 0.3.7

data/lib/linked_in/api/update_methods.rb

@@ -0,0 +1,55 @@
+module LinkedIn
+  module Api
+
+    module UpdateMethods
+
+      def add_share(share)
+        path = "/people/~/shares"
+        defaults = {:visibility => {:code => "anyone"}}
+        post(path, defaults.merge(share).to_json, "Content-Type" => "application/json")
+      end
+
+      # def share(options={})
+      #   path = "/people/~/shares"
+      #   defaults = { :visability => 'anyone' }
+      #   post(path, share_to_xml(defaults.merge(options)))
+      # end
+      #
+      # def update_comment(network_key, comment)
+      #   path = "/people/~/network/updates/key=#{network_key}/update-comments"
+      #   post(path, comment_to_xml(comment))
+      # end
+      #
+      # def update_network(message)
+      #   path = "/people/~/person-activities"
+      #   post(path, network_update_to_xml(message))
+      # end
+      #
+      # def send_message(subject, body, recipient_paths)
+      #   path = "/people/~/mailbox"
+      #
+      #   message         = LinkedIn::Message.new
+      #   message.subject = subject
+      #   message.body    = body
+      #   recipients      = LinkedIn::Recipients.new
+      #
+      #   recipients.recipients = recipient_paths.map do |profile_path|
+      #     recipient             = LinkedIn::Recipient.new
+      #     recipient.person      = LinkedIn::Person.new
+      #     recipient.person.path = "/people/#{profile_path}"
+      #     recipient
+      #   end
+      #   message.recipients = recipients
+      #   post(path, message_to_xml(message)).code
+      # end
+      #
+      # def clear_status
+      #   path = "/people/~/current-status"
+      #   delete(path).code
+      # end
+      #
+
+    end
+
+  end
+end

data/lib/linked_in/client.rb

@@ -0,0 +1,46 @@
+require 'cgi'
+
+module LinkedIn
+
+  class Client
+    include Helpers::Request
+    include Helpers::Authorization
+    include Api::QueryMethods
+    include Api::UpdateMethods
+    include Search
+
+    attr_reader :consumer_token, :consumer_secret, :consumer_options
+
+    def initialize(ctoken=LinkedIn.token, csecret=LinkedIn.secret, options={})
+      @consumer_token   = ctoken
+      @consumer_secret  = csecret
+      @consumer_options = options
+    end
+
+    #
+    # def current_status
+    #   path = "/people/~/current-status"
+    #   Crack::XML.parse(get(path))['current_status']
+    # end
+    #
+    # def network_statuses(options={})
+    #   options[:type] = 'STAT'
+    #   network_updates(options)
+    # end
+    #
+    # def network_updates(options={})
+    #   path = "/people/~/network"
+    #   Network.from_xml(get(to_uri(path, options)))
+    # end
+    #
+    # # helpful in making authenticated calls and writing the
+    # # raw xml to a fixture file
+    # def write_fixture(path, filename)
+    #   file = File.new("test/fixtures/#{filename}", "w")
+    #   file.puts(access_token.get(path).body)
+    #   file.close
+    # end
+
+  end
+
+end

data/lib/linked_in/errors.rb

@@ -0,0 +1,19 @@
+module LinkedIn
+  module Errors
+    class LinkedInError < StandardError
+      attr_reader :data
+      def initialize(data)
+        @data = data
+        super
+      end
+    end
+
+    class UnauthorizedError      < LinkedInError; end
+    class GeneralError           < LinkedInError; end
+    class AccessDeniedError      < LinkedInError; end
+
+    class UnavailableError       < StandardError; end
+    class InformLinkedInError    < StandardError; end
+    class NotFoundError          < StandardError; end
+  end
+end

data/lib/linked_in/helpers.rb

@@ -0,0 +1,6 @@
+module LinkedIn
+  module Helpers
+    autoload :Authorization, "linked_in/helpers/authorization"
+    autoload :Request,       "linked_in/helpers/request"
+  end
+end

data/lib/linked_in/helpers/authorization.rb

@@ -0,0 +1,68 @@
+module LinkedIn
+  module Helpers
+
+    module Authorization
+
+      DEFAULT_OAUTH_OPTIONS = {
+        :request_token_path => "/uas/oauth/requestToken",
+        :access_token_path  => "/uas/oauth/accessToken",
+        :authorize_path     => "/uas/oauth/authorize",
+        :api_host           => "https://api.linkedin.com",
+        :auth_host          => "https://www.linkedin.com"
+      }
+
+      def consumer
+        @consumer ||= ::OAuth::Consumer.new(@consumer_token, @consumer_secret, parse_oauth_options)
+      end
+
+      # Note: If using oauth with a web app, be sure to provide :oauth_callback.
+      # Options:
+      #   :oauth_callback => String, url that LinkedIn should redirect to
+      def request_token(options={})
+        @request_token ||= consumer.get_request_token(options)
+      end
+
+      # For web apps use params[:oauth_verifier], for desktop apps,
+      # use the verifier is the pin that LinkedIn gives users.
+      def authorize_from_request(request_token, request_secret, verifier_or_pin)
+        request_token = ::OAuth::RequestToken.new(consumer, request_token, request_secret)
+        access_token  = request_token.get_access_token(:oauth_verifier => verifier_or_pin)
+        @auth_token, @auth_secret = access_token.token, access_token.secret
+      end
+
+      def access_token
+        @access_token ||= ::OAuth::AccessToken.new(consumer, @auth_token, @auth_secret)
+      end
+
+      def authorize_from_access(atoken, asecret)
+        @auth_token, @auth_secret = atoken, asecret
+      end
+
+      private
+
+        # since LinkedIn uses api.linkedin.com for request and access token exchanges,
+        # but www.linkedin.com for authorize/authenticate, we have to take care
+        # of the url creation ourselves.
+        def parse_oauth_options
+          {
+            :request_token_url => full_oauth_url_for(:request_token, :api_host),
+            :access_token_url  => full_oauth_url_for(:access_token,  :api_host),
+            :authorize_url     => full_oauth_url_for(:authorize,     :auth_host),
+            :site              => @consumer_options[:site] || @consumer_options[:api_host] || DEFAULT_OAUTH_OPTIONS[:api_host]
+          }
+        end
+
+        def full_oauth_url_for(url_type, host_type)
+          if @consumer_options["#{url_type}_url".to_sym]
+            @consumer_options["#{url_type}_url".to_sym]
+          else
+            host = @consumer_options[:site] || @consumer_options[host_type] || DEFAULT_OAUTH_OPTIONS[host_type]
+            path = @consumer_options[:"#{url_type}_path".to_sym] || DEFAULT_OAUTH_OPTIONS["#{url_type}_path".to_sym]
+            "#{host}#{path}"
+          end
+        end
+
+    end
+
+  end
+end

data/lib/linked_in/helpers/request.rb

@@ -0,0 +1,80 @@
+module LinkedIn
+  module Helpers
+
+    module Request
+
+      DEFAULT_HEADERS = {
+        'x-li-format' => 'json'
+      }
+
+      API_PATH = '/v1'
+
+      protected
+
+        def get(path, options={})
+          response = access_token.get("#{API_PATH}#{path}", DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response.body
+        end
+
+        def post(path, body='', options={})
+          response = access_token.post("#{API_PATH}#{path}", body, DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response
+        end
+
+        def put(path, body, options={})
+          response = access_token.put("#{API_PATH}#{path}", body, DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response
+        end
+
+        def delete(path, options={})
+          response = access_token.delete("#{API_PATH}#{path}", DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response
+        end
+
+      private
+
+        def raise_errors(response)
+          # Even if the json answer contains the HTTP status code, LinkedIn also sets this code
+          # in the HTTP answer (thankfully).
+          case response.code.to_i
+          when 401
+            data = Mash.from_json(response.body)
+            raise LinkedIn::Errors::UnauthorizedError.new(data), "(#{data.status}): #{data.message}"
+          when 400
+            data = Mash.from_json(response.body)
+            raise LinkedIn::Errors::GeneralError.new(data), "(#{data.status}): #{data.message}"
+          when 403
+            data = Mash.from_json(response.body)
+            raise LinkedIn::Errors::AccessDeniedError.new(data), "(#{data.status}): #{data.message}"
+          when 404
+            raise LinkedIn::Errors::NotFoundError, "(#{response.code}): #{response.message}"
+          when 500
+            raise LinkedIn::Errors::InformLinkedInError, "LinkedIn had an internal error. Please let them know in the forum. (#{response.code}): #{response.message}"
+          when 502..503
+            raise LinkedIn::Errors::UnavailableError, "(#{response.code}): #{response.message}"
+          end
+        end
+
+        def to_query(options)
+          options.inject([]) do |collection, opt|
+            collection << "#{opt[0]}=#{opt[1]}"
+            collection
+          end * '&'
+        end
+
+        def to_uri(path, options)
+          uri = URI.parse(path)
+
+          if options && options != {}
+            uri.query = to_query(options)
+          end
+          uri.to_s
+        end
+    end
+
+  end
+end

data/lib/linked_in/mash.rb

@@ -0,0 +1,68 @@
+require 'hashie'
+require 'multi_json'
+
+module LinkedIn
+  class Mash < ::Hashie::Mash
+
+    # a simple helper to convert a json string to a Mash
+    def self.from_json(json_string)
+      result_hash = ::MultiJson.decode(json_string)
+      new(result_hash)
+    end
+
+    # returns a Date if we have year, month and day, and no conflicting key
+    def to_date
+      if !self.has_key?('to_date') && contains_date_fields?
+        Date.civil(self.year, self.month, self.day)
+      else
+        super
+      end
+    end
+
+    def timestamp
+      value = self['timestamp']
+      if value.kind_of? Integer
+        value = value / 1000 if value > 9999999999
+        Time.at(value)
+      else
+        value
+      end
+    end
+
+    protected
+
+      def contains_date_fields?
+        self.year? && self.month? && self.day?
+      end
+
+      # overload the convert_key mash method so that the LinkedIn
+      # keys are made a little more ruby-ish
+      def convert_key(key)
+        case key.to_s
+        when '_key'
+          'id'
+        when '_total'
+          'total'
+        when 'values'
+          'all'
+        when 'numResults'
+          'total_results'
+        else
+          underscore(key)
+        end
+      end
+
+      # borrowed from ActiveSupport
+      # no need require an entire lib when we only need one method
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+  end
+end

data/lib/linked_in/search.rb

@@ -0,0 +1,56 @@
+module LinkedIn
+
+  module Search
+    def search(options={}, type='people')
+
+      path = "/#{type.to_s}-search"
+
+      if options.is_a?(Hash)
+        fields = options.delete(:fields)
+        path += field_selector(fields) if fields
+      end
+
+      options = { :keywords => options } if options.is_a?(String)
+      options = format_options_for_query(options)
+
+      result_json = get(to_uri(path, options))
+
+      Mash.from_json(result_json)
+    end
+
+    private
+
+      def format_options_for_query(opts)
+        opts.inject({}) do |list, kv|
+          key, value = kv.first.to_s.gsub("_","-"), kv.last
+          list[key]  = sanitize_value(value)
+          list
+        end
+      end
+
+      def sanitize_value(value)
+        value = value.join("+") if value.is_a?(Array)
+        value = value.gsub(" ", "+") if value.is_a?(String)
+        value
+      end
+
+      def field_selector(fields)
+        result = ":("
+        fields = fields.to_a.map do |field|
+          if field.is_a?(Hash)
+            innerFields = []
+            field.each do |key, value|
+              innerFields << key.to_s.gsub("_","-") + field_selector(value)
+            end
+            innerFields.join(',')
+          else
+            field.to_s.gsub("_","-")
+          end
+        end
+        result += fields.join(',')
+        result += ")"
+        result
+      end
+  end
+
+end

data/lib/linked_in/version.rb

@@ -0,0 +1,11 @@
+module LinkedIn
+
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 3
+    PATCH = 7
+    PRE   = nil
+    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+  end
+
+end

data/lib/linkedin.rb

@@ -0,0 +1,32 @@
+require 'oauth'
+
+module LinkedIn
+
+  class << self
+    attr_accessor :token, :secret, :default_profile_fields
+
+    # config/initializers/linkedin.rb (for instance)
+    #
+    # LinkedIn.configure do |config|
+    #   config.token = 'consumer_token'
+    #   config.secret = 'consumer_secret'
+    #   config.default_profile_fields = ['education', 'positions']
+    # end
+    #
+    # elsewhere
+    #
+    # client = LinkedIn::Client.new
+    def configure
+      yield self
+      true
+    end
+  end
+
+  autoload :Api,     "linked_in/api"
+  autoload :Client,  "linked_in/client"
+  autoload :Mash,    "linked_in/mash"
+  autoload :Errors,  "linked_in/errors"
+  autoload :Helpers, "linked_in/helpers"
+  autoload :Search,  "linked_in/search"
+  autoload :Version, "linked_in/version"
+end