adapi 0.0.2 → 0.0.3

data/examples/log_to_specific_account.rb

@@ -1,20 +1,33 @@
 
 require 'adapi'
 
-# use specific config data
-Adapi::Config.set({
-  :authentication => {
-    :method => 'ClientLogin',
-    :email => 'sandbox_email@gmail.com',
-    :password => 'sandbox_password',
-    :developer_token => 'sandbox_developer_token',
-    :client_email => 'sandbox_client_email@gmail.com',
-    :user_agent => 'Adwords API Test'
+Adapi::Config.load_settings(:in_hash => {
+  :coca_cola => {
+    :authentication => {
+      :method => 'ClientLogin',
+      :email => 'coca_cola_email@gmail.com',
+      :password => 'coca_cola_password',
+      :developer_token => 'coca_cola_developer_token',
+      :user_agent => 'Coca-Cola Adwords API Test'
+    },
+    :service => {
+      :environment => 'SANDBOX'
+    }
   },
-  :service => {
-    :environment => 'SANDBOX'
+ :pepsi => {
+    :authentication => {
+      :method => 'ClientLogin',
+      :email => 'pepsi_email@gmail.com',
+      :password => 'pepsi_password',
+      :developer_token => 'pepsi_developer_token',
+      :user_agent => 'Pepsi Adwords API Test'
+    },
+    :service => {
+      :environment => 'SANDBOX'
+    }
   }
 })
 
-# create campaign
-require 'add_bare_campaign'
+Adapi::Config.set(:pepsi, :client_customer_id => '555-666-7777')
+
+p Adapi::Config.read

data/examples/rollback_campaign.rb

@@ -0,0 +1,56 @@
+
+require 'adapi'
+
+# create campaign by single command, with campaing targets, with ad_groups
+# including keywords and ads
+
+campaign_data = {
+  :name => "Campaign #%d" % (Time.new.to_f * 1000).to_i,
+  :status => 'PAUSED',
+  # Automatic CPC: BudgetOptimizer or ManualCPC
+  :bidding_strategy => { :xsi_type => 'BudgetOptimizer', :bid_ceiling => 100 },
+  :budget => { :amount => 50, :delivery_method => 'STANDARD' },
+
+  :network_setting => {
+    :target_google_search => true,
+    :target_search_network => true,
+    :target_content_network => false,
+    :target_content_contextual => false
+  },
+
+  :targets => {
+    :language => [ 'en', 'cs' ],
+    # TODO test together with city target
+    :geo => { :proximity => { :geo_point => '38.89859,-77.035971', :radius => '10 km' } }
+  },
+
+  :ad_groups => [
+    {
+      :name => "AdGroup #%d" % (Time.new.to_f * 1000).to_i,
+      :status => 'ENABLED',
+
+      :keywords => [ 'dem codez', '"top coder"', "[-code]" ],
+
+      :ads => [
+        {
+          :headline => "Code like Neo",
+          :description1 => 'Need mad coding skills?',
+          :description2 => 'Check out my new blog!',
+          :url => '', # THIS FAILS
+          :display_url => 'http://www.demcodez.com'
+        }
+      ]
+    }
+  ]
+
+}
+ 
+$campaign = Adapi::Campaign.create(campaign_data)
+
+p "Campaign ID #{$campaign.id} created"
+p "with status DELETED and changed name"
+pp $campaign.attributes
+
+p "with errors:"
+pp $campaign.errors.to_a
+

data/examples/update_campaign.rb

@@ -1,23 +1,22 @@
-
 require 'adapi'
 
 # create campaign
-require 'add_bare_campaign'
-
-p 'original status: %s' % $campaign[:status]
-
-campaign_updates = {
-  :id => $campaign[:id],
-  :status => 'ACTIVE'
-}
-
-$campaign = Adapi::Campaign.update(:data => campaign_updates)
+require File.join(File.dirname(__FILE__), 'add_bare_campaign')
 
-p 'updated status: %s' % $campaign[:status]
+p "ORIGINAL CAMPAIGN:"
+pp $campaign.attributes
 
-$campaign = Adapi::Campaign.update(
+$updated_campaign = Adapi::Campaign.update(
   :id => $campaign[:id],
-  :data => {:status => 'DELETED'}
+  :status => 'ACTIVE',
+  :name => "UPDATED_#{$campaign[:name]}",
+  :network_setting => {
+    :target_google_search => false,
+    :target_search_network => false,
+    :target_content_network => true,
+    :target_content_contextual => true
+  }
 )
 
-p 'updated status (again): %s' % $campaign[:status]
+p "UPDATED CAMPAIGN:"
+pp $updated_campaign.attributes

data/examples/update_campaign_status.rb

@@ -2,14 +2,14 @@
 require 'adapi'
 
 # create campaign
-require 'add_bare_campaign'
+require File.join(File.dirname(__FILE__), 'add_bare_campaign')
 
-p 'original status: %s' % $campaign[:status]
+p "ORIGINAL STATUS: %s" % $campaign.status
 
-$campaign = Adapi::Campaign.activate(:id => $campaign[:id])
+$campaign.activate
 
-p 'updated status: %s' % $campaign[:status]
+p "STATUS UPDATE 1: %s" % $campaign.status
 
-$campaign = Adapi::Campaign.delete(:id => $campaign[:id])
+$campaign.delete
 
-p 'updated status (again): %s' % $campaign[:status]
+p "STATUS UPDATE 2: %s" % $campaign.status

data/lib/adapi.rb

@@ -3,15 +3,33 @@ require 'rubygems'
 require 'adwords_api'
 require 'collection'
 require 'yaml'
+require 'pp'
 
+require 'active_model'
+# require only ActiveSupport parts that we actually use
+require 'active_support/all'
+
+require 'adapi/version'
 require 'adapi/config'
 require 'adapi/api'
 require 'adapi/campaign'
 require 'adapi/campaign_target'
 require 'adapi/ad_group'
 require 'adapi/ad_group_criterion'
+require 'adapi/keyword'
 require 'adapi/ad'
-require 'adapi/version'
+require 'adapi/ad/text_ad'
+
+# monkeypatch HTTPI
+require 'httpi_request_monkeypatch'
+
+HTTPI.adapter = :curb
+# supress HTTPI output
+# HTTPI.log = false
+
+# load factories for development environment
+# require 'factory_girl'
+# Dir[ File.join(File.dirname(__FILE__), '../test/factories/*.rb') ].each { |f| require f }
 
 module Adapi
   API_VERSION = :v201101  

data/lib/adapi/ad.rb

@@ -1,63 +1,76 @@
 module Adapi
 
-  # TODO add synonym for actual service name: AdGroupAd
-  #
+  # Ad == AdGroupAd
+  # wraps all types of ads: text ads, image ads...
   class Ad < Api
 
-    def initialize(params = {})
-      params[:service_name] = :AdGroupAdService
-      super(params)
-    end
+    attr_accessor :ad_group_id, :url, :display_url, :approval_status,
+      :disapproval_reasons, :trademark_disapproved
 
-    def self.create(params = {})
-      ad_service = Ad.new
+    validates_presence_of :ad_group_id
 
-      ad_group_id = params[:data].delete(:ad_group_id)
-
-      operation = { :operator => 'ADD', 
-        :operand => { :ad_group_id => ad_group_id, :ad => params[:data] }
-      } 
-    
-      response = ad_service.service.mutate([operation])
+    # PS: create won't work with id and ad_group_id
+    # 'id' => id, 'ad_group_id' => ad_group_id, 
+    def attributes
+      super.merge('url' => url, 'display_url' => display_url)
+    end
 
-      ad_group = response[:value].first
+    def initialize(params = {})
+      params[:service_name] = :AdGroupAdService
 
-      ad = nil
-      if response and response[:value]
-        ad = response[:value].first
-        puts "  Ad ID is #{ad[:ad][:id]}, type is '#{ad[:ad][:xsi_type]}' and status is '#{ad[:status]}'."
+      %w{ id ad_group_id url display_url status }.each do |param_name|
+        self.send "#{param_name}=", params[param_name.to_sym]
       end
 
-      ad
+      super(params)
     end
 
-    def self.find(params = {})
-      ad_service = Ad.new
+    # deletes ad
+    #
+    def destroy
+      response = self.mutate(
+        :operator => 'REMOVE',
+        :operand => {
+          :ad_group_id => self.ad_group_id,
+          :ad => { :id => self.id, :xsi_type => 'Ad' }
+        }
+      )
 
-      raise "No AdGroup ID" unless params[:ad_group_id]
-      ad_group_id = params[:ad_group_id].to_i
+      (response and response[:value]) ? true : false
+    end
 
-      selector = {
-        :fields => ['Id', 'Headline'],
-        :ordering => [{:field => 'Id', :sort_order => 'ASCENDING'}],
-        :predicates => [
-          {:field => 'AdGroupId', :operator => 'EQUALS', :values => ad_group_id }
-          # { :field => 'Status', :operator => 'IN', :values => ['ENABLED', 'PAUSED', 'DISABLED'] }
-        ]
-      }
 
-      response = ad_service.service.get(selector)
+    # ad-specific mutate wrapper, deals with PolicyViolations for ads
+    #
+    def mutate(operation)
+      operation = [operation] unless operation.is_a?(Array)
+      
+      # fix to save space during specifyng operations
+      operation = operation.map do |op|
+        op[:operand].delete(:status) if op[:operand][:status].nil?
+        op
+      end
+      
+      begin    
+        response = @service.mutate(operation)
+    
+      rescue AdsCommon::Errors::HttpError => e
+        self.errors.add(:base, e.message)
 
-      if response and response[:entries]
-        ads = response[:entries]
-        puts "Ad group ##{ad_group_id} has #{ads.length} ad(s)."
-        ads.each do |ad|
-          puts "  Ad id is #{ad[:ad][:id]}, type is #{ad[:ad][:xsi_type]} and " +
-              "status is \"#{ad[:status]}\"."
+      # traps any exceptions raised by AdWords API
+      rescue AdwordsApi::Errors::ApiException => e
+        # return PolicyViolations so they can be sent again
+        e.errors.each do |error|
+          if (error[:api_error_type] == 'PolicyViolationError') && error[:is_exemptable]
+            self.errors.add(error[:api_error_type], error[:key])
+          else 
+            # otherwise, just report the errors
+            self.errors.add( "[#{self.xsi_type.underscore}]", "#{error[:error_string]} @ #{error[:field_path]}")
+          end
         end
-      else
-        puts "No ads found for ad group ##{ad_group_id}."
       end
+      
+      response
     end
 
   end

data/lib/adapi/ad/text_ad.rb

@@ -0,0 +1,126 @@
+module Adapi
+  # Ad::TextAd == AdGroupAd::TextAd
+  #
+  # http://code.google.com/apis/adwords/docs/reference/latest/AdGroupAdService.TextAd.html
+  #
+  class Ad::TextAd < Ad
+
+    attr_accessor :headline, :description1, :description2
+
+    def attributes
+      super.merge('headline' => headline, 'description1' => description1, 'description2' => description2)
+    end
+
+    def initialize(params = {})
+      params[:service_name] = :AdGroupAdService
+
+      @xsi_type = 'TextAd'
+
+      %w{ headline description1 description2 }.each do |param_name|
+        self.send "#{param_name}=", params[param_name.to_sym]
+      end
+
+      super(params)
+    end
+
+    def save
+      self.new? ? self.create : self.update
+    end
+ 
+    def create
+      operation = {
+        :operator => 'ADD',
+        :operand => {
+          :ad_group_id => @ad_group_id,
+          :status => @status,
+          :ad => self.data
+        }
+      }
+
+      response = self.mutate(operation)
+ 
+      # check for PolicyViolationError(s)
+      # PS: check google-adwords-api/examples/handle_policy_violation_error.rb
+      if (self.errors['PolicyViolationError'].size > 0)
+        # set exemptions and try again
+        operation[:exemption_requests] = errors['PolicyViolationError'].map do |error|
+          { :key => error }
+        end
+
+        self.errors.clear
+
+        response = self.mutate(operation)  
+      end
+
+      return false unless (response and response[:value])
+  
+      self.id = response[:value].first[:ad][:id] rescue nil
+  
+      true
+    end
+
+    # params - specify hash of params and values to update
+    # PS: I think it's possible to edit only status, but not headline,
+    # descriptions... instead you should delete existing ad and create a new one
+    #
+    def update(params = {})
+      # set params (:status param makes it a little complicated)
+      #
+      updated_params = (params || self.attributes).symbolize_keys
+      updated_status = updated_params.delete(:status)
+      
+      response = self.mutate(
+        :operator => 'SET', 
+        :operand => {
+          :ad_group_id => self.ad_group_id,
+          :ad => updated_params.merge(:id => self.id),
+          :status => updated_status
+        }
+      )
+
+      (response and response[:value]) ? true : false
+    end
+
+    def find # == refresh
+      TextAd.find(:first, :ad_group_id => self.ad_group_id, :id => self.id)
+    end
+
+    def self.find(amount = :all, params = {})
+      params.symbolize_keys!
+      first_only = (amount.to_sym == :first)
+
+      # for ActiveRecord compatibility, we don't use anything besides conditions
+      # params for now
+      params = params[:conditions] if params[:conditions]
+
+      # 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, :id ].map do |param_name|
+        if params[param_name]
+          {:field => param_name.to_s.camelcase, :operator => 'EQUALS', :values => params[param_name] }
+        end
+      end.compact
+
+      selector = {
+        :fields => ['Id', 'Headline'],
+        :ordering => [{:field => 'Id', :sort_order => 'ASCENDING'}],
+        :predicates => predicates
+      }
+
+      response = TextAd.new.service.get(selector)
+
+      response = (response and response[:entries]) ? response[:entries] : []
+
+      response.map! do |data|
+        TextAd.new(data[:ad].merge(:ad_group_id => data[:ad_group_id], :status => data[:status]))
+      end
+
+      # TODO convert to TextAd instances
+      # PS: we already have ad_group_id parameter
+      first_only ? response.first : response
+    end
+
+  end
+end

data/lib/adapi/ad_group.rb

@@ -1,69 +1,107 @@
 module Adapi
   class AdGroup < Api
+  
+    attr_accessor :campaign_id, :name, :bids, :keywords, :ads
+
+    validates_presence_of :campaign_id, :name, :status
+    validates_inclusion_of :status, :in => %w{ ENABLED PAUSED DELETED }
+
+    def attributes
+      super.merge('campaign_id' => campaign_id, 'name' => name, 'bids' => bids)
+    end
 
     def initialize(params = {})
       params[:service_name] = :AdGroupService
-      super(params)
-    end
 
-    def self.create(params = {})
-      ad_group_service = AdGroup.new
+      @xsi_type = 'AdGroup'
 
-      criteria = params[:data].delete(:criteria)
-      ads = params[:data].delete(:ads) || []
+      %w{ campaign_id name status bids keywords ads }.each do |param_name|
+        self.send "#{param_name}=", params[param_name.to_sym]
+      end
 
-      # prepare for adding campaign
-      operation = { :operator => 'ADD', :operand => params[:data] }
-    
-      response = ad_group_service.service.mutate([operation])
+      @keywords ||= []
+      @ads ||= []
 
-      ad_group = response[:value].first
+      super(params)
+    end
+
+    def create
+      return false unless self.valid?
+      
+      operand = Hash[
+        [:campaign_id, :name, :status, :bids].map do |k|
+          [ k.to_sym, self.send(k) ] if self.send(k)
+        end.compact
+      ]
 
-      if criteria
-        Adapi::AdGroupCriterion.create(
-          :ad_group_id => ad_group[:id],
-          :criteria => criteria
+      response = self.mutate(
+        :operator => 'ADD', 
+        :operand => operand
+      )
+
+      return false unless (response and response[:value])
+      
+      self.id = response[:value].first[:id] rescue nil
+      
+      if @keywords.size > 0
+        keyword = Adapi::Keyword.create(
+          :ad_group_id => @id,
+          :keywords => @keywords
         )
+        
+        if (keyword.errors.size > 0)
+          self.errors.add("[keyword]", keyword.errors.to_a)
+          return false 
+        end
       end
 
-      ads.each do |ad_data|
-        Adapi::Ad.create(
-          :data => ad_data.merge(:ad_group_id => ad_group[:id])
-        )
+      @ads.each do |ad_data|
+        ad = Adapi::Ad::TextAd.create( ad_data.merge(:ad_group_id => @id) )
+
+        if (ad.errors.size > 0)
+          self.errors.add("[ad] \"#{ad.headline}\"", ad.errors.to_a)
+          return false 
+        end
       end
 
-      # puts "Ad group ID %d was successfully added." % ad_group[:id]
-      ad_group
+      true
     end
+ 
+    def self.find(amount = :all, params = {})
+      params.symbolize_keys!
+      first_only = (amount.to_sym == :first)
 
-    # should be sorted out later, but leave it be for now
-    #
-    def self.find(params = {})
-      ad_group_service = AdGroup.new
+      raise "No Campaign ID is required" unless params[:campaign_id]
 
-      raise "No Campaign ID" unless params[:campaign_id]
-      campaign_id = params[:campaign_id]
+      predicates = [ :campaign_id, :id ].map do |param_name|
+        if params[param_name]
+          {:field => param_name.to_s.camelcase, :operator => 'EQUALS', :values => params[param_name] }
+        end
+      end.compact
 
       selector = {
-        :fields => ['Id', 'Name'],
-        # :ordering => [{:field => 'Name', :sort_order => 'ASCENDING'}],
-        :predicates => [{
-          :field => 'CampaignId', :operator => 'EQUALS', :values => campaign_id
-        }]
+        :fields => ['Id', 'Name', 'Status'],
+        :ordering => [{:field => 'Name', :sort_order => 'ASCENDING'}],
+        :predicates => predicates
       }
 
-      response = ad_group_service.service.get(selector)
+      response = AdGroup.new.service.get(selector)
 
-      if response and response[:entries]
-        ad_groups = response[:entries]
-        puts "Campaign ##{campaign_id} has #{ad_groups.length} ad group(s)."
-        ad_groups.each do |ad_group|
-          puts "  Ad group name is \"#{ad_group[:name]}\" and id is #{ad_group[:id]}."
-        end
-     else
-       puts "No ad groups found for campaign ##{campaign_id}."
-     end
+      response = (response and response[:entries]) ? response[:entries] : []
+
+      #response.map! do |data|
+      #  TextAd.new(data[:ad].merge(:ad_group_id => data[:ad_group_id], :status => data[:status]))
+      #end
+
+      first_only ? response.first : response
+    end
+
+    def find_keywords(first_only = false)
+      Keyword.find( (first_only ? :first : :all), :ad_group_id => self.id )
+    end
 
+    def find_ads(first_only = false)
+      Ad::TextAd.find( (first_only ? :first : :all), :ad_group_id => self.id )
     end
 
   end