omnigroupcontacts 0.3.10 → 0.3.11

data/lib/omnigroupcontacts/middleware/oauth1.rb

@@ -0,0 +1,70 @@
+require "omnigroupcontacts/authorization/oauth1"
+require "omnigroupcontacts/middleware/base_oauth"
+
+# This class is an OAuth 1.0 Rack middleware.
+#
+# Extending classes are required to 
+# implement the following methods:
+# * fetch_token_from_token_and_verifier -> this method has to
+#   fetch the list of contacts from the authorization server.
+module OmniGroupContacts
+  module Middleware
+    class OAuth1 < BaseOAuth
+      include Authorization::OAuth1
+
+      attr_reader :consumer_key, :consumer_secret, :callback_path
+
+      def initialize app, consumer_key, consumer_secret, options = {}
+        super app, options
+        @consumer_key = consumer_key
+        @consumer_secret = consumer_secret
+        @callback_path = options[:callback_path] || "#{ MOUNT_PATH }#{class_name}/callback"
+        @token_prop_name = "#{base_prop_name}.oauth_token"
+      end
+
+      def callback
+        host_url_from_rack_env(@env) + callback_path
+      end
+
+      alias :redirect_path :callback_path
+
+      # Obtains an authorization token from the server,
+      # stores it and the session and redirect the user
+      # to the authorization website.
+      def request_authorization_from_user
+        (auth_token, auth_token_secret) = fetch_authorization_token
+        session[@token_prop_name] = auth_token
+        session[token_secret_prop_name(auth_token)] = auth_token_secret
+        redirect_to_authorization_site(auth_token)
+      end
+
+      def token_secret_prop_name oauth_token
+        "#{base_prop_name}.#{oauth_token}.oauth_token_secret"
+      end
+
+      def redirect_to_authorization_site auth_token
+        authorization_url = authorization_url(auth_token)
+        target_url = append_state_query(authorization_url)
+        [302, {"Content-Type" => "application/x-www-form-urlencoded", "location" => target_url}, []]
+      end
+
+      # Parses the authorization token from the query string and 
+      # obtain the relative secret from the session.
+      # Finally it calls fetch_contacts_from_token_and_verifier.
+      # If token is found in the query string an AuhorizationError
+      # is raised.
+      def fetch_contacts
+        params = query_string_to_map(@env["QUERY_STRING"])
+        oauth_token = params["oauth_token"]
+        oauth_verifier = params["oauth_verifier"]
+        oauth_token_secret = session[token_secret_prop_name(oauth_token)]
+        if oauth_token && oauth_verifier && oauth_token_secret
+          fetch_contacts_from_token_and_verifier(oauth_token, oauth_token_secret, oauth_verifier)
+        else
+          raise AuthorizationError.new("User did not grant access to contacts list")
+        end
+      end
+
+    end
+  end
+end

data/lib/omnigroupcontacts/middleware/oauth2.rb

