adapi 0.0.4 → 0.0.5

data/lib/adapi/config.rb

@@ -1,15 +1,27 @@
 # encoding: utf-8
 
-# PS: what about this config setting?
-# Campaign.create(:data => campaign_data, :account => :my_account_alias)
+# This class hold configuration data for AdWords API
+
+# TODO enable this way of using configuration
+# Adapi::Campaign.create(:data => campaign_data, :account => :my_account_alias)
 
 module Adapi
   class Config
+    class << self
+      attr_accessor :dir, :filename
+    end
+
+    self.dir = ENV['HOME']
+    self.filename = 'adapi.yml'
 
     # display hash of all account settings
     #
-    def self.settings
-      @settings ||= self.load_settings
+    def self.settings(reload = false)
+      if reload
+        @settings = self.load_settings
+      else
+        @settings ||= self.load_settings
+      end
     end
 
     # display actual account settings
@@ -26,44 +38,37 @@ module Adapi
       custom_settings = @settings[account_alias.to_sym]
       custom_settings[:authentication] = custom_settings[:authentication].merge(authentication_params)
       @data = custom_settings
-
-=begin original method, to be merged into the new one
-      # hash of params - default
-      if params.is_a?(Hash)
-        @data = params
-      # set alias from adapi.yml
-      elsif params.is_a?(Symbol)
-        @data = @settings[params]
-      end
-=end
     end
 
+    # Loads adapi configuration from given hash or from external configuration
+    # file
+    #
     # params:
-    # * path - default: user's home directory
-    # * filename - default: adapi.yml
-    # TODO: set to HOME/adwords_api as default
+    # * dir (default: HOME)
+    # * filename (default: adapi.yml)
+    # * in_hash - hash to use instead of external configuration
+    #
     def self.load_settings(params = {})
-      params[:path] ||= ENV['HOME']
-      params[:filename] ||= 'adapi.yml'
-      params[:in_hash] ||= nil
-
-      # HOTFIX enable load by hash
       if params[:in_hash]
-        @settings = params[:in_hash]
-        return @settings
+        return @settings = params[:in_hash]
       end
 
-      adapi_path = File.join(params[:path], params[:filename])
-      adwords_api_path = File.join(ENV['HOME'], 'adwords_api.yml')
+      # load external config file (defaults to ~/adapi.yml)
+      self.dir = params[:dir] if params[:dir]
+      self.filename = params[:filename] if params[:filename]
+      path = (self.dir.present? ? File.join(self.dir, self.filename) : self.filename)
 
-      if File.exists?(adapi_path)
-        @settings = YAML::load(File.read(adapi_path)) rescue {}
-      elsif File.exists?(adwords_api_path)
-        @settings = { :default => YAML::load(File.read(adwords_api_path)) } rescue {}
+      if File.exists?(path)
+        @settings = YAML::load(File.read(path)) rescue {}
+        @settings.symbolize_keys!
+
+        # is it an adwords_api config-file?
+        if @settings.present? && @settings[:authentication].present?
+          @settings = {:default => @settings}
+        end
       end
 
       @settings
     end
-
   end
 end

data/lib/adapi/constant_data.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Adapi
+  class ConstantData < Api
+
+    def initialize(params = {})
+      params[:service_name] = :ConstantDataService
+
+      super(params)
+    end
+
+  end
+end

data/lib/adapi/constant_data/language.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Adapi
+  class ConstantData::Language < ConstantData
+
+    LANGUAGE_IDS = { :en => 1000, :de => 1001, :fr => 1002, :es => 1003,
+      :it => 1004, :ja => 1005, :da => 1009, :nl => 1010, :fi => 1011, :ko => 1012,
+      :no => 1013, :pt => 1014, :sv => 1015, :zh_CN => 1017, :zh_TW => 1018,
+      :ar => 1019, :bg => 1020, :cs => 1021, :el => 1022, :hi => 1023, :hu => 1024,
+      :id => 1025, :is => 1026, :iw => 1027, :lv => 1028, :lt => 1029, :pl => 1030,
+      :ru => 1031, :ro => 1032, :sk => 1033, :sl => 1034, :sr => 1035, :uk => 1036,
+      :tr => 1037, :ca => 1038, :hr => 1039, :vi => 1040, :ur => 1041, :tl => 1042,
+      :et => 1043, :th => 1044
+    }
+
+    attr_accessor :id, :code
+
+    def initialize(params = {})
+      @id = params[:id]
+      @code = params[:code]
+
+      super(params)
+    end
+
+    # Returns AdWords API language id based for language code
+    #
+    def self.find(code)
+      
+      # let's also allow searching by id
+      if code.is_a?(Integer)
+        Language.new(
+          :id => code,
+          :code => LANGUAGE_IDS.find { |k,v| v == code }.first
+        )
+
+      else
+        Language.new(
+          :id => LANGUAGE_IDS[code.to_sym.downcase],
+          :code => code.to_sym.downcase
+        )
+      end
+    end
+
+  end
+end

