garb 0.9.1 → 0.9.7

data/lib/garb/management/web_property.rb

@@ -1,29 +1,24 @@
 module Garb
   module Management
     class WebProperty
-      attr_accessor :session, :path
-      attr_accessor :id, :account_id
+      extend Attributes
+      include PathAttribute
 
-      def self.all(session = Session, path='/accounts/~all/webproperties')
+      attr_reader :session, :entry
+      ga_attribute :id, :name, :account_id, :website_url
+
+      def self.all(session = Session, path = '/accounts/~all/webproperties')
         feed = Feed.new(session, path)
-        feed.entries.map {|entry| new_from_entry(entry, session)}
+        feed.entries.map { |entry| new(entry, session) }
       end
 
       def self.for_account(account)
-        all(account.session, account.path+'/webproperties')
-      end
-
-      def self.new_from_entry(entry, session)
-        web_property = new
-        web_property.session = session
-        web_property.path = Garb.parse_link(entry, "self").gsub(Feed::BASE_URL, '')
-        web_property.properties = Garb.parse_properties(entry)
-        web_property
+        all(account.session, account.path + '/webproperties')
       end
 
-      def properties=(properties)
-        self.id = properties["web_property_id"]
-        self.account_id = properties["account_id"]
+      def initialize(entry, session)
+        @entry = entry
+        @session = session
       end
 
       def profiles

data/lib/garb/model.rb

@@ -1,10 +1,11 @@
 module Garb
   module Model
     MONTH = 2592000
-    URL = "https://www.google.com/analytics/feeds/data"
+    URL = 'https://www.googleapis.com/analytics/v3/data/ga'
 
     def self.extended(base)
       ProfileReports.add_report_method(base)
+      # base.set_instance_klass(base)
     end
 
     def metrics(*fields)
@@ -26,8 +27,10 @@ module Garb
     end
 
     def results(profile, options = {})
-      start_date = options.fetch(:start_date, Time.now - MONTH)
-      end_date = options.fetch(:end_date, Time.now)
+      return all_results(profile, options) if options.delete(:all)
+
+      start_date = options[:start_date] || Time.now - MONTH
+      end_date = options[:end_date] || Time.now
       default_params = build_default_params(profile, start_date, end_date)
 
       param_set = [
@@ -39,31 +42,49 @@ module Garb
         parse_sort(options).to_params,
         build_page_params(options)
       ]
-
       data = send_request_for_data(profile, build_params(param_set))
       ReportResponse.new(data, instance_klass).results
     end
 
+    def all_results(profile, options = {})
+      options = options.dup
+      limit = options.delete(:limit)
+      options[:limit] = 10_000 # maximum allowed
+      results = nil
+      while ((rs = results(profile, options)) && !rs.empty?)
+        results = results ? results + rs : rs
+        options[:offset] = results.size + 1
+        
+        break if limit && results.size >= limit
+        break if results.size >= results.total_results
+      end
+      limit && results ? results[0...limit] : results
+    end
+    
     private
     def send_request_for_data(profile, params)
-      request = DataRequest.new(profile.session, URL, params)
+      request = Request::Data.new(profile.session, URL, params)
       response = request.send_request
       response.body
     end
 
     def build_params(param_set)
-      param_set.inject({}) {|p,i| p.merge(i)}.reject{|k,v| v.nil?}
+      param_set.inject({}) { |p,i| p.merge i }.reject { |k,v| v.nil? }
     end
 
     def parse_filters(options)
-      filters = FilterParameters.new
-      filters.parameters << options[:filters] if options.has_key?(:filters)
-      filters
+      FilterParameters.new(options[:filters])
     end
 
     def parse_segment(options)
-      segment_id = "gaid::#{options[:segment_id].to_i}" if options.has_key?(:segment_id)
-      {'segment' => segment_id}
+      # dirty hack to support dynamic segments
+      if options.has_key?(:segment_id)
+        segment = "gaid::#{options[:segment_id]}"
+      elsif options.has_key?(:dynamic_segment)
+        filters = FilterParameters.new(options[:dynamic_segment])
+        segment = "dynamic::#{filters.to_params['filters']}"
+      end
+      {'segment' => segment}
     end
 
     def parse_sort(options)
@@ -81,11 +102,14 @@ module Garb
     end
 
     def build_page_params(options)
