adapi 0.0.2 → 0.0.3

data/lib/adapi/campaign_target.rb

@@ -4,63 +4,66 @@ module Adapi
   #
   class CampaignTarget < Api
 
+    attr_accessor :campaign_id, :targets
+
+    validates_presence_of :campaign_id
+
+    # TODO validate if targets are in correct format
+
+    def attributes
+      super.merge( 'campaign_id' => campaign_id, 'targets' => targets )
+    end
+
     def initialize(params = {})
       params[:service_name] = :CampaignTargetService
-      super(params)
-    end
 
-    # FIXME params should be the same as in other services, for example ad_group 
-    # 
-    def self.create(params = {})
-      campaign_target_service = CampaignTarget.new
+      @xsi_type = 'CampaignTarget'
 
-      raise "No Campaign ID" unless params[:campaign_id]
-      campaign_id = params[:campaign_id].to_i
+      %w{ campaign_id targets }.each do |param_name|
+        self.send "#{param_name}=", params[param_name.to_sym]
+      end
 
+      super(params)
+    end
+
+    def set
       # transform our own high-level target parameters to google low-level
       # target parameters
       operations = []
 
-      params[:targets].each_pair do |targetting_type, targetting_settings|
+      @targets.each_pair do |targetting_type, targetting_settings|
         operations << { :operator => 'SET',
           :operand => {
             :xsi_type => "#{targetting_type.to_s.capitalize}TargetList",
-            :campaign_id => campaign_id,
-            :targets => self.create_targets(targetting_type, targetting_settings)
+            :campaign_id => @campaign_id,
+            :targets => CampaignTarget::create_targets(targetting_type, targetting_settings)
           }
         }
       end
 
-      response = campaign_target_service.service.mutate(operations)
+      response = self.mutate(operations)
 
-      targets = response[:value] || []
-      targets.each do |target|
-        puts "Campaign target of type #{target[:"@xsi:type"]} for campaign id " +
-          "#{target[:campaign_id]} was set."
-      end
-
-      targets
+      (response and response[:value]) ? true : false
     end
   
-    def self.find(params = {})
-      campaign_target_service = CampaignTarget.new
+    alias :create :set
+
+    # FIXME doesn't display everything, check the issues in google-adwords-api
+    #
+    def self.find(amount = :all, params = {})
+      params.symbolize_keys!
+      params = params[:conditions] if params[:conditions]
+      first_only = (amount.to_sym == :first)
 
-      selector = {} # select all campaign targets by default
-      selector[:campaign_ids] = params[:campaign_ids] if params[:campaign_ids]
+      raise ArgumentError, "Campaing ID is required" unless params[:campaign_id]
   
-      response = campaign_target_service.service.get(selector)
-
-      targets = nil
-      if response and response[:entries]
-        targets = response[:entries]
-        targets.each do |target|
-          p target
-        end
-      else
-        puts "No campaign targets found."
-      end
+      selector = { :campaign_ids => [ params[:campaign_id].to_i ] }
+  
+      response = CampaignTarget.new.service.get(selector)
 
-      targets
+      response = (response and response[:entries]) ? response[:entries] : []
+
+      first_only ? response.first : response
     end
 
     # transform our own high-level target parameters to google low-level
@@ -71,20 +74,65 @@ module Adapi
           target_data.map { |language| { :language_code => language } }       
           # example: ['cz','sk'] => [{:language_code => 'cz'}, {:language_code => 'sk'}]
         when :geo
-          geo_targets = []
-          target_data.each_pair do |geo_type, geo_values|
-            geo_values.each do |geo_value|
-              geo_targets << {
-                :xsi_type => "#{geo_type.to_s.capitalize}Target",
-                :excluded => false,
-                "#{geo_type}_code".to_sym => geo_value
-              }
+          target_data.map do |geo_type, geo_values|
+            case geo_type
+              when :proximity
+                radius_in_units, radius_units = parse_radius(geo_values[:radius])
+                long, lat = parse_geodata(geo_values[:geo_point])
+
+                {
+                  :xsi_type => "#{geo_type.to_s.capitalize}Target",
+                  :excluded => false,
+                  :radius_in_units => radius_in_units,
+                  :radius_distance_units => radius_units,
+                  :geo_point => {
+                    :longitude_in_micro_degrees => long,
+                    :latitude_in_micro_degrees => lat
+                  }
+                }
+
+              when :city
+                geo_values.merge(
+                  :xsi_type => "#{geo_type.to_s.capitalize}Target",
+                  :excluded => false
+                )
+
+              else # :country, :province
+                {
+                  :xsi_type => "#{geo_type.to_s.capitalize}Target",
+                  :excluded => false,
+                  "#{geo_type}_code".to_sym => geo_values
+                }
             end
           end
