adtekio_adnetworks 0.0.4

data/lib/adtekio_adnetworks/importers/revenue/applifier.rb

@@ -0,0 +1,55 @@
+class AdtekioAdnetworks::Revenue::Applifier
+  include AdtekioAdnetworks::RevenueImport
+
+  CsvOptions = {
+    :col_sep    => ",",
+    :quote_char => '"',
+    :headers    => :first_row,
+  }
+
+  BASE_URL = "https://gameads-admin.applifier.com/stats/monetization-api"
+
+  define_required_credentials do
+    [:api_key]
+  end
+
+  def revenues(from, to)
+    report(from,to).map do |csv_data|
+      CSV(csv_data, CsvOptions).map do |row|
+        {
+          :impressions => row["views"].to_i,
+          :amount      => row["revenue"].to_f,
+          :date        => Date.strptime(row["Date"], "%Y-%m-%d"),
+          :appname     => row["Source game name"]
+        }
+      end
+    end.flatten
+  end
+
+  def report(from,to)
+    (from..to).map do |day|
+      csv_data(day)
+    end
+  end
+
+  def csv_data(date)
+    uri = Addressable::URI.new
+    uri.query_values = {
+      :apikey  => credentials.api_key,
+      :start   => date.strftime("%Y-%m-%d"),
+      :end     => (date+1).strftime("%Y-%m-%d"),
+      :fields  => 'views,revenue',
+      :splitBy => 'source'
+    }
+    datauri = URI.parse("%s?%s" % [BASE_URL, uri.query])
+
+    # follow one redirect.
+    request = Net::HTTP::Persistent.new('applifier').request(datauri)
+    if request.code =~ /3../
+      Net::HTTP::Persistent.new('applifier').
+        request(URI.parse(request.header["Location"])).body
+    else
+      request.body
+    end
+  end
+end

data/lib/adtekio_adnetworks/importers/revenue/applovin.rb

@@ -0,0 +1,58 @@
+class AdtekioAdnetworks::Revenue::Applovin
+  include AdtekioAdnetworks::RevenueImport
+
+  BaseUrl = "https://r.applovin.com/report"
+  ReportColumns = "application,platform,package_name,revenue,day,impressions,clicks,ad_type"
+
+  define_required_credentials do
+    [:api_key]
+  end
+
+  def revenues(from, to)
+    report(from, to).map do |(package, ad_type, date), values|
+      osv = values.map{ |a| OpenStruct.new(a) }
+
+      {
+        :impressions => osv.map(&:impressions).map(&:to_i).sum,
+        :clicks      => osv.map(&:clicks).map(&:to_i).sum,
+        :amount      => osv.map(&:revenue).map(&:to_f).sum,
+        :date        => date,
+        :appname     => package,
+        :not_matched => not_matched(:ad_type => ad_type,
+                                    :platform => osv.map(&:platform).join(","))
+      }
+    end
+  end
+
+  def report(from, to)
+    @report ||= data({ :api_key     => credentials.api_key,
+                       :start       => from.strftime("%Y-%m-%d"),
+                       :end         => to.strftime("%Y-%m-%d"),
+                       :format      => :json,
+                       :columns     => ReportColumns,
+                       :report_type => :publisher,
+                     }).group_by do |row|
+      [row[:package_name], row[:ad_type], Date.parse(row[:day])]
+    end
+  end
+
+  def data(params)
+    cipher_suit_backup = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
+
+    uri = Addressable::URI.parse(BaseUrl)
+    uri.query_values = params
+
+    OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers] =
+      'HIGH:MEDIUM:!ADH:!EDH:!DHE'
+
+    http = Net::HTTP.new(uri.hostname, 443)
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    http.use_ssl = true
+
+    request = Net::HTTP::Get.new uri.request_uri
+    response = http.request(request)
+    JSON.parse(response.body, :symbolize_names => true)[:results]
+  ensure
+    OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers] = cipher_suit_backup
+  end
+end

data/lib/adtekio_adnetworks/importers/revenue/chartboost.rb

