adtekio_adnetworks 0.0.4

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

@@ -0,0 +1,54 @@
+class AdtekioAdnetworks::Revenue::Mopub
+  include AdtekioAdnetworks::RevenueImport
+
+  define_required_credentials do
+    [:account, :key]
+  end
+
+  def revenues(from, to)
+    # index meanings can be taken from exp_cols
+    report(from,to).map do |row|
+      {
+        :appname     => row[1],
+        :date        => Date.strptime(row[0], "%Y-%m-%d"),
+        :impressions => row[3],
+        :requests    => row[4].to_i,
+        :clicks      => row[5],
+        :amount      => row[6]
+      }
+    end
+  end
+
+  def report(from,to)
+    d = data(from,to)
+    raise "Columns mismatch: #{d['columns']}" if d['columns'] != exp_cols
+    d["rows"]
+  end
+
+  def exp_cols
+    ["date", "app", "conversions", "impressions", "attempts",
+     "clicks", "revenue"]
+  end
+
+  def http_client
+    Net::HTTP::Persistent.new('chartboost').tap do |h|
+      h.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+  end
+
+  def data(from,to)
+    params = {
+      :group_by   => "date,app",
+      :start_date => from.strftime("%Y-%m-%d"),
+      :end_date   => to.strftime("%Y-%m-%d"),
+      :account    => credentials.account,
+      :key        => credentials.key,
+    }
+
+    uri = Addressable::URI.new
+    uri.query_values = params
+    url = URI.parse("%s?%s" % ["https://data-service.mopub.com/mpx",
+                               uri.query])
+    JSON(http_client.request(url).body)
+  end
+end

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

@@ -0,0 +1,71 @@
+class AdtekioAdnetworks::Revenue::Nexage
+  include AdtekioAdnetworks::RevenueImport
+
+  define_required_credentials do
+    [:company_id, :access_key, :secret_key]
+  end
+
+  def revenues(from, to)
+    []
+  end
+
+  def report(from,to)
+    []
+  end
+
+  def seller_revenue_by_app(from,to)
+    Hash[site_ids(from,to)["detail"].map do |site_data|
+           uri = Addressable::URI.new
+           uri.query_values = {
+             :start => from.strftime("%Y-%m-%d"),
+             :stop  => to.strftime("%Y-%m-%d"),
+             :dim   => "day",
+             :site  => site_data["siteId"]
+           }
+           url = ("https://reports.nexage.com/access/"+
+                  "#{credentials.company_id}"+
+                  "/reports/sellerrevenue")
+
+           [site_data["site"],
+            do_request("%s?%s" % [url, uri.query])["detail"]]
+         end]
+  end
+
+  def site_ids(from,to)
+    uri = Addressable::URI.new
+    uri.query_values = {
+      :start => from.strftime("%Y-%m-%d"),
+      :stop  => to.strftime("%Y-%m-%d"),
+      :dim   => "site"
+    }
+    url = ("https://reports.nexage.com/access/#{credentials.company_id}"+
+           "/reports/sellerrevenue")
+    do_request("%s?%s" % [url, uri.query])
+  end
+
+  def do_request(urlstring)
+    digest_auth = Net::HTTP::DigestAuth.new
+
+    uri = URI.parse(urlstring)
+    uri.user = credentials.access_key
+    uri.password = credentials.secret_key
+
+    h = Net::HTTP::Persistent.new('whatever')
+    h.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+    req = Net::HTTP::Get.new uri.request_uri
+
+    res = h.request uri, req
+
+    auth = digest_auth.auth_header uri, res['www-authenticate'], 'GET'
+
+    req = Net::HTTP::Get.new uri.request_uri
+    req.add_field 'Authorization', auth
+
+    res = h.request uri,req
+
+    raise "No data available" if res.code.to_i == 204
+    raise "Unable to authenticate" if res.code.to_i != 200
+    JSON(res.body)
+  end
+end

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