-          geo_targets
-        else nil
+        else nil 
       end
     end
 
+    def self.parse_radius(radius)
+      radius_in_units, radius_units = radius.split(' ', 2)
+      [
+        radius_in_units.to_i,
+        (radius_units == 'm') ? 'MILES' : 'KILOMETERS'
+      ]
+    end
+
+    # parse longitude and lattitude from string in this format:
+    # "longitude,lattitude" to [int,int] in Google microdegrees
+    # for example: "38.89859,-77.035971" -> [38898590, -77035971]
+    #
+    def self.parse_geodata(long_lat)
+      long_lat.split(',', 2).map { |x| to_microdegrees(x) }
+    end
+
+    # convert latitude or longitude data to microdegrees,
+    # a format with AdWords API accepts
+    #
+    # TODO alias :to_microdegrees :to_micro_units
+    #
+    def self.to_microdegrees(x)
+      Api.to_micro_units(x)
+    end
+
   end
 end

data/lib/adapi/config.rb

@@ -18,9 +18,15 @@ module Adapi
       @data ||= self.settings[:default]
     end
 
-    # TODO described in README, but should be documented here as well
+    # account_alias - alias of an account set in settings
+    # authentication_params - ...which we want to override
     #
-    def self.set(params = {})
+    def self.set(account_alias = :default, authentication_params = {})
+      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
@@ -28,6 +34,7 @@ module Adapi
       elsif params.is_a?(Symbol)
         @data = @settings[params]
       end
+=end
     end
 
     # params:
@@ -37,6 +44,13 @@ module Adapi
     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
+      end
 
       adapi_path = File.join(params[:path], params[:filename])
       adwords_api_path = File.join(ENV['HOME'], 'adwords_api.yml')

data/lib/adapi/keyword.rb

@@ -0,0 +1,109 @@
+module Adapi
+  class Keyword < AdGroupCriterion
+
+    attr_accessor :keywords
+
+    def attributes
+      super.merge('keywords' => keywords)
+    end
+
+    def initialize(params = {})
+      params[:service_name] = :AdGroupCriterionService
+
+      @xsi_type = 'AdGroupCriterion'
+
+      %w{ keywords }.each do |param_name|
+        self.send "#{param_name}=", params[param_name.to_sym]
+      end
+
+      self.keywords ||= []
+      self.keywords.map! { |k| Keyword.keyword_attributes(k) }
+
+      super(params)
+    end
+
+    # TODO include formatting in create method
+    #
+    def self.keyword_attributes(keyword)
+      # detect match type
+      match_type = case keyword[0]
+        when '"'
+          keyword = keyword.slice(1, (keyword.size - 2))
+          'PHRASE'
+        when '['
+          keyword = keyword.slice(1, (keyword.size - 2))
+          'EXACT'
+        else
+          'BROAD'
+      end
+
+      # detect if keyword is negative
+      negative = if (keyword =~ /^\-/)
+        keyword.slice!(0, 1)
+        true
+      else
+        false
+      end
+
+      { :text => keyword, :match_type => match_type, :negative => negative }
+    end
+
+    def create
+      operations = @keywords.map do |keyword|
+        {
+          :operator => 'ADD', 
+          :operand => {
+            :xsi_type => (keyword[:negative] ? 'NegativeAdGroupCriterion' : 'BiddableAdGroupCriterion'),
+            :ad_group_id => @ad_group_id,
+            :criterion => {
+              :xsi_type => 'Keyword',
+              :text => keyword[:text],
+              :match_type => keyword[:match_type]
+            }
+          }
+        }
+      end
+
+      response = self.mutate(operations)
+
+      return false unless (response and response[:value])
+      
+      self.keywords = response[:value].map { |keyword| keyword[:criterion] }
+
+      true
+    end
+
+    def self.find(amount = :all, params = {})
+      params.symbolize_keys!
+      # this has no effect, it's here just to have the same interface everywhere
+      first_only = (amount.to_sym == :first)
+
+      # 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|
+        if params[param_name]
+          {:field => param_name.to_s.camelcase, :operator => 'EQUALS', :values => params[param_name] }
+        end
+      end.compact
+
+      # Get all the criteria for this ad group.
+      selector = {
+        :fields => ['Id', 'Text'],
+        :ordering => [{ :field => 'AdGroupId', :sort_order => 'ASCENDING' }],
+        :predicates => predicates
+      }
+
+      response = Keyword.new.service.get(selector)
+
+      response = (response and response[:entries]) ? response[:entries] : []
+
+      Keyword.new(
+        :ad_group_id => params[:ad_group_id],
+        :keywords => response.map { |keyword| keyword[:criterion] }
+      )
+    end
+
+  end
+end

