ppc 1.3.2 → 2.0.0

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

@@ -6,196 +6,103 @@ module PPC
         Service = 'Keyword'
 
         Match_type  = { 'exact' => 1, 'phrase' => 2, 'wide' => 3,1 => 'exact', 2=> 'phrase' , 3 => 'wide'  }
+        @match_types = Match_type
         Device      = { 'pc' => 0, 'mobile' => 1, 'all' => 2 }
         Type        = { 'plan' => 3, 'group' => 5, 'keyword' => 11 }
         
-        @map  = [
-                  [:id,:keywordId],
-                  [:group_id,:adgroupId],
-                  [:keyword,:keyword],
-                  [:price,:price],
-                  [:pc_destination,:pcDestinationUrl],
-                  [:mobile_destination,:mobileDestinationUrl],
-                  [:match_type,:matchType],
-                  [:phrase_type,:phraseType],
-                  [:status,:status],
-                  [:pause,:pause]
-                ]
+        KeywordType  = {
+          id:                 :keywordId,
+          group_id:           :adgroupId,
+          plan_id:            :campaignId,
+          keyword:            :keyword,
+          price:              :price,
+          pc_destination:     :pcDestinationUrl,
+          mobile_destination: :mobileDestinationUrl,
+          match_type:         :matchType,
+          phrase_type:        :phraseType,
+          status:             :status,
+          pause:              :pause,
+          wmatchprefer:       :wmatchprefer,
+        }
+        @map = KeywordType
+
+        KeywordQualityType = {
+          id:               :id,
+          group_id:         :adgroupId,
+          plan_id:          :campaignId,
+          pc_quality:       :pcQuality,
+          pc_reliable:      :pcReliable,
+          pc_reason:        :pcReason,
+          pc_scale:         :pcScale,
+          mobile_quality:   :mobileQuality,
+          mobile_reliable:  :mobileReliable,
+          mobile_reason:    :mobileReason,
+          mobile_scale:     :mobileScale,
+        }
+        @quality10_map = KeywordQualityType
+
+        def self.info( auth, ids )
+          body = { ids: ids, idType: 11, wordFields: KeywordType.values}
+          response = request( auth, Service, 'getWord', body )
+          process(response, 'keywordType' ){|x| reverse_type( x )[0] }
+        end
+
+        def self.all( auth, group_ids )
+          body = { ids: group_ids, idType: 5, wordFields: KeywordType.values}
+          response = request( auth, Service, 'getWord', body )
+          process(response, 'groupKeywords' ){|x| reverse_type( x ) }
+        end
 
-        @quality10_map = [
-                          [ :id, :id ],
-                          [ :group_id, :adgroupId ],
-                          [ :plan_id, :Campaigned ],
-                          [ :pc_quality, :pcQuality ],
-                          [ :pc_reliable, :pcReliable ],
-                          [ :pc_reason, :pcReason ],
-                          [ :pc_scale, :pcScale ],
-                          [ :mobile_quality, :mobileQuality ],
-                          [ :mobile_reliable, :mobileReliable ],
-                          [ :mobile_reason, :mobileReason ],
-                          [ :mobile_scale, :mobileScale ]
-                          ]
+        def self.ids( auth, group_ids )
+          body = { ids: group_ids, idType: 5, wordFields: [:keywordId]}
+          response = request( auth, Service, 'getWord', body )
+          process(response, 'groupKeywordIds' ){|x| reverse_type( x ) }
+        end
 
-        # 后面改成info方法
         def self.get( auth, ids )