@@ -0,0 +1,73 @@
+class AdtekioAdnetworks::Revenue::Supersonic
+  include AdtekioAdnetworks::RevenueImport
+
+  BASE_URL = "https://api.supersonicads.com/api/rest/v1/ultra/statistics"
+
+  define_required_credentials do
+    [:access_key, :secret_key]
+  end
+
+  def revenues(from, to)
+    report(from,to).map do |(appname, appid, providerName, date), values|
+      values.map do |dpt|
+        # we assume: impressions == clicks, strange but true!
+        if dpt.impressions != dpt.clicks
+          raise "impressions didn't match clicks: "+
+            "#{dpt.impressions}/#{dpt.clicks}"
+        end
+
+        nmstuff = {
+          :provider        => providerName,
+          :appid           => appid,
+          :uniqUser        => dpt.uniqueUsers.remove(',').to_i,
+          :uniqPayingUsers => dpt.uniquePayingUsers.remove(',').to_i,
+          :rewards         => dpt.rewards.remove(',').to_i,
+        }
+
+        {
+          :date        => Date.strptime(date, "%Y-%m-%d"),
+          :appname     => appname,
+          :amount      => dpt.revenue.remove('$').to_f,
+          :requests    => dpt.hits.remove(',').to_i,
+          :impressions => dpt.fulfillments.remove(',').to_i,
+          :clicks      => dpt.clicks.remove(',').to_i,
+          :completions => dpt.completions.remove(',').to_i,
+          :not_matched => not_matched(nmstuff)
+        }
+      end
+    end.flatten
+  end
+
+  def report(from,to)
+    CSV(ultra_data(from,to), :col_sep => ",", :headers => true ).map do |a|
+      OpenStruct.new(a.to_h)
+    end[0..-2].group_by do |a| ## last line is a summary row, ignore it.
+      [a.applicationName, a.applicationId, a.providerName, a.theDate]
+    end
+  end
+
+  def http_client
+    @http_client ||= Net::HTTP::Persistent.new('supersonic').tap do |client|
+      client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+  end
+
+  def ultra_data(from_date, to_date)
+    http_client.request(ultra_url(from_date, to_date)).body
+  end
+
+  def ultra_url(from_date, to_date)
+    uri = Addressable::URI.new
+    uri.query_values = {
+      :accessKey     => credentials.access_key,
+      :secretKey     => credentials.secret_key,
+      :onlyRevenue   => 0,
+      :fromDate      => from_date.strftime("%Y-%m-%d"),
+      :toDate        => to_date.strftime("%Y-%m-%d"),
+      :format        => "csv",
+      "breakdowns[]" => ["date", "application", "provider"]
+    }
+
+    URI.parse("%s?%s" % [BASE_URL, uri.query])
+  end
+end

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

@@ -0,0 +1,38 @@
+class AdtekioAdnetworks::Revenue::Tapsense
+  include AdtekioAdnetworks::RevenueImport
+  ## More info on the API:
+  ## https://github.com/TapSense/tapsense-adapters/wiki/TapSense-Reporting-API-for-Publishers
+
+  define_required_credentials do
+    [:username, :password]
+  end
+
+  def revenues(from, to)
+  end
+
+  def report(from,to)
+  end
+
+  def data(from, to)
+    require 'mechanize'
+    agent = Mechanize.new
+    agent.user_agent_alias = 'Mac Safari'
+
+    agent.post("https://dashboard.tapsense.com/console/login", {
+                 :username   => credentials.username,
+                 :password   => credentials.password}.to_json,
+               {"Content-Type" => "application/json",
+                 "Accept"      => "application/json" })
+
+    uri = Addressable::URI.new
+    uri.query_values = {
+      :start_date  => from.strftime("%Y-%m-%d"),
+      :end_date    => to.strftime("%Y-%m-%d"),
+      :format      => :json,
+      :rollup      => "date,country",
+      :action_type => "report"
+    }
+    url = "https://dashboard.tapsense.com/console/publisher/report"
+    agent.get("%s?%s" % [url, uri.query]).body
+  end
+end

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

@@ -0,0 +1,41 @@
+class AdtekioAdnetworks::Revenue::Trialpay
+  include AdtekioAdnetworks::RevenueImport
+
+  define_required_credentials do
+    [:username, :password]
+  end
+
+  def revenues(from, to)
+  end
+
+  def report(from,to)
+  end
+
+  def dailysummary
+    require 'mechanize'
+    agent = Mechanize.new
+    agent.user_agent_alias = 'Mac Safari'
+
+    agent.post("https://merchant.trialpay.com/login/", {
+                 :action   => "del",
+                 :email    => credentials.username,
+                 :password => credentials.password})
+
+    uri = Addressable::URI.new
+    uri.query_values = {
+      :app_id                    => "",
+      :context                   => "",
+      :group_by                  => "group_by_app_id_context_and_date",
+      :date_group                => "day",
+      :date_type                 => 1,
+      :date_interval             => 6, # 30 days back
+      :csv                       => "Export to CSV",
+      "[sort_by]"                => "date",
+      "[sort_order]"             => "asc",
+      "report_table[sort_by]"    => "date",
+      "report_table[sort_order]" => "asc",
+    }
+    url = "https://merchant.trialpay.com/reports/dailysummary/"
+    agent.get("%s?%s" % [url, uri.query]).body
+  end
+end

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

