gaapi 0.0.1alpha1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4dc705d6ef1673cc61fd228e716935310202fb97
-  data.tar.gz: cce405242ef7cc676bbecb13bf1718c72955d117
+SHA256:
+  metadata.gz: ffff326579e103303525b129d3befd2c26304126a20bb7c1f3f54b1aa6d0c7bd
+  data.tar.gz: cef8c48c415155959499cb1c8faec0a422c8cb592ef4159fba906afcbeb47297
 SHA512:
-  metadata.gz: a009423f2f1b1c53c85b4cb4de3fd25263924065c96b116f872e0c7e3d91d4ffad2b1e3cebdb7c5ece6c492b26b2caab096fd31e9e1eff436e6620ce9e0ef3b5
-  data.tar.gz: 6e91d1973d4442dadb9f476db61cf9aec8295122b1f6150e3ef84ae4b576c9efad21e9746f3546d2fa54a46d94296831f684dd9ce2926ef55dd4477fc597086a
+  metadata.gz: edf53d316f4c32fadddf748770779f6ab56dd26192b2a3683d42c938e63ae79f2310460cbc7aa87bae516d7ae8fe3166093c5933907ab786e7573cca476eef0d
+  data.tar.gz: 5d67cb658c49b4b883cf75c09d0fb08089d1662ff40ed1a11adfa2e50c0a4bc79299f150f0876e1009a22fe9e8c4b5376db87c06dec7be02b7cd004567a74691

data/bin/gaapi

@@ -4,4 +4,5 @@
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
 require "gaapi"
 
-Main.call
+GAAPI::Main.call
+# FIXME: This doesn't seem to return the status to the shell the way we want.

data/lib/gaapi/access_token.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GAAPI
+  # An access token generated from a credential file provided by Google Analystics.
+  # The credential file is suitable for using in applications where humans aren't
+  # involved, such as scheduled jobs. To obtain a credential file, follow the instructions
+  #   at https://developers.google.com/identity/protocols/OAuth2ServiceAccount.
+  class AccessToken
+    # Get a new access token. The actual token is lazily-generated, so no call is
+    # made to Google Analytics until #token is called.
+    # @param credential_file [String] File name of a credential file provided by
+    #   Google Analytics.
+    def initialize(credential_file = nil)
+      @credential_file = credential_file || File.expand_path("~/.gaapi/ga-api-key")
+      stat = File::Stat.new(@credential_file)
+      raise "#{@credential_file} must be readable and writable only by you." if stat.world_readable? || stat.world_writable?
+    end
+
+    # An access token that can be used in a request to Google Analytics Reporting API v4.
+    # @return [String] An access token.
+    def token
+      (@token ||= fetch_access_token)["access_token"]
+    end
+    alias to_s token
+
+    private
+
+    def fetch_access_token
+      File.open(@credential_file) do |fd|
+        authorization = Google::Auth::ServiceAccountCredentials.make_creds(
+          json_key_io: fd,
+          scope: "https://www.googleapis.com/auth/analytics.readonly"
+        )
+        authorization.fetch_access_token!
+      end
+    end
+  end
+end

data/lib/gaapi/main.rb

@@ -2,104 +2,123 @@
 
 require "optparse"
 
-##
-# Basic runner for nginx config file generation.
-module Main
-  class << self
-    def call
-      options = process_options
+module GAAPI
+  module Main
+    class << self
+      def call
+        begin
+          return 1 if (options = process_options).nil?
+
+          puts "options: #{options.inspect}" if options[:debug]
+
+          # return unless (result = Query.call(options))
+          query = Query.new((options[:query_file] || $stdin).read,
+            options[:view_id],
+            options[:access_token],
+            options[:start_date],
+            options[:end_date])
+          puts "query: #{query.inspect}" if options[:debug]
+        rescue StandardError => e
+          $stderr.puts e.message # rubocop:disable Style/StderrPuts
+          return 1
+        end
 
-      puts "options: #{options.inspect}" if options[:debug]
+        return 0 if options[:dry_run]
 
-      # return unless (result = Query.call(options))
-      query = Query.new((options[:query_file] || STDIN).read, options)
+        result = query.execute
+        puts "result: #{result.inspect}" if options[:debug]
 
-      return if options[:dry_run]
+        unless result.success?
+          # Show the output unformatted, because we don't know what we're going
+          # to get back.
+          puts result.body
+          return 1
+        end
 