-          '''
-          getKeywordByKeywordId
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { keywordIds: ids}
-          response = request( auth, Service, 'getKeywordByKeywordId', body )
-          return process(response, 'keywordTypes' ){|x| reverse_type( x ) }
+          body = { ids: ids, idType: 11, wordFields: KeywordType.values}
+          response = request( auth, Service, 'getWord', body )
+          process(response, 'keywordTypes' ){|x| reverse_type( x ) }
         end
 
         def self.add( auth, keywords )
-          '''
-          '''
-          keywordtypes = make_type( keywords ) 
-          body = { keywordTypes: keywordtypes }
-          response = request( auth, Service, "addKeyword", body )
-          return process(response, 'keywordTypes' ){|x| reverse_type(x)  }
+          body = { keywordTypes: make_type( keywords ) }
+          response = request( auth, Service, "addWord", body )
+          process(response, 'keywordTypes' ){|x| reverse_type(x)  }
         end
 
         def self.update( auth, keywords  )
-          '''
-          '''
-          keywordtypes = make_type( keywords ) 
-          body = { keywordTypes: keywordtypes }
-          response = request( auth, Service, "updateKeyword", body )
-          return process(response, 'keywordTypes' ){|x| reverse_type(x)  }
+          body = { keywordTypes: make_type( keywords ) }
+          response = request( auth, Service, "updateWord", body )
+          process(response, 'keywordTypes' ){|x| reverse_type(x)  }
         end
 
         def self.delete( auth, ids )
-          """
-          """
-          ids = [ ids ] unless ids.is_a? Array
           body = { keywordIds: ids}
-          response = request( auth, Service, 'deleteKeyword', body )
-          return process(response, 'result' ){|x| x }
-        end
-
-        def self.activate( auth, ids )
-          """
-          """
-          ids = [ ids ] unless ids.is_a? Array
-          body = { keywordIds: ids }
-          response = request( auth, Service, 'activateKeyword', body)
-          return process(response, 'keywordTypes' ){|x| reverse_type(x)  }
-        end
-
-        def self.search_by_group_id( auth, group_ids  )
-          """
-          getKeywordByGroupIds
-          @input: list of group id
-          @output:  list of groupKeyword
-          """
-          group_ids = [ group_ids ] unless group_ids.is_a? Array
-          body = { adgroupIds: group_ids }
-          response = request( auth, Service, "getKeywordByAdgroupId", body )
-          return process(response, 'groupKeywords' ){|x| make_groupKeywords( x ) }
-        end
-
-        def self.search_id_by_group_id( auth, group_ids  )
-          group_ids = [ group_ids ] unless group_ids.is_a? Array
-          body = { adgroupIds: group_ids }
-          response = request( auth, Service, "getKeywordIdByAdgroupId", body )
-          return process(response, 'groupKeywordIds' ){|x| make_groupKeywordIds( x ) }
-        end
-
-        # 下面三个操作操作对象包括计划，组和关键字
-        # 不知道放在这里合不合适
-        def self.status( auth, ids, type )
-          '''
-          Return [{ id: id, status: status } ... ]
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { ids: ids, type: Type[type]}
-          response = request( auth, Service, 'getKeywordStatus', body )
-          return process(response, 'keywordStatus' ){  |statusTypes| 
-            statusTypes = [statusTypes] unless statusTypes.is_a? Array
-            status =[]
-
-            statusTypes.each do |statusType|
-              status << { id: statusType['id'], status: statusType['status'] }
-            end
-            return status
-           }
-        end
-
-        def self.quality( auth ,ids, type, device )
-          '''
-          Return 10Quanlity *Not the old Quality* of given ketword id
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { ids: ids, type: Type[type], device:Device[device] }
-          response = request( auth, Service, 'getKeyword10Quality', body )
-          return process(response, 'keyword10Quality' ){|x| reverse_type( x, @quality10_map ) }
+          response = request( auth, Service, 'deleteWord', body )
+          process(response, 'result' ){|x| x }
         end
 
-        private
-        def self.make_groupKeywordIds( groupKeywordIds )
-          group_keyword_ids = []
-          groupKeywordIds.each do |groupKeywordId|
-            group_keyword_id = { }
-            group_keyword_id[:group_id] = groupKeywordId['adgroupIds']
-            group_keyword_id[:keyword_ids] = groupKeywordId['keywordIds']
-            group_keyword_ids << group_keyword_id
-          end
-          return group_keyword_ids
+        def self.enable( auth, ids )
+          keywords = ids.map{|id| {id: id, pause: false} }
+          self.update( auth, keywords )
         end
 
-        private
-        def self.make_groupKeywords( groupKeywords )
-          group_keywords = []
-          groupKeywords.each do |groupKeyword|
-            group_keyword = {}
-            group_keyword[:group_id] = groupKeyword['adgroupId']
-            group_keyword[:keywords] = reverse_type( groupKeyword['keywordTypes'] )
-            group_keywords << group_keyword
-          end
-          return group_keywords
+        def self.pause( auth, ids )
+          keywords = ids.map{|id| {id: id, pause: true} }
+          self.update( auth, keywords )
         end
 
-        # Override
-       def self.make_type( params, map = @map)
-          params = [ params ] unless params.is_a? Array
-          types = []
-          params.each do |param|
-            type = {}
-              map.each do |key|
-                # 增加对matchtype的自动转换
-                if key[0] == :match_type
-                   value = param[ key[0] ]
-                  type[ key[1] ] = Match_type[ value ] if value                 
-                else
-                  value = param[ key[0] ]
-                  type[ key[1] ] = value if value
-                end
-              end
-            types << type
-          end
-          return types
+        def self.status( auth, ids )
+          body = { ids: ids, idType: 11, keywordTypes: [:keywordId, :status]}
+          response = request( auth, Service, 'getWord', body )
+          process(response, 'groupKeywords' ){|x| reverse_type( x ) }
         end
 
-        # Overwrite
-        def self.reverse_type( types, map = @map )
-          types = [ types ] unless types.is_a? Array
-          params = []
-          types.each do |type|
-            param = {}
-             # 增加对matchtype的自动转换
-              map.each do |key|
-                if key[0] == :match_type
-                   value = type[ key[1].to_s ]
-                  param[ key[0] ] = Match_type[ value ] if value                 
-                else
-                  value = type[ key[1].to_s ]
-                  param[ key[0] ] = value if value
-                end
-              end # map.each
-            params << param
-          end # types.each
-          return params
+        def self.quality( auth, ids )
+          body = { ids: ids, idType: 11, keywordTypes: KeywordQualityType.values}
+          response = request( auth, Service, 'getWord', body )
+          process(response, 'groupKeywords' ){|x| reverse_type( x , KeywordQualityType) }
         end
 
       end # keyword

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

@@ -5,12 +5,13 @@ module PPC
       class Phone < Baidu
         Service = 'NewCreative'
 
-        @map =[
-                [:id,:phoneId],
-                [:group_id,:adgroupId],
-                [:phone_num,:phoneNum],
-                [:pause,:pause],
-              ]     
+        PhoneType = {
+          id:        :phoneId,
+          group_id:  :adgroupId,
+          phone_num: :phoneNum,
+          pause:     :pause,
+        }
+        @map = PhoneType
 
         def self.update( auth, phones )
           '''