data/lib/adapi/keyword.rb

@@ -65,6 +65,7 @@ module Adapi
       { :text => keyword, :match_type => match_type, :negative => negative }
     end
 
+
     def create
       operations = @keywords.map do |keyword|
         {
@@ -100,8 +101,13 @@ module Adapi
       # we need ad_group_id
       raise ArgumentError, "AdGroup ID is required" unless params[:ad_group_id]
  
-      # supported condition parameters: ad_group_id and id
-      predicates = [ :ad_group_id ].map do |param_name|
+      # basic predicates for searching keywords - both are required
+      predicates = [
+        { :field => 'CriteriaType', :operator => 'EQUALS', :values => [ 'KEYWORD' ] },
+        { :field => 'AdGroupId', :operator => 'EQUALS', :values => [ params[:ad_group_id] ] }
+      ]
+      # supported parameters: id
+      predicates += [ :id ].map do |param_name|
         if params[param_name]
           {:field => param_name.to_s.camelcase, :operator => 'EQUALS', :values => params[param_name] }
         end
@@ -109,9 +115,13 @@ module Adapi
 
       # Get all the criteria for this ad group.
       selector = {
-        :fields => ['Id', 'Text'],
+        :fields => ['Id', 'CriteriaType', 'KeywordText'],
         :ordering => [{ :field => 'AdGroupId', :sort_order => 'ASCENDING' }],
-        :predicates => predicates
+        :predicates => predicates,
+        :paging => {
+          :start_index => 0,
+          :number_results => 10
+        }
       }
 
       response = Keyword.new.service.get(selector)
@@ -173,4 +183,4 @@ module Adapi
     end
 
   end
-end
+end

data/lib/adapi/location.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+# TODO map results of find to location object
+
+module Adapi
+  class Location < Api
+
+    # display types. region was formerly called province, and province is still
+    # supported as parameter, a synonym for region
+    LOCATIONS_HIERARCHY = [ :city, :region, :country ]
+
+    def initialize(params = {})
+      params[:service_name] = :LocationCriterionService
+      
+      @xsi_type = 'LocationCriterion'
+
+      super(params)
+    end
+
+    # Example:
+    # Location.find(:city => 'Prague')
+    # Location.find(:country => 'CZ', :city => 'Prague')
+    # Location.find(:country => 'CZ', :region => 'Prague' :city => 'Prague')
+    #
+    # TODO add legacy aliases: :city_name, :province_code, :country_code
+    #
+    def self.find(amount = :all, params = {})
+      # set amount = :first by default
+      if amount.is_a?(Hash) and params.empty?
+        params = amount.clone
+        amount = :first
+      end
+
+      params.symbolize_keys!
+      first_only = (amount.to_sym == :first)
+      # in which language to retrieve locations
+      params[:locale] ||= 'en'
+      # support for legacy parameter
+      if params[:province] and not params[:region]
+        params[:region] = params[:province]
+      end
+
+      # determine by what criteria to search
+      location_type, location_name = nil, nil
+      LOCATIONS_HIERARCHY.each do |param_name|
+        if params[param_name]
+          # FIXME use correct helper instead of humanize HOTFIX
+          location_type, location_name = param_name.to_s.humanize, params[param_name]
+          break
+        end
+      end
+      
+      raise "Invalid params" unless location_name
+      
+      selector = {
+        :fields => ['Id', 'LocationName', 'CanonicalName', 'DisplayType', 'ParentLocations', 'Reach'],
+        :predicates => [
+            # PS: for searching more locations at once, switch to IN operator
+            # values array for EQUALS can contain only one value (sic!)
+            { :field => 'LocationName', :operator => 'EQUALS', :values => [ location_name ] },
+            { :field => 'Locale', :operator => 'EQUALS', :values => [ params[:locale] ] }
+        ]
+      }
+
+      # returns array of locations. and now the fun begins    
+      locations = Location.new.service.get(selector)
+      
+      # now we have to find location with correct display_type and TODO hierarchy
+      # problematic example: Prague is both city and province (region)
+      
+      location = nil 
+      locations.each do |entry|
+        if entry[:location][:display_type] == location_type
+          location = entry[:location]
+          break
+        end
+      end
+      
+      # FIXME for now, omit hierarchy as check just display type. results will be in 99,5% the same
+
+      location
+    end
+
+    # Displays location tree - location with its parents
+    # 
+    def self.location_tree(location = {})
+      "TODO"
+    end
+
+  end
+end

data/lib/adapi/version.rb

@@ -1,10 +1,17 @@
 # encoding: utf-8
 
 module Adapi
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 
   # CHANGELOG:
   #
+  # 0.0.5
+  # converted to AdWords API version v201109
+  #   moved from CampaignTarget to CampaignCriterion
+  #   implemented Location and Language finders
+  # started writing integration tests
+  # added logging of SOAP requests
+  #
   # 0.0.4
   # changed README to markdown format
   # updated DSL for creating campaign and campaign target

data/lib/httpi_request_monkeypatch.rb

@@ -29,6 +29,10 @@ module HTTPI
         setup_http_auth request if request.auth.http?
         # setup_ssl_auth request.auth.ssl if request.auth.ssl?
         # setup_ntlm_auth request if request.auth.ntlm?
+
+        # HOTFIX for bug in curb 0.7.16, see issue:
+        # https://github.com/taf2/curb/issues/96
+        client.resolve_mode = :ipv4
       end
       
     end

data/test/config/adapi.yml.template

@@ -0,0 +1,21 @@
+:default:
+  :authentication:
+    :method: ClientLogin
+    :email: adapi_yml@example.com
+    :password: default_password
+    :developer_token: default_token
+    :client_customer_id: 555-666-7777
+    :user_agent: My Adwords API Client
+  :service:
+    :environment: PRODUCTION
+
+:sandbox:
+  :authentication:
+    :method: ClientLogin
+    :email: sandbox_email@example.com
+    :password: sandbox_password
+    :developer_token: sandbox_token
+    :client_customer_id: 555-666-7777
+    :user_agent: Adwords API Test
+  :service:
+    :environment: SANDBOX

data/test/config/adwords_api.yml.template

@@ -0,0 +1,10 @@
+:authentication:
+  :method: ClientLogin
+  :email: adwords_api_yml@example.com
+  :password: default_password
+  :developer_token: default_token
+  :client_customer_id: 555-666-7777
+  :user_agent: My Adwords API Client
+:service:
+  :environment: PRODUCTION
+

data/test/integration/create_campaign_test.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'test_helper'
+
+module Adapi
+  class CreateCampaignTest < Test::Unit::TestCase
+    context "non-existent Campaign" do
+      should "not be found" do
+        # FIXME randomly generated id, but it might actually exist        
+        assert_nil Adapi::Campaign.find(Time.new.to_i)
+      end
+    end
+
+    context "existing Campaign" do
+      setup do 
+        @campaign_data = {
+          :name => "Campaign #%d" % (Time.new.to_f * 1000).to_i,
+          :status => 'PAUSED',
+          :bidding_strategy => { :xsi_type => 'BudgetOptimizer', :bid_ceiling => 55 },
+          :budget => 50,      
+          :network_setting => {
+            :target_google_search => true,
+            :target_search_network => true,
+            :target_content_network => false,
+            :target_content_contextual => false
+          }
+        }
+        
+        c = Adapi::Campaign.create(@campaign_data)
+        
+        @campaign = Adapi::Campaign.find(c.id)
+      end
+
+      # this basically tests creating bare campaign
+      should "be found" do
+        assert_not_nil @campaign
+
+        assert_equal @campaign_data[:status], @campaign.status
+        assert_equal @campaign_data[:name], @campaign.name
+      end      
+
+      should "still be found after deletion" do
+        @campaign.delete
+
+        deleted_campaign = Adapi::Campaign.find(@campaign.id)
+
+        assert_equal "DELETED", deleted_campaign.status
+        assert_equal @campaign_data[:name], deleted_campaign.name
+      end      
+
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+# FIXME for some reason, tests don't return errors, only quietly fail
+
 require 'rubygems'
 gem 'minitest'
 require 'test/unit'
@@ -16,8 +18,5 @@ require File.join(File.dirname(__FILE__), '..', 'lib', 'adapi')
 Dir[ File.join(File.dirname(__FILE__), 'factories', '*.rb') ].each { |f| require f }
 
 class Test::Unit::TestCase
-  
   FakeWeb.allow_net_connect = false
-
-
 end

data/test/unit/ad_group_test.rb

@@ -4,7 +4,7 @@ require 'test_helper'
 
 module Adapi
   class AdGroupTest < Test::Unit::TestCase
-    include ActiveModel::Lint::Tests
+    # include ActiveModel::Lint::Tests
 
     def setup
       @model = AdGroup.new
@@ -20,13 +20,12 @@ module Adapi
       end
 
       should "parse :bids correctly" do
-        # FIXME factory doesn't work in this case for some reason
-        ag = AdGroup.new( :bids => { :xsi_type => 'ManualCPCAdGroupBids', :keyword_max_cpc => 10 } )
+        ag = AdGroup.new( :bids => { :xsi_type => 'ManualCPCAdGroupBids', :proxy_keyword_max_cpc => 10 } )
 
         assert_equal ag.bids,
         {
           :xsi_type => 'ManualCPCAdGroupBids',
-          :keyword_max_cpc => { :amount => { :micro_amount => 10000000 } }
+          :proxy_keyword_max_cpc => { :amount => { :micro_amount => 10000000 } }
         }
       end