linkedin-build 1.1.14

data/lib/linked_in/api/query_helpers.rb

@@ -0,0 +1,86 @@
+module LinkedIn
+  module Api
+
+    module QueryHelpers
+      private
+
+      def group_path(options)
+        path = "/groups"
+        if id = options.delete(:id)
+          path += "/#{id}"
+        end
+      end
+
+      def simple_query(path, options={})
+        fields = options.delete(:fields) || LinkedIn.default_profile_fields
+
+        if options.delete(:public)
+          path +=":public"
+        elsif fields
+          path +=":(#{build_fields_params(fields)})"
+        end
+
+        headers = options.delete(:headers) || {}
+        params  = to_query(options)
+        path   += "#{path.include?("?") ? "&" : "?"}#{params}" if !params.empty?
+
+        Mash.from_json(get(path, headers))
+      end
+
+      def build_fields_params(fields)
+        if fields.is_a?(Hash) && !fields.empty?
+          fields.map {|index,value| "#{index}:(#{build_fields_params(value)})" }.join(',')
+        elsif fields.respond_to?(:each)
+          fields.map {|field| build_fields_params(field) }.join(',')
+        else
+          fields.to_s.gsub("_", "-")
+        end
+      end
+
+      def person_path(options)
+        path = "/people"
+        if id = options.delete(:id)
+          path += "/id=#{id}"
+        elsif url = options.delete(:url)
+          path += "/url=#{CGI.escape(url)}"
+        elsif email = options.delete(:email)
+          path += "::(#{email})"
+        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}"
+        elsif url = options.delete(:url)
+          path += "/url=#{CGI.escape(url)}"
+        elsif name = options.delete(:name)
+          path += "/universal-name=#{CGI.escape(name)}"
+        elsif is_admin = options.delete(:is_admin)
+          path += "?is-company-admin=#{CGI.escape(is_admin)}"
+        else
+          path += "/~"
+        end
+      end
+
+      def picture_urls_path(options)
+        path = person_path(options)
+        path += "/picture-urls"
+      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/share_and_social_stream.rb

@@ -0,0 +1,137 @@
+module LinkedIn
+  module Api
+
+    # Share and Social Stream APIs
+    #
+    # @see https://developer.linkedin.com/docs/share-on-linkedin Share API
+    #
+    # The following API actions do not have corresponding methods in
+    # this module
+    #
+    #   * GET Network Statistics
+    #   * POST Post Network Update
+    #
+    # [(contribute here)](https://github.com/hexgnu/linkedin)
+    module ShareAndSocialStream
+
+      # Retrieve the authenticated users network updates
+      #
+      # Permissions: rw_nus
+      #
+      # @see http://developer.linkedin.com/documents/get-network-updates-and-statistics-api
+      # @see http://developer.linkedin.com/documents/network-update-types Network Update Types
+      #
+      # @macro person_path_options
+      # @option options [String] :scope
+      # @option options [String] :type
+      # @option options [String] :count
+      # @option options [String] :start
+      # @option options [String] :after
+      # @option options [String] :before
+      # @option options [String] :show-hidden-members
+      # @return [LinkedIn::Mash]
+      def network_updates(options={})
+        path = "#{person_path(options)}/network/updates"
+        simple_query(path, options)
+      end
+
+      # TODO refactor to use #network_updates
+      def shares(options={})
+        path = "#{person_path(options)}/network/updates"
+        simple_query(path, {:type => "SHAR", :scope => "self"}.merge(options))
+      end
+
+      def share(update_key, options={})
+        path = "#{person_path(options)}/network/updates/key=#{update_key}"
+        simple_query(path, options)
+      end
+
+      # Retrieve all comments for a particular network update
+      #
+      # @note The first 5 comments are included in the response to #network_updates
+      #
+      # Permissions: rw_nus
+      #
+      # @see http://developer.linkedin.com/documents/commenting-reading-comments-and-likes-network-updates
+      #
+      # @param [String] update_key a update/update-key representing a
+      #   particular network update
+      # @macro person_path_options
+      # @return [LinkedIn::Mash]
+      def share_comments(update_key, options={})
+        path = "#{person_path(options)}/network/updates/key=#{update_key}/update-comments"
+        simple_query(path, options)
+      end
+
+      # Retrieve all likes for a particular network update
+      #
+      # @note Some likes are included in the response to #network_updates
+      #
+      # Permissions: rw_nus
+      #
+      # @see http://developer.linkedin.com/documents/commenting-reading-comments-and-likes-network-updates
+      #
+      # @param [String] update_key a update/update-key representing a
+      #   particular network update
+      # @macro person_path_options
+      # @return [LinkedIn::Mash]
+      def share_likes(update_key, options={})
+        path = "#{person_path(options)}/network/updates/key=#{update_key}/likes"
+        simple_query(path, options)
+      end
+
+      # Create a share for the authenticated user
+      #
+      # Permissions: rw_nus
+      #
+      # @see https://developer.linkedin.com/docs/share-on-linkedin Share API
+      #
+      # @macro share_input_fields
+      # @return [void]
+      def add_share(share)
+        path = "/people/~/shares"
+        defaults = {:visibility => {:code => "anyone"}}
+        post(path, MultiJson.dump(defaults.merge(share)), "Content-Type" => "application/json")
+      end
+
+      # Create a comment on an update from the authenticated user
+      #
+      # @see http://developer.linkedin.com/documents/commenting-reading-comments-and-likes-network-updates
+      #
+      # @param [String] update_key a update/update-key representing a
+      #   particular network update
+      # @param [String] comment The text of the comment
+      # @return [void]
+      def update_comment(update_key, comment)
+        path = "/people/~/network/updates/key=#{update_key}/update-comments"
+        body = {'comment' => comment}
+        post(path, MultiJson.dump(body), "Content-Type" => "application/json")
+      end
+
+      # (Update) like an update as the authenticated user
+      #
+      # @see http://developer.linkedin.com/documents/commenting-reading-comments-and-likes-network-updates
+      #
+      # @param [String] update_key a update/update-key representing a
+      #   particular network update
+      # @return [void]
+      def like_share(update_key)
+        path = "/people/~/network/updates/key=#{update_key}/is-liked"
+        put(path, 'true', "Content-Type" => "application/json")
+      end
+
+      # (Destroy) unlike an update the authenticated user previously
+      # liked
+      #
+      # @see http://developer.linkedin.com/documents/commenting-reading-comments-and-likes-network-updates
+      #
+      # @param [String] update_key a update/update-key representing a
+      #   particular network update
+      # @return [void]
+      def unlike_share(update_key)
+        path = "/people/~/network/updates/key=#{update_key}/is-liked"
+        put(path, 'false', "Content-Type" => "application/json")
+      end
+    end
+  end
+end

