ppc 1.3.0 → 1.3.2

data/lib/ppc.rb

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

data/lib/ppc/api.rb

@@ -1,8 +1,143 @@
+require 'awesome_print'
+require 'net/http'
+require 'net/https'
+require 'httparty'
+require 'json'
+require 'savon'
+require 'active_support'
 require 'ppc/api/baidu'
+require 'ppc/api/sogou'
+require 'ppc/api/qihu'
+require 'ppc/api/sm'
 
 module PPC
   module API
-    attr_reader :header,:body,:rquota,:quota,:status,:desc,:oprs,:oprtime,:code,:message
-    attr_accessor :username,:password,:token,:debug
+
+    @map = nil
+    @debug = false
+
+    def debug_on
+      @debug = true
+    end
+
+    def debug_off
+      @debug = false
+    end
+
+    def request_uri(param = {})
+      raise 'you need build the uri'
+    end
+
+    def request_http_body(auth, params = {})
+      {
+        header: {
+          username:   auth[:username],
+          password:   auth[:password],
+          token:      auth[:token],
+          target:     auth[:target]
+        },
+        body: params
+      }.to_json
+    end
+
+    def request_http_header(auth)
+      {'Content-Type' => 'application/json; charset=UTF-8'}
+    end
+
+    def request(auth, service, method, params = {}, http_method = 'post')
+      '''
+        request should return whole http response including header
+      '''
+      uri = request_uri(service: service, method: method)
+      http_body = request_http_body(auth, params)
+      http_header = request_http_header(auth)
+
+      # set request proxy
+      if ENV["PROXY_HOST"]
+        proxy_port = ENV["PROXY_PORT"] ? ENV["PROXY_PORT"].to_i : 80
+        http = Net::HTTP.new(uri.host, 443, ENV["PROXY_HOST"], proxy_port)
+      else
+        http = Net::HTTP.new(uri.host, 443)
+      end
+
+      # 是否显示http通信输出
+      http.set_debug_output( $stdout ) if @debug
+      http.use_ssl = true
+      if http_method == 'delete'
+        req = Net::HTTP::Delete.new(uri.path, http_header)
+        req.body = http_body
+        response = http.request req
+      else
+        response = http.post(uri.path, http_body, http_header)
+      end
+      begin JSON.parse(response.body) rescue response.body end
+    end
+
+    def 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.
+      '''
+      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
+        @ input
+          params : list of hash complying with PPC gem api  
+          map : list of pairs(lists) of symbol complying with following api
+          map = [ 
+                        [ ppc_key, api_key ],
+                        [ ppc_key, api_key ],
+                        [ ppc_key, api_key ],
+                                        ...
+                        ]
+          Ex: 
+          baidu_group_map = [ [ :id, :adgroupId],
+                                                  [ :price, :maxPrice],
+                                                          ...                 ]
+        ===================
+        @ 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])}
+        item
+      end
+    end
+
+    def reverse_type( types, maps = @map )
+      '''
+        transfer search engine api to ppc api
+        @ input
+          types : list of hash that complying with search engine api
+          map : list of pairs(lists) of symbol, for more details please 
+                      read docs of make_type()
+        ===================
+        @ 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])}
+        item
+      end
+    end
   end
 end

data/lib/ppc/api/baidu.rb

@@ -6,127 +6,48 @@ require 'ppc/api/baidu/group'
 require 'ppc/api/baidu/keyword'
 require 'ppc/api/baidu/report'
 require 'ppc/api/baidu/creative'
-require 'awesome_print'
-require 'net/http'
-require 'net/https'
-require 'json'
+require 'ppc/api/baidu/phone_new_creative'
+require 'ppc/api/baidu/rank'
+
 module PPC
   module API
-    class Baidu
-
-      @map = nil
-
-      def self.request( auth, service, method, params = {} )
-        '''
-        request should return whole http response including header
-        '''
-        uri = URI("https://api.baidu.com/json/sms/v3/#{service}Service/#{method}")
-        http_body = {
-          header: {
-            username:   auth[:username],
-            password:   auth[:password],
-            token:      auth[:token]
-          },
-          body: params
-        }.to_json
-
-        http_header = {
-          'Content-Type' => 'application/json; charset=UTF-8'
-        }
+    class Baidu 
 
-        http = Net::HTTP.new(uri.host, 443)
-        http.set_debug_output $stderr
-        http.use_ssl = true
-
-        response = http.post(uri.path, http_body, http_header)
-        response = JSON.parse response.body
-
-        # return response if with_header else response['body']
+      extend ::PPC::API
+      
+      def self.request_uri(param)
+        URI("https://api.baidu.com/json/sms/v3/#{param[:service]}Service/#{param[:method]}")
       end
 