@@ -21,7 +22,7 @@ module PPC
           process( response, 'phoneTypes' ){ |x| reverse_type(x) }
         end
 
-        def self.search_id_by_group_id( auth, ids, getTemp = 0 )
+        def self.ids( auth, ids, getTemp = 0 )
           '''
           \'getPhoneIdByAdgroupId\'
           @ input: group ids

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

@@ -4,63 +4,80 @@ module PPC
       class Plan< Baidu
         Service = 'Campaign'
 
-        @map = [
-                [:id,:campaignId],
-                [:name,:campaignName],
-                [:budget,:budget], 
-                [:region,:regionTarget],
-                [:ip,:excludeIp] ,
-                [:negative,:negativeWords],
-                [:exact_negative,:exactNegativeWords],
-                [:schedule,:schedule], 
-                [:budget_offline_time,:budgetOfflineTime],
-                [:show_prob,:showProb],   
-                [:device,:device],
-                [:price_ratio,:priceRatio], 
-                [:is_dynamic,:isDynamicCreative],
-                [:pause,:pause],
-                [:status,:status]
-               ]
+        PlanType = {
+          id:                   :campaignId,
+          name:                 :campaignName,
+          budget:               :budget,
+          region:               :regionTarget,
+          negative:             :negativeWords,
+          exact_negative:       :exactNegativeWords,
+          schedule:             :schedule,
+          budget_offline_time:  :budgetOfflineTime,
+          show_prob:            :showProb,
+          device:               :device,
+          price_ratio:          :priceRatio,
+          is_dynamic:           :isDynamicCreative,
+          pause:                :pause,
+          status:               :status,
+          rmkt_status:          :rmktStatus,
+          type:                 :campaignType,
+          isdynamictagsublink:  :isDynamicTagSublink,
+          isdynamichotredirect: :isDynamicHotRedirect,
+          isdynamictitle:       :isDynamicTitle,
+          rmkt_price_ratio:     :rmktPriceRatio,
+        }
+        @map = PlanType
+
+        def self.info( auth, ids )
+          body = { campaignIds: ids, campaignFields: PlanType.values}
+          response = request(auth,Service,'getCampaign',body)
+          process( response, 'campaignType' ){ |x|reverse_type(x)[0] }
+        end
 
         def self.all( auth )
-          response = request( auth, Service, 'getAllCampaign' )
-          process( response, 'campaignTypes' ){ |x| reverse_type(x) }
+          body = { campaignIds: nil, campaignFields: PlanType.values}
+          response = request(auth,Service,'getCampaign',body)
+          process( response, 'campaignTypes' ){ |x|reverse_type(x) }
         end
 
         def self.ids( auth )
-          response = request( auth, Service, 'getAllCampaignId' )
-          process( response, 'campaignIds' ){ |x| x }
+          body = { campaignIds: nil, campaignFields: ["campaignId"]}
+          response = request(auth,Service,'getCampaign',body)
+          process( response, 'campaignIds' ){ |x|reverse_type(x) }
         end
 
         def self.get( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { campaignIds: ids }
-          response = request( auth, Service, 'getCampaignByCampaignId', body)
-          process( response, 'campaignTypes' ){ |x| reverse_type(x) }
+          body = { campaignIds: ids, campaignFields: PlanType.values}
+          response = request( auth, Service, 'getCampaign', body)
+          process( response, 'campaignTypes' ){ |x| reverse_type(x)}
         end
 
         def self.add( auth, plans )
-          campaigntypes = make_type( plans )
-          # set extended = 1 to allow change of isDynamicCreative
-          body = { campaignTypes: campaigntypes, extended:1 }
+          body = { campaignTypes: make_type( plans ) }
           response = request( auth, Service, 'addCampaign', body)
           process( response, 'campaignTypes' ){ |x| reverse_type(x) }
         end
 
         def self.update(auth,plans )
-          campaigntypes = make_type( plans )
-          # set extended = 1 to allow change of isDynamicCreative
-          body = { campaignTypes: campaigntypes, extended:1 }
+          body = { campaignTypes: make_type( plans ) }
           response = request( auth, Service, 'updateCampaign', body)
           process( response, 'campaignTypes' ){ |x| reverse_type(x) }
         end
 
         def self.delete(auth, ids )
-          ids = [ ids ] unless ids.class == Array
-          body = { campaignIds: ids }
-          response = request( auth, Service, 'deleteCampaign', body)
+          response = request( auth, Service, 'deleteCampaign', {campaignIds: ids} )
           process( response, 'result' ){ |x| x }
         end
+
+        def self.enable( auth, ids )
+          plans = ids.map{|id| {id: id, pause: false} }
+          self.update( auth, plans )
+        end
+
+        def self.pause( auth, ids )
+          plans = ids.map{|id| {id: id, pause: true} }
+          self.update( auth, plans )
+        end
        
       end # Service
     end # baidu

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

@@ -25,7 +25,7 @@ module PPC
           request = make_reportrequest( params )
           body =  { reportRequestType:  request }
           response = request( auth, Service, 'getProfessionalReportId' ,body) 
-          process( response, 'reportId' ){ |x| x }
+          process( response, 'reportId' ){ |x| x[0]["reportId"] }
         end
 
         def self.get_state( auth, id )
@@ -35,13 +35,13 @@ module PPC
           status = {1=>'Waiting' ,2=>'Opearting' ,3=>'Finished'}
           body = { reportId:  id }
           response = request( auth, Service, 'getReportState' ,body)
-          process( response, 'isGenerated' ){ |x| status[x] }
+          process( response, 'isGenerated' ){ |x| status[x[0]["isGenerated"]] }
         end
 
         def self.get_url( auth, id  )
           body = { reportId:  id }
           response = request( auth, Service, 'getReportFileUrl' ,body)
-          process( response, 'reportFilePath' ){ |x| x }       
+          process( response, 'reportFilePath' ){ |x| x[0]["reportFilePath"] }       
         end
         
         private
@@ -63,33 +63,15 @@ module PPC
           requesttype[:unitOfTime]        =     Unit_map[ param[:unit] ]      if param[:unit]
           requesttype[:device]            =     Device_map[ param[:device] ]  if param[:device]
           requesttype[:idOnly]            =     param[:id_only] || false
-          requesttype[:startDate]         =     parse_date( param[:startDate] )
-          requesttype[:endDate]           =     parse_date( param[:endDate] )
-          return requesttype
-        end
-
-        private 
-        def self.parse_date( date )
-          """
-          Cast string to time:
-          'YYYYMMDD' => Time
-          """
-          if date
-            y = date[0..3]
-            m = date[4..5]
-            d = date[6..7]
-            date = Time.new( y, m, d )
-          else
-            date = (Time.now - 24*3600)
-          end
-          date
+          requesttype[:startDate]         =     Time.parse( param[:startDate] ) rescue Time.now - 86400
+          requesttype[:endDate]           =     Time.parse( param[:endDate] )   rescue Time.now - 86400
+          requesttype
         end
 
         #################################
         # useful function for operation #
         #################################
-        def self.query_report( auth, param = nil, debug = false )
-          param = {} if not param
+        def self.query_report( auth, param = {}, debug = false )
           param[:type]   ||= 'query'
           param[:fields] ||=  %w(click impression)
           param[:level]  ||= 'pair'
@@ -98,8 +80,7 @@ module PPC
           download_report( auth, param, debug )
         end
 
-        def self.creative_report( auth, param = nil, debug = false )
-          param = {} if not param
+        def self.creative_report( auth, param = {}, debug = false )
           param[:type]   ||= 'creative'
           param[:fields] ||=  %w(impression click cpc cost ctr cpm position conversion)
           param[:level]  ||= 'creative'
@@ -108,8 +89,7 @@ module PPC
           download_report( auth, param, debug )
         end
 
-        def self.keyword_report( auth, param = nil, debug = false )
-          param = {} if not param
+        def self.keyword_report( auth, param = {}, debug = false )
           param[:type]   ||= 'keyword'
           param[:fields] ||=  %w(impression click cpc cost ctr cpm position conversion)
           param[:level]  ||= 'keywordid'