titanous-garb 0.8.5

data/lib/garb/data_request.rb

@@ -0,0 +1,42 @@
+module Garb
+  class DataRequest
+    class ClientError < StandardError; end
+
+    def initialize(session, base_url, parameters={})
+      @session = session
+      @base_url = base_url
+      @parameters = parameters
+    end
+
+    def query_string
+      parameter_list = @parameters.map {|k,v| "#{k}=#{v}" }
+      parameter_list.empty? ? '' : "?#{parameter_list.join('&')}"
+    end
+
+    def uri
+      URI.parse(@base_url)
+    end
+
+    def send_request
+      response = if @session.single_user?
+        single_user_request(@session.auth_sub?  ? 'AuthSub' : 'GoogleLogin')
+      elsif @session.oauth_user?
+        oauth_user_request
+      end
+
+      raise ClientError, response.body.inspect unless response.kind_of?(Net::HTTPSuccess)
+      response
+    end
+
+    def single_user_request(auth='GoogleLogin')
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http.get("#{uri.path}#{query_string}", { 'Authorization' => "#{auth} #{auth == 'GoogleLogin' ? 'auth' : 'token'}=#{@session.auth_token}", 'GData-Version' => '2' })
+    end
+
+    def oauth_user_request
+      @session.access_token.get("#{uri}#{query_string}", {'GData-Version' => '2'})
+    end
+  end
+end

data/lib/garb/destination.rb

@@ -0,0 +1,20 @@
+module Garb
+  class Destination
+    attr_reader :match_type, :expression, :steps
+
+    def initialize(attributes)
+      return unless attributes.is_a?(Hash)
+
+      @match_type = attributes['matchType']
+      @expression = attributes['expression']
+      @case_sensitive = (attributes['caseSensitive'] == 'true')
+
+      step_attributes = attributes[Garb.to_ga('step')]
+      @steps = Array(step_attributes.is_a?(Hash) ? [step_attributes] : step_attributes).map {|s| Step.new(s)}
+    end
+
+    def case_sensitive?
+      @case_sensitive
+    end
+  end
+end

data/lib/garb/filter_parameters.rb

