linkedin-drspin 0.3.6

data/lib/linked_in/api/company_search_methods.rb

@@ -0,0 +1,65 @@
+module LinkedIn
+  module Api
+    module CompanySearchMethods
+
+      # Public: Search the LinkedIn service for companies
+      #
+      # options - The Hash options used to refine the selection:
+      #           :sort  - Controls the search result order. 
+      #           :start - The people record to start the return from.
+      #                    Used for page wrapping when the total number
+      #                    of records matching the search exceeds count
+      #                    (default: 0).
+      #           :count - The number of companiy records to return 
+      #                    (default: 25).
+      #           :companies - The company fields to be returned
+      #                        (default: id,name,website-url)
+      #           :keywords  - The keywords to search for (optional).
+      #
+      # Examples
+      #
+      #    > y linkedin.company_search(:keywords => "social,local",
+      #                                :count => 2) 
+      #    ---
+      #    companies:
+      #      _count: 2
+      #      _start: 0
+      #      total: 8620
+      #      all:
+      #      - id: 1355
+      #        name: DHL
+      #        website_url: http://www.dhl.com
+      #      - id: 15656
+      #        name: AECOM
+      #        website_url: www.aecom.com
+      #      => nil
+      #
+      # Returns a Hashie::Mash of the matched companies.
+      def company_search(options={})
+        options.reverse_merge!({
+          :sort => 'relevance',
+          :start => 0,
+          :count => 25,
+          :companies => 'id,name,website-url'
+        })
+
+        path = "/company-search:(companies:(#{options[:companies]}))" +
+               "?sort=#{options[:sort]}" +
+               "&start=#{options[:start]}" +
+               "&count=#{options[:count]}"
+        
+        path += "&keywords=#{CGI.escape(options[:keywords])}" if 
+          options[:keywords]
+
+        Mash.from_json(get(path))
+      end
+
+
+      def location(options={})
+        path = "/people-search:(facets:(code,buckets:(code,name)))?company-name=microsoft&facets=location"
+        simple_query(path)
+      end
+
+    end # CompanySearchMethods
+  end # Api
+end # LinkedIn

data/lib/linked_in/api/group_methods.rb

@@ -0,0 +1,18 @@
+module LinkedIn
+  module Api
+    module GroupMethods
+      
+      def groups(options={})
+        path = "#{person_path(options)}/group-memberships?membership-state=member"
+        group_mash = simple_query(path, options)
+        group_mash.all
+      end
+
+      def suggested_groups(options={})
+        path   = "#{person_path(options)}/suggestions/groups"
+        simple_query(path, options)
+      end
+
+    end # GroupMethods
+  end # Api
+end # LinkedIn

data/lib/linked_in/api/people_search_methods.rb

