omnigroupcontacts 0.3.10 → 0.3.11

data/lib/omnigroupcontacts/http_utils.rb

@@ -0,0 +1,101 @@
+require "net/http"
+require "net/https"
+require "cgi"
+require "openssl"
+
+# This module contains a set of utility methods  related to the HTTP protocol.
+module OmniGroupContacts
+  module HTTPUtils
+
+    SSL_PORT = 443
+
+    module_function
+
+    def query_string_to_map query_string
+      query_string.split('&').reduce({}) do |memo, key_value|
+        (key, value) = key_value.split('=')
+        memo[key]= value
+        memo
+      end
+    end
+
+    def to_query_string map
+      map.collect do |key, value|
+        key.to_s + "=" + value.to_s
+      end.join("&")
+    end
+
+    # Encodes the given input according to RFC 3986
+    def encode to_encode
+      CGI.escape(to_encode)
+    end
+
+    # Calculates the url of the host from a Rack environment.
+    # The result is in the form scheme://host:port
+    # If port is 80 the result is scheme://host
+    # According to Rack specification the HTTP_HOST variable is preferred over SERVER_NAME.
+    def host_url_from_rack_env env
+      port = ((env["SERVER_PORT"] == 80) && "") || ":#{env['SERVER_PORT']}"
+      host = (env["HTTP_HOST"]) || (env["SERVER_NAME"] + port)
+      "#{scheme(env)}://#{host}"
+    end
+
+    def scheme env
+      if env['HTTPS'] == 'on'
+        'https'
+      elsif env['HTTP_X_FORWARDED_SSL'] == 'on'
+        'https'
+      elsif env['HTTP_X_FORWARDED_PROTO']
+        env['HTTP_X_FORWARDED_PROTO'].split(',').first
+      else
+        env["rack.url_scheme"]
+      end
+    end
+
+    # Classes including the module must respond to the ssl_ca_file message in order to use the following methods.
+    # The response will be the path to the CA file to use when making https requests.
+    # If the result of ssl_ca_file is nil no file is used. In this case a warn message is logged.
+    private
+
+    # Executes an HTTP GET request.
+    # It raises a RuntimeError if the response code is not equal to 200
+    def http_get host, path, params
+      connection = Net::HTTP.new(host)
+      process_http_response connection.request_get(path + "?" + to_query_string(params))
+    end
+
+    # Executes an HTTP POST request over SSL
+    # It raises a RuntimeError if the response code is not equal to 200
+    def https_post host, path, params
+      https_connection host do |connection|
+        connection.request_post(path, to_query_string(params))
+      end
+    end
+
+    # Executes an HTTP GET request over SSL
+    # It raises a RuntimeError if the response code is not equal to 200
+    def https_get host, path, params, headers = nil
+      https_connection host do |connection|
+        connection.request_get(path + "?" + to_query_string(params), headers)
+      end
+    end
+
+    def https_connection (host)
+      connection = Net::HTTP.new(host, SSL_PORT)
+      connection.use_ssl = true
+      if ssl_ca_file
+        connection.ca_file = ssl_ca_file
+      else
+        logger << "No SSL ca file provided. It is highly reccomended to use one in production envinronments" if respond_to?(:logger) && logger
+        connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      process_http_response(yield(connection))
+    end
+
+    def process_http_response response
+      raise response.body if response.code != "200"
+      response.body
+    end
+
+  end
+end

data/lib/omnigroupcontacts/importer.rb

@@ -0,0 +1,5 @@
+module OmniGroupContacts
+  module Importer
+    autoload :Gmailgroup, "omnigroupcontacts/importer/gmailgroup"
+  end
+end

data/lib/omnigroupcontacts/importer/gmailgroup.rb