@@ -0,0 +1,80 @@
+require "omnigroupcontacts/authorization/oauth2"
+require "omnigroupcontacts/middleware/base_oauth"
+
+# This class is a OAuth 2 Rack middleware.
+#
+# Extending class are required to implement
+# the following methods:
+# * fetch_contacts_using_access_token -> it
+#   fetches the list of contacts from the authorization
+#   server.
+module OmniGroupContacts
+  module Middleware
+    class OAuth2 < BaseOAuth
+      include Authorization::OAuth2
+
+      attr_reader :client_id, :client_secret, :redirect_path
+
+      def initialize app, client_id, client_secret, options ={}
+        super app, options
+        @client_id = client_id
+        @client_secret = client_secret
+        @redirect_path = options[:redirect_path] || "#{ MOUNT_PATH }#{class_name}/callback"
+        @ssl_ca_file = options[:ssl_ca_file]
+      end
+
+      def request_authorization_from_user
+        target_url = append_state_query(authorization_url)
+        [302, {"Content-Type" => "application/x-www-form-urlencoded", "location" => target_url}, []]
+      end
+
+      def redirect_uri
+        host_url_from_rack_env(@env) + redirect_path
+      end
+
+      # It extract the authorization code from the query string.
+      # It uses it to obtain an access token.
+      # If the authorization code has a refresh token associated
+      # with it in the session, it uses the obtain an access token.
+      # It fetches the list of contacts and stores the refresh token
+      # associated with the access token in the session.
+      # Finally it returns the list of contacts.
+      # If no authorization code is found in the query string an
+      # AuthoriazationError is raised.
+      def fetch_groups
+        code = query_string_to_map(@env["QUERY_STRING"])["code"]
+        if code
+          refresh_token = session[refresh_token_prop_name(code)]
+          (access_token, token_type, refresh_token) = if refresh_token
+                                                        refresh_access_token(refresh_token)
+                                                      else
+                                                        fetch_access_token(code)
+                                                      end
+          groups = fetch_groups_using_access_token(access_token, token_type)
+          group_contacts = fetch_group_contacts(groups, access_token, token_type)
+          session[refresh_token_prop_name(code)] = refresh_token if refresh_token
+          group_contacts
+        else
+          raise AuthorizationError.new("User did not grant access to contacts list")
+        end
+      end
+
+      def fetch_group_contacts(groups, access_token, token_type)
+        group_contacts_all = {}
+        
+        groups.each do |group|
+          Rails.logger.info "---------#{group.inspect}---------"
+          group_contacts = fetch_contacts_using_access_token(access_token, token_type, group[:id])
+          group_contacts_all[group[:title]] = group_contacts
+        end
+
+        group_contacts_all
+      end
+
+      def refresh_token_prop_name code
+        "#{base_prop_name}.#{code}.refresh_token"
+      end
+
+    end
+  end
+end

data/lib/omnigroupcontacts/parse_utils.rb

@@ -0,0 +1,56 @@
+module OmniGroupContacts
+  module ParseUtils
+
+    # return has of birthday day, month and year
+    def birthday_format month, day, year
+      return {:day => day.to_i, :month => month.to_i, :year => year.to_i}if year && month && day
+      return {:day => day.to_i, :month => month.to_i, :year => nil} if !year && month && day
+      return nil if (!year && !month) || (!year && !day)
+    end
+
+    # normalize the name
+    def normalize_name name
+      return nil if name.nil?
+      name.chomp!
+      name.squeeze!(' ')
+      name.strip!
+      return name
+    end
+
+    # create a full name given the individual first and last name
+    def full_name first_name, last_name
+      return "#{first_name} #{last_name}" if first_name && last_name
+      return "#{first_name}" if first_name && !last_name
+      return "#{last_name}" if !first_name && last_name
+      return nil
+    end
+
+    # create a username/name from a given email
+    def email_to_name username_or_email
+      username_or_email = username_or_email.split('@').first if username_or_email.include?('@')
+      if group = (/(?<first>[a-z|A-Z]+)[\.|_](?<last>[a-z|A-Z]+)/).match(username_or_email)
+        first_name = normalize_name(group[:first])
+        last_name = normalize_name(group[:last])
+        return first_name, last_name, "#{first_name} #{last_name}"
+      end
+      username = normalize_name(username_or_email)
+      return username, nil, username
+    end
+
+    # create an image_url from a gmail or yahoo email id.
+    def image_url_from_email email
+      return nil if email.nil? || !email.include?('@')
+      username, domain = *(email.split('@'))
+      return nil if username.nil? or domain.nil?
+      gmail_base_url = "https://profiles.google.com/s2/photos/profile/"
+      yahoo_base_url = "https://img.msg.yahoo.com/avatar.php?yids="
+      if domain.include?('gmail')
+        image_url = gmail_base_url + username
+      elsif domain.include?('yahoo')
+        image_url = yahoo_base_url + username
+      end
+      image_url
+    end
+
+  end
+end