-      {'max-results' => options[:limit], 'start-index' => options[:offset]}
+      params = {}
+      params['max-results'] = options[:limit] if options.has_key? :limit
+      params['start-index'] = options[:offset] if options.has_key? :offset
+      params
     end
 
     def format_time(t)
       t.strftime('%Y-%m-%d')
     end
   end
-end
+end

data/lib/garb/path_attribute.rb

@@ -0,0 +1,7 @@
+module Garb
+  module PathAttribute
+    def path
+      @path ||= @entry['selfLink'].gsub(Management::Feed::BASE_URL, '')
+    end
+  end
+end

data/lib/garb/report_parameter.rb

@@ -2,23 +2,23 @@ module Garb
   class ReportParameter
 
     attr_reader :elements
-    
+
     def initialize(name)
       @name = name
       @elements = []
     end
-    
+
     def name
       @name.to_s
     end
-    
+
     def <<(element)
       (@elements += [element].flatten).compact!
       self
     end
-    
+
     def to_params
-      value = self.elements.map{|param| Garb.to_google_analytics(param)}.join(',')
+      value = self.elements.map { |param| Garb.to_google_analytics(param) }.join(',')
       value.empty? ? {} : {self.name => value}
     end
   end

data/lib/garb/report_response.rb

@@ -1,56 +1,57 @@
-module Garb  
+module Garb
   class ReportResponse
-    KEYS = ['dxp:metric', 'dxp:dimension']
 
     def initialize(response_body, instance_klass = OpenStruct)
-      @xml = response_body
+      @response_body = response_body
       @instance_klass = instance_klass
     end
 
     def results
       if @results.nil?
         @results = ResultSet.new(parse)
-        @results.total_results = parse_total_results
-        @results.sampled = parse_sampled_flag
+        @results.total_results = total_results
+        @results.sampled = sampled?
       end
-
       @results
     end
 
-    def sampled?
-    end
-
-    private
-    def parse
-      entries.map do |entry|
-        @instance_klass.new(Hash[
-          values_for(entry).map {|v| [Garb.from_ga(v['name']), v['value']]}
-        ])
-      end
+    def total_results
+      data[:total_results]
     end
 
-    def entries
-      feed? ? [parsed_xml['feed']['entry']].flatten.compact : []
+    def sampled?
+      data[:contains_sampled_data]
     end
 
-    def parse_total_results
-      feed? ? parsed_xml['feed']['openSearch:totalResults'].to_i : 0
+    private
+    def keys
+      @keys ||= column_headers.map { |header| Garb.from_ga header['name'] }
     end
 
-    def parse_sampled_flag
-      feed? ? (parsed_xml['feed']['dxp:containsSampledData'] == 'true') : false
+    def parse
+      rows.map do |row|
+        @instance_klass.new(Hash[*keys.zip(row).flatten])
+      end
     end
 
-    def parsed_xml
-      @parsed_xml ||= Crack::XML.parse(@xml)
+    def column_headers
+      data[:column_headers] || []
     end
 
-    def feed?
-      !parsed_xml['feed'].nil?
+    def rows
+      data[:rows] || []
     end
 
-    def values_for(entry)
-      KEYS.map {|k| entry[k]}.flatten.compact
+    def data
+      unless @data
+        @data = MultiJson.load @response_body
+        @data = @data.inject({}) do |data, pair|
+          key, value = pair
+          data[key.underscore.to_sym] = value
+          data
+        end
+      end
+      @data
     end
   end
 end

data/lib/garb/reports/bounces.rb

@@ -1,5 +1,5 @@
 class Bounces
-  extend Garb::Resource
+  extend Garb::Model
 
   metrics :bounces
 end

data/lib/garb/reports/exits.rb

@@ -1,5 +1,5 @@
 class Exits
-  extend Garb::Resource
+  extend Garb::Model
 
   metrics :exits
 end

data/lib/garb/reports/pageviews.rb

@@ -1,5 +1,5 @@
 class Pageviews
-  extend Garb::Resource
+  extend Garb::Model
 
   metrics :pageviews
 end

data/lib/garb/reports/unique_pageviews.rb

@@ -1,5 +1,5 @@
 class UniquePageviews
-  extend Garb::Resource
+  extend Garb::Model
 
   metrics :unique_pageviews
 end

data/lib/garb/reports/visits.rb

@@ -1,5 +1,5 @@
 class Visits
-  extend Garb::Resource
+  extend Garb::Model
 
   metrics :visits
 end

data/lib/garb/request/authentication.rb