@@ -0,0 +1,112 @@
+module LinkedIn
+  module Api
+    module PeopleSearchMethods
+
+      # Public: Search the LinkedIn service for people
+      #
+      # options - The Hash options used to refine the selection:
+      #           :people - The people fields to be returned 
+      #                     (default: public-profile-url,id,first-name,
+      #                               last-name,headline,location).
+      #           :count  - The number of people records to return
+      #                     (default: 25).
+      #           :start  - The people record to start the return from.
+      #                     Used for page wrapping when the total number
+      #                     of records matching the search exceeds count
+      #                     (default: 0).
+      #           :companies - A comma separated list of company codes to
+      #                        to match against the current-company field
+      #                        of people (optional).
+      #           :locations - A comma separated list of location codes to
+      #                        match agains the location field of people
+      #                        (optional).
+      #           :get_all - Boolean variable telling us to get all of 
+      #                      the people that match our search. LinkedIn
+      #                      will only return the first 25 by default
+      #                      (optional).
+      #
+      # Examples
+      #
+      #   > y client.people_search(:locations => 'us:91', 
+      #                            :company => 1035, 
+      #                            :count => 1)
+      #  ---
+      #  people:
+      #    _count: 1
+      #    _start: 0
+      #    total: 110
+      #    all:
+      #    - first_name: Ben
+      #      headline: Designer at SkB Architects
+      #      id: EHp0p-X67f
+      #      last_name: Humphrey
+      #      location:
+      #        country:
+      #          code: us
+      #        name: Greater Seattle Area
+      #      public_profile_url: http://www.linkedin.com/in/benhumphrey
+      #   => nil
+      #
+      # Returns a Hashie::Mash of the matched people. 
+      def people_search(options={})
+
+        # revere merge defaults into options has so that we don't 
+        # overwrite what the user has given us.
+        options.reverse_merge!({
+          :people => "public-profile-url,id,first-name,last-name" +
+                     ",headline,location",
+          :count  => 25,
+          :start  => 0
+        })
+
+        # initialize path string for a people-search
+        path = "/people-search:(people:(#{options[:people]}))" +
+               "?count=#{options[:count]}" +
+               "&start=#{options[:start]}"
+
+        # add a facet so that we find everyone in the given companys
+        # if the :company option is defined.
+        path += "&facet=current-company,#{options[:companies]}" if 
+          options[:companies]
+
+        # add a facet so that we find everyone in the given locations
+        # if the :location option is defined.
+        path += "&facet=location,#{CGI.escape(options[:locations])}" if
+          options[:locations]
+
+        # hit the linkedin service with the search. we store the payload
+        # as an array so that we can manipulate it below.
+        payload = MultiJson.decode(get(path))
+        Rails.logger.debug path
+
+        # if the :get_all option is set, we check to make sure that
+        # the count of items returned from the linkedin service is 
+        # not less than the total number of items that match our 
+        # search in the linkedin service. 
+        while ((payload['people']['_start'] +
+                payload['people']['_count']) <
+                payload['people']['_total'])
+
+          # update the path string so that we start from where we 
+          # left off from the last search.
+          path.sub!(/start=\d+/, 
+                    "start=#{payload['people']['_start'] + 
+                             payload['people']['_count']}")
+          Rails.logger.debug path
+
+          # update the count in our payload
+          payload['people']['_count'] += options[:count]
+
+          # hit the linkedin service again and merge teh new 
+          # results into our payload.
+          payload['people']['values'] += 
+            MultiJson.decode(get(path))['people']['values']
+
+        end if options[:get_all]
+
+        Mash.from_json(MultiJson.encode(payload))
+
+      end # people_search()
+    end # PeopleSearchMethods
+  end # Api
+end # LinkedIn

data/lib/linked_in/api/post_methods.rb

@@ -0,0 +1,33 @@
+module LinkedIn
+  module Api
+    module PostMethods
+      #
+      # group_posts(options={})
+      #
+      # inputs: 
+      #   REQUIRED
+      #     :group_id - the numeric id of the group to pull posts from.
+      #   OPTIONAL
+      #     :count - number of posts to retun (max 50)
+      #     :start - post number to start pulling from
+      #
+      # outputs:
+      #   Mash of json results from LinkedIn service
+      #
+      # description: Retreive posts from a given group and filter
+      #              based on optional inputs.
+      #
+      def group_posts(options={})
+        options.reverse_merge!({:order => "recency"})
+        if options[:group_id]
+          group_id = options.delete(:group_id)
+        else
+          raise ":group_id option required for group_posts method"
+        end
+        path = "/groups/#{group_id}/posts:(title,summary,creator,id)"
+        simple_query(path, options)
+      end
+
+    end # PostMethods
+  end # Api
+end # LinkedIn

data/lib/linked_in/api/query_methods.rb

@@ -0,0 +1,81 @@
+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
+
+
+      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  = options.map { |k,v| "#{k}=#{v}" }.join("&")
+          path   += "?#{params}" if not params.empty?
+
+          Mash.from_json(get(path, headers))
+        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)}"
+          else
+            path += "~"
+          end
+        end
+
+        def company_path(options)
+          # We leave out the trailing slash because it is used by keys but not
+          # by filters
+          path = "/companies"
+          
+          # Add a trailing slash for keys (i.e. input values that return one
+          # company)
+          if 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)}"
+          # Add a question mark for filters (i.e. input values that return
+          # an array of companies.
+          elsif domain = options.delete(:domain)
+            path += "?email-domain=#{CGI.escape(domain)}"
+          else
+            path += "~"
+          end
+        end
+
+    end
+
+  end
+end

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,51 @@
+require 'cgi'
+
+module LinkedIn
+
+  class Client
+    include Helpers::Request
+    include Helpers::Authorization
+    include Api::QueryMethods
+    include Api::UpdateMethods
+    include Api::GroupMethods
+    include Api::PostMethods
+    include Api::CompanySearchMethods
+    include Api::PeopleSearchMethods
+    include Api::CommentMethods
+    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