-      result = query.execute
+        case options[:output_format]
+        when :csv
+          puts result.csv
+        else
+          puts result.pp
+        end
 
-      if result.code != "200"
-        puts "Request failed #{result.code}"
-        puts Query.pp(result.body)
-        return
+        0
       end
 
-      case options[:output_format]
-      when :csv
-        puts Query.csv(result.body)
-      else
-        puts Query.pp(result.body)
-      end
-    end
+      def process_options
+        options = {}
+        credential_file = File.join(Dir.home, ".gaapi/ga-api-key")
+        parsed_options = OptionParser.new do |opts|
+          opts.banner = "Usage: [options] VIEW_ID"
+          opts.accept(Date)
+
+          opts.on("-a TOKEN",
+            "--access-token TOKEN",
+            "An access token obtained from https://developers.google.com/oauthplayground.") do |access_token|
+            options[:access_token] = access_token
+          end
 
-    def process_options
-      options = { credentials: File.join(Dir.home, ".gaapi/ga-api-key") }
-      opts = OptionParser.new do |opts|
-        opts.banner = "Usage: [options] VIEW_ID"
-        opts.accept(Date)
+          opts.on("--csv",
+            "Output result as a csv file.") do
+            options[:output_format] = :csv
+          end
 
-        opts.on("-a TOKEN",
-          "--access-token TOKEN",
-          "An access token obtained from https://developers.google.com/oauthplayground.") do |access_token|
-          options[:access_token] = access_token
-        end
+          opts.on("-c CREDENTIALS",
+            "--credentials CREDENTIALS",
+            "Location of the credentials file. Default: `#{credential_file}`.") do |credentials|
+              credential_file = credentials
+            end
 
-        opts.on("--csv",
-          "Output result as a csv file.") do
-          options[:output_format] = :csv
-        end
+          opts.on("-d", "--debug", "Print debugging information.") do
+            options[:debug] = true
+          end
 
-        opts.on("-c CREDENTIALS",
-          "--credentials CREDENTIALS",
-          "Location of the credentials file. Default: #{options[:credentials]}.") do |credentials|
-            options[:credentials] = credentials
+          opts.on("-e",
+            "--end-date END_DATE",
+            Date,
+            "Report including END_DATE.") do |end_date|
+            options[:end_date] = end_date
           end
 
-        opts.on("-d", "--debug", "Print debugging information.") do
-          options[:debug] = true
-        end
+          opts.on("-n", "--dry-run", "Don't actually send the query to Google.") do
+            options[:dry_run] = true
+          end
 
-        opts.on("-e",
-          "--end-date END_DATE",
-          Date,
-          "Report including END_DATE.") do |end_date|
-          options[:end_date] = end_date
+          opts.on("-q QUERYFILE",
+            "--query-file QUERYFILE",
+            "File containing the query. Default STDIN.") do |query_file|
+              options[:query_file] = File.open(query_file)
+            end
+
+          opts.on("-s",
+            "--start-date START_DATE",
+            Date,
+            "Report including START_DATE.") do |start_date|
+            options[:start_date] = start_date
+          end
         end
-
-        opts.on("-n", "--dry-run", "Don't actually send the query to Google.") do
-          options[:dry_run] = true
+        parsed_options.parse!
+        unless ARGV.size == 1
+          $stderr.puts("gaapi: You must provide a view ID.\n" + parsed_options.to_s) # rubocop:disable Style/StderrPuts
+          return nil
         end
+        options[:view_id] = ARGV[0]
 
-        opts.on("-q QUERYFILE",
-          "--query-file QUERYFILE",
-          "File containing the query. Default STDIN.") do |query_file|
-            options[:query_file] = File.open(query_file)
-          end
+        options[:access_token] ||= GAAPI::AccessToken.new(credential_file)
 
-        opts.on("-s",
-          "--start-date START_DATE",
-          Date,
-          "Report including START_DATE.") do |start_date|
-          options[:start_date] = start_date
+        if options[:end_date].nil? && !options[:start_date].nil?
+          options[:end_date] = options[:start_date]
+        elsif options[:start_date].nil? && !options[:end_date].nil?
+          options[:start_date] = options[:end_date]
+        elsif options[:start_date].nil? && options[:end_date].nil?
+          options[:end_date] = options[:start_date] = (Date.today - 1).to_s
         end
