ppc 0.3.0 → 1.0.1

data/lib/ppc/api/shenma.rb

@@ -1,64 +0,0 @@
-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

@@ -1,135 +0,0 @@
-# -*- 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

@@ -1,122 +0,0 @@
-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
-

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

@@ -1,42 +0,0 @@
-module PPC
-  module API
-    class Sogou
-      class Account< Sogou
-        Service = 'Account'
-
-        @map = [
-                [:id,:accountid],            
-                [:balance,:balance],         
-                [:cost,:totalCost],               
-                [:payment,:totalPay],                          
-                [:budget_type,:type],                   
-                [:budget,:budget],                              
-                [:region,:regions],                    
-                [:exclude_ip,:excludeIps],                        
-                [:open_domains,:domains],                  
-                [:offline_time,:budgetOfflineTime],         
-                [:opt,:opt]                                  
-              ]
-
-        def self.info(auth, debug = false)
-          response = request(auth,Service,'getAccountInfo'  )
-          return process( response, 'accountInfoType', debug ){ |x|reverse_type(x)[0] }
-        end
-
-        def self.update(auth, param = {}, debug = false)
-          """
-          update account info
-          @ params : account_info_type
-          @return : account info_type
-          """
-          # for account service, there is not bulk operation
-          infoType = make_type( param )[0]
-          body = { accountInfoType: infoType }
-          response = request(auth,Service,'updateAccountInfo', body)
-          return process( response, 'accountInfoType', debug ){ |x|reverse_type(x)[0] }
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-# -*- coding:utf-8 -*-
-module PPC
-  module API
-    class Sogou
-      class Creative< Sogou
-        Service = 'CpcIdea'
-
-        @map =[
-                        [:id,:cpcIdeaId],
-                        [:group_id,:cpcGrpId],
-                        [:title,:title],
-                        [:description1,:description1],
-                        [:description2,:description2],
-                        [:pc_destination,:visitUrl],
-                        [:pc_display,:showUrl],
-                        [:moile_destination,:mobileVisitUrl],
-                        [:mobile_display,:mobileShowUrl],
-                        [:pause,:pause],
-                        [:status,:status] 
-                      ]
-
-        @status_map = [
-                                    [:id,:cpcIdeaId],
-                                    [:status,:status]
-                                  ]
-
-
-        def self.add( auth, creatives, debug = false )
-          body = { cpcIdeaTypes: make_type( creatives ) }
-          response = request( auth, Service, 'addCpcIdea', body )
-          process( response, 'cpcIdeaTypes', debug ){ |x| reverse_type(x) }
-        end
-
-        def self.get( auth, ids,  getTemp = 0, debug = false  )
-          '''
-          \'getCreativeByCreativeId\'
-          @ input : creative ids
-          @ output: creative informations
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcIdeaIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCpcIdeaByCpcIdeaId', body )
-          process( response, 'cpcIdeaTypes', debug ){ |x| reverse_type(x) }
-        end
-
-        def self.update( auth, creatives, debug = false )
-          '''
-          根据实际使用情况，更新的时候creative title为必填选
-          '''
-          body = { cpcIdeaTypes: make_type( creatives ) }
-          response = request( auth, Service, 'updateCpcIdea', body )
-          process( response, 'cpcIdeaTypes', debug ){ |x| reverse_type(x) }
-        end
-
-        def self.delete( auth, ids, debug = false )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcIdeaIds: ids }
-          response = request( auth, Service, 'deleteCpcIdea', body )
-          process( response, 'nil', debug ){ |x| x }
-        end
-
-        def self.status( auth, ids, getTemp = 0,  debug = false )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcIdeaIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCpcIdeaByCpcIdeaId', body )
-          process( response, 'cpcIdeaTypes', debug ){ |x| reverse_type(x, @status_map) }
-        end
-
-        def self.search_id_by_group_id( auth, ids,  getTemp = 0, debug = false )
-          '''
-          \'getCreativeIdByAdgroupId\'
-          @ input: group ids
-          @ output:  groupCreativeIds
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcGrpIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCpcIdeaIdByCpcGrpId', body )
-          process( response, 'cpcGrpIdeaIds', debug ){ |x| make_groupCreativeIds( x ) }
-        end
-
-        def self.search_by_group_id( auth, ids,  getTemp = 0, debug = false )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcGrpIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCpcIdeaByCpcGrpId', body )
-          process( response, 'cpcGrpIdeas', debug ){ |x| make_groupCreatives( x ) }
-        end
-
-        private
-        def self.make_groupCreativeIds( cpcGrpIdeaIdTypes )
-          cpcGrpIdeaIdTypes = [cpcGrpIdeaIdTypes] unless cpcGrpIdeaIdTypes.is_a? Array
-          group_creative_ids = []
-          cpcGrpIdeaIdTypes.each do |cpcGrpIdeaIdType|
-            group_creative_id = { }
-            group_creative_id[:group_id] = cpcGrpIdeaIdType[:cpc_grp_id]
-            group_creative_id[:creative_ids] = cpcGrpIdeaIdType[:cpc_idea_ids]
-            group_creative_ids << group_creative_id
-          end
-          return group_creative_ids
-        end
-
-        private
-        def self.make_groupCreatives( cpcGrpIdeaTypes )
-          cpcGrpIdeaTypes = [cpcGrpIdeaTypes] unless cpcGrpIdeaTypes.is_a? Array
-          group_creatives = []
-          cpcGrpIdeaTypes.each do |cpcGrpIdeaType|
-            group_creative = {}
-            group_creative[:group_id] = cpcGrpIdeaType[:cpc_grp_id]
-            group_creative[:creatives] = reverse_type( cpcGrpIdeaType[:cpc_idea_types] )
-            group_creatives << group_creative
-          end
-          return group_creatives
-        end
-
-      end
-    end
-  end
-end