@@ -0,0 +1,238 @@
+require "omnigroupcontacts/parse_utils"
+require "omnigroupcontacts/middleware/oauth2"
+
+module OmniGroupContacts
+  module Importer
+    class Gmailgroup < Middleware::OAuth2
+      include ParseUtils
+
+      attr_reader :auth_host, :authorize_path, :auth_token_path, :scope
+
+      def initialize *args
+        super *args
+        @auth_host = "accounts.google.com"
+        @authorize_path = "/o/oauth2/auth"
+        @auth_token_path = "/o/oauth2/token"
+        @scope = (args[3] && args[3][:scope]) || "https://www.google.com/m8/feeds https://www.googleapis.com/auth/userinfo#email https://www.googleapis.com/auth/userinfo.profile"
+        @contacts_host = "www.google.com"
+        @contacts_path = "/m8/feeds/groups/default/full"
+        @max_results =  (args[3] && args[3][:max_results]) || 100
+        @self_host = "www.googleapis.com"
+        @profile_path = "/oauth2/v1/userinfo"
+      end
+
+      def fetch_groups_using_access_token access_token, token_type
+        fetch_current_user(access_token, token_type)
+        groups_response = https_get(@contacts_host, @contacts_path, contacts_req_params, contacts_req_headers(access_token, token_type))
+        groups_from_response groups_response
+      end
+
+      def fetch_contacts_using_access_token access_token, token_type, group_id
+        fetch_current_user(access_token, token_type)
+        @contacts_path = "/m8/feeds/contacts/default/full?&group=#{group_id}"
+        contacts_response = https_get(@contacts_host, @contacts_path, contacts_req_params, contacts_req_headers(access_token, token_type))
+        contacts_from_response contacts_response
+      end
+
+      def fetch_current_user access_token, token_type
+        self_response = https_get(@self_host, @profile_path, contacts_req_params, contacts_req_headers(access_token, token_type))
+        user = current_user(self_response, access_token, token_type)
+        set_current_user user
+      end
+
+      private
+
+      def contacts_req_params
+        {'max-results' => @max_results.to_s, 'alt' => 'json'}
+      end
+
+      def contacts_req_headers token, token_type
+        {"GData-Version" => "3.0", "Authorization" => "#{token_type} #{token}"}
+      end
+
+      def groups_from_response response_as_json
+        response = JSON.parse(response_as_json)
+        
+        return [] if response['feed'].nil? || response['feed']['entry'].nil?
+        groups = []
+        return groups if response.nil?
+        response['feed']['entry'].each do |entry|
+          group = {
+            :id => nil,
+            :title => nil
+          }
+          group[:id] = entry['id']["$t"]
+          group[:title] = entry['title']["$t"]
+
+          groups << group
+        end
+        groups
+
+      end
+
+      def contacts_from_response response_as_json
+        response = JSON.parse(response_as_json)
+        return [] if response['feed'].nil? || response['feed']['entry'].nil?
+        contacts = []
+        return contacts if response.nil?
+        response['feed']['entry'].each do |entry|
+          # creating nil fields to keep the fields consistent across other networks
+
+          contact = { :id => nil,
+                      :first_name => nil,
+                      :last_name => nil,
+                      :name => nil,
+                      :emails => nil,
+                      :gender => nil,
+                      :birthday => nil,
+                      :profile_picture=> nil,
+                      :relation => nil,
+                      :addresses => nil,
+                      :phone_numbers => nil,
+                      :dates => nil,
+                      :company => nil,
+                      :position => nil,
+                      :groups => nil
+          }
+          contact[:id] = entry['id']['$t'] if entry['id']
+          if entry['gd$name']
+            gd_name = entry['gd$name']
+            contact[:first_name] = normalize_name(entry['gd$name']['gd$givenName']['$t']) if gd_name['gd$givenName']
+            contact[:last_name] = normalize_name(entry['gd$name']['gd$familyName']['$t']) if gd_name['gd$familyName']
+            contact[:name] = normalize_name(entry['gd$name']['gd$fullName']['$t']) if gd_name['gd$fullName']
+            contact[:name] = full_name(contact[:first_name],contact[:last_name]) if contact[:name].nil?
+          end
+
+          contact[:emails] = []
+          entry['gd$email'].each do |email|
+            if email['rel']
+              split_index = email['rel'].index('#')
+              contact[:emails] << {:name => email['rel'][split_index + 1, email['rel'].length - 1], :email => email['address']}
+            elsif email['label']
+              contact[:emails] << {:name => email['label'], :email => email['address']}
+            end
+          end if entry['gd$email']
+
+          # Support older versions of the gem by keeping singular entries around
+          contact[:email] = contact[:emails][0][:email] if contact[:emails][0]
+          contact[:first_name], contact[:last_name], contact[:name] = email_to_name(contact[:name]) if !contact[:name].nil? && contact[:name].include?('@')
+          contact[:first_name], contact[:last_name], contact[:name] = email_to_name(contact[:emails][0][:email]) if (contact[:name].nil? && contact[:emails][0] && contact[:emails][0][:email])
+          #format - year-month-date
+          contact[:birthday] = birthday(entry['gContact$birthday']['when'])  if entry['gContact$birthday']
+
+          # value is either "male" or "female"
+          contact[:gender] = entry['gContact$gender']['value']  if entry['gContact$gender']
+
+          if entry['gContact$relation']
+            if entry['gContact$relation'].is_a?(Hash)
+              contact[:relation] = entry['gContact$relation']['rel']
+            elsif entry['gContact$relation'].is_a?(Array)
+              contact[:relation] = entry['gContact$relation'].first['rel']
+            end
+          end
+
+          contact[:addresses] = []
+          entry['gd$structuredPostalAddress'].each do |address|
+            if address['rel']
+              split_index = address['rel'].index('#')
+              new_address = {:name => address['rel'][split_index + 1, address['rel'].length - 1]}
+            elsif address['label']
+              new_address = {:name => address['label']}
+            end
+
+            new_address[:address_1] = address['gd$street']['$t'] if address['gd$street']
+            new_address[:address_1] = address['gd$formattedAddress']['$t'] if new_address[:address_1].nil? && address['gd$formattedAddress']
+            if new_address[:address_1].index("\n")
+              parts = new_address[:address_1].split("\n")
+              new_address[:address_1] = parts.first
+              # this may contain city/state/zip if user jammed it all into one string.... :-(
+              new_address[:address_2] = parts[1..-1].join(', ')
+            end
+            new_address[:city] = address['gd$city']['$t'] if address['gd$city']
+            new_address[:region] = address['gd$region']['$t'] if address['gd$region'] # like state or province
+            new_address[:country] = address['gd$country']['code'] if address['gd$country']
+            new_address[:postcode] = address['gd$postcode']['$t'] if address['gd$postcode']
+            contact[:addresses] << new_address
+          end if entry['gd$structuredPostalAddress']
+
+          # Support older versions of the gem by keeping singular entries around
+          if contact[:addresses][0]
+            contact[:address_1] = contact[:addresses][0][:address_1]
+            contact[:address_2] = contact[:addresses][0][:address_2]
+            contact[:city] = contact[:addresses][0][:city]
+            contact[:region] = contact[:addresses][0][:region]
+            contact[:country] = contact[:addresses][0][:country]
+            contact[:postcode] = contact[:addresses][0][:postcode]
+          end
+
+          contact[:phone_numbers] = []
+          entry['gd$phoneNumber'].each do |phone_number|
+            if phone_number['rel']
+              split_index = phone_number['rel'].index('#')
+              contact[:phone_numbers] << {:name => phone_number['rel'][split_index + 1, phone_number['rel'].length - 1], :number => phone_number['$t']}
+            elsif phone_number['label']
+              contact[:phone_numbers] << {:name => phone_number['label'], :number => phone_number['$t']}
+            end
+          end if entry['gd$phoneNumber']
+
+          # Support older versions of the gem by keeping singular entries around
+          contact[:phone_number] = contact[:phone_numbers][0][:number] if contact[:phone_numbers][0]
+
+          if entry['gContact$website'] && entry['gContact$website'][0]["rel"] == "profile"
+            contact[:id] = contact_id(entry['gContact$website'][0]["href"])
+            contact[:profile_picture] = image_url(contact[:id])
+          else
+            contact[:profile_picture] = image_url_from_email(contact[:email])
+          end
+
+          if entry['gContact$event']
+            contact[:dates] = []
+            entry['gContact$event'].each do |event|
+              if event['rel']
+                contact[:dates] << {:name => event['rel'], :date => birthday(event['gd$when']['startTime'])}
+              elsif event['label']
+                contact[:dates] << {:name => event['label'], :date => birthday(event['gd$when']['startTime'])}
+              end
+            end
+          end
+
+          if entry['gd$organization']
+            contact[:company] = entry['gd$organization'][0]['gd$orgName']['$t'] if entry['gd$organization'][0]['gd$orgName']
+            contact[:position] = entry['gd$organization'][0]['gd$orgTitle']['$t'] if entry['gd$organization'][0]['gd$orgTitle']
+          end
+
+          contacts << contact if contact[:name]
+        end
+        contacts.uniq! {|c| c[:email] || c[:profile_picture] || c[:name]}
+        contacts
+      end
+
+      def image_url gmail_id
+        return "https://profiles.google.com/s2/photos/profile/" + gmail_id if gmail_id
+      end
+
+      def current_user me, access_token, token_type
+        return nil if me.nil?
+        me = JSON.parse(me)
+        user = {:id => me['id'], :email => me['email'], :name => me['name'], :first_name => me['given_name'],
+                :last_name => me['family_name'], :gender => me['gender'], :birthday => birthday(me['birthday']), :profile_picture => image_url(me['id']),
+                :access_token => access_token, :token_type => token_type
+        }
+        user
+      end
+
+      def birthday dob
+        return nil if dob.nil?
+        birthday = dob.split('-')
+        return birthday_format(birthday[2], birthday[3], nil) if birthday.size == 4
+        return birthday_format(birthday[1], birthday[2], birthday[0]) if birthday.size == 3
+      end
+
+      def contact_id(profile_url)
+        id = (profile_url.present?) ? File.basename(profile_url) : nil
+        id
+      end
+
+    end
+  end
+end