-      end
-      opts.parse!
-      opts.abort("You must provide a view ID. \n" + opts.to_s) unless ARGV.size == 1
-      options[:view_id] = ARGV[0]
-
-      if options[:end_date].nil? && !options[:start_date].nil?
-        options[:end_date] = options[:start_date]
-      elsif options[:start_date].nil? && !options[:end_date].nil?
-        options[:start_date] = options[:end_date]
-      elsif options[:start_date].nil? && options[:end_date].nil?
-        options[:end_date] = options[:start_date] = (Date.today - 1).to_s
-      end
 
-      options
+        options
+      end
     end
   end
 end
-
 # Some hints:
 # https://stackoverflow.com/a/41179467/3109926
 # http://www.daimto.com/google-service-accounts-with-json-file/

data/lib/gaapi/query.rb

@@ -3,172 +3,47 @@
 require "csv"
 require "net/http"
 
-class Query
-  class << self
-    def call(options)
-      # http://www.rubydoc.info/github/google/google-api-ruby-client/toplevel
-      # https://github.com/google/google-auth-library-ruby
-      scopes = %w[
-        https://www.googleapis.com/auth/analytics
-        https://www.googleapis.com/auth/analytics.readonly
-      ]
-
-      authorization = Google::Auth::ServiceAccountCredentials.make_creds(
-        json_key_io: File
-                      .open(options[:credentials] || File.join(Dir.home,
-                        ".ga-credentials/ga-api-key")),
-        scope: scopes
-      )
-
-      service = Google::Apis::AnalyticsreportingV4::AnalyticsReportingService.new
-      service.authorization = authorization
-
-      request = Google::Apis::AnalyticsreportingV4::ReportRequest.new(
-        view_id: options[:view_id],
-        date_ranges: [Google::Apis::AnalyticsreportingV4::DateRange.new(
-          start_date: options[:start_date],
-          end_date: options[:end_date]
-        )],
-        # dimensions: [
-        #   Google::Apis::AnalyticsreportingV4::Dimension.new(name: "ga:segment")
-        #   # Google::Apis::AnalyticsreportingV4::Dimension.new(name: "ga:adContent"),
-        #   # Google::Apis::AnalyticsreportingV4::Dimension.new(name: "ga:campaign"),
-        #   # Google::Apis::AnalyticsreportingV4::Dimension.new(name: "ga:keyword"),
-        #   # Google::Apis::AnalyticsreportingV4::Dimension.new(name: "ga:medium"),
-        #   # Google::Apis::AnalyticsreportingV4::Dimension.new(name: "ga:socialNetwork"),
-        #   # Google::Apis::AnalyticsreportingV4::Dimension.new(name: "ga:source")
-        # ],
-        metrics: [
-          # Google::Apis::AnalyticsreportingV4::Metric.new(
-          #   expression: "ga:bounces"
-          # ),
-          Google::Apis::AnalyticsreportingV4::Metric.new(
-            expression: "ga:newUsers"
-          ),
-          Google::Apis::AnalyticsreportingV4::Metric.new(
-            expression: "ga:pageviewsPerSession"
-          ),
-          Google::Apis::AnalyticsreportingV4::Metric.new(
-            expression: "ga:sessions"
-          ),
-          Google::Apis::AnalyticsreportingV4::Metric.new(
-            expression: "ga:sessionDuration"
-          ),
-          # Google::Apis::AnalyticsreportingV4::Metric.new(
-          #   expression: "ga:organicSearches"
-          # ),
-          Google::Apis::AnalyticsreportingV4::Metric.new(
-            expression: "ga:users"
-          )
-        ],
-        metric_filter_clauses: [
-          Google::Apis::AnalyticsreportingV4::MetricFilterClause.new(
-            filters: [
-              Google::Apis::AnalyticsreportingV4::MetricFilter.new(
-                metric_name: "ga:pageviews",
-                comparison_value: "0",
-                operator: "GREATER_THAN"
-              )
-            ]
-          )
-        ],
-        include_empty_rows: true
-      )
-
-      # puts "request.to_json: #{JSON.pretty_generate(JSON.parse(request.to_json))}" if options[:debug]
-      get_reports_requests = Google::Apis::AnalyticsreportingV4::GetReportsRequest.new(report_requests: [request])
-      # puts get_reports_requests.to_json if options[:debug]
-      puts JSON.pretty_generate(JSON.parse(get_reports_requests.to_json)) if options[:debug]
-      return nil if options[:dry_run]
-
-      result = service.batch_get_reports(get_reports_requests)
-      puts "result: #{result.inspect}" if options[:debug]
-      result
-    end
-
-    def csv(result)
-      result = result.to_json if result.is_a?(Google::Apis::AnalyticsreportingV4::GetReportsResponse)
-      result = JSON.parse(result) if result.is_a?(String)
-      CSV.generate do |csv|
-        result["reports"].each do |report|
-          # puts report.column_header.dimensions.inspect
-          # puts report.column_header.metric_header.metric_header_entries.map(&:name).inspect
-          csv << csv_header_row(report)
-          report["data"]["rows"].each do |row|
-            csv << csv_data_row(row["dimensions"], row["metrics"])
-          end
-          csv << csv_data_row("Totals", report["data"]["totals"]) if report["data"]["totals"]
-        end
-      end
-    end
-
-    def csv_data_row(row_headers, metrics)
-      (Array(row_headers) || []) + metrics[0]["values"]
-    end
-
-    def csv_header_row(report)
-      (report["columnHeader"]["dimensions"] || []) + report["columnHeader"]["metricHeader"]["metricHeaderEntries"].map do |entry|
-        entry["name"]
+module GAAPI
+  class Query
+    # Create a Query object.
+    # @param access_token [String] A valid access token with which to make a request to
+    #   the specified View ID.
+    # @param end_date [Date, String] The end date for the report.
+    # @param query_string [String] The query in JSON format.
+    # @param start_date [Date, String] The start date for the report.
+    # @param view_id [String] The view ID of the property for which to submit the
+    #   query.
+    def initialize(query_string, view_id, access_token, start_date, end_date)
+      @access_token = access_token
+      query_string = JSON.parse(query_string) unless query_string.is_a?(Hash)
+      @query = {}
+      @query["reportRequests"] = query_string["reportRequests"].map do |report_request|
+        report_request["viewId"] = view_id
+        report_request["dateRanges"] = [
+          "startDate": start_date.to_s,
+          "endDate": end_date.to_s
+        ]
+        report_request
       end