@@ -0,0 +1,43 @@
+class AdtekioAdnetworks::Revenue::Chartboost
+  include AdtekioAdnetworks::RevenueImport
+
+  BASE_URL = "https://analytics.chartboost.com/queue/app"
+
+  define_required_credentials do
+    [:user_id, :signature]
+  end
+
+  def revenues(from, to)
+    report(from,to).map do |hsh|
+      {
+        :impressions => hsh["impressionsDelivered"].to_i,
+        :amount      => hsh["moneyEarned"].to_f,
+        :date        => Date.strptime(hsh["dt"], "%Y-%m-%d"),
+        :appname     => hsh["app"],
+        :not_matched => not_matched(:platform    => hsh["platform"],
+                                    :appBundleId => hsh["appBundleId"],
+                                    :appId       => hsh["appId"])
+      }
+    end
+  end
+
+  def report(from, to)
+    JSON(Net::HTTP::Persistent.new('chartboost').
+         request(query_url(from,to)).body)
+  end
+
+  def query_url(from, to)
+    params = {
+      :userId        => credentials.user_id,
+      :userSignature => credentials.signature,
+      :dateMin       => from.strftime("%Y-%m-%d"),
+      :dateMax       => to.strftime("%Y-%m-%d"),
+      :groupBy       => :app,
+      :aggregate     => :daily,
+    }
+
+    uri = Addressable::URI.new
+    uri.query_values = params
+    URI.parse("%s?%s" % [BASE_URL, uri.query])
+  end
+end

data/lib/adtekio_adnetworks/importers/revenue/flurry.rb

@@ -0,0 +1,85 @@
+class AdtekioAdnetworks::Revenue::Flurry
+  include AdtekioAdnetworks::RevenueImport
+
+  define_required_credentials do
+    [:keys, :access_code]
+  end
+
+  def revenues(from, to)
+    report(from, to).map do |data|
+      data.map do |adspace_id, values|
+        next if values.nil?
+        values.map do |hsh|
+          check_version!(hsh['@version'], "1.0")
+          check_currency!(hsh["currency"], "usd")
+
+          next if hsh["results"].nil?
+          date = Date.strptime(hsh["results"]["date"], "%Y-%m-%d")
+
+          # Kinda confusing since the data is duplicated for each
+          # day. We import everything but flurry sends on a per-country
+          # basis with then a global value. That means the total
+          # of all entries for day with country should be the same
+          # as the entry with country == null.
+          ( (hsh["results"]["country_stats"] || []) +
+            [hsh['results']["global_stats"]]).compact.map do |dpt|
+            {
+              :date        => date,
+              :appname     => adspace_id,
+              :country     => dpt["country"],
+              :amount      => dpt["revenue"].to_f,
+              :clicks      => dpt["clicks"].to_i,
+              :impressions => dpt["impressions"].to_i,
+              :installs    => dpt["installs"].to_i
+            }
+          end
+        end
+      end
+    end.flatten.compact
+  end
+
+  def report(from,to)
+    creds = credentials.keys["adspace_id"].zip(credentials.keys["api_key"])
+    creds.map do |adspace_id, api_key|
+      { adspace_id => ( (from..to).map do |date|
+                          data_for_apikey(api_key, adspace_id, date)
+                        end)
+      }
+    end
+  end
+
+  def data_for_apikey(key, adspaceid, for_date = Date.today-1)
+    sdate, edate = [for_date, for_date+1].map { |a| a.strftime("%Y-%m-%d") }
+
+    uri = Addressable::URI.new
+    uri.query_values = {
+      :apiAccessCode => credentials.access_code,
+      :adSpaceId     => adspaceid,
+      :apiKey        => key,
+      :startDate     => sdate,
+      :endDate       => edate
+    }
+
+    datauri = URI.
+      parse("%s?%s" % ["http://api.flurry.com/ffp/v1/AdSpaceCountry",
+                       uri.query])
+
+    repeatthis(10) do
+      JSON(Net::HTTP::Persistent.new('flurry').request(datauri).body)
+    end
+  end
+
+  def repeatthis(cnt=5, timeout=0.1, &block)
+    last_exception = nil
+    cnt.times do
+      begin
+        return yield
+      rescue Exception => e
+        last_exception = e
+        sleep timeout
+        next
+      end
+    end
+    raise last_exception
+  end
+end

