linkedin-v2 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 188d3b8c708aa23a58b655c5e2196919bb9bba99
+  data.tar.gz: b8391342b546d18f5b8c322a002a81d262863745
+SHA512:
+  metadata.gz: ca09e965f66642dfc2dec5d63554be7980a828e6f0c4cfc6d2e20f8bc923209971013319131e0e2f10469e163c03fb958b3fa100d368252d15b431b232e2cc40
+  data.tar.gz: e2cc077b53c6e9bf080d73822e18fcad500e6a5a6a1d9f8abf71da3ade3d1d1082268fed3aabea01cf5bdb38f03b1629c75e15923e86ea61715415a009556140

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 1.0.0 - August 1, 2014
+
+* Complete re-architecture of the Oauth2.0 gem.
+
+## 0.1.0 - July 15, 2013
+
+* Migrated API over to use Linkedin's OAuth 2.0
+* **NOTE:** This was based off of a heavily modified fork from hexgnu/linkedin

data/CONTRIBUTING.md

@@ -0,0 +1 @@
+Read [GitHub's "Contributing to Open Source on GitHub"](https://guides.github.com/activities/contributing-to-open-source/)

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Dependencies defined in linkedin-oauth2.gemspec
+gemspec
+
+group :test do
+  gem "coveralls", require: false
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2014-present Evan Morikawa (evan@evanmorikawa.com) 2013-2014
+Matt Kirk 2009-11 Wynn Netherland.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,224 @@
+# LinkedIn v2
+
+## WARNING: DANGER WILL ROBINSON
+
+This is very much a work in progress. Currently only the shares/social stream
+and organization related endpoints have been verified to work. Having said that,
+those endpoints are using this gem in a production application, so they're
+reliable enough. :)
+
+Many endpoints still need to be written, and as I don't have the requisite partner
+status w/ LinkedIn, I can't develop against the jobs API. Many of the specs still
+fail. *Caveat emptor*
+
+## NOW BACK TO YOUR REGULARLY SCHEDULED PROGRAMMING
+
+Ruby wrapper for v2 if the [LinkedIn API](http://developer.linkedin.com). This gem is entirely
+based on emorikawa's excellent [linkedin-oauth2](https://github.com/emorikawa/linkedin-oauth2)
+gem.
+
+If you are using OAuth 1.0, see [hexgnu/linkedin](https://github.com/hexgnu/linkedin)
+If you are using OAuth 2.0 and the v1 LinkedIn API, see [emorikawa/linkedin-oauth2](https://github.com/emorikawa/linkedin-oauth2), on which this gem is based.
+
+# Installation
+
+In Bundler:
+
+```ruby
+gem "linkedin-v2", "~> 0.1.0"
+```
+
+Otherwise:
+
+    [sudo|rvm] gem install linkedin-v2
+
+# Usage
+
+**[Step 1:](#step-1-register-your-application)** [Register](https://www.linkedin.com/secure/developer) your
+application with LinkedIn. They will give you a **Client ID** (aka API
+Key) and a **Client Secret** (aka Secret Key)
+
+**[Step 2:](#step-2-getting-an-access-token)** Use your **Client ID** and **Client Secret** to obtain an **Access Token** from some user.
+
+**[Step 3:](#step-3-using-linkedins-api)** Use an **Access Token** to query the API.
+
+```ruby
+api = LinkedIn::API.new(access_token)
+me = api.profile
+```
+
+## Step 1: Register your Application
+
+You first need to create and register an application with LinkedIn
+[here](https://www.linkedin.com/secure/developer).
+
+You will not be able to use any part of the API without registering first.
+
+Once you have registered you will need to take note of a few key items on
+your Application Details page.
+
+1. **API Key** - We refer to this as your client id or `client_id`
+1. **Secret Key** - We refer to this as your client secret or
+   `client_secret`
+1. **Default Scope** - This is the set of permissions you request from
+   users when they connect to your app. If you want to set this on a
+   request-by-request basis, you can use the `scope` option with the
+   `auth_code_url` method.
+1. **OAuth 2.0 Redirect URLs** - For security reasons, the url you enter
+   in this box must exactly match the `redirect_uri` you use in this gem.
+
+You do NOT need **OAuth User Token** nor **OAuth User Secret**. That is
+for OAuth 1.0. This gem is for OAuth 2.0.
+
+## Step 2: Getting An Access Token
+
+All LinkedIn API requests must be made in the context of an access token.
+The access token encodes what LinkedIn information your AwesomeApp® can
+gather on behalf of "John Doe".
+
+There are a few different ways to get an access token from a user.
+
+1. You can use [LinkedIn's Javascript API](https://developer.linkedin.com/documents/javascript-api-reference-0) to authenticate on the front-end and then pass the access token to the backend via [this procedure](https://developer.linkedin.com/documents/exchange-jsapi-tokens-rest-api-oauth-tokens).
+
+1. If you use OmniAuth, I would recommend looking at [decioferreira/omniauth-linkedin-oauth2](https://github.com/decioferreira/omniauth-linkedin-oauth2) to help automate authentication.
+
+1. You can do it manually using this linkedin-oauth2 gem and the steps
+   below.
+
+Here is how to get an access token using this linkedin-oauth2 gem:
+
+### Step 2A: Configuration
+
+You will need to configure the following items:
+
+1. Your **client id** (aka API Key)
+1. Your **client secret** (aka Secret Key)
+1. Your **redirect uri**. On LinkedIn's website you must input a list of
+   valid redirect URIs. If you use the same one each time, you can set it
+   in the `LinkedIn.configure` block. If your redirect uris change
+   depending on business logic, you can pass it into the `auth_code_url`
+   method.
+
+```ruby
+# It's best practice to keep secret credentials out of source code.
+# You can, of course, hardcode dev keys or directly pass them in as the
+# first two arguments of LinkedIn::OAuth2.new
+LinkedIn.configure do |config|
+  config.client_id     = ENV["LINKEDIN_CLIENT_ID"]
+  config.client_secret = ENV["LINKEDIN_CLIENT_SECRET"]
+
+  # This must exactly match the redirect URI you set on your application's
+  # settings page. If your redirect_uri is dynamic, pass it into
+  # `auth_code_url` instead.
+  config.redirect_uri  = "https://getawesomeapp.io/linkedin/oauth2"
+end
+```
+
+### Step 2B: Get Auth Code URL
+
+```ruby
+oauth = LinkedIn::OAuth2.new
+
+url = oauth.auth_code_url
+```
+
+### Step 2C: User Sign In
+
+You must now load url from Step 2B in a browser. It will pull up the
+LinkedIn sign in box. Once LinkedIn user credentials are entered, the box
+will close and redirect to your redirect url, passing along with it the
+**OAuth code** as the `code` GET param.
+
+Be sure to read the extended documentation around the LinkedIn::OAuth2
+module for more options you can set.
+
+**Note:** The **OAuth code** only lasts for ~20 seconds!
+
+### Step 2D: Get Access Token
+
+```ruby
+code = "THE_OAUTH_CODE_LINKEDIN_GAVE_ME"
+
+access_token = oauth.get_access_token(code)
+```
+
+Now that you have an access token, you can use it to query the API.
+
+The `LinkedIn::OAuth2` inherits from [intreda/oauth2](https://github.com/intridea/oauth2)'s `OAuth2::Client` class. See that gem's [documentation](https://github.com/intridea/oauth2/blob/master/lib/oauth2/client.rb) for more usage examples.
+
+## Step 3: Using LinkedIn's API
+
+Once you have an access token, you can query LinkedIn's API.
+
+Your access token encodes the permissions you're allowed to have. See Step
+2 and [this LinkedIn document](https://developer.linkedin.com/documents/authentication#granting) for how to change the permissions. See each section's documentation on LinkedIn for more information on what permissions get you access to.
+
+### People
+
+## TBD
+
+### Organizations
+
+Detailed overviews of Organizations
+
+See https://developer.linkedin.com/docs/guide/v2/organizations
+
+```ruby
+# Organization info
+api.organization(name: "google")
+api.organization(id: 12345)
+api.organization(urn: 'urn:li:organization:12345')
+```
+
+### Jobs
+
+## DON'T HAVE ACCESS. :(
+```
+
+### Share and Social Stream
+
+View and update content on social streams
+
+See https://developer.linkedin.com/docs/guide/v2/shares
+
+```ruby
+# Your news feed
+api.shares
+
+api.share(content: "hi")
+
+# For a particular feed item
+api.comments(urn: "urn:li:article:12345")
+api.likes(urn: "urn:li:article:12345")
+
+api.like(urn: "urn:li:activity:12345")
+api.unlike(urn: "urn:li:activity:12345")
+```
+
+### Communications
+
+## TBD
+
+# Documentation
+
+On [RubyDoc here](http://rubydoc.info/github/mdesjardins/linkedin-v2/frames/file/README.md)
+
+Read the source for [LinkedIn::API](https://github.com/mdesjardins/linkedin-v2/blob/master/lib/linked_in/api.rb) and [LinkedIn::OAuth2](https://github.com/mdesjardins/linkedin-v2/blob/master/lib/linked_in/oauth2.rb)
+
+# Contributing
+
+Please see [CONTRIBUTING.md](https://github.com/mdesjardins/linkedin-v2/blob/master/CONTRIBUTING.md) for details.
+
+# Credits
+Huge, huge props to Evan Morikawa for writing the v1 version of this gem. This gem is
+pretty much all of that work, but gutted and replaced with v2 endpoints.
+
+* [Evan Morikawa](https://twitter.com/eom) ([emorikawa](https://github.com/emorikawa))
+* [Matt Kirk](http://matthewkirk.com) ([hexgnu](https://github.com/hexgnu))
+* [Wynn Netherland](http://wynnetherland.com) ([pengwynn](https://github.com/pengwynn))
+* Josh Kalderimis ([joshk](https://github.com/joshk))
+* Erik Michaels-Ober ([sferik](https://github.com/sferik))
+* And Many More [Contributors](https://github.com/emorikawa/linkedin-oauth2/graphs/contributors)
+
+# License
+Copyright :copyright: 2018-present [Mike Desjardins](https://twitter.com/mdesjardins) 2014-2018 [Evan Morikawa](https://twitter.com/e0m) 2013-2014 [Matt Kirk](http://matthewkirk.com/) 2009-11 [Wynn Netherland](http://wynnnetherland.com/) and [contributors](https://github.com/emorikawa/linkedin-oauth2/graphs/contributors). It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file. See [LICENSE](https://github.com/emorikawa/linkedin-oauth2/blob/master/LICENSE) for details.

data/Rakefile

@@ -0,0 +1,19 @@
+# Adds the following task:
+#   spec - Run RSpec tests & setup $LOAD_PATH properly
+#
+# We recommend you set the following RSpec options in your own ~/.rspec
+# --color
+# --format documentation
+# --profile
+# --order rand
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+# Adds the following tasks:
+#   build   - Build gem in pkg/ directory
+#   install - Build and install gem
+#   release - Create tag, build gem, and push it to Rubygems
+require 'bundler/gem_helper'
+Bundler::GemHelper.install_tasks
+
+task default: :spec

data/lib/linked_in/access_token.rb

@@ -0,0 +1,24 @@
+module LinkedIn
+  # A simple data object to contain the token string and expiration data.
+  class AccessToken
+    attr_accessor :token, :expires_in, :expires_at
+
+    # Creates a simple data wrapper for an access token.
+    #
+    # LinkedIn returns only an `expires_in` value. This calculates and
+    # sets and `expires_at` field for convenience.
+    #
+    # @param [String] token the access token
+    # @param [FixNum] expires_in number of seconds the token lasts for
+    # @param [Time] expires_at when the token will expire.
+    def initialize(token=nil, expires_in=nil, expires_at=nil)
+      self.token = token
+      self.expires_in = expires_in
+      if expires_at.nil? and not self.expires_in.nil?
+        self.expires_at = Time.now + expires_in
+      else
+        self.expires_at = expires_at
+      end
+    end
+  end
+end

data/lib/linked_in/api.rb

@@ -0,0 +1,108 @@
+module LinkedIn
+  class API
+
+    attr_accessor :access_token
+
+    def initialize(access_token=nil)
+      access_token = parse_access_token(access_token)
+      verify_access_token!(access_token)
+      @access_token = access_token
+
+      @connection = LinkedIn::Connection.new params: default_params,
+                                             headers: default_headers
+
+      initialize_endpoints
+    end
+
+    extend Forwardable # Composition over inheritance
+
+    # I do not have access to the jobs related endpoints.
+    # def_delegators :@jobs, :job,
+    #                        :job_bookmarks,
+    #                        :job_suggestions,
+    #                        :add_job_bookmark
+
+    def_delegators :@people, :profile,
+                             :skills,
+                             :connections,
+                             :picture_urls,
+                             :new_connections
+
+    def_delegators :@search, :search
+
+    # Not part of v2??
+    # def_delegators :@groups, :join_group,
+    #                          :group_posts,
+    #                          :group_profile,
+    #                          :add_group_share,
+    #                          :group_suggestions,
+    #                          :group_memberships,
+    #                          :post_group_discussion
+
+    def_delegators :@organizations, :organization,
+                                    :brand,
+                                    :organization_acls,
+                                    :organization_search,
+                                    :organization_page_statistics,
+                                    :organization_follower_statistics,
+                                    :organization_share_statistics
+
+    def_delegators :@communications, :send_message
+
+    def_delegators :@share_and_social_stream, :shares,
+                                              :share,
+                                              :likes,
+                                              :like,
+                                              :unlike,
+                                              :comments,
+                                              :comment
+                                              # :update_comment,
+                                              # :network_updates
+
+    def_delegators :@media, :summary
+
+    private ##############################################################
+
+    def initialize_endpoints
+      @jobs = LinkedIn::Jobs.new(@connection)
+      @people = LinkedIn::People.new(@connection)
+      @search = LinkedIn::Search.new(@connection)
+      # @groups = LinkedIn::Groups.new(@connection) not supported by v2 API?
+      @organizations = LinkedIn::Organizations.new(@connection)
+      @communications = LinkedIn::Communications.new(@connection)
+      @share_and_social_stream = LinkedIn::ShareAndSocialStream.new(@connection)
+      @media = LinkedIn::Media.new(@connection)
+    end
+
+    def default_params
+      # LIv2 TODO - Probably can just remove?
+      # https//developer.linkedin.com/documents/authentication
+      #return { oauth2_access_token: @access_token.token }
+      {}
+    end
+
+    def default_headers
+      # https://developer.linkedin.com/documents/api-requests-json
+      return {"x-li-format" => "json", "Authorization" => "Bearer #{@access_token.token}"}
+    end
+
+    def verify_access_token!(access_token)
+      if not access_token.is_a? LinkedIn::AccessToken
+        raise no_access_token_error
+      end
+    end
+
+    def parse_access_token(access_token)
+      if access_token.is_a? LinkedIn::AccessToken
+        return access_token
+      elsif access_token.is_a? String
+        return LinkedIn::AccessToken.new(access_token)
+      end
+    end
+
+    def no_access_token_error
+      msg = LinkedIn::ErrorMessages.no_access_token
+      LinkedIn::InvalidRequest.new(msg)
+    end
+  end
+end

data/lib/linked_in/api_resource.rb

@@ -0,0 +1,180 @@
+module LinkedIn
+  # The abstract class all API endpoints inherit from. Providers common
+  # builder methods across all endpoints.
+  #
+  # @!macro profile_options
+  #   @options opts [String] :id LinkedIn ID to fetch profile for
+  #   @options opts [String] :url The profile url
+  #   @options opts [String] :lang Requests the language of the profile.
+  #     Options are: en, fr, de, it, pt, es
+  #   @options opts [Array, Hash] :fields fields to fetch. The list of
+  #     fields can be found at
+  #     https://developer.linkedin.com/documents/profile-fields
+  #   @options opts [String] :secure (true) specify if urls in the
+  #     response should be https
+  #   @options opts [String] :"secure-urls" (true) alias to secure option
+  #
+  # @!macro share_input_fields
+  #   @param [Hash] share content of the share
+  #   @option share [String] :comment
+  #   @option share [String] :content
+  #   @option share [String] :title
+  #   @option share [String] :submitted-url
+  #   @option share [String] :submitted-image-url
+  #   @option share [String] :description
+  #   @option share [String] :visibility
+  #   @option share [String] :code
+  #
+  # @!macro organization_path_options
+  #   @param [Hash] options identifies the organization profile you want
+  #   @option options [String] :email_domain organization email domain
+  #   @option options [String] :id organization ID
+  #   @option options [String] :urn organization URN
+  #   @option options [String] :vanity_name organization vanity name
+  #
+  # @!macro brand_path_options
+  #   @param [Hash] options identifies the brand profile you want
+  #   @option options [String] :id brand ID
+  #   @option options [String] :vanity_name brand vanity name
+  #   @option options [String] :parent_id brand's parent organization ID.
+  class APIResource
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def urn_to_id(urn)
+      urn.split(':').last
+    end
+
+    def id_to_urn(resource, id)
+      ['urn', 'li', resource, id].join(':')
+    end
+
+    protected ############################################################
+
+    def get(path, options={})
+      url, params, headers = prepare_connection_params(path, options)
+
+      response = @connection.get(url, params, headers)
+      Mash.from_json(response.body)
+    end
+
+    def post(path=nil, body=nil, headers=nil, &block)
+      @connection.post(prepend_prefix(path), body, headers, &block)
+    end
+
+    def put(path=nil, body=nil, headers=nil, &block)
+      @connection.put(prepend_prefix(path), body, headers, &block)
+      Mash.from_json(response.body)
+    end
+
+    def delete(path=nil, body=nil, headers=nil, &block)
+      # @connection.delete(prepend_prefix(path), params, headers, &block)
+      # To be able to DELETE with a body:
+      reponse = @connection.run_request(:delete, prepend_prefix(path), body, headers, &block)
+
+      Mash.from_json(response.body)
+    end
+
+    def deprecated
+      LinkedIn::Deprecated.new(LinkedIn::ErrorMessages.deprecated)
+    end
+
+    private ##############################################################
+
+    def prepend_prefix(path)
+      return @connection.path_prefix + path
+    end
+
+    def prepare_connection_params(path, options)
+      path = prepend_prefix(path)
+      path += generate_field_selectors(options)
+
+      headers = options.delete(:headers) || {}
+
+      params = format_options_for_query(options)
+
+      return [path, params, headers]
+    end
+
+    # Dasherizes the param keys
+    def format_options_for_query(options)
+      options.reduce({}) do |list, kv|
+        key, value = kv.first.to_s.gsub("_","-"), kv.last
+        list[key]  = value
+        list
+      end
+    end
+
+    def generate_field_selectors(options)
+      default = LinkedIn.config.default_profile_fields || {}
+      fields = options.delete(:fields) || default
+      if options.delete(:public)
+        return ":public"
+      elsif fields.empty?
+        return ""
+      else
+        return "?projection=(#{fields})"
+      end
+    end
+
+    def build_fields_params(fields)
+      if fields.is_a?(Hash) && !fields.empty?
+        fields.map {|v| "(#{build_fields_params(v)})" }.join(',')
+      elsif fields.respond_to?(:each)
+        fields.map {|field| build_fields_params(field) }.join(',')
+      else
+        fields.to_s.gsub("_", "-")
+      end
+    end
+
+    def profile_path(options={}, allow_multiple=true)
+      path = "/people"
+
+      id = options.delete(:id)
+      url = options.delete(:url)
+
+      ids = options.delete(:ids)
+      urls = options.delete(:urls)
+
+      if options.delete(:email) then raise deprecated end
+
+      if (id or url)
+        path += single_person_path(id, url)
+      elsif allow_multiple and (ids or urls)
+        path += multiple_people_path(ids, urls)
+      else
+        path = "/me"
+      end
+    end
+
+    def single_person_path(id=nil, url=nil)
+      if id
+        return "/id=#{id}"
+      elsif url
+        return "/url=#{CGI.escape(url)}"
+      else
+        return "/me"
+      end
+    end
+
+    # See syntax here: https://developer.linkedin.com/documents/field-selectors
+    def multiple_people_path(ids=[], urls=[])
+      if ids.nil? then ids = [] end
+      if urls.nil? then urls = [] end
+
+      ids = ids.map do |id|
+        if is_self(id) then "me" else "id=#{id}" end
+      end
+      urls = urls.map do |url|
+        if is_self(url) then "me" else "url=#{CGI.escape(url)}" end
+      end
+      return "::(#{(ids+urls).join(",")})"
+    end
+
+    def is_self(str)
+      str == "self" or str == "me"
+    end
+  end
+end