+      # puts "query: #{JSON.pretty_generate(query)}"
     end
 
-    def pp(result)
-      JSON.pretty_generate(JSON.parse(result))
+    # Send the requested query to Google Analytics and return the response.
+    # @return [HTTPResponse] The response from the request.
+    def execute
+      uri = URI.parse("https://analyticsreporting.googleapis.com/v4/reports:batchGet")
+      https = Net::HTTP.new(uri.host, uri.port)
+      https.use_ssl = true
+      # https.set_debug_output($stdout)
+      request = Net::HTTP::Post.new(uri.request_uri,
+        "Content-Type" => "application/json",
+        "Authorization" => "Bearer #{access_token}")
+      request.body = query.to_json
+      Response.new(https.request(request))
     end
-  end
-
-  def initialize(query_string, options)
-    # puts "query_string: #{query_string}"
-    puts "Initializing query. Options: #{options.inspect}" if options[:debug]
 
-    puts "options[:access_token]: #{options[:access_token]}"
-    @access_token = options[:access_token]
-    puts "options[:credentials]: #{options[:credentials]}"
-    @access_token ||= access_token_from_credentials(options[:credentials])
-    puts "Final access_token: #{access_token}"
-    @dry_run = options[:dry_run]
-
-    query_string = JSON.parse(query_string) unless query_string.is_a?(Hash)
-    @query = {}
-    @query["reportRequests"] = query_string["reportRequests"].map do |report_request|
-      report_request["viewId"] = options[:view_id]
-      report_request["dateRanges"] = [
-        "startDate": options[:start_date],
-        "endDate": options[:end_date]
-      ]
-      report_request
-    end
-    # puts "query: #{JSON.pretty_generate(query)}"
-  end
+    private
 