data/lib/adtekio_adnetworks/importers/revenue/fyber.rb

@@ -0,0 +1,61 @@
+class AdtekioAdnetworks::Revenue::Fyber
+  include AdtekioAdnetworks::RevenueImport
+
+  REPORT_URL =
+    "https://dashboard.fyber.com/publishers/v1/28839/statistics.json"
+
+  define_required_credentials do
+    [:key]
+  end
+
+  def revenues(from, to)
+    report(from,to).map do |dpt|
+      appname = dpt['readable'].strip
+      from.upto(to).each_with_index.map do |date, idx|
+        {
+          :completions => dpt["transactions"][idx].to_i,
+          :impressions => dpt["views"][idx].to_i,
+          :clicks      => dpt["clicks"][idx].to_i,
+          :amount      => dpt["payout_usd"][idx].to_f,
+          :date        => date,
+          :appname     => appname,
+          :not_matched => not_matched(:id => dpt["id"])
+        }
+      end
+    end.flatten.compact
+  end
+
+  def report(from,to)
+    load_data({
+                :start_date         => from.to_s,
+                :end_date           => to.to_s,
+                :group_by           => :applications,
+                :aggregation_level  => :days,
+              })
+  end
+
+  def hash(params)
+    value = Hash[params.sort_by{|k, _| k}].reject do |_,v|
+      v.to_s.blank?
+    end.map do |k,v|
+      "#{k}=#{v}"
+    end.inject("/publishers/v1/28839/statistics.json") do |string, param|
+      string + "&" + param
+    end + "&" + credentials.key
+
+    Digest::SHA1.hexdigest value
+  end
+
+  def load_data(params)
+    uri = Addressable::URI.parse(REPORT_URL)
+    uri.query_values = params.merge({:hashkey => hash(params)})
+    response = http_client.request(URI.parse(uri.to_s))
+    JSON(response.body)['applications']
+  end
+
+  def http_client
+    @http_client ||= Net::HTTP::Persistent.new('fyber').tap do |client|
+      client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+  end
+end

data/lib/adtekio_adnetworks/importers/revenue/hypr_mx.rb

@@ -0,0 +1,69 @@
+class AdtekioAdnetworks::Revenue::HyprMx
+  include AdtekioAdnetworks::RevenueImport
+
+  BASE_URL = 'https://live.hyprmx.com/fyber/v1/'
+
+  define_required_credentials do
+    [:apps]
+  end
+
+  def revenues(from, to)
+    # We import everything but hypermx sends on a per-country
+    # basis with then a global value. That means the total
+    # of all entries for day with country should be the same
+    # as the entry with country == null, for a specific date.
+    report(from,to).map do |dpt|
+      ((dpt[:country_stats] || []) + [dpt[:global_stats]]).map do |stats|
+        {
+          :appname     => dpt[:appname],
+          :date        => dpt[:date],
+          :amount      => stats[:revenue].to_f,
+          :impressions => stats[:impressions].to_i,
+          :completions => stats[:completions].to_i,
+          :country     => stats[:country],
+          :not_matched => not_matched(:dist_id => dpt[:dist_id])
+        }
+      end
+    end.flatten.compact
+  end
+
+  def report(from,to)
+    cnt = (credentials.apps["dist_id"] || []).count
+
+    cnt.times.map do |idx|
+      data = load_data({ :app_id       => credentials.apps["dist_id"][idx],
+                         :placement_id => credentials.apps["placement_id"][idx],
+                         :start_date   => from.to_s,
+                         :end_date     => to.to_s,
+                       }, credentials.apps["api_key"][idx])
+
+      check_currency!(data[:currency], "usd")
+
+      data[:results].map do |dpt|
+        dpt.merge({ :appname => credentials.apps["placement_id"][idx],
+                    :date    => Date.strptime(dpt[:date],"%Y-%m-%d"),
+                    :dist_id => credentials.apps["dist_id"][idx]})
+      end
+    end.flatten.compact
+  end
+
+  def http_client
+    @http_client ||= Net::HTTP::Persistent.new('hyprmx').tap do |client|
+      client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+  end
+
+  def hash(params, api_key)
+    value = Hash[params.sort_by{|k, _| k}].map do |k,v|
+      "#{k}=#{v}"
+    end.join('&') + "&" + api_key
+    Digest::SHA1.hexdigest value
+  end
+
+  def load_data(params, api_key)
+    uri = Addressable::URI.parse(BASE_URL)
+    uri.query_values = params.merge({:hash_value => hash(params, api_key)})
+    response = http_client.request(URI.parse(uri.to_s))
+    JSON(response.body, :symbolize_names => true)
+  end
+end

