ppc 1.3.2 → 2.0.0

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/ppc.rb

@@ -3,7 +3,7 @@ require 'ppc/operation'
 require 'ppc/ext'
 module PPC
 
-  VERSION = "1.3.2"
+  VERSION = "2.0.0"
 
   protected
   def print_debug(var,varname=nil)

data/lib/ppc/api.rb

@@ -15,6 +15,7 @@ module PPC
 
     @map = nil
     @debug = false
+    @match_types = nil
 
     def debug_on
       @debug = true
@@ -87,13 +88,6 @@ module PPC
       raise 'you need build the response result'
     end
 
-    def is_no_quota(failure, code)
-      return false if failure.nil?
-      failure = [failure].flatten
-      return false if failure.size.zero?
-      return failure[0]["code"] == code
-    end
-
     def make_type( params, maps = @map)
       '''
         tranfesr ppc api to search engine api
@@ -114,10 +108,9 @@ module PPC
         @ output:
           types : list of hash that complying with search engine api
       '''
-      params = [ params ] unless params.is_a? Array
-      params.map do |item| 
-        item.select!{|key| maps.map{|m| m[0]}.include? key}
-        maps.each{|m| item.filter_and_replace_key(m[1],m[0])}
+      [ params ].flatten.map do |item| 
+        item.select!{|key| maps.any?{|m| m[0] == key} }
+        maps.each{|key_new, key_old| item[key_old] = (key_new == :match_type && @match_types ? @match_types[item.delete(key_new)] : item.delete(key_new)) if item[key_new] }
         item
       end
     end
