ppc 1.3.0 → 1.3.2

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

@@ -0,0 +1,113 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Qihu
+      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]
+                ]
+
+        @status_map = [ 
+                        [:id,:id], 
+                        [:quality,:qualityScore],
+                        [:status,:status]
+                      ]
+
+        def self.get( auth, ids )
+          ids = to_json_string( ids )
+          body  = { 'idList' => ids }
+          response = request( auth, Service, 'getInfoByIdList', body )
+          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)  }
+        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
+        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 }        
+        end
+
+        # 对update的再封装实现activate方法
+        def self.activate( auth, ids )
+          keywords = []
+          ids.each{ |id| keywords << { id: id, status:'enable'} }
+          update( auth, keywords )
+        end
+
+        def self.delete( auth, ids )
+          body = { 'idList' => to_json_string( ids ) }
+          response = request( auth, Service, 'deleteByIdList', body )
+          process( response, 'affectedRecords' ){ |x|  x  }     
+        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) }     
+        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
+        end
+
+        def self.getChangedIdList
+          # unimplemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Qihu
+      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]
+        ]
+
+
+        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) }
+        end
+
+        # 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)}
+        end 
+
+        # combine two original method to provice new method
+        def self.all( auth )
+          plan_ids = ids( auth )[:result]
+          get( auth, plan_ids )
+        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 } ] }
+        end
+
+        def self.update( auth, plan ) 
+          response = request( auth, Service, 'update', make_type( plan )[0])
+          #同上，保证接口一致性
+          process( response, 'id' ){ |x| [ { id:x.to_i } ] }
+        end
+
+        def self.delete( auth, id )
+          response = request( auth, Service, 'deleteById', { id: id } )
+          process( response, 'affectedRecords' ){ |x|  x == '1'? 'success' : 'fail' }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module PPC
+  module API
+    class Qihu
+      class Rank < Qihu
+        Service = 'tool'
+
+        @map = [
+                 [:id,:id] ,
+                 [:group_id, :groupId],
+                 [:anchor,:text],
+                 [:url, :link],
+                 [:image, :image],
+                 [:status, :status]
+                ]
+
+        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'] ) }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+# -*- coding:utf-8 -*-
+require 'json'
+
+module PPC
+  module API
+    class Qihu
+      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]
+              ]
+
+        ###################
+        # 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 )
+          process( response, key ){ |x| func[ x ] }
+        end
+
+        type_list = ['keyword', 'query', 'creative', 'sublink']
+        type_list.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
+          end
+          # typeNow
+          define_singleton_method (type+'_now').to_sym do |auth, param|
+              abstract( auth, type, type+'Now', type+'List', param ){ |x| x['item']}
+          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
+          end
+        end
+
+        ############################
+        # Interfaces for operation #
+        ############################
+        def self.keyword_report( auth, param, debug = false )
+          download_report(auth, 'keyword', param, debug )
+        end
+
+        def self.creative_report( auth, param, debug = false )
+          download_report(auth, 'creative', param, debug)
+        end
+        
+        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])
+        
+          # 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
+          
+          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
+          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]
+        end
+
+      end # Report
+    end # Qihu
+  end # API
+end # PPC

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

@@ -0,0 +1,71 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Qihu
+      class Sublink< Qihu
+        Service = 'sublink'
+
+        @map = [
+                 [:id,:id] ,
+                 [:group_id, :groupId],
+                 [:anchor,:text],
+                 [:url, :link],
+                 [:image, :image],
+                 [:status, :status]
+                ]
+
+        def self.get( auth, ids )
+          body  = { 'idList' => to_json_string( ids ) }
+          response = request( auth, Service, 'getInfoByIdList', body )
+          process( response, 'sublinkList'){ |x| reverse_type( x['item'] ) }
+        end
+
+        def self.add( auth, sublinks )
+          sublink_types = make_type( sublinks ).to_json
+          body = { 'sublinks' => sublink_types}
+          response = request( auth, Service, 'add', body )
+          process( response, 'sublinkIdList'){ |x| to_id_hash_list( x['item'] ) }
+        end
+
+        def self.delete( auth, ids )
+          ids = to_json_string( ids )
+          body = { 'idList' => ids }
+          response = request( auth, Service, 'deleteByIdList', body )
+          process( response, 'affectedRecords' ){ |x|x }     
+        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
+        end
+
+        def self.update( auth, sublinks )
+          sublink_types = make_type( sublinks ).to_json
+          body = { 'sublinks' => sublink_types}
+          response = request( auth, Service, 'update', body )
+          process( response, 'affectedRecords', 'failKeywordIds' ){ |x| x }        
+        end
+
+         # 对update的再封装实现activate方法,未测试
+        def self.activate( auth, ids )
+          sublinks = []
+          ids.each{ |id| sublinks << { id: id, status:'enable'} }
+          update( auth, sublinks )
+        end       
+
+        def self.delete( auth, ids )
+          ids = to_json_string( ids )
+          body = { 'idList' => ids }
+          response = request( auth, Service, 'deleteByIdList', body )
+          process( response, 'affectedRecords' ){ |x|x }     
+        end
+
+      end
+    end
+  end
+end

data/lib/ppc/api/shenma.rb

@@ -0,0 +1,64 @@
+module PPC
+  module API
+    class Baidu
+      @map = nil
+      @@debug = false
+
+      def self.debug_on
+        @@debug = true
+      end
+
+      def self.debug_off
+        @@debug = false
+      end
+
+      def self.request( auth, path, params = {} )
+        '''
+        request should return whole http response including header
+        '''
+        uri = URI("https://e.sm.cn#{path}")
+        http_body = {
+          header: {
+            username:   auth[:username],
+            password:   auth[:password],
+            token:      auth[:token],
+            target:     auth[:tarvget]
+          },
+          body: params
+        }.to_json
+
+        http_header = {
+          'Content-Type' => 'application/json; charset=UTF-8'
+        }
+
+        http = Net::HTTP.new(uri.host, 443)
+        # 是否显示http通信输出
+        http.set_debug_output( $stdout ) if @@debug
+        http.use_ssl = true
+
+        response = http.post(uri.path, http_body, http_header)
+        response = JSON.parse( response.body )
+      end
+
+      def self.process( response, key, &func)
+        '''
+        Process Http response. If operation successes, return value of given keys.
+        You can process the result using function &func, or do nothing by passing 
+        block {|x|x}
+        =========================== 
+        @Output: resultType{ desc: boolean, failure: Array,  result: Array }
+
+        failure is the failures part of response\'s header
+        result is the processed response body.
+        '''
+        p response
+        result = {}
+        result[:succ] = response['header']['desc']=='success'? true : false
+        result[:failure] = response['header']['failures']
+        result[:result] = func[ response['body'][key] ]
+        return result
+      end # process
+      
+    end
+  end
+end