@@ -0,0 +1,75 @@
+class AdtekioAdnetworks::Revenue::Vungle
+  include AdtekioAdnetworks::RevenueImport
+
+  BASE_URL = "https://ssl.vungle.com"
+
+  define_required_credentials do
+    [:api_key]
+  end
+
+  def revenues(from, to)
+    report(from,to).map do |dpt|
+      nmstuff = {
+        :appId      => dpt['appId'],
+        :installs   => dpt['installs'],
+        :platform   => dpt['platform'],
+        :status     => dpt['status'],
+        :connection => dpt['connection']
+      }
+
+      {
+        :appname     => dpt['name'],
+        :date        => dpt['datestamp'],
+        :amount      => dpt['revenue'].to_f,
+        :impressions => dpt['impressions'].to_i,
+        :clicks      => dpt['views'].to_i,
+        :completions => dpt['completes'].to_i,
+        :not_matched => not_matched(nmstuff)
+      }
+    end
+  end
+
+  def report(from,to)
+    # Because we have a api rate limit of 2 per 10 seconds:
+    #    ApiError: Rate limit hit. Maximum 2 requests every 10 seconds
+    # batch the dates together and sleep 5 seconds between requests.
+    applications.map do |app|
+      sleep 5
+      retrieve_data(app["id"], from, to).map do |data|
+        data.merge(app).
+          merge("datestamp" => Date.strptime(data["date"], "%Y-%m-%d"))
+      end
+    end.flatten
+  end
+
+  def applications
+    uri = Addressable::URI.new
+    uri.query_values = { :key => credentials.api_key }
+    datauri = URI.
+      parse("%s/api/applications?%s" % [BASE_URL, uri.query])
+
+    JSON(Net::HTTP::Persistent.new('vungle').request(datauri).body)
+  end
+
+  def retrieve_data(app, startdate, enddate)
+    uri = Addressable::URI.new
+    uri.query_values = {
+      :key   => credentials.api_key,
+      :start => startdate.strftime("%Y-%m-%d"),
+      :end   => enddate.strftime("%Y-%m-%d")
+    }
+    datauri = URI.
+      parse("%s/api/applications/%s?%s" % [BASE_URL, app, uri.query])
+
+    json_data_string =
+      Net::HTTP::Persistent.new('vungle').request(datauri).body
+
+    begin
+      JSON(json_data_string)
+    rescue Exception => e
+      $stderr.puts("vungle data failure: #{e}")
+      $stderr.puts("json data string: #{json_data_string}")
+      []
+    end
+  end
+end

data/lib/adtekio_adnetworks/importers/revenue_import.rb

@@ -0,0 +1,27 @@
+module AdtekioAdnetworks
+  module Revenue
+    # placeholder
+  end
+
+  module RevenueImport
+    include BaseImporter
+
+    def check_version!(version, expected_version)
+      raise "Unsupported version: #{version}" if version != expected_version
+    end
+
+    def check_currency!(currency, expected_currency)
+      raise "Unsupported currency: #{currency}" if currency != expected_currency
+    end
+
+    def not_matched(hsh)
+      uri = Addressable::URI.new
+      uri.query_values = hsh
+      uri.query
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'revenue', '*.rb')].each do |f|
+  require f
+end

data/lib/adtekio_adnetworks/postbacks.rb