@@ -0,0 +1,41 @@
+module Garb
+  class FilterParameters
+    def self.define_operators(*methods)
+      methods.each do |method|
+        class_eval <<-CODE
+          def #{method}(field, value)
+            @filter_hash.merge!({SymbolOperator.new(field, :#{method}) => value})
+          end
+        CODE
+      end
+    end
+
+    define_operators :eql, :not_eql, :gt, :gte, :lt, :lte, :matches,
+      :does_not_match, :contains, :does_not_contain, :substring, :not_substring
+
+    attr_accessor :parameters
+
+    def initialize
+      self.parameters = []
+    end
+
+    def filters(&block)
+      @filter_hash = {}
+
+      instance_eval &block
+
+      self.parameters << @filter_hash
+    end
+
+    def to_params
+      value = self.parameters.map do |param|
+        param.map do |k,v|
+          next unless k.is_a?(SymbolOperator)
+          "#{URI.encode(k.to_google_analytics, /[=<>]/)}#{CGI::escape(v.to_s)}"
+        end.join('%3B') # Hash AND (no duplicate keys), escape char for ';' fixes oauth
+      end.join(',') # Array OR
+
+      value.empty? ? {} : {'filters' => value}
+    end
+  end
+end

data/lib/garb/goal.rb

@@ -0,0 +1,20 @@
+module Garb
+  class Goal
+    attr_reader :name, :number, :value, :destination
+
+    def initialize(attributes={})
+      return unless attributes.is_a?(Hash)
+
+      @name = attributes['name']
+      @number = attributes['number'].to_i
+      @value = attributes['value'].to_f
+      @active = (attributes['active'] == 'true')
+
+      @destination = Destination.new(attributes[Garb.to_ga('destination')])
+    end
+
+    def active?
+      @active
+    end
+  end
+end

data/lib/garb/management/account.rb

@@ -0,0 +1,32 @@
+module Garb
+  module Management
+    class Account
+      attr_reader :session, :path
+      attr_reader :id, :title, :name
+
+      def self.all(session = Session)
+        feed = Feed.new(session, '/accounts') # builds request and parses response
+
+        feed.entries.map {|entry| new(entry, session)}
+      end
+
+      def initialize(entry, session)
+        @session = session
+        @path = Garb.parse_link(entry, "self").gsub(Feed::BASE_URL, '')
+        @title = entry['title'].gsub('Google Analytics Account ', '')
+
+        properties = Garb.parse_properties(entry)
+        @id = properties["account_id"]
+        @name = properties["account_name"]
+      end
+
+      def web_properties
+        @web_properties ||= WebProperty.for_account(self) # will call path
+      end
+
+      def profiles
+        @profiles ||= Profile.for_account(self)
+      end
+    end
+  end
+end

data/lib/garb/management/feed.rb

@@ -0,0 +1,26 @@
+module Garb
+  module Management
+    class Feed
+      BASE_URL = "https://www.google.com/analytics/feeds/datasources/ga"
+
+      attr_reader :request
+
+      def initialize(session, path)
+        @request = DataRequest.new(session, BASE_URL+path)
+      end
+
+      def parsed_response
+        @parsed_response ||= Crack::XML.parse(response.body)
+      end
+
+      def entries
+        # possible to have nil entries, yuck
+        parsed_response ? [parsed_response['feed']['entry']].flatten.reject {|e| e.nil?} : []
+      end
+
+      def response
+        @response ||= request.send_request
+      end
+    end
+  end
+end

data/lib/garb/management/goal.rb

@@ -0,0 +1,20 @@
+module Garb
+  class Goal
+    attr_reader :name, :number, :value, :destination
+
+    def initialize(attributes={})
+      return unless attributes.is_a?(Hash)
+
+      @name = attributes['name']
+      @number = attributes['number'].to_i
+      @value = attributes['value'].to_f
+      @active = (attributes['active'] == 'true')
+
+      @destination = Destination.new(attributes[Garb.to_ga('destination')])
+    end
+
+    def active?
+      @active
+    end
+  end
+end

data/lib/garb/management/profile.rb

@@ -0,0 +1,39 @@
+module Garb
+  module Management
+    class Profile
+
+      include ProfileReports
+
+      attr_reader :session, :path
+      attr_reader :id, :table_id, :title, :account_id, :web_property_id
+
+      def self.all(session = Session, path = '/accounts/~all/webproperties/~all/profiles')
+        feed = Feed.new(session, path)
+        feed.entries.map {|entry| new(entry, session)}
+      end
+
+      def self.for_account(account)
+        all(account.session, account.path+'/webproperties/~all/profiles')
+      end
+
+      def self.for_web_property(web_property)
+        all(web_property.session, web_property.path+'/profiles')
+      end
+
+      def initialize(entry, session)
+        @session = session
+        @path = Garb.parse_link(entry, "self").gsub(Feed::BASE_URL, '')
+
+        properties = Garb.parse_properties(entry)
+        @id = properties['profile_id']
+        @table_id = properties['table_id']
+        @title = properties['profile_name']
+        @account_id = properties['account_id']
+        @web_property_id = properties['web_property_id']
+      end
+
+      # def goals
+      # end
+    end
+  end
+end

data/lib/garb/management/web_property.rb

@@ -0,0 +1,30 @@
+module Garb
+  module Management
+    class WebProperty
+      attr_reader :session, :path
+      attr_reader :id, :account_id
+
+      def self.all(session = Session, path='/accounts/~all/webproperties')
+        feed = Feed.new(session, path)
+        feed.entries.map {|entry| new(entry, session)}
+      end
+
+      def self.for_account(account)
+        all(account.session, account.path+'/webproperties')
+      end
+
+      def initialize(entry, session)
+        @session = session
+        @path = Garb.parse_link(entry, "self").gsub(Feed::BASE_URL, '')
+
+        properties = Garb.parse_properties(entry)
+        @id = properties["web_property_id"]
+        @account_id = properties["account_id"]
+      end
+
+      def profiles
+        @profiles ||= Profile.for_web_property(self)
+      end
+    end
+  end
+end

data/lib/garb/model.rb

@@ -0,0 +1,89 @@
+module Garb
+  module Model
+    MONTH = 2592000
+    URL = "https://www.google.com/analytics/feeds/data"
+
+    def self.extended(base)
+      ProfileReports.add_report_method(base)
+    end
+
+    def metrics(*fields)
+      @metrics ||= ReportParameter.new(:metrics)
+      @metrics << fields
+    end
+
+    def dimensions(*fields)
+      @dimensions ||= ReportParameter.new(:dimensions)
+      @dimensions << fields
+    end
+
+    def set_instance_klass(klass)
+      @instance_klass = klass
+    end
+
+    def instance_klass
+      @instance_klass || OpenStruct
+    end
+
+    def results(profile, options = {})
+      default_params = build_default_params(profile)
+
+      param_set = [
+        default_params,
+        metrics.to_params,
+        dimensions.to_params,
+        parse_filters(options).to_params,
+        parse_segment(options),
+        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
+
+    private
+    def send_request_for_data(profile, params)
+      request = DataRequest.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?}
+    end
+
+    def parse_filters(options)
+      filters = FilterParameters.new
+      filters.parameters << options[:filters] if options.has_key?(:filters)
+      filters
+    end
+
+    def parse_segment(options)
+      segment_id = "gaid::#{options[:segment_id].to_i}" if options.has_key?(:segment_id)
+      {'segment' => segment_id}
+    end
+
+    def parse_sort(options)
+      sort = ReportParameter.new(:sort)
+      sort << options[:sort] if options.has_key?(:sort)
+      sort
+    end
+
+    def build_default_params(profile)
+      {
+        'ids' => Garb.to_ga(profile.id),
+        'start-date' => format_time(Time.now - Model::MONTH),
+        'end-date' => format_time(Time.now)
+      }
+    end
+
+    def build_page_params(options)
+      {'max-results' => options[:limit], 'start-index' => options[:offset]}
+    end
+
+    def format_time(t)
+      t.strftime('%Y-%m-%d')
+    end
+  end
+end

data/lib/garb/profile.rb

@@ -0,0 +1,33 @@
+module Garb
+  class Profile
+
+    include ProfileReports
+
+    attr_reader :session, :table_id, :title, :account_name, :account_id, :web_property_id, :goals
+
+    def initialize(entry, session)
+      @session = session
+      @title = entry['title']
+      @table_id = entry['dxp:tableId']
+      @goals = (entry[Garb.to_ga('goal')] || []).map {|g| Goal.new(g)}
+
+      Garb.parse_properties(entry).each do |k,v|
+        instance_variable_set :"@#{k}", v
+      end
+    end
+
+    def id
+      Garb.from_ga(@table_id)
+    end
+
+    def self.all(session = Session)
+      ActiveSupport::Deprecation.warn("Garb::Profile.all is deprecated in favor of Garb::Management::Profile.all")
+      AccountFeedRequest.new(session).entries.map {|entry| new(entry, session)}
+    end
+
+    def self.first(id, session = Session)
+      ActiveSupport::Deprecation.warn("Garb::Profile.first is deprecated in favor of Garb::Management::WebProperty")
+      all(session).detect {|profile| profile.id == id || profile.web_property_id == id }
+    end
+  end
+end

data/lib/garb/profile_reports.rb

@@ -0,0 +1,16 @@
+module Garb
+  module ProfileReports
+    def self.add_report_method(klass)
+      # demodulize leaves potential to redefine
+      # these methods given different namespaces
+      method_name = klass.name.demodulize.underscore
+      return unless method_name.length > 0
+
+      class_eval <<-CODE
+        def #{method_name}(opts = {}, &block)
+          #{klass}.results(self, opts, &block)
+        end
+      CODE
+    end
+  end
+end

data/lib/garb/report.rb

@@ -0,0 +1,28 @@
+module Garb
+  class Report
+    include Resource
+
+    MONTH = 2592000
+    URL = "https://www.google.com/analytics/feeds/data"
+
+    def initialize(profile, opts={})
+      ActiveSupport::Deprecation.warn("The use of Report will be removed in favor of 'extend Garb::Model'")
+
+      @profile = profile
+
+      @start_date = opts.fetch(:start_date, Time.now - MONTH)
+      @end_date = opts.fetch(:end_date, Time.now)
+      @limit = opts.fetch(:limit, nil)
+      @offset = opts.fetch(:offset, nil)
+
+      metrics opts.fetch(:metrics, [])
+      dimensions opts.fetch(:dimensions, [])
+      sort opts.fetch(:sort, [])
+    end
+
+    def results
+      ReportResponse.new(send_request_for_body).results
+    end
+
+  end
+end