linkedin-oauth2 0.1.1

data/examples/status.rb

@@ -0,0 +1,6 @@
+# AUTHENTICATE FIRST found in examples/authenticate.rb
+
+# client is a LinkedIn::Client
+
+# update status for the authenticated user
+client.add_share(:comment => 'is playing with the LinkedIn Ruby gem')

data/lib/linked_in/api.rb

@@ -0,0 +1,6 @@
+module LinkedIn
+  module Api
+    autoload :QueryMethods,  "linked_in/api/query_methods"
+    autoload :UpdateMethods, "linked_in/api/update_methods"
+  end
+end

data/lib/linked_in/api/query_methods.rb

@@ -0,0 +1,123 @@
+module LinkedIn
+  module Api
+
+    module QueryMethods
+
+      def profile(options={})
+        path = person_path(options)
+        simple_query(path, options)
+      end
+
+      def connections(options={})
+        path = "#{person_path(options)}/connections"
+        simple_query(path, options)
+      end
+
+      def network_updates(options={})
+        path = "#{person_path(options)}/network/updates"
+        simple_query(path, options)
+      end
+
+      def company(options = {})
+        path   = company_path(options)
+        simple_query(path, options)
+      end
+
+      def job(options = {})
+        path = jobs_path(options)
+        simple_query(path, options)
+      end
+
+      def job_bookmarks(options = {})
+        path = "#{person_path(options)}/job-bookmarks"
+        simple_query(path, options)
+      end
+
+      def job_suggestions(options = {})
+        path = "#{person_path(options)}/suggestions/job-suggestions"
+        simple_query(path, options)
+      end
+
+      def group_memberships(options = {})
+        path = "#{person_path(options)}/group-memberships"
+        simple_query(path, options)
+      end
+
+      def shares(options={})
+        path = "#{person_path(options)}/network/updates?type=SHAR&scope=self"
+        simple_query(path, options)
+      end
+
+      def share_comments(update_key, options={})
+        path = "#{person_path(options)}/network/updates/key=#{update_key}/update-comments"
+        simple_query(path, options)
+      end
+
+      def share_likes(update_key, options={})
+        path = "#{person_path(options)}/network/updates/key=#{update_key}/likes"
+        simple_query(path, options)
+      end
+
+      private
+
+        def simple_query(path, options={})
+          fields = options.delete(:fields) || LinkedIn.default_profile_fields
+
+          if options.delete(:public)
+            path +=":public"
+          elsif fields
+            path +=":(#{fields.map{ |f| f.to_s.gsub("_","-") }.join(',')})"
+          end
+
+          headers = options.delete(:headers) || {}
+
+          params  = to_query(options)
+          path   += "?#{params}" if !params.empty?
+
+          Mash.from_json(get(path, headers))
+        end
+
+        def person_path(options)
+          path = "/people"
+          if id = options.delete(:id)
+            if id.is_a? Array
+              path += "::(#{id.join(",")})"
+            else
+              path += "/id=#{id}"
+            end
+          elsif url = options.delete(:url)
+            path += "/url=#{CGI.escape(url)}"
+          else
+            path += "/~"
+          end
+        end
+
+        def company_path(options)
+          path = "/companies"
+
+          if domain = options.delete(:domain)
+            path += "?email-domain=#{CGI.escape(domain)}"
+          elsif id = options.delete(:id)
+            path += "/id=#{id}"
+          elsif url = options.delete(:url)
+            path += "/url=#{CGI.escape(url)}"
+          elsif name = options.delete(:name)
+            path += "/universal-name=#{CGI.escape(name)}"
+          else
+            path += "/~"
+          end
+        end
+
+        def jobs_path(options)
+          path = "/jobs"
+          if id = options.delete(:id)
+            path += "/id=#{id}"
+          else
+            path += "/~"
+          end
+        end
+
+    end
+
+  end
+end

data/lib/linked_in/api/update_methods.rb

