ppc 0.3.0

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['item']}
+          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/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

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

@@ -0,0 +1,135 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Shenma
+      class Report< Shenma
+        Service = 'Report'
+      
+        # 需要用到的映射集合
+        Type_map = { 'account' =>2, 'plan'=> 10, 'group'=> 11, 
+                      'keyword'=> 14, 'creative'=> 12, 'region'=> 3, 
+                       'query'=> 6, 'phone' => 22, 'app' => 23 }
+
+        Level_map = {  'account' => 2, 'plan' => 3, 'group' => 5, 
+                        'creative' => 7, 'keyword' => 11, 'phone' => 22,
+                         'app' => 23, 'pair' => 12 }
+
+        Unit_map = { 'day' => 5, 'month' => 3, 'default' => 8 }
+
+        def self.get_id( auth, params, debug = false )
+          request = make_reportrequest( params )
+          body =  { ReportRequestType: request }
+          response = request( auth, '/report/getReport' ,body) 
+          process( response, 'reportId', debug ){ |x| x }
+        end
+
+        def self.get_state( auth, id, debug = false)
+          '''
+          input id should be string
+          '''
+          status = {1=>'Waiting' ,2=>'Opearting' ,3=>'Finished'}
+          body = { taskId:  id }
+          response = request( auth, '/task/getTaskState' ,body)
+          process( response, 'isGenerated', debug ){ |x| status[x] }
+        end
+
+        # todo : rewrite method
+        def self.download( auth, id, debug = false )
+          body = { fileId:  id }
+          response = request( auth, '/file/download' ,body)
+          process( response, 'reportPath', debug ){ |x| x }       
+        end
+
+        private
+        def self.make_reportrequest( param )
+          '''
+          make RepoerRequestType
+          ======================
+          For more docs please have a look at
+          ::PPC::API::Baidu::Report:make_reportrequest()
+          '''
+          requesttype = {}
+          requesttype[:performanceData]    =     param[:fields] 
+          requesttype[:reportType]         =     Type_map[ param[:type] ]        if  param[:type] 
+          requesttype[:levelOfDetails]     =     Level_map[  param[:level] ]     if param[:level]
+          requesttype[:statRange]          =     Level_map[ param[:range] ]      if param[:range]
+          requesttype[:unitOfTime]         =     Unit_map[ param[:unit] ]        if param[:unit]
+          requesttype[:idOnly]             =     param[:id_only]   || false
+          requesttype[:statIds]            =     param[:ids] if param[:ids] != nil
+          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.to_s[0,10]
+        end
+
+        def download_report( auth, param, debug = false )
+          response = call('report').get_id( auth, param )
+          if response[:succ]
+            id = response[:result]
+            p "Got report id:" + id.to_s if debug 
+            loop do
+              sleep 2 
+              break if call('report').get_state( auth, id )[:result] == 'Finished'
+              p "Report is not generated, waiting..." if debug 
+            end
+            # need to rewrite the download method here.
+            url = call('report').get_url( auth, id )[:result]
+            return open(url).read.force_encoding('gb18030').encode('utf-8')
+          else
+            raise response[:failure][0]["message"]
+          end
+        end
+
+        ###########################
+        # intreface for Operation #
+        ###########################
+        def query_report( auth, param = nil, debug = false )
+          param = {} if not param
+          param[:type]   ||= 'query'
+          param[:fields] ||=  %w(click)
+          param[:level]  ||= 'pair'
+          param[:range]  ||= 'account'
+          param[:unit]   ||= 'day'
+          download_report( param, debug )
+        end
+
+        def creative_report( auth, param = nil, debug = false )
+          param = {} if not param
+          param[:type]   ||= 'creative'
+          param[:fields] ||=  %w( cost cpc click impression ctr )
+          param[:level]  ||= 'creative'
+          param[:range]  ||= 'creative'
+          param[:unit]   ||= 'day'
+          download_report( param, debug )
+        end
+
+        def keyword_report( auth, param = nil, debug = false )
+          param = {} if not param
+          param[:type]   ||= 'keyword'
+          param[:fields] ||=  %w( cost cpc click impression ctr )
+          param[:level]  ||= 'keywordid'
+          param[:range]  ||= 'keywordid'
+          param[:unit]   ||= 'day'
+          download_report( param, debug )
+        end
+
+      end # Repost
+    end # Baidu
+  end # API
+end # PPC

data/lib/ppc/api/sogou.rb

@@ -0,0 +1,122 @@
+require 'savon'
+require 'active_support'
+require 'ppc/api/sogou/account'
+require 'ppc/api/sogou/plan'
+require 'ppc/api/sogou/group'
+require 'ppc/api/sogou/keyword'
+require 'ppc/api/sogou/report'
+require 'ppc/api/sogou/creative'
+
+module PPC
+  module API
+    class Sogou
+
+      @map = nil
+      @@debug = false
+
+      def self.debug_on
+        @@debug = true
+      end
+
+      def self.debug_off
+        @@debug = false
+      end
+
+      def self.request( auth, service, method, params = {})
+        '''
+        ps. in savon3, .hash method will turn CamelXML to snake hash
+        preprocess response, extract 
+        '''
+
+        service = service + "Service"
+        client = Savon.new( "http://api.agent.sogou.com:8080/sem/sms/v1/#{service}?wsdl" )
+        operation = client.operation( service, service, method )
+            
+        operation.header = { 
+            AuthHeader:{
+                username:   auth[:username],
+                password:   auth[:password],
+                token:      auth[:token]
+                              }
+                                        }
+        operation.body = {  (method+'Request').to_sym => params }
+        # debug print
+        debug_print( operation ) if @@debug
+        result = operation.call.hash[:envelope]
+        #extract header and body
+        response = { }
+        response[:header] = result[:header][:res_header]
+        response[:body] = result[:body][ (method + "Response").snake_case.to_sym ]
+        # debug print
+        p response if @@debug
+        return response
+      end
+
+      def self.debug_print( operation )
+        p '{:header=>' + operation.header.to_s + ',  :body=>' + operation.body.to_s + '}'
+      end
+
+      def self.process( response, key, debug = false, &func )
+        '''
+        @input
+        : type key : string
+        : param key : type name, we will transfer camel string 
+                               into snake_case symbol inside the method
+        '''
+        return response if debug
+
+        result = {}
+        result[:succ] = response[:header][:desc]=='success'? true : false
+        result[:failure] = response[:header][:failures]
+        result[:result] = func[ response[:body][ key.snake_case.to_sym ] ]
+        return result
+      end
+
+     def self.make_type( params, map = @map)
+        '''
+        For more info visit ::PPC::API::sogou:make_type
+        '''
+        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 != nil
+            end
+
+          types << type
+        end
+        return types
+      end
+
+      def self.reverse_type( types, map = @map )
+        '''
+        For more info visit ::PPC::API::sogou:reverse_type
+        Here, the camel key will be turn into snake key
+        '''
+        types = [ types ] unless types.is_a? Array
+
+        params = []
+        types.each do |type|
+          param = {}
+          
+            map.each do |key|
+                # 这里做两次转换并不是十分高效的方法，考虑maintain两张map
+                value = type[ key[1].to_s.snake_case.to_sym ]
+                param[ key[0] ] = value if value != nil
+            end
+
+          params << param
+        end
+        return params
+      end
+
+
+
+    end
+  end
+end
+