data/lib/linked_in/client.rb

@@ -0,0 +1,51 @@
+require 'cgi'
+
+module LinkedIn
+
+  class Client
+    include Helpers::Request
+    include Helpers::Authorization
+    include Api::QueryHelpers
+    include Api::People
+    include Api::Groups
+    include Api::Companies
+    include Api::Jobs
+    include Api::ShareAndSocialStream
+    include Api::Communications
+    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,29 @@
+module LinkedIn
+  module Errors
+    class LinkedInError < StandardError
+      attr_reader :data
+      def initialize(data)
+        @data = data
+        super
+      end
+    end
+
+    # Raised when a 401 response status code is received
+    class UnauthorizedError      < LinkedInError; end
+
+    # Raised when a 400 response status code is received
+    class GeneralError           < LinkedInError; end
+
+    # Raised when a 403 response status code is received
+    class AccessDeniedError      < LinkedInError; end
+
+    # Raised when a 404 response status code is received
+    class NotFoundError          < LinkedInError; end
+
+    # Raised when a 500 response status code is received
+    class InformLinkedInError    < LinkedInError; end
+
+    # Raised when a 502 or 503 response status code is received
+    class UnavailableError       < LinkedInError; 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,69 @@
+module LinkedIn
+  module Helpers
+
+    module Authorization
+
+      DEFAULT_OAUTH_OPTIONS = {
+        #:request_token_path => "/uas/oauth/requestToken",
+        :access_token_path  => "/oauth/v2/accessToken", #"/uas/oauth/accessToken",
+        :authorize_path     => "/oauth/v2/authorize",
+        :api_host           => "https://api.linkedin.com",
+        :auth_host          => "https://www.linkedin.com"
+      }
+
+      def consumer
+        @consumer ||= ::OAuth2::Client.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={}, *arguments, &block)
+        @request_token ||= consumer.get_request_token(options, *arguments, &block)
+      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 ||= ::OAuth2::AccessToken.new(consumer, @auth_token, :expires_at => @expires_at)
+      end
+
+      def authorize_from_access(atoken, expires_at)
+        @auth_token, @expires_at = atoken, expires_at
+      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],
+              :proxy             => @consumer_options.fetch(:proxy, nil)
+          }
+        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,85 @@
+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
+        end
+
+        def post(path, body='', options={})
+          response = access_token.post("#{API_PATH}#{path}", {:body => body, :headers => DEFAULT_HEADERS.merge(options)})
+          raise_errors(response)
+          response
+        end
+
+        def put(path, body, options={})
+          response = access_token.put("#{API_PATH}#{path}", {:body => body, :headers => DEFAULT_HEADERS.merge(options)})
+          raise_errors(response)
+          response
+        end
+
+        def delete(path, options={})
+          response = access_token.delete("#{API_PATH}#{path}", {:headers => 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.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