@@ -133,9 +126,20 @@ module PPC
         @ output:
           params : list of hash complying with PPC gem api  
       '''
-      types = [ types ] unless types.is_a? Array
-      types.map do |item| 
-        maps.each{|m| item.filter_and_replace_key(m[0],m[1])}
+      [ types ].flatten.map do |item| 
+        maps.each{|key_new, key_old| 
+          value = item.delete(key_old)
+          value = item.delete(key_old.to_s) if value.nil?
+          next if value.nil?
+          if key_new == :pause && (key_old == :status || key_old == :sysStatus)
+            if value[/(pause|enable)/]
+              value = value[/pause/] ? true : false
+            else
+              key_new = :status
+            end
+          end
+          item[key_new.to_sym] = (key_new == :match_type && @match_types ? @match_types[value] : value)
+        }
         item
       end
     end

data/lib/ppc/api/baidu.rb

@@ -16,7 +16,7 @@ module PPC
       extend ::PPC::API
       
       def self.request_uri(param)
-        URI("https://api.baidu.com/json/sms/v3/#{param[:service]}Service/#{param[:method]}")
+        URI("https://api.baidu.com/json/sms/service/#{param[:service]}Service/#{param[:method]}")
       end
 
       def self.process(response, key, &func)
@@ -33,19 +33,10 @@ module PPC
         result = {}
         result[:succ] = response['header']['desc'] =='success'
         result[:failure] = response['header']['failures']
-        if !response['body'].nil? && response['body'][key]
-          result[:result] = func[ response['body'][key] ]
-        end
-        result[:no_quota] = is_no_quota(response['header']['failures'], '8501')
-        return result
-      end
-
-      def self.reverse_type( types, maps = @map )
-        types = [ types ] unless types.is_a? Array
-        types.map do |item| 
-          maps.each{|m| item.filter_and_replace_key(m[0],m[1].to_s)}
-          item
-        end
+        result[:result] ||= func[ response['body']['data'] ] rescue nil
+        result[:rquota] = response['header']['rquota'] if response['header']['rquota']
+        result[:no_quota] = (response['header']['failures']['code'] == '8501') rescue true
+        result
       end
 
     end # Baidu

data/lib/ppc/api/baidu/account.rb

@@ -4,28 +4,34 @@ module PPC
       class Account< Baidu
         Service = 'Account'
 
-        @map = [
-                  [:id,:userid],            
-                  [:balance,:balance],         
-                  [:cost,:cost],               
-                  [:payment,:payment],                          
-                  [:status,:userStat],                            
-                  [:budget_type,:budgetType],                   
-                  [:budget,:budget],                              
-                  [:region,:regionTarget],                    
-                  [:exclude_ip,:excludeIp],                        
-                  [:isdynamic,:isDynamicCreative],         
-                  [:dynamic_param,:dynamicCreativeParam], 
-                  [:open_domains,:openDomains],                  
-                  [:reg_domain,:regDomain],                       
-                  [:offline_time,:budgetOfflineTime],         
-                  [:weekly_budget,:weeklyBudget],                
-                  [:opt,:opt]                                  
-                ]
+        AccountInfoType = {
+          id:                   :userId,
+          balance:              :balance,
+          pc_balance:           :pcBalance,
+          mobile_balance:       :mobileBalance,
+          cost:                 :cost,
+          payment:              :payment,
+          status:               :userStat,
+          budget_type:          :budgetType,
+          budget:               :budget,
+          region:               :regionTarget,
+          exclude_ip:           :excludeIp,
+          isdynamic:            :isDynamicCreative,
+          isdynamictagsublink:  :isDynamicTagSublink,
+          isdynamichotredirect: :isDynamicHotRedirect,
+          isdynamictitle:       :isDynamicTitle,
+          dynamic_param:        :dynamicCreativeParam,
+          open_domains:         :openDomains,
+          reg_domain:           :regDomain,
+          offline_time:         :budgetOfflineTime,
+          weekly_budget:        :weeklyBudget,
+        }
+        @map = AccountInfoType
 
         def self.info( auth )
-          response = request(auth,Service,'getAccountInfo'  )
-          return process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
+          body = {:accountFields => AccountInfoType.values}
+          response = request(auth,Service,'getAccountInfo',body)
+          process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
         end
 
         def self.update(auth, param = {} )
@@ -35,10 +41,9 @@ module PPC
           @return : account info_type
           """
           # for account service, there is not bulk operation
-          infoType = make_type( param )[0]
-          body = { accountInfoType: infoType }
+          body = { accountInfo: make_type( param )[0] }
           response = request(auth,Service,'updateAccountInfo', body)
-          return process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
+          process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
         end
 
       end

data/lib/ppc/api/baidu/bulk.rb

@@ -68,7 +68,7 @@ module PPC
           rescue => e
             p "Error encounter:#{e.to_s}"
           end  
-          return false
+          false
         end
 
       end

data/lib/ppc/api/baidu/creative.rb

@@ -5,19 +5,40 @@ module PPC
       class Creative< Baidu
         Service = 'Creative'
 
-        @map =[
-                [:id,:creativeId],
-                [:group_id,:adgroupId],
-                [:title,:title],
-                [:description1,:description1],
-                [:description2,:description2],
-                [:pc_destination,:pcDestinationUrl],
-                [:pc_display,:pcDisplayUrl],
-                [:mobile_destination,:mobileDestinationUrl],
-                [:mobile_display,:mobileDisplayUrl],
-                [:pause,:pause],
-                [:preference,:devicePreference] 
-              ]     
+        CreativeType = {
+          id:                 :creativeId,
+          group_id:           :adgroupId,
+          title:              :title,
+          description1:       :description1,
+          description2:       :description2,
+          pc_destination:     :pcDestinationUrl,
+          pc_display:         :pcDisplayUrl,
+          mobile_destination: :mobileDestinationUrl,
+          mobile_display:     :mobileDisplayUrl,
+          pause:              :pause,
+          preference:         :devicePreference,
+          status:             :status,
+          device_preference:  :devicePreference,
+        }
+        @map = CreativeType
+
+        def self.info( auth, ids )
+          body = { ids: ids, idType: 7, creativeFields: CreativeType.values }
+          response = request( auth, Service, 'getCreative', body )
+          process(response, 'creativeType' ){|x| reverse_type( x )[0] }
+        end
+
+        def self.all( auth, group_ids )
+          body = { ids: group_ids, idType: 5, creativeFields: CreativeType.values}
+          response = request( auth, Service, 'getCreative', body )
+          process(response, 'groupCreatives' ){|x| reverse_type( x ) }
+        end
+
+        def self.ids( auth, group_ids )
+          body = { ids: group_ids, idType: 5, creativeFields: [:creativeId]}
+          response = request( auth, Service, 'getCreative', body )
+          process(response, 'groupCreativeIds' ){|x| reverse_type( x ) }
+        end
 
         def self.add( auth, creatives )
           body = { creativeTypes: make_type( creatives ) }
@@ -25,98 +46,38 @@ module PPC
           process( response, 'creativeTypes' ){ |x| reverse_type(x) }
         end
 
-        def self.get( auth, ids, getTemp = 0 )
-          '''
-          \'getCreativeByCreativeId\'
-          @ input : creative ids
-          @ output: creative informations
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { creativeIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCreativeByCreativeId', body )
+        def self.get( auth, ids )
+          body = { ids: ids, idType: 7, creativeFields: CreativeType.values }
+          response = request( auth, Service, 'getCreative', body )
           process( response, 'creativeTypes' ){ |x| reverse_type(x) }
         end
 
         def self.update( auth, creatives )
-          '''
-          根据实际使用情况，更新的时候creative title为必填选
-          '''
           body = { creativeTypes: make_type( creatives ) }
           response = request( auth, Service, 'updateCreative', body )
           process( response, 'creativeTypes' ){ |x| reverse_type(x) }
         end
 
         def self.delete( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
           body = { creativeIds: ids }
           response = request( auth, Service, 'deleteCreative', body )
           process( response, 'result' ){ |x| x }
         end
 
-        def self.activate( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { creativeIds: ids }
-          response = request( auth, Service, 'activateCreative', body )
-          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
-        end
-
-        def self.status( auth, ids, type )
-          ids = [ ids ] unless ids.is_a? Array
-          
-          type = case type
-            when  'plan'      then    3 
-            when  'group'     then    5
-            when  'creative'  then    7
-            else
-              Exception.new( 'type must among: \'plan\',\'group\' and \'key\' ')            
-          end
-
-          body = { ids: ids, type: type }
-          response = request( auth, Service, 'getCreativeStatus', body )
-          process( response, 'CreativeStatus' ){ |x| x }
-        end
-
-        def self.search_id_by_group_id( auth, ids, getTemp = 0 )
-          '''
-          \'getCreativeIdByAdgroupId\'
-          @ input: group ids
-          @ output:  groupCreativeIds
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { adgroupIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCreativeIdByAdgroupId', body )
-          process( response, 'groupCreativeIds' ){ |x| make_groupCreativeIds( x ) }
-        end
-
-        def self.search_by_group_id( auth, ids, getTemp = 0 )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { adgroupIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCreativeByAdgroupId', body )
-          process( response, 'groupCreatives' ){ |x| make_groupCreatives( x ) }
+        def self.enable( auth, ids )
+          creatives = ids.map{|id| {id: id, pause: false} }
+          self.update( auth, creatives )
         end
 
-        private
-        def self.make_groupCreativeIds( groupCreativeIds )
-          group_creative_ids = []
-          groupCreativeIds.each do |groupCreativeId|
-            group_creative_id = { }
-            group_creative_id[:group_id] = groupCreativeId['adgroupIds']
-            group_creative_id[:creative_ids] = groupCreativeId['creativeIds']
-            group_creative_ids << group_creative_id
-          end
-          return group_creative_ids
+        def self.pause( auth, ids )
+          creatives = ids.map{|id| {id: id, pause: true} }
+          self.update( auth, creatives )
         end
 
-        private
-        def self.make_groupCreatives( groupCreatives )
-          group_creatives = []
-          groupCreatives.each do |groupCreative |
-            group_creative = {}
-            group_creative[:group_id] = groupCreative['adgroupId']
-            group_creative[:creatives] = reverse_type( groupCreative['creativeTypes'] )
-            group_creatives << group_creative
-          end
-          return group_creatives
+        def self.status( auth, ids )
+          body = { ids: ids, idType: 7, creativeFields: [:creativeId, :status]}
+          response = request( auth, Service, 'getCreative', body )
+          process(response, 'groupCreatives' ){|x| reverse_type( x ) }
         end
 
       end

data/lib/ppc/api/baidu/group.rb

@@ -5,104 +5,73 @@ module PPC
       class Group< Baidu
         Service = 'Adgroup'
 
-        @map =[
-                        [:plan_id, :campaignId],
-                        [:id, :adgroupId],
-                        [:name, :adgroupName],
-                        [:price, :maxPrice],
-                        [:negative, :negativeWords],
-                        [:exact_negative, :exactNegativeWords],
-                        [:pause, :pause],
-                        [:status, :status],
-                        [:reserved, :reserved]
-                      ]
+        GroupType = {
+          plan_id:            :campaignId,
+          id:                 :adgroupId,
+          name:               :adgroupName,
+          price:              :maxPrice,
+          negative:           :negativeWords,
+          exact_negative:     :exactNegativeWords,
+          pause:              :pause,
+          status:             :status,
+          price_ratio:        :priceRatio,
+          accu_price_factor:  :accuPriceFactor,
+          word_price_factor:  :wordPriceFactor,
+          wide_price_factor:  :widePriceFactor,
+          match_price_status: :matchPriceStatus,
+        }
+        @map = GroupType
 
-        def self.ids(auth )
-          """
-          @return : Array of campaignAdgroupIds
-          """
-          response = request( auth, Service , "getAllAdgroupId" )
-          process( response, 'campaignAdgroupIds' ){ |x| make_planGroupIds( x ) }
+        def self.info( auth, ids)
+          body = {ids: ids, idType: 5, adgroupFields: GroupType.values}
+          response = request(auth, Service, "getAdgroup",body )
+          process( response, 'adgroupType' ){ |x| reverse_type( x )[0] }
+        end
+
+        def self.all( auth, plan_ids )
+          body = { ids: plan_ids, idType: 3, adgroupFields: GroupType.values}
+          response = request(auth, Service, 'getAdgroup', body)
+          process( response, 'campaignAdgroups' ){ |x|reverse_type(x) }
+        end
+
+        def self.ids( auth, plan_ids )
+          body = {ids: plan_ids, idType: 3, adgroupFields: [:adgroupId]}
+          response = request(auth, Service, "getAdgroup",body )
+          process( response, 'campaignAdgroupIds' ){ |x| reverse_type( x ) }
         end
 
         def self.get( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { adgroupIds: ids }
-          response = request(auth, Service, "getAdgroupByAdgroupId",body )
-          process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
+          body = {ids: ids, idType: 5, adgroupFields: GroupType.values}
+          response = request(auth, Service, "getAdgroup",body )
+          process( response, 'adgroupTypes' ){ |x| reverse_type( x ) }
         end
 
         def self.add( auth, groups )
-          """
-          @ input : one or list of AdgroupType
-          @ output : list of AdgroupType
-          """
-          adgrouptypes = make_type( groups )
-
-          body = {adgroupTypes:  adgrouptypes }
-          
+          body = {adgroupTypes:  make_type( groups ) }
           response = request( auth, Service, "addAdgroup", body  )
           process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
         end
 
         def self.update( auth, groups )
-          """
-          @ input : one or list of AdgroupType
-          @ output : list of AdgroupType
-          """
-          adgrouptypes = make_type( groups )
-          body = {adgroupTypes: adgrouptypes}
-          
+          body = {adgroupTypes: make_type( groups )}
           response = request( auth, Service, "updateAdgroup",body )
           process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
         end
 
         def self.delete( auth, ids )
-          """
-          delete group body has no message
-          """
-          ids = [ ids ] unless ids.is_a? Array
           body = { adgroupIds: ids }
           response = request( auth, Service,"deleteAdgroup", body )
           process( response, 'nil' ){ |x|  x  }
         end
 
-        def self.search_by_plan_id( auth, ids )
-          ids = [ ids ] unless ids.class == Array
-          body = { campaignIds: ids }
-          response = request( auth, Service ,"getAdgroupByCampaignId",  body )
-          process( response, 'campaignAdgroups' ){ |x| make_planGroups( x ) }
-        end
-
-        def self.search_id_by_plan_id( auth, ids )
-          ids = [ ids ] unless ids.class == Array
-          body = { campaignIds: ids }
-          response = request( auth, Service ,"getAdgroupIdByCampaignId",  body )
-          process( response, 'campaignAdgroupIds' ){ |x| make_planGroupIds( x ) }
-        end
-
-        private
-        def self.make_planGroupIds( campaignAdgroupIds )
-          planGroupIds = []
-          campaignAdgroupIds.each do |campaignAdgroupId|
-            planGroupId = { }
-            planGroupId[:plan_id] = campaignAdgroupId['campaignId']
-            planGroupId[:group_ids] = campaignAdgroupId['adgroupIds']
-            planGroupIds << planGroupId
-          end
-          return planGroupIds
+        def self.enable( auth, ids )
+          groups = ids.map{|id| {id: id, pause: false} }
+          self.update( auth, groups )
         end
 
-        private
-        def self.make_planGroups( campaignAdgroups )
-          planGroups = []
-          campaignAdgroups.each do |campaignAdgroup|
-            planGroup = {}
-            planGroup[:plan_id] = campaignAdgroup['campaignId']
-            planGroup[:groups] = reverse_type( campaignAdgroup['adgroupTypes'] )
-            planGroups << planGroup
-          end
-          return planGroups
+        def self.pause( auth, ids )
+          groups = ids.map{|id| {id: id, pause: true} }
+          self.update( auth, groups )
         end
 
       end # class group