-      def self.process( response, key , debug = false ,  &func)
+      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.
         '''
-        # 保留 debug 功能
-        return response if debug
-
         result = {}
-        result[:succ] = response['header']['desc']=='success'? true : false
+        result[:succ] = response['header']['desc'] =='success'
         result[:failure] = response['header']['failures']
-        result[:result] = func[ response['body'][key] ]
-        return result
-      end # process
-
-      def self.make_type( params, map = @map)
-        '''
-        tranfesr ppc api to search engine api
-        @ input
-          params : list of hash complying with PPC gem api  
-          map : list of pairs(lists) of symbol complying with following api
-          map = [ 
-                        [ ppc_key, api_key ],
-                        [ ppc_key, api_key ],
-                        [ ppc_key, api_key ],
-                                        ...
-                        ]
-          Ex: 
-          baidu_group_map = [ [ :id, :adgroupId],
-                                                  [ :price, :maxPrice],
-                                                          ...                 ]
-        ===================
-        @ output:
-        : types : list of hash that complying with search engine api
-        '''
-        params = [ params ] unless params.is_a? Array
-
-        types = []
-        params.each do |param|
-          type = {}
-
-            map.each do |key|
-              value = param[ key[0] ]
-              type[ key[1] ] = value if value
-            end
-
-          types << type
+        if !response['body'].nil? && response['body'][key]
+          result[:result] = func[ response['body'][key] ]
         end
-        return types
+        result[:no_quota] = is_no_quota(response['header']['failures'], '8501')
+        return result
       end
 
-      def self.reverse_type( types, map = @map )
-        '''
-        transfer search engine api to ppc api
-        @ input
-          types : list of hash that complying with search engine api
-          map : list of pairs(lists) of symbol, for more details please 
-                      read docs of make_type()
-        ===================
-        @ output:
-          params : list of hash complying with PPC gem api  
-        '''
+      def self.reverse_type( types, maps = @map )
         types = [ types ] unless types.is_a? Array
-
-        params = []
-        types.each do |type|
-          param = {}
-          
-            map.each do |key|
-                value = type[ key[1].to_s ]
-                param[ key[0] ] = value if value
-            end
-
-          params << param
+        types.map do |item| 
+          maps.each{|m| item.filter_and_replace_key(m[0],m[1].to_s)}
+          item
         end
-        return params
       end
 
-      end # Baidu
+    end # Baidu
   end # API
 end # PPC

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

@@ -5,30 +5,30 @@ module PPC
         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]                                  
-                        ]
+                  [: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]                                  
+                ]
 
-        def self.info(auth, debug = false)
+        def self.info( auth )
           response = request(auth,Service,'getAccountInfo'  )
-          return process( response, 'accountInfoType', debug ){ |x|reverse_type(x) }
+          return process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
         end
 
-        def self.update(auth, param = {}, debug = false)
+        def self.update(auth, param = {} )
           """
           update account info
           @ params : account_info_type
@@ -38,7 +38,7 @@ module PPC
           infoType = make_type( param )[0]
           body = { accountInfoType: infoType }
           response = request(auth,Service,'updateAccountInfo', body)
-          return process( response, 'accountInfoType', debug ){ |x|reverse_type(x) }
+          return process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
         end
 
       end

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

@@ -23,16 +23,52 @@ module PPC
             extended:                 params[:extended]     || 0
           }
           response = request( auth, Service, 'getAllObjects',options )
-          response[:get_all_objects_response][:file_id]
+          process( response, 'fileId'){ |x| x }
         end
 
         def self.state( auth, id)
           raise "empty id" if id.nil? or id.empty?
-          request(auth, Service, 'getFileState',{fileId:id})[:get_file_state_response][:is_generated]
+          response = request(auth, Service, 'getFileState',{fileId:id})
+          process( response, 'isGenerated'){ |x| x }
         end
 
         def self.path( auth, id)
-          request( auth, Service, 'getFilePath',{fileId:id})[:get_file_path_response][:file_paths]
+          response = request( auth, Service, 'getFilePath',{fileId:id})
+          process( response, 'filePaths' ){ |x| x }       
+        end
+
+        ###########################
+        # interface for operation #
+        ###########################
+        def self.download( auth, params = {} )
+          """
+          """
+          params[:extended] = params[:extended] || 2
+          begin
+            file_id = get_all_object( auth, params )
+            if file_id[:succ]
+              file_id = file_id[:result]
+            else
+              raise file_id[:failure][0]['message']
+            end
+
+            puts "file_id: #{file_id}" if @debug
+
+            loop do
+              state = state( auth, file_id )[:result].to_s
+              raise "invalid file state: #{state}" unless %w(1 2 3 null).include? state
+              break if state == '3'
+              puts "waiting for #{file_id} to be ready. current state:#{state}" if @debug
+              sleep 3
+            end
+
+            puts "#{file_id} is ready" if @debug
+            return path( auth, file_id )
+
+          rescue => e
+            p "Error encounter:#{e.to_s}"
+          end  
+          return false
         end
 
       end

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

@@ -6,26 +6,26 @@ module PPC
         Service = 'Creative'
 
         @map =[
-                        [:id,:creativeId],
-                        [:group_id,:adgroupId],
-                        [:title,:title],
-                        [:description1,:description1],
-                        [:description2,:description2],
-                        [:pc_destination,:pcDestinationUrl],
-                        [:pc_display,:pcDisplayUrl],
-                        [:moile_destination,:mobileDestinationUrl],
-                        [:mobile_display,:mobileDisplayUrl],
-                        [:pause,:pause],
-                        [:preference,:devicePreference] 
-                      ]
+                [: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] 
+              ]     
 
-        def self.add( auth, creatives, debug = false )
+        def self.add( auth, creatives )
           body = { creativeTypes: make_type( creatives ) }
           response = request( auth, Service, 'addCreative', body )
-          process( response, 'creativeTypes', debug ){ |x| reverse_type(x) }
+          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
         end
 
-        def self.get( auth, ids,  getTemp = 0, debug = false  )
+        def self.get( auth, ids, getTemp = 0 )
           '''
           \'getCreativeByCreativeId\'
           @ input : creative ids