data/lib/adtekio_adnetworks/importers/revenue/lifestreet.rb

@@ -0,0 +1,59 @@
+class AdtekioAdnetworks::Revenue::Lifestreet
+  include AdtekioAdnetworks::RevenueImport
+
+  define_required_credentials do
+    [:username, :password]
+  end
+
+  def revenues(from, to)
+    add_global_stats(from, to).map do |(date, appname), values|
+      values.map do |dpt|
+        {
+          :appname     => appname,
+          :date        => Date.strptime(date, "%Y-%m-%d"),
+          :country     => dpt["Country.name"],
+          :impressions => dpt["adImps"].to_i,
+          :amount      => dpt["adCost"].to_f
+        }
+      end
+    end.flatten
+  end
+
+  def add_global_stats(from, to)
+    # report comes split by country without a summary entry
+    # over all countries, so add this summary.
+    Hash[report(from,to)["data"].
+         group_by { |a| [a["Date"], a["AdSlot.name"]] }.
+         map do |(date, appname), values|
+           [ [date,appname], values +
+             [{ "Date"         => date,
+                "AdSlot.name"  => appname,
+                "Country.name" => nil,
+                "adImps"       => values.map{ |a| a["adImps"] }.sum,
+                "adCost"       => values.map{ |a| a["adCost"] }.sum }]]
+         end]
+  end
+
+  def report(from, to)
+    uri = Addressable::URI.
+      parse("https://my.lifestreetmedia.com/reporting/run/")
+    request = Net::HTTP::Post.new uri.request_uri
+    request.basic_auth credentials.username, credentials.password
+    # body is cgi encoded parameter with json values.
+    request.body = "data=" + ({
+                                "measurements" => ["adImps", "adCost"],
+                                "dimensions"   => ["Date", "AdSlot.name",
+                                                   "Country.name"],
+                                "start_date" => from.to_s,
+                                "end_date"   => to.to_s,
+                                "mobile"     => true
+                              }.to_json)
+
+    http = Net::HTTP.new(uri.hostname, 443)
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    http.use_ssl = true
+
+    response = http.request(request)
+    JSON.parse(response.body)
+  end
+end

data/lib/adtekio_adnetworks/importers/revenue/mdotm.rb

@@ -0,0 +1,38 @@
+class AdtekioAdnetworks::Revenue::Mdotm
+  include AdtekioAdnetworks::RevenueImport
+
+  define_required_credentials do
+    [:account_id, :secret_key]
+  end
+
+  def revenues(from, to)
+    report(from, to).map do |data|
+      {
+        :impressions => data["impressions"].to_i,
+        :requests    => data["requests"].to_i,
+        :clicks      => data["clicks"].to_i,
+        :amount      => data["earnings"].to_f,
+        :date        => Date.strptime(data["logDT"], "%Y-%m-%d"),
+        :appname     => data["appname"]
+      }
+    end
+  end
+
+  def report(from,to)
+    url = "http://platform.mdotm.com/monetize/appstats/" +
+      credentials.account_id.to_s + "/" +
+      credentials.secret_key.to_s + "/" +
+      from.strftime("%Y-%m-%d") + "/" +
+      to.strftime("%Y-%m-%d")
+
+    JSON(do_request(url))
+  end
+
+  def do_request(url)
+    h = Net::HTTP::Persistent.new('whatever')
+    h.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    uri = URI.parse(url)
+    req = Net::HTTP::Get.new uri.request_uri
+    h.request(uri,req).body
+  end
+end