ppc 1.3.2 → 2.0.0

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

@@ -5,102 +5,86 @@ module PPC
       class Keyword< Qihu
         Service = 'keyword'
 
-        @map = [
-                  [:id, :id],
-                  [:group_id, :groupId],
-                  [:keyword, :word],
-                  [:price, :price],
-                  [:match_type, :matchType],
-                  [:pc_destination, :url],
-                  [:mobile_destination, :mobileUrl],
-                  [:status, :status]
-                ]
+        KeywordType = {
+          id:                     :id,
+          group_id:               :groupId,
+          keyword:                :word,
+          price:                  :price,
+          match_type:             :matchType,
+          pc_destination:         :url,
+          "pc_destination"     => :destinationUrl,
+          mobile_destination:     :mobileUrl,
+          "mobile_destination" => :mobileDestinationUrl,
+          pause:                  :status,
+          mobile_pause:           :mobileStatus,
+          add_time:               :addTime,
+          update_time:            :updateTime,
+        }
+        @map = KeywordType
 
-        @status_map = [ 
-                        [:id,:id], 
-                        [:quality,:qualityScore],
-                        [:status,:status]
-                      ]
+        @status_map = {
+          id:                   :id,
+          pc_quality:           :qualityScore,
+          mobile_quality:       :mobileQualityScore,
+          pause:                :status,
+          mobile_pause:         :mobileStatus,
+          pc_lowest_price:      :pcLowestPrice,
+          mobile_lowest_price:  :mobileLowestPrice,
+        }
+
+        def self.info( auth, ids )
+          response = request( auth, Service, 'getInfoByIdList', { idList: ids } )
+          process( response, 'keywordList'){ |x| reverse_type(x)[0] }
+        end
+
+        # combine search_id and get to provide another method
+        def self.all( auth, group_id )
+          results = self.ids( auth, group_id )
+          return results unless results[:succ]
+          self.get( auth , results[:result] )
+        end
+
+        def self.ids( auth, group_id )
+          response = request( auth, Service, 'getIdListByGroupId', {'groupId' => group_id[0]} )
+          process( response, 'keywordIdList' ){ |x| x.map(&:to_i) }
+        end
 
         def self.get( auth, ids )
-          ids = to_json_string( ids )
-          body  = { 'idList' => ids }
-          response = request( auth, Service, 'getInfoByIdList', body )
+          response = request( auth, Service, 'getInfoByIdList', { idList: ids } )
           process( response, 'keywordList'){ |x| reverse_type(x) }
         end
 
         def self.add( auth,  keywords )
-          keyword_types =  make_type( keywords ).to_json
-          body = { 'keywords' => keyword_types}
-          response = request( auth, Service, 'add', body )
-          p response
-          process( response, 'keywordIdList'){ |x| to_id_hash_list(x)  }
+          response = request( auth, Service, 'add', { keywords: make_type( keywords )} )
+          process( response, 'keywordIdList'){ |x| x.map.with_index{|id, index| {id: id, keyword: keywords[index][:word]}} }
         end
 
-        # helper function for self.add() method
-        private
-        def self.to_id_hash_list( str )
-          reuturn [] if str == nil
-          str = [str] unless str.is_a?Array
-          x= []
-          str.each{ |i| x << { id: i.to_i } }
-          return x
+        def self.update( auth, keywords )
+          response = request( auth, Service, 'update', { keywords: make_type( keywords )} )
+          process( response, 'affectedRecords', 'failKeywordIds' ){ |x| x == keywords.size ? keywords.map{|keyword| {id: keyword[:id]}} : nil }
         end
 
-        def self.update( auth, keywords )
-          keyword_types = make_type( keywords ).to_json
-          body = { 'keywords' => keyword_types}
-          response = request( auth, Service, 'update', body )
-          process( response, 'affectedRecords', 'failKeywordIds' ){ |x| x }        
+        def self.delete( auth, ids )
+          response = request( auth, Service, 'deleteByIdList', { idList: ids } )
+          process( response, 'affectedRecords' ){ |x|  x == keywords.size ? keywords.map{|keyword| {id: keyword[:id]}} : nil  }     
         end
 
-        # 对update的再封装实现activate方法
-        def self.activate( auth, ids )
-          keywords = []
-          ids.each{ |id| keywords << { id: id, status:'enable'} }
-          update( auth, keywords )
+        def self.enable( auth, ids )
+          self.update( auth, ids.map{ |id| { id: id, pause:'enable'} } )
         end
 