@@ -0,0 +1,76 @@
+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 join_group(group_id)
+        path = "/people/~/group-memberships/#{group_id}"
+        body = {'membership-state' => {'code' => 'member' }}
+        put(path, body.to_json, "Content-Type" => "application/json")
+      end
+
+      def add_job_bookmark(bookmark)
+        path = "/people/~/job-bookmarks"
+        body = {'job' => {'id' => bookmark}}
+        post(path, body.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"
+        body = {'comment' => comment}
+        post(path, body.to_json, "Content-Type" => "application/json")
+      end
+      #
+      # def update_network(message)
+      #   path = "/people/~/person-activities"
+      #   post(path, network_update_to_xml(message))
+      # end
+      #
+
+      def like_share(network_key)
+        path = "/people/~/network/updates/key=#{network_key}/is-liked"
+        put(path, 'true', "Content-Type" => "application/json")
+      end
+
+      def unlike_share(network_key)
+        path = "/people/~/network/updates/key=#{network_key}/is-liked"
+        put(path, 'false', "Content-Type" => "application/json")
+      end
+
+      def send_message(subject, body, recipient_paths)
+        path = "/people/~/mailbox"
+      
+        message = {
+            'subject' => subject, 
+            'body' => body,
+            'recipients' => {
+                'values' => recipient_paths.map do |profile_path| 
+                  { 'person' => { '_path' => "/people/#{profile_path}" } } 
+                end
+            }
+        }
+        post(path, message.to_json, "Content-Type" => "application/json")
+      end
+      #
+      # def clear_status
+      #   path = "/people/~/current-status"
+      #   delete(path).code
+      # end
+      #
+
+    end
+
+  end
+end

data/lib/linked_in/client.rb

@@ -0,0 +1,31 @@
+require 'cgi'
+
+module LinkedIn
+
+  class Client
+    include Helpers::Request
+    include Helpers::Authorization
+    include Api::QueryMethods
+    include Api::UpdateMethods
+    include Search
+
+    attr_reader :client_id, :client_secret, :access_token
+
+    # The first two arguments must be your client_id, and client_secret.
+    # The third option may either be an access_token or an options hash.
+    def initialize(client_id=LinkedIn.client_id,
+                   client_secret=LinkedIn.client_secret,
+                   initial_access_token=nil,
+                   options={})
+      @client_id     = client_id
+      @client_secret = client_secret
+      if initial_access_token.is_a? Hash
+        @client_options = initial_access_token
+      else
+        @client_options = options
+        self.set_access_token initial_access_token
+      end
+    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,106 @@
+
+# TODO
+# `consumer` renamed to `client`
+#
+# rename OAuth to OAuth2
+#
+# deprecate `request_token`
+# deprecate `access_token`
+#
+# deprecate `authorize_from_request`
+# deprecate `authorize_from_access`
+#
+# cleanup bottom
+# deprecate `oauth_callback`
+#
+# DONE 
+# `consumer_token renamed to `client_id`
+# `consumer_secret renamed to `client_secret`
+# request_token_url is deprecated. Replaced with token_url
+# access_token_url is deprecated. Replaced with token_url
+# request_token_path is deprecated
+# access_token_path has changed
+# authorize_path has been deprecated
+
+module LinkedIn
+  module Helpers
+
+    module Authorization
+
+      DEFAULT_OAUTH2_OPTIONS = {
+        authorize_path: "/uas/oauth2/authorization",
+        access_token_path: "/uas/oauth2/accessToken",
+        api_host: "https://api.linkedin.com",
+        auth_host: "https://www.linkedin.com"
+      }
+
+      def oauth2_client
+        @oauth2_client ||= ::OAuth2::Client.new(@client_id,
+                                                @client_secret,
+                                                parse_oauth2_options)
+      end
+
+      # A way to fetch the authorize_url
+      # @param :redirect_uri - Where you want it to redirect to after
+      # @param :scope - A list of member permissions you would like to
+      # request.
+      def authorize_url(params={})
+        # response_type param included by default by using the OAuth 2.0
+        # auth_code strategy
+        # client_id param included automatically by the OAuth 2.0 gem
+        params[:state] ||= state
+        params[:redirect_uri] ||= "http://localhost"
+        oauth2_client.auth_code.authorize_url(params)
+      rescue OAuth2::Error => e
+        raise LinkedIn::Errors::UnauthorizedError.new(e.code), e.description
+      end
+
+      # Fetches the access_token given the auth_code fetched by
+      # navigating to `authorize_url`
+      # @param :redirect_uri - Where you want to redirect after you have
+      # fetched the token.
+      def request_access_token(code, params={})
+        params[:redirect_uri] ||= "http://localhost"
+        opts = {}
+        opts[:mode] = :query
+        opts[:param_name] = "oauth2_access_token"
+        @access_token = oauth2_client.auth_code.get_token(code, params, opts)
+      rescue OAuth2::Error => e
+        raise LinkedIn::Errors::UnauthorizedError.new(e.code), e.description
+      end
+
+      # If one already has an access_token string, it can be set here and
+      # turned into an OAuth2::AccessToken object.
+      def set_access_token(token, options={})
+        options[:access_token] = token
+        options[:mode] = :query
+        options[:param_name] = "oauth2_access_token"
+        @access_token = OAuth2::AccessToken.from_hash oauth2_client, options
+      end
+
+      # NOTE: There is an attr_reader for :access_token.
+
+      private
+
+        # The keys of this hash are designed to match the OAuth2
+        # initialize spec.
+        def parse_oauth2_options
+          default = {site: DEFAULT_OAUTH2_OPTIONS[:api_host],
+                     token_url: full_oauth_url_for(:access_token, :auth_host),
+                     authorize_url: full_oauth_url_for(:authorize, :auth_host)}
+          return default.merge(@client_options)
+        end
+
+        def full_oauth_url_for(url_type, host_type)
+          host = DEFAULT_OAUTH2_OPTIONS[host_type]
+          path = DEFAULT_OAUTH2_OPTIONS["#{url_type}_path".to_sym]
+          "#{host}#{path}"
+        end
+
+        def state
+          o = [('a'..'z'),('A'..'Z')].map{|i| i.to_a}.flatten
+          @state ||= (0...50).map{ o[rand(o.length)] }.join
+        end
+    end
+  end
+end

data/lib/linked_in/helpers/request.rb

@@ -0,0 +1,93 @@
+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}", headers: DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response.body
+        rescue OAuth2::Error => e
+          raise LinkedIn::Errors::AccessDeniedError.new(e.code), e.description
+        end
+
+        def post(path, body='', options={})
+          response = access_token.post("#{API_PATH}#{path}", body: body, headers: DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response
+        rescue OAuth2::Error => e
+          raise LinkedIn::Errors::AccessDeniedError.new(e.code), e.description
+        end
+
+        def put(path, body, options={})
+          response = access_token.put("#{API_PATH}#{path}", body: body, headers: DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response
+        rescue OAuth2::Error => e
+          raise LinkedIn::Errors::AccessDeniedError.new(e.code), e.description
+        end
+
+        def delete(path, options={})
+          response = access_token.delete("#{API_PATH}#{path}", headers: DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response
+        rescue OAuth2::Error => e
+          raise LinkedIn::Errors::AccessDeniedError.new(e.code), e.description
+        end
+
+      private
+
+        def raise_errors(response)
+          # Even if the json answer contains the HTTP status code, LinkedIn also sets this status
+          # in the HTTP answer (thankfully).
+          case response.status.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.status}): #{response.message}"
+          when 500
+            raise LinkedIn::Errors::InformLinkedInError, "LinkedIn had an internal error. Please let them know in the forum. (#{response.status}): #{response.message}"
+          when 502..503
+            raise LinkedIn::Errors::UnavailableError, "(#{response.status}): #{response.message}"
+          end
+        end
+
+
+        # Stolen from Rack::Util.build_query
+        def to_query(params)
+          params.map { |k, v|
+            if v.class == Array
+              to_query(v.map { |x| [k, x] })
+            else
+              v.nil? ? escape(k) : "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"
+            end
+          }.join("&")
+        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