data/omnigroupcontacts.gemspec

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require File.expand_path('../lib/omnigroupcontacts', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name = 'omnigroupcontacts'
+  gem.description = %q{A generalized Rack middleware for importing group contacts from gmail.}
+  gem.authors = ['Mitesh Jain']
+  gem.email = ['mitijain123@gmail.com']
+
+  gem.add_runtime_dependency 'rack'
+  gem.add_runtime_dependency 'json'
+
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rack-test'
+  gem.add_development_dependency 'rspec'
+
+  gem.version = OmniGroupContacts::VERSION  
+  gem.files = `git ls-files`.split("\n")
+  gem.homepage = 'http://github.com/mitijain123/omnicontacts'
+  gem.require_paths = ['lib']
+  gem.required_rubygems_version = Gem::Requirement.new('>= 1.3.6') if gem.respond_to? :required_rubygems_version=
+  gem.summary = gem.description
+  gem.test_files = `git ls-files -- {spec}/*`.split("\n")
+end

data/spec/omnicontacts/authorization/oauth1_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+require "omnigroupcontacts/authorization/oauth1"
+
+describe OmniGroupContacts::Authorization::OAuth1 do
+
+  before(:all) do
+    OAuth1TestClass= Struct.new(:consumer_key, :consumer_secret, :auth_host, :auth_token_path, :auth_path, :access_token_path, :callback)
+    class OAuth1TestClass
+      include OmniGroupContacts::Authorization::OAuth1
+    end
+  end
+
+  let(:test_target) do
+    OAuth1TestClass.new("consumer_key", "secret1", "auth_host", "auth_token_path", "auth_path", "access_token_path", "callback")
+  end
+
+  describe "fetch_authorization_token" do
+
+    it "should request the token providing all mandatory parameters" do
+      test_target.should_receive(:https_post) do |host, path, params|
+        host.should eq(test_target.auth_host)
+        path.should eq(test_target.auth_token_path)
+        params[:oauth_consumer_key].should eq(test_target.consumer_key)
+        params[:oauth_nonce].should_not be_nil
+        params[:oauth_signature_method].should eq("PLAINTEXT")
+        params[:oauth_signature].should eq(test_target.consumer_secret + "%26")
+        params[:oauth_timestamp].should_not be_nil
+        params[:oauth_version].should eq("1.0")
+        params[:oauth_callback].should eq(test_target.callback)
+        "oauth_token=token&oauth_token_secret=token_secret"
+      end
+      test_target.fetch_authorization_token
+    end
+
+    it "should successfully parse the result" do
+      test_target.should_receive(:https_post).and_return("oauth_token=token&oauth_token_secret=token_secret")
+      test_target.fetch_authorization_token.should eq(["token", "token_secret"])
+    end
+
+    it "should raise an error if request is invalid" do
+      test_target.should_receive(:https_post).and_return("invalid_request")
+      expect { test_target.fetch_authorization_token }.to raise_error
+    end
+
+  end
+
+  describe "authorization_url" do
+    subject { test_target.authorization_url("token") }
+    it { should eq("https://#{test_target.auth_host}#{test_target.auth_path}?oauth_token=token") }
+  end
+
+  describe "fetch_access_token" do
+    it "should request the access token using all required parameters" do
+      auth_token = "token"
+      auth_token_secret = "token_secret"
+      auth_verifier = "verifier"
+      test_target.should_receive(:https_post) do |host, path, params|
+        host.should eq(test_target.auth_host)
+        path.should eq(test_target.access_token_path)
+        params[:oauth_consumer_key].should eq(test_target.consumer_key)
+        params[:oauth_nonce].should_not be_nil
+        params[:oauth_signature_method].should eq("PLAINTEXT")
+        params[:oauth_version].should eq("1.0")
+        params[:oauth_signature].should eq("#{test_target.consumer_secret}%26#{auth_token_secret}")
+        params[:oauth_token].should eq(auth_token)
+        params[:oauth_verifier].should eq(auth_verifier)
+        "oauth_token=access_token&oauth_token_secret=access_token_secret&other_param=other_value"
+      end
+      test_target.fetch_access_token auth_token, auth_token_secret, auth_verifier, ["other_param"]
+    end
+
+    it "should successfully extract access_token and the other fields" do
+      test_target.should_receive(:https_post).and_return("oauth_token=access_token&oauth_token_secret=access_token_secret&other_param=other_value")
+      test_target.fetch_access_token("token", "token_scret", "verified", ["other_param"]).should eq(["access_token", "access_token_secret", "other_value"])
+    end
+  end
+
+  describe "oauth_signature" do
+    subject { test_target.oauth_signature("GET", "https://social.yahooapis.com/v1/user", {:name => "diego", :surname => "castorina"}, "secret2") }
+    it { should eq("xfumZoyVYUbHXSAafdha3HZUqQg%3D") }
+  end
+end

data/spec/omnicontacts/authorization/oauth2_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+require "omnigroupcontacts/authorization/oauth2"
+
+describe OmniGroupContacts::Authorization::OAuth2 do
+
+  before(:all) do
+    OAuth2TestClass= Struct.new(:auth_host, :authorize_path, :client_id, :client_secret, :scope, :redirect_uri, :auth_token_path)
+    class OAuth2TestClass
+      include OmniGroupContacts::Authorization::OAuth2
+    end
+  end
+
+  let(:test_target) do
+    OAuth2TestClass.new("auth_host", "authorize_path", "client_id", "client_secret", "scope", "redirect_uri", "auth_token_path")
+  end
+
+  describe "authorization_url" do
+
+    subject { test_target.authorization_url }
+
+    it { should include("https://#{test_target.auth_host}#{test_target.authorize_path}") }
+    it { should include("client_id=#{test_target.client_id}") }
+    it { should include("scope=#{test_target.scope}") }
+    it { should include("redirect_uri=#{test_target.redirect_uri}") }
+    it { should include("access_type=online") }
+    it { should include("response_type=code") }
+  end
+
+  let(:access_token_response) { %[{"access_token": "access_token", "token_type":"token_type", "refresh_token":"refresh_token"}] }
+
+  describe "fetch_access_token" do
+
+    it "should provide all mandatory parameters in a https post request" do
+      code = "code"
+      test_target.should_receive(:https_post) do |host, path, params|
+        host.should eq(test_target.auth_host)
+        path.should eq(test_target.auth_token_path)
+        params[:code].should eq(code)
+        params[:client_id].should eq(test_target.client_id)
+        params[:client_secret].should eq(test_target.client_secret)
+        params[:redirect_uri].should eq(test_target.redirect_uri)
+        params[:grant_type].should eq("authorization_code")
+        access_token_response
+      end
+      test_target.fetch_access_token code
+    end
+
+    it "should successfully parse the token from the JSON response" do
+      test_target.should_receive(:https_post).and_return(access_token_response)
+      (access_token, token_type, refresh_token) = test_target.fetch_access_token "code"
+      access_token.should eq("access_token")
+      token_type.should eq("token_type")
+      refresh_token.should eq("refresh_token")
+    end
+
+    it "should raise if the http request fails" do
+      test_target.should_receive(:https_post).and_raise("Invalid code")
+      expect { test_target.fetch_access_token("code") }.to raise_error
+    end
+
+    it "should raise an error if the JSON response contains an error field" do
+      test_target.should_receive(:https_post).and_return(%[{"error": "error_message"}])
+      expect { test_target.fetch_access_token("code") }.to raise_error
+    end
+  end
+
+  describe "refresh_access_token" do
+    it "should provide all mandatory fields in a https post request" do
+      refresh_token = "refresh_token"
+      test_target.should_receive(:https_post) do |host, path, params|
+        host.should eq(test_target.auth_host)
+        path.should eq(test_target.auth_token_path)
+        params[:client_id].should eq(test_target.client_id)
+        params[:client_secret].should eq(test_target.client_secret)
+        params[:refresh_token].should eq(refresh_token)
+        params[:grant_type].should eq("refresh_token")
+        access_token_response
+      end
+      test_target.refresh_access_token refresh_token
+    end
+
+    it "should successfully parse the token from the JSON response" do
+      test_target.should_receive(:https_post).and_return(access_token_response)
+      (access_token, token_type, refresh_token) = test_target.refresh_access_token "refresh_token"
+      access_token.should eq("access_token")
+      token_type.should eq("token_type")
+      refresh_token.should eq("refresh_token")
+    end
+
+  end
+
+end

data/spec/omnicontacts/http_utils_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+require "omnigroupcontacts/http_utils"
+
+describe OmniGroupContacts::HTTPUtils do
+
+  describe "to_query_string" do
+    it "should create a query string from a map" do
+      result = OmniGroupContacts::HTTPUtils.to_query_string(:name => "john", :surname => "doe")
+      if result.match(/^name/)
+        result.should eq("name=john&surname=doe")
+      else
+        result.should eq("surname=doe&name=john")
+      end
+    end
+
+    it "should work for integer values in the map" do
+      result = OmniGroupContacts::HTTPUtils.to_query_string(:client_id => 1234, :secret => "1234HJL8")
+      result.should eq("client_id=1234&secret=1234HJL8")
+    end
+
+  end
+
+  describe "encode" do
+    it "should encode the space" do
+      OmniGroupContacts::HTTPUtils.encode("name=\"john\"").should eq("name%3D%22john%22")
+    end
+  end
+
+  describe "query_string_to_map" do
+    it "should split a query string into a map" do
+      query_string = "name=john&surname=doe"
+      result = OmniGroupContacts::HTTPUtils.query_string_to_map(query_string)
+      result["name"].should eq("john")
+      result["surname"].should eq("doe")
+    end
+  end
+
+  describe "host_url_from_rack_env" do
+    it "should calculate the host url using the HTTP_HOST variable" do
+      env = {"rack.url_scheme" => "http", "HTTP_HOST" => "localhost:8080", "SERVER_NAME" => "localhost", "SERVER_PORT" => 8080}
+      OmniGroupContacts::HTTPUtils.host_url_from_rack_env(env).should eq("http://localhost:8080")
+    end
+
+    it "should calculate the host url using SERVER_NAME and SERVER_PORT variables" do
+      env = {"rack.url_scheme" => "http", "SERVER_NAME" => "localhost", "SERVER_PORT" => 8080}
+      OmniGroupContacts::HTTPUtils.host_url_from_rack_env(env).should eq("http://localhost:8080")
+    end
+  end
+
+  describe "https_post" do
+
+    before(:each) do
+      @connection = double
+      Net::HTTP.should_receive(:new).and_return(@connection)
+      @connection.should_receive(:use_ssl=).with(true)
+      @test_target = Object.new
+      @test_target.extend OmniGroupContacts::HTTPUtils
+      @response = double
+    end
+
+    it "should execute a request with success" do
+      @test_target.should_receive(:ssl_ca_file).and_return(nil)
+      @connection.should_receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+      @connection.should_receive(:request_post).and_return(@response)
+      @response.should_receive(:code).and_return("200")
+      @response.should_receive(:body).and_return("some content")
+      @test_target.send(:https_post, "host", "path", {})
+    end
+
+    it "should raise an exception with response code != 200" do
+      @test_target.should_receive(:ssl_ca_file).and_return(nil)
+      @connection.should_receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+      @connection.should_receive(:request_get).and_return(@response)
+      @response.should_receive(:code).and_return("500")
+      @response.should_receive(:body).and_return("some error message")
+      expect { @test_target.send(:https_get, "host", "path", {}) }.to raise_error
+    end
+  end
+end