-        def self.delete( auth, ids )
-          body = { 'idList' => to_json_string( ids ) }
-          response = request( auth, Service, 'deleteByIdList', body )
-          process( response, 'affectedRecords' ){ |x|  x  }     
+        def self.pause( auth, ids )
+          self.update( auth, ids.map{ |id| { id: id, pause:'pause'} } )
         end
 
         def self.status( auth, ids )
-          body = { idList: to_json_string( ids ) }
-          response = request( auth, Service, 'getStatusByIdList', body )
-          process( response, 'keywordList' ){ |x| reverse_type(x, @status_map) }     
+          response = request( auth, Service, 'getStatusByIdList', { idList: ids } )
+          process( response, 'keywordList' ){ |x| reverse_type(x, @status_map) }
         end
 
         # quality 本质上和 status 在一个方法里面
         def self.quality( auth, ids )
-          status( auth, ids)
-        end
-        
-        def self.search_id_by_group_id( auth, id, status = nil, match_type = nil )
-          # 处理条件  
-          body = {}
-          body['status'] = status if status
-          body['matchType'] = match_type if match_type
-          body['groupId'] = id
-          response = request( auth, Service, 'getIdListByGroupId', body )
-          # 伪装成百度接口
-          process( response, 'keywordIdList' ){ 
-            |x|
-            [{group_id:id, keyword_ids:to_id_list(x)}]
-          }     
-        end
-
-        # combine search_id and get to provide another method
-        def self.search_by_group_id( auth, id )
-          keyword_ids = search_id_by_group_id( auth, id )[:result][0][:keyword_ids]
-          response = get( auth, keyword_ids )
-          if response[:succ]
-            # 伪装成百度接口
-            response[:result] = [ { group_id:id, keywords:response[:result] } ]
-          end
-          return response
+          self.status( auth, ids)
         end
 
         def self.getChangedIdList

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

@@ -5,59 +5,79 @@ module PPC
       class Plan < Qihu
         Service = 'campaign'
 
-        @map = [
-          [:id, :id],
-          [:name,:name],
-          [:budget, :budget],
-          [:region, :region],
-          [:schedule, :schedule],
-          [:startDate, :startDate],
-          [:endDate, :endDate ],
-          [:status,:status], 
-          [:extend_ad_type,:extendAdType]
-        ]
+        PlanType = {
+          id:                 :id,
+          name:               :name,
+          budget:             :budget,
+          region:             :region,
+          search_intention:   :searchIntention,
+          schedule:           :schedule,
+          start_date:         :startDate,
+          end_date:           :endDate,
+          status:             :sysStatus,
+          pause:              :status,
+          add_time:           :addTime,
+          update_time:        :updateTime,
+          price_ratio:        :mobilePriceRate,
+          extend_adtype:      :extendAdType,
+          "negative" =>       :negtiveWords,
+          negative:           :negativeWords,
+          "exact_negative" => :exactNegtiveWords,
+          exact_negative:     :exactNegativeWords,
+          device:             :device,
+          is_precise:         :isPrecise,
+        }
+        @map = PlanType
 
+        def self.info(auth, ids)
+          response = request( auth, Service, 'getInfoByIdList', {idList: ids} )
+          process( response, 'campaignList' ){ |x| reverse_type(x)[0] }
+        end
 
-        def self.get(auth, ids)
-          '''
-          :Type ids: ( Array of ) String or integer
-          '''
-          ids = to_json_string( ids )    
-          body = {'idList' => ids}
-          response = request( auth, Service, 'getInfoByIdList', body )
-          process( response, 'campaignList' ){ |x| reverse_type(x) }
+        # combine two original method to provice new method
+        def self.all( auth )
+          self.get( auth, self.ids( auth )[:result] )
         end
 
-        # move getCampaignId to plan module for operation call
+         # move getCampaignId to plan module for operation call
         def self.ids( auth )
           response = request( auth, 'account', 'getCampaignIdList' )
-          process( response, 'campaignIdList' ){ |x| to_id_list(x)}
+          process( response, 'campaignIdList' ){ |x| x.map(&:to_i) }
         end 
 