@@ -0,0 +1,193 @@
+require 'uuidtools'
+require 'json'
+require 'digest/sha2'
+require 'digest/md5'
+require 'erubis'
+require 'active_support'
+require 'active_support/core_ext'
+
+module AdtekioAdnetworks
+  module Postbacks
+    extend self
+
+    PossibleEvents =  {
+      :mac => "Attribution",
+      :ist => "Application Install",
+      :apo => "Application Open",
+      :fun => "Tutorial",
+      :pay => "Payment",
+      :eor => "End of Round",
+      :scs => "Scene Start",
+      :scc => "Scene Complete",
+    }
+
+    def networks
+      @networks ||= {}
+    end
+
+    def register(postback_klz)
+      networks[postback_klz.network] = postback_klz
+    end
+  end
+
+  class BasePostbackClass
+    attr_reader :event, :params, :user, :netcfg
+
+    class CGIEruby < Erubis::PI::Eruby
+      REGEXP = Regexp.new("[^#{URI::PATTERN::UNRESERVED}]").freeze
+
+      def escaped_expr(code)
+        "URI.encode((#{code.strip}).to_s, CGIEruby::REGEXP)"
+      end
+    end
+
+    class MD5 < Digest::MD5
+      class << self
+        alias orig_new new
+        def new(str = nil)
+          str ? orig_new.update(str) : orig_new
+        end
+
+        def md5(*args)
+          new(*args)
+        end
+      end
+    end
+
+    def initialize(event, user, netcfg, params = nil)
+      @event  = event
+      @params = params || (event && event.params)
+      @user   = user
+      @netcfg = netcfg
+    end
+
+    def sha1(value)
+      Digest::SHA1.hexdigest(value || "")
+    end
+
+    def muidify(val)
+      Base64.encode64(MD5.md5(val).digest).tr("+/=", "-_\n").strip
+    end
+
+    def contains_eruby?(val)
+      val && !!(val =~ /@\{.*\}@/ || val =~ /<%.*%>/m)
+    end
+
+    def parse_string(str)
+      contains_eruby?(str) ? CGIEruby.new(str).result(binding) : str
+    end
+
+    def should_handle?(cfg)
+      cfg.check.nil? ||
+        !!(cfg.check.is_a?(Symbol) ? send(cfg.check) : eval(cfg.check))
+    end
+
+    def either_hash_or_symbol_to_string(val)
+      if val.is_a?(Hash)
+        uri = Addressable::URI.new
+        uri.query_values = val
+        CGI.unescape(uri.to_s).gsub(/^[?]/,'')
+      elsif val.is_a?(Symbol)
+        send(val)
+      else
+        val.to_s
+      end
+    end
+
+    def cfg_to_url(cfg)
+      return unless should_handle?(cfg)
+
+      header = either_hash_or_symbol_to_string(cfg.header)
+      body   = either_hash_or_symbol_to_string(cfg.post)
+
+      urlparams = ( (cfg.params.is_a?(Hash) && cfg.params) ||
+                    cfg.params.is_a?(Symbol) && send(cfg.params) ) || {}
+
+      uri = Addressable::URI.parse(cfg.url)
+      uri.query_values = urlparams unless urlparams.empty?
+      url = CGI.unescape(uri.to_s)
+
+      parsed_header = CGI::parse(parse_string(header) || "")
+      parsed_header.each { |key, value| parsed_header[key] = value.first }
+
+      { :url    => parse_string(url),
+        :body   => parse_string(body),
+        :header => parsed_header}
+    end
+  end
+
+  module BasePostbacks
+    def self.included(klz)
+      klz.class_eval do
+        def self.postbacks
+          @postbacks ||= Hash.new{ |k,v| k[v] = [] }
+        end
+
+        def self.pbcfg
+          @pbcfg ||= Hash.new{ |k,v| k[v] = Hash.new{ |k,v| k[v] = [] }}
+        end
+
+        def self.define_network_config(&block)
+          @network_config = yield
+          self.class_eval do
+            def self.netcfg
+              @network_config
+            end
+          end
+        end
+
+        def self.define_postback_for(platform, type, &block)
+          cfg = OpenStruct.new(yield)
+
+          postbacks[platform] << type.to_sym
+          pbcfg[platform][type.to_sym] << cfg
+
+          self.send(:define_method, type, Proc.new do |platform|
+                      pbc = self.class.instance_variable_get("@pbcfg")
+                      pbc[platform.to_sym][type.to_sym].map do |cfg|
+                        cfg_to_url(cfg)
+                      end.compact
+                    end)
+
+          self.class.send(:define_method, type, Proc.new do |platform|
+                            @pbcfg[platform.to_sym][type.to_sym].map do |cfg|
+                              cfg_to_description(cfg)
+                            end
+                          end)
+        end
+
+        def self.cfg_to_description(cfg)
+          url = if cfg.params.is_a?(Hash)
+            uri = Addressable::URI.parse(cfg.url)
+            uri.query_values = cfg.params unless cfg.params.empty?
+            CGI.unescape(uri.to_s)
+          else
+            "%s?%s" % [cfg.url, cfg.params.to_s]
+          end
+
+          { :url           => url,
+            :user_required => cfg.user_required || false,
+            :store_user    => cfg.store_user || false }
+        end
+
+        def self.user_required?(event, platform)
+          self.send(event, platform).any? { |desc| desc[:user_required] }
+        end
+
+        def self.store_user?(event, platform)
+          self.send(event, platform).any? { |desc| desc[:store_user] }
+        end
+
+        def self.network
+          name.to_s.sub(/^.+::([^:]+)$/,'\1').snakecase.to_sym
+        end
+      end
+
+      Postbacks.register(klz)
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'postbacks', '*.rb')].each do |f|
+  require f
+end