data/lib/omnigroupcontacts/integration_test.rb

@@ -0,0 +1,36 @@
+require 'singleton'
+
+class IntegrationTest
+  include Singleton
+  
+  attr_accessor :enabled
+  
+  def initialize
+    enabled = false
+    clear_mocks
+  end
+  
+  def clear_mocks
+    @mock = {}
+  end
+  
+  def mock provider, mock
+    @mock[provider.to_sym] = mock
+  end
+  
+  def mock_authorization_from_user provider
+    [302, {"Content-Type" => "application/x-www-form-urlencoded", "location" => provider.redirect_path}, []]
+  end
+  
+  def mock_fetch_contacts provider
+    result = @mock[provider.class_name.to_sym] || []
+    if result.is_a? Array
+      result
+    elsif result.is_a? Hash
+      [result]
+    else
+      raise result.to_s
+    end
+  end
+  
+end

data/lib/omnigroupcontacts/middleware/base_oauth.rb

@@ -0,0 +1,120 @@
+# This class contains the common behavior for middlewares
+# implementing either versions of OAuth.
+#
+# Extending classes are required to implement
+# the following methods:
+# * request_authorization_from_user 
+# * fetch_contatcs
+module OmniGroupContacts
+  module Middleware
+    class BaseOAuth
+
+      attr_reader :ssl_ca_file
+
+      def initialize app, options
+        @app = app
+        @listening_path = MOUNT_PATH + class_name
+        @ssl_ca_file = options[:ssl_ca_file]
+      end
+
+      def class_name
+        self.class.name.split('::').last.downcase
+      end
+
+      # Rack callback. It handles three cases:
+      # * user visit middleware entry point. 
+      #   In this case request_authorization_from_user is called
+      # * user is redirected back to the application 
+      #   from the authorization site. In this case the list
+      #   of contacts is fetched and stored in the variables
+      #   omnigroupcontacts.contacts within the Rack env variable.
+      #   Once that is done the next middleware component is called.
+      # * user visits any other resource. In this case the request
+      #   is simply forwarded to the next middleware component.
+      def call env
+        @env = env
+        if env["PATH_INFO"] =~ /^#{@listening_path}\/?$/
+          handle_initial_request
+        elsif env["PATH_INFO"] =~ /^#{redirect_path}/
+          handle_callback
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+      
+      def test_mode?
+        IntegrationTest.instance.enabled
+      end
+
+      def handle_initial_request
+        execute_and_rescue_exceptions do
+          if test_mode?
+            IntegrationTest.instance.mock_authorization_from_user(self)
+          else
+            request_authorization_from_user
+          end
+        end
+      end
+
+      def handle_callback
+        execute_and_rescue_exceptions do
+          @env["omnicontacts.contacts"] = if test_mode?
+            IntegrationTest.instance.mock_fetch_contacts(self)
+          else
+            fetch_groups
+          end          
+          @app.call(@env)
+        end
+      end
+
+      def set_current_user user
+        @env["omnigroupcontacts.user"] = user
+      end
+
+      #  This method rescues executes a block of code and
+      #  rescue all exceptions. In case of an exception the 
+      #  user is redirected to the failure endpoint.
+      def execute_and_rescue_exceptions
+        yield
+      rescue AuthorizationError => e
+        handle_error :not_authorized, e
+      rescue ::Timeout::Error, ::Errno::ETIMEDOUT => e
+        handle_error :timeout, e
+      rescue ::RuntimeError => e
+        handle_error :internal_error, e
+      end
+
+      def handle_error error_type, exception
+        logger.puts("Error #{error_type} while processing #{@env["PATH_INFO"]}: #{exception.message}") if logger
+        failure_url = "#{ MOUNT_PATH }failure?error_message=#{error_type}&importer=#{class_name}"
+        target_url = append_state_query(failure_url)
+        [302, {"Content-Type" => "text/html", "location" => target_url}, []]
+      end
+
+      def session
+        raise "You must provide a session to use omnigroupcontacts" unless @env["rack.session"]
+        @env["rack.session"]
+      end
+
+      def logger
+        @env["rack.errors"] if @env
+      end
+
+      def base_prop_name
+        "omnigroupcontacts." + class_name
+      end
+
+      def append_state_query(target_url)
+        state = Rack::Utils.parse_query(@env['QUERY_STRING'])['state']
+
+        unless state.nil?
+          target_url = target_url + (target_url.include?("?")?"&":"?") + 'state=' + state
+        end
+
+        return target_url
+      end
+    end
+  end
+end