@@ -34,49 +34,49 @@ module PPC
           ids = [ ids ] unless ids.is_a? Array
           body = { creativeIds: ids, getTemp: getTemp }
           response = request( auth, Service, 'getCreativeByCreativeId', body )
-          process( response, 'creativeTypes', debug ){ |x| reverse_type(x) }
+          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
         end
 
-        def self.update( auth, creatives, debug = false )
+        def self.update( auth, creatives )
           '''
           根据实际使用情况，更新的时候creative title为必填选
           '''
           body = { creativeTypes: make_type( creatives ) }
-          response = request( auth, Service, 'addCreative', body )
-          process( response, 'creativeTypes', debug ){ |x| reverse_type(x) }
+          response = request( auth, Service, 'updateCreative', body )
+          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
         end
 
-        def self.delete( auth, ids, debug = false )
+        def self.delete( auth, ids )
           ids = [ ids ] unless ids.is_a? Array
           body = { creativeIds: ids }
           response = request( auth, Service, 'deleteCreative', body )
-          process( response, 'result', debug ){ |x| x }
+          process( response, 'result' ){ |x| x }
         end
 
-        def self.activate( auth, ids, debug = false )
+        def self.activate( auth, ids )
           ids = [ ids ] unless ids.is_a? Array
           body = { creativeIds: ids }
           response = request( auth, Service, 'activateCreative', body )
-          process( response, 'creativeTypes', debug ){ |x| reverse_type(x) }
+          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
         end
 
-        def self.status( auth, ids, type, debug = false )
+        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
+            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', debug ){ |x| x }
+          process( response, 'CreativeStatus' ){ |x| x }
         end
 
-        def self.search_id_by_group_id( auth, ids,  getTemp = 0, debug = false )
+        def self.search_id_by_group_id( auth, ids, getTemp = 0 )
           '''
           \'getCreativeIdByAdgroupId\'
           @ input: group ids
@@ -85,14 +85,14 @@ module PPC
           ids = [ ids ] unless ids.is_a? Array
           body = { adgroupIds: ids, getTemp: getTemp }
           response = request( auth, Service, 'getCreativeIdByAdgroupId', body )
-          process( response, 'groupCreativeIds', debug ){ |x| make_groupCreativeIds( x ) }
+          process( response, 'groupCreativeIds' ){ |x| make_groupCreativeIds( x ) }
         end
 
-        def self.search_by_group_id( auth, ids,  getTemp = 0, debug = false )
+        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', debug ){ |x| make_groupCreatives( x ) }
+          process( response, 'groupCreatives' ){ |x| make_groupCreatives( x ) }
         end
 
         private
@@ -110,10 +110,10 @@ module PPC
         private
         def self.make_groupCreatives( groupCreatives )
           group_creatives = []
-          groupCreative.each do |groupKeyword|
+          groupCreatives.each do |groupCreative |
             group_creative = {}
             group_creative[:group_id] = groupCreative['adgroupId']
-            group_creative[:keywords] = reverse_type( groupCreative['keywordTypes'] )
+            group_creative[:creatives] = reverse_type( groupCreative['creativeTypes'] )
             group_creatives << group_creative
           end
           return group_creatives