@@ -0,0 +1,54 @@
+module Garb
+  module Request
+    class Authentication
+      URL = 'https://www.google.com/accounts/ClientLogin'
+
+      def initialize(email, password, opts = {})
+        @email = email
+        @password = password
+        @account_type = opts[:account_type] || 'HOSTED_OR_GOOGLE'
+      end
+
+      def parameters
+        {
+          'Email'       => @email,
+          'Passwd'      => @password,
+          'accountType' => @account_type,
+          'service'     => 'analytics',
+          'source'      => "sija-garb-v#{Garb::VERSION}"
+        }
+      end
+
+      def uri
+        @uri ||= URI.parse(URL)
+      end
+
+      def send_request(ssl_mode)
+        http = Net::HTTP.new(uri.host, uri.port, Garb.proxy_address, Garb.proxy_port)
+        http.open_timeout = Garb.open_timeout
+        http.read_timeout = Garb.read_timeout
+        http.use_ssl = true
+        http.verify_mode = ssl_mode
+
+        if ssl_mode == OpenSSL::SSL::VERIFY_PEER
+          http.ca_file = Garb.ca_cert_file
+        end
+
+        http.request(build_request) do |response|
+          raise AuthError unless response.is_a?(Net::HTTPOK)
+        end
+      end
+
+      def build_request
+        post = Net::HTTP::Post.new(uri.path)
+        post.set_form_data(parameters)
+        post
+      end
+
+      def auth_token(opts = {})
+        ssl_mode = opts[:secure] ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+        send_request(ssl_mode).body.match(/^Auth=(.*)$/)[1]
+      end
+    end
+  end
+end

data/lib/garb/request/data.rb

@@ -0,0 +1,98 @@
+module Garb
+  module Request
+    class Data
+      def initialize(session, base_url, parameters = {})
+        @session, @base_url, @parameters = session, base_url, parameters
+      end
+
+      def parameters
+        @parameters ||= {}
+        @parameters['key'] ||= @session.api_key unless @session.api_key.nil?
+        @parameters
+      end
+
+      def query_string
+        params_list = parameters.map { |k, v| "#{k}=#{v}" }.join('&')
+        params_list.empty? ? '' : "?#{params_list}"
+      end
+
+      def uri
+        @uri ||= URI.parse(@base_url)
+      end
+
+      def absolute_uri
+        uri.to_s + query_string
+      end
+
+      def relative_uri
+        uri.path.to_s + query_string
+      end
+
+      def send_request
+        Garb.log "Garb::Request -> #{relative_uri}"
+        
+        response = if @session.single_user?
+          if Garb.use_fibers
+            single_user_request_evented
+          else
+            single_user_request
+          end
+        elsif @session.oauth_user?
+          oauth_user_request
+        end
+        
+        Garb.log "Garb::Response -> #{response.inspect}"
+        handle_response response
+      end
+
+      def handle_response(response)
+        unless response.kind_of?(Net::HTTPSuccess) || (response.respond_to?(:status) && response.status == 200)
+          body, parsed = response.body, MultiJson.load(response.body) rescue nil
+          if parsed and error = parsed['error']
+            klass = case error['code']
+              when 400 then BadRequestError
+              when 401 then InvalidCredentialsError
+              when 403 then InsufficientPermissionsError
+              when 503 then BackendError
+              else ClientError
+            end
+            raise klass.new(absolute_uri, error['message'], error['code'], error['errors'])
+          else
+            raise ClientError.new(absolute_uri, body)
+          end
+        end
+        response
+      end
+
+      def single_user_request_evented
+        f = Fiber.current
+        fiber = Fiber.new do
+          f.resume single_user_request
+        end
+        fiber.resume
+        Fiber.yield
+      end
+
+      def single_user_request
+        http = Net::HTTP.new(uri.host, uri.port, Garb.proxy_address, Garb.proxy_port)
+        http.open_timeout = Garb.open_timeout
+        http.read_timeout = Garb.read_timeout
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        unless @session.access_token.nil?
+          http.request_get(relative_uri, {'Authorization' => "Bearer #{@session.access_token.token}"})
+        else
+          http.request_get(relative_uri, {
+            'Authorization' => "GoogleLogin auth=#{@session.auth_token}",
+            'GData-Version' => '3'
+          })
+        end
+      end
+
+      def oauth_user_request
+        @session.access_token.get(absolute_uri, {'GData-Version' => '3'})
+      end
+    end
+  end
+end