-  def execute
-    uri = URI.parse("https://analyticsreporting.googleapis.com/v4/reports:batchGet")
-    https = Net::HTTP.new(uri.host, uri.port)
-    https.use_ssl = true
-    # https.set_debug_output($stdout)
-    request = Net::HTTP::Post.new(uri.request_uri,
-      "Content-Type" => "application/json",
-      "Authorization" => "Bearer #{access_token}")
-    request.body = query.to_json
-    response = https.request(request)
-    response
-  end
-
-  private
-
-  attr_reader :access_token, :dry_run, :query
-
-  def access_token_from_credentials(credential_file_name)
-    stat = File::Stat.new(credential_file_name)
-    if stat.world_readable? || stat.world_writable?
-      raise "#{credential_file_name} must be readable and writable only by you."
-    end
-    authorization = Google::Auth::ServiceAccountCredentials.make_creds(
-      json_key_io: File.open(credential_file_name),
-      scope: "https://www.googleapis.com/auth/analytics.readonly"
-    )
-    token = authorization.fetch_access_token!
-    puts token
-    token["access_token"]
+    attr_reader :access_token, :query
   end
 end

data/lib/gaapi/response.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module GAAPI
+  # Holds the result of a Google Analytics query, and provides some methods to
+  # present the result in useful ways.
+  class Response
+    attr_reader :response
+
+    # Raw body of the response. Typically only used for diagnostic purposes.
+    def body
+      response.body
+    end
+
+    # Raw code of the response. Typically only used for diagnostic purposes.
+    def code
+      response.code
+    end
+
+    # Convert a response from Google Analytics into a comma-separated values
+    # format file.
+    # @return [String] The result of the query formatted as a comma-separated
+    #   values string.
+    def csv
+      result = to_json
+      @csv ||= CSV.generate do |csv|
+        result["reports"].each do |report|
+          # puts report.column_header.dimensions.inspect
+          # puts report.column_header.metric_header.metric_header_entries.map(&:name).inspect
+          csv << csv_header_row(report)
+          report["data"]["rows"].each do |row|
+            csv << csv_data_row(row["dimensions"], row["metrics"])
+          end
+          csv << csv_data_row("Totals", report["data"]["totals"]) if report["data"]["totals"]
+        end
+      end
+    end
+
+    def initialize(response)
+      @response = response
+    end
+
+    # Return the JSON result in a readable format.
+    # @return [String] The JSON result formatted in a human-readable way.
+    def pp
+      @pp ||= JSON.pretty_generate(to_json)
+    end
+
+    # Return true if the request was successful.
+    # @return [Boolean] True if the request was successful (response code 200).
+    def success?
+      code == "200"
+    end
+
+    # Return the body of the response
+    # @return [String] JSON-formatted response in a String.
+    def to_json
+      @to_json ||= JSON.parse(to_s)
+    end
+
+    # Return the body of the response
+    # @return [String] JSON-formatted response in a String.
+    def to_s
+      response.body
+    end
+
+    private
+
+    def csv_data_row(row_headers, metrics)
+      (Array(row_headers) || []) + metrics[0]["values"]
+    end
+
+    def csv_header_row(report)
+      (report["columnHeader"]["dimensions"] || []) + report["columnHeader"]["metricHeader"]["metricHeaderEntries"].map do |entry|
+        entry["name"]
+      end
+    end
+  end
+end

data/lib/gaapi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GAAPI
+  VERSION = "0.2.0"
+end

data/lib/gaapi.rb

@@ -3,5 +3,7 @@
 # http://www.rubydoc.info/github/google/google-api-ruby-client/
 require "google/apis/analyticsreporting_v4"
 require "googleauth"
+require "gaapi/access_token.rb"
 require "gaapi/main.rb"
 require "gaapi/query.rb"
+require "gaapi/response.rb"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gaapi
 version: !ruby/object:Gem::Version
-  version: 0.0.1alpha1
+  version: 0.2.0
 platform: ruby
 authors:
 - Larry Reid
@@ -9,8 +9,50 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-23 00:00:00.000000000 Z
+date: 2018-09-06 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: chandler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: google-api-client
   requirement: !ruby/object:Gem::Requirement
@@ -25,6 +67,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: googleauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       Submit queries expressed in JSON to Google Analytics. Can be run
       from unattended scripts, batch jobs, etc.
@@ -36,8 +92,11 @@ extra_rdoc_files: []
 files:
 - bin/gaapi
 - lib/gaapi.rb
+- lib/gaapi/access_token.rb
 - lib/gaapi/main.rb
 - lib/gaapi/query.rb
+- lib/gaapi/response.rb
+- lib/gaapi/version.rb
 homepage: https://github.com/weenhanceit/gaapi
 licenses:
 - MIT
@@ -54,12 +113,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Query Google Analytics from the command line.