-        # combine two original method to provice new method
-        def self.all( auth )
-          plan_ids = ids( auth )[:result]
-          get( auth, plan_ids )
+        def self.get(auth, ids)
+          response = request( auth, Service, 'getInfoByIdList', {idList: ids} )
+          process( response, 'campaignList' ){ |x| reverse_type(x) }
         end
 
         # 奇虎计划API不提供批量服务
         def self.add( auth, plan )
-          response = request( auth, Service, 'add', make_type( plan )[0])
-          # 这里将返回的简单int做一个array和hash的封装一保证接口和百度，搜狗的一致性
-          process( response, 'id' ){ |x| [ { id:x.to_i } ] }
+          plan[0][:negative] = {exact: plan[0].delete(:exact_negative), phrase: plan[0].delete(:negative)}.to_json if plan[0][:exact_negative] || plan[0][:negative]
+          params = make_type(plan)[0]
+          response = request( auth, Service, 'add', params )
+          process( response, 'id' ){ |x| [ { id:x.to_i, name: plan[0][:name]} ] }
         end
 
-        def self.update( auth, plan ) 
-          response = request( auth, Service, 'update', make_type( plan )[0])
-          #同上，保证接口一致性
+        def self.update( auth, plan )
+          plan[0][:negative] = {exact: plan[0].delete(:exact_negative), phrase: plan[0].delete(:negative)}.to_json if plan[0][:exact_negative] || plan[0][:negative]
+          params = make_type(plan)[0]
+          response = request( auth, Service, 'update', params )
           process( response, 'id' ){ |x| [ { id:x.to_i } ] }
         end
 
         def self.delete( auth, id )
-          response = request( auth, Service, 'deleteById', { id: id } )
+          response = request( auth, Service, 'deleteById', { id: id[0] } )
           process( response, 'affectedRecords' ){ |x|  x == '1'? 'success' : 'fail' }
         end
 
+        def self.enable( auth, id )
+          self.update(auth, {id: id[0], pause: "enable"})
+        end
+
+        def self.pause( auth, id )
+          self.update(auth, {id: id[0], pause: "pause"})
+        end
+
       end
     end
   end

data/lib/ppc/api/qihu/rank.rb

@@ -4,19 +4,20 @@ module PPC
       class Rank < Qihu
         Service = 'tool'
 
-        @map = [
-                 [:id,:id] ,
-                 [:group_id, :groupId],
-                 [:anchor,:text],
-                 [:url, :link],
-                 [:image, :image],
-                 [:status, :status]
-                ]
+        RankType = {
+          id:       :id,
+          group_id: :groupId,
+          anchor:   :text,
+          url:      :link,
+          image:    :image,
+          status:   :status,
+        }
+        @map = RankType
 
         def self.getRank( auth, region, queryInfo )
           body  = {'region'=> region, 'queryInfo' => queryInfo}
-          response = request(auth, Service, 'realTimeQueryResult', body)
-          # process( response, 'sublinkList'){ |x| reverse_type( x['item'] ) }
+          response = request( auth, Service, 'realTimeQueryResult', body)
+          process( response, "" ){|x| x["left"]["ranking"]}
         end
 
       end

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

@@ -7,44 +7,41 @@ module PPC
       class Report< Qihu
         Service = 'report'
 
-        @map =[
-                [:queryword,:queryword],
-                [:plan_id,:campaignId],
-                [:creative_id,:creativeId],
-                [:keyword,:keyword],
-                [:views,:views],
-                [:clicks,:clicks],
-                [:startDate,:startDate],
-                [:endDate,:endDate],
-                [:date,:date],
-                [:keyword_id,:keywordId],
-                [:group_id,:groupId],
-                [:cost,:totalCost],
-                [:position,:avgPosition],
-                [:total_num,:totalNumber],
-                [:total_page,:totalPage]
-              ]
+        ReportType = {
+          queryword:    :queryword,
+          plan_id:      :campaignId,
+          creative_id:  :creativeId,
+          keyword:      :keyword,
+          views:        :views,
+          clicks:       :clicks,
+          startDate:    :startDate,
+          endDate:      :endDate,
+          date:         :date,
+          keyword_id:   :keywordId,
+          group_id:     :groupId,
+          cost:         :totalCost,
+          position:     :avgPosition,
+          total_num:    :totalNumber,
+          total_page:   :totalPage,
+        }
+        @map = ReportType
 
         ###################
         # API abstraction #
         ###################
         def self.abstract( auth, type_name, method_name, key, param = nil, &func )