data/lib/adapi/version.rb

@@ -1,7 +1,18 @@
 module Adapi
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 
   # CHANGELOG:
+  #
+  # 0.0.3
+  # converted to ActiveModel
+  # moved common functionality to Api class
+  # changed http client to curb and hotfix ssl authentication bug in HTTPI
+  # added basic error handling
+  # changed DSL for Campaign attributes
+  # changed Ad model to general Ad model and moved TextAd to separate model
+  # added support for more target types and changed DSL for CampaignTarget
+  # converted to Ruby 1.9.2 (should work in Ruby 1.8.7 as well)
+  #
   # 0.0.2
   # [FIX] switched google gem dependencies from edge to stable release
 end

data/lib/httpi_request_monkeypatch.rb

@@ -0,0 +1,35 @@
+
+# manually hardcode timeouts for HTTPI to 5 minutes (300 seconds)
+# HOTFIX there's no way how to do it properly through HTTPI
+
+module HTTPI
+  class Request
+    def open_timeout
+      300
+    end
+
+    def read_timeout
+      300
+    end
+  end
+end
+
+# disable ssl authentication in curb
+# HOTFIX for bug in HTTPI
+
+module HTTPI
+  module Adapter
+    class Curb
+
+    private
+
+      def setup_client(request)
+        basic_setup request
+        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?
+      end
+      
+    end
+  end
+end

data/test/factories/ad_group_factory.rb

@@ -0,0 +1,20 @@
+
+Factory.define :ad_group, :class => Adapi::AdGroup do |f|
+  f.sequence(:campaign_id)    { |n| n }
+  f.name                      "AdGroup %d" % (Time.new.to_f * 1000).to_i
+  f.status                    'ENABLED'
+  # f.bids                    {}
+  f.keywords                  [ 'dem codez', '"top coder"', '[-code]' ]
+end
+
+=begin
+ad_group_data = {
+  :bids => {
+    :xsi_type => 'ManualCPCAdGroupBids',
+    :keyword_max_cpc => {
+      :amount => {
+        :micro_amount => 10000000
+      }
+    }
+  },
+=end

data/test/factories/ad_text_factory.rb

@@ -0,0 +1,9 @@
+
+Factory.define :text_ad, :class => Adapi::Ad::TextAd do |f|
+  f.sequence(:ad_group_id)    { |n| n }
+  f.headline                  'Code like Neo'
+  f.description1              'Need mad coding skills?'
+  f.description2              'Check out my new blog!'
+  f.url                       'http://www.demcodez.com'
+  f.display_url               'http://www.demcodez.com'  
+end

data/test/test_helper.rb

@@ -8,13 +8,13 @@ require 'factory_girl'
 
 # always test the latest version of the gem
 # TODO make it an option only through ENV variable switch
-require 'lib/adapi'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'adapi')
 
 # load factories
-Dir[ File.join(File.dirname(__FILE__), 'factories/*.rb') ].each { |f| require f }
+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/ad_text_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+module Adapi
+  class TextAdTest < Test::Unit::TestCase
+    include ActiveModel::Lint::Tests
+
+    def setup
+      @model = Ad::TextAd.new
+    end
+
+    context "valid new TextAd instance" do
+      setup do
+        @text_ad = Factory.build(:text_ad)
+      end
+
+      should "be valid" do
+        assert @text_ad.valid?
+      end
+
+      context " / data method" do
+        should "return TextAd params in hash" do
+          assert @text_ad.data.is_a?(Hash)
+          assert_equal @text_ad.headline, @text_ad.data[:headline]
+        end
+      end
+
+    end
+
+  end
+end