-          body = make_type( param )
-          response = request( auth, Service, method_name, body )
+          response = request( auth, Service, method_name, make_type( param ) )
           process( response, key ){ |x| func[ x ] }
         end
 
-        type_list = ['keyword', 'query', 'creative', 'sublink']
-        type_list.each do |type|
+        %w(keyword query creative sublink).each do |type|
           # type
           define_singleton_method type.to_sym do |auth, param|
               abstract( auth, type, type, type+'List', param ){ |x| x}
           end
           # typeCount
           define_singleton_method (type+'_count').to_sym do |auth, param|
-              response = abstract( auth, type, type+'Count', '', param ){ |x| get_item(x) }
-              response[:result] = response[:result][0]
-              return response
+              abstract( auth, type, type+'Count', '', param ){ |x| reverse_type( x )[0] }
           end
           # typeNow
           define_singleton_method (type+'_now').to_sym do |auth, param|
@@ -52,9 +49,7 @@ module PPC
           end
           # typeNowCount
           define_singleton_method (type+'_now_count').to_sym do |auth, param|
-              response = abstract( auth, type, type+'NowCount', '', param ){ |x| get_item(x) }
-              response[:result] = response[:result][0]
-              return response
+              abstract( auth, type, type+'NowCount', '', param ){ |x| reverse_type( x )[0] }
           end
         end
 
@@ -71,86 +66,38 @@ module PPC
         
         def self.download_report(auth, type, param, debug = false)
           # deal_with time
-          now = Time.now.to_s[0...10]
-          is_now = now==parse_date(param[:startDate])
+          is_now = Date.today == Date.parse(param[:startDate])
         
           # get page num
-          if is_now
-            method = (type+'_now_count').to_sym
-            count = send(method, auth, param)[:result]
-            method = (type+'_now').to_sym
-          else
-            method = (type+'_count').to_sym
-            count = send(method, auth, param)[:result]
-            method = type.to_sym
-          end
+          method    = (type+ (is_now ? '_now' : '') + '_count').to_sym
+          response  = send(method, auth, param)
+          count     = response[:result]
+          method    = (type+ (is_now ? '_now' : '')).to_sym
           
-          report = []
-          count[:total_page].to_i.times do | page_i|
-            p "Start downloading #{page_i+1}th page, totally #{count[:total_page]} pages"
-            param[:page] = page_i +1
-            report_i = send(method, auth, param)[:result]
-            report += report_i
+          if count && count[:total_page]
+            count[:total_page].to_i.times.map{ | page_i|
+              p "Start downloading #{page_i+1}th page, totally #{count[:total_page]} pages"
+              param[:page] = page_i +1
+              send(method, auth, param)[:result]
+            }.flatten
+          else
+            response
           end
-        
-          return report
         end
 
         ###################
         # Helper Function #
         ###################
         # incase idlist == nil
-        private
-        def self.get_item( params )
-          return nil if params == nil
-          return reverse_type( params ) 
-        end
 
         private 
         def self.make_type( param )
-          type = {}
-          # add option
-          type[:level] = param[:level] || 'account'
-          type[:page] = param[:page] || 1
-          # add ids
-          if param[:ids] != nil
-            ids = param[:ids] 
-            ids = [ ids ] unless ids.is_a? Array
-            type[:IdList] = ids.to_json
-          end
-          # add date
-          if param[:startDate]==nil || param[:endDate]==nil
-            type[:startDate], type[:endDate] = get_date()
-          else
-            type[:startDate] = parse_date( param[:startDate] )
-            type[:endDate] = parse_date( param[:endDate] )
-          end
-
-          return type
-        end
-
-        private
-        def self.get_date()
-            endDate = Time.now.to_s[0,10]
-            startDate = (Time.now - 24*3600).to_s[0,10]
-          return startDate,endDate
-        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.to_s[0,10]
+          param[:level]   ||= 'account'
+          param[:page]    ||= 1
+          param[:IdList]    = [param.delete(:ids)].flatten.map(&:to_s)
+          param[:startDate] = Date.parse(param[:startDate]).to_s rescue Date.today.to_s
+          param[:endDate]   = Date.parse(param[:endDate]).to_s   rescue Date.today.to_s
+          param
         end
 
       end # Report