ppc 0.3.0 → 1.0.1

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

@@ -1,68 +0,0 @@
-module PPC
-  module API
-    class Baidu
-      class Plan< Baidu
-        Service = 'Campaign'
-
-        @map = [
-                [:id,:campaignId],
-                [:name,:campaignName],
-                [:budget,:budget], 
-                [:region,:regionTarget],
-                [:ip,:excludeIp] ,
-                [:negative,:negativeWords],
-                [:exact_negative,:exactNegativeWords],
-                [:schedule,:schedule], 
-                [:budget_offline_time,:budgetOfflineTime],
-                [:show_prob,:showProb],   
-                [:device,:device],
-                [:price_ratio,:priceRatio], 
-                [:is_dynamic,:isDynamicCreative],
-                [:pause,:pause],
-                [:status,:status]
-               ]
-
-        def self.all( auth )
-          response = request( auth, Service, 'getAllCampaign' )
-          process( response, 'campaignTypes' ){ |x| reverse_type(x) }
-        end
-
-        def self.ids( auth )
-          response = request( auth, Service, 'getAllCampaignId' )
-          process( response, 'campaignIds' ){ |x| x }
-        end
-
-        def self.get( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { campaignIds: ids }
-          response = request( auth, Service, 'getCampaignByCampaignId', body)
-          process( response, 'campaignTypes' ){ |x| reverse_type(x) }
-        end
-
-        def self.add( auth, plans )
-          campaigntypes = make_type( plans )
-          # set extended = 1 to allow change of isDynamicCreative
-          body = { campaignTypes: campaigntypes, extended:1 }
-          response = request( auth, Service, 'addCampaign', body)
-          process( response, 'campaignTypes' ){ |x| reverse_type(x) }
-        end
-
-        def self.update(auth,plans )
-          campaigntypes = make_type( plans )
-          # set extended = 1 to allow change of isDynamicCreative
-          body = { campaignTypes: campaigntypes, extended:1 }
-          response = request( auth, Service, 'updateCampaign', body)
-          process( response, 'campaignTypes' ){ |x| reverse_type(x) }
-        end
-
-        def self.delete(auth, ids )
-          ids = [ ids ] unless ids.class == Array
-          body = { campaignIds: ids }
-          response = request( auth, Service, 'deleteCampaign', body)
-          process( response, 'result' ){ |x| x }
-        end
-       
-      end # Service
-    end # baidu
-  end # API
-end # PPC

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

@@ -1,143 +0,0 @@
-# -*- coding:utf-8 -*-
-module PPC
-  module API
-    class Baidu
-      class Report< Baidu
-        Service = 'Report'
-      
-        # 需要用到的映射集合
-        Type_map = { 'account' => 2, 'plan'=> 10, 'group'=> 11, 
-                      'keyword'=> 14, 'creative'=> 12, 'pair'=> 15, 
-                       'region'=> 3, 'wordid'=> 9 , 'query'=>6 }
-
-        Level_map = {  'account' => 2, 'plan' => 3, 'group' => 5, 
-                        'creative'=> 7, 'keywordid' => 11, 'pair' => 12, 
-                         'wordid' => 6 }
-
-        Device_map = { 'all' => 0, 'pc' => 1, 'mobile' => 2 }
-
-        Unit_map = { 'day' => 5, 'week' => 4, 'month' => 3, 'year' => 1, 'hour' => 7 }
-
-        ########################
-        # API wraping function #
-        ########################
-        def self.get_id( auth, params  )
-          request = make_reportrequest( params )
-          body =  { reportRequestType:  request }
-          response = request( auth, Service, 'getProfessionalReportId' ,body) 
-          process( response, 'reportId' ){ |x| x }
-        end
-
-        def self.get_state( auth, id )
-          '''
-          input id should be string
-          '''
-          status = {1=>'Waiting' ,2=>'Opearting' ,3=>'Finished'}
-          body = { reportId:  id }
-          response = request( auth, Service, 'getReportState' ,body)
-          process( response, 'isGenerated' ){ |x| status[x] }
-        end
-
-        def self.get_url( auth, id  )
-          body = { reportId:  id }
-          response = request( auth, Service, 'getReportFileUrl' ,body)
-          process( response, 'reportFilePath' ){ |x| x }       
-        end
-        
-        private
-        def self.make_reportrequest( param )
-          """
-          make RepoerRequestType
-          ==============
-          @Input : :fields,:type,:level,:range,:unit,:device,:id_only,:startDate:endDate
-          ==============
-          Note:
-            We cast [ type, level, range, unit,device ] from int to string.
-          For more information please see those map at the begining of the file
-          """
-          requesttype = {}
-          requesttype[:performanceData]   =     param[:fields]  || %w(click impression)
-          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[:device]            =     Device_map[ param[:device] ]  if param[:device]
-          requesttype[:idOnly]            =     param[:id_only] || false
-          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
-        end
-
-        #################################
-        # useful function for operation #
-        #################################
-        def self.query_report( auth, param = nil, debug = false )
-          param = {} if not param
-          param[:type]   ||= 'query'
-          param[:fields] ||=  %w(click impression)
-          param[:level]  ||= 'pair'
-          param[:range]  ||= 'account'
-          param[:unit]   ||= 'day'
-          download_report( auth, param, debug )
-        end
-
-        def self.creative_report( auth, param = nil, debug = false )
-          param = {} if not param
-          param[:type]   ||= 'creative'
-          param[:fields] ||=  %w(impression click cpc cost ctr cpm position conversion)
-          param[:level]  ||= 'creative'
-          param[:range]  ||= 'creative'
-          param[:unit]   ||= 'day'
-          download_report( auth, param, debug )
-        end
-
-        def self.keyword_report( auth, param = nil, debug = false )
-          param = {} if not param
-          param[:type]   ||= 'keyword'
-          param[:fields] ||=  %w(impression click cpc cost ctr cpm position conversion)
-          param[:level]  ||= 'keywordid'
-          param[:range]  ||= 'keywordid'
-          param[:unit]   ||= 'day'
-          download_report( auth, param, debug )
-        end
-   
-        def self.download_report( auth, param, debug = false )
-          p param
-          response = 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 get_state( auth, id )[:result] == 'Finished'
-              p "Report is not generated, waiting..." if debug 
-            end
-
-            url = get_url( auth, id )[:result]
-            return open(url).read.force_encoding('gb18030').encode('utf-8')
-          else
-            raise response[:failure][0]["message"]
-          end
-        end
-
-      end # Repost
-    end # Baidu
-  end # API
-end # PPC

data/lib/ppc/api/qihu.rb

@@ -1,107 +0,0 @@
-# -*- coding:utf-8 -*-
-require 'ppc/api/qihu/account'
-require 'ppc/api/qihu/plan'
-require 'ppc/api/qihu/group'
-require 'ppc/api/qihu/keyword'
-require 'ppc/api/qihu/creative'
-require 'ppc/api/qihu/report'
-require 'httparty'
-require 'json'
-
-module PPC
-  module API
-    class Qihu
-
-      def self.request( auth, service, method, params = {} )
-        url = "https://api.e.360.cn/2.0/#{service}/#{method}"
-        # 日后考虑将httpparty用Net/http代替
-        response = HTTParty.post(url, 
-                body: params,
-                headers: {'apiKey' => auth[:token], 
-                                'accessToken' => auth[:accessToken], 
-                                'serveToken' => Time.now.to_i.to_s  }
-              )
-        response.parsed_response
-      end
-
-      def self.process( response, key, failure_key = '', &func )
-        response_key = response.keys[0]
-        content = response[ response_key ]
-        # special case solution
-        if content == nil
-          return{ succ:true, failure:nil, result:nil }
-        end
-
-        result = { }
-        if content['failures'] != nil
-          result[:succ] = false
-          result[:failure] = content['failures']['item']
-          result[:result] = nil
-        else
-          result[:succ] = true
-          result[:result] = func[ key==''? content : content[ key ] ]
-          result[:failure] = failure_key == ''? nil : content[ failure_key ]
-        end
-        return result
-      end
-
-      def self.to_json_string( items )
-        '''
-        convert list of string/int to list of json string
-        '''
-        return '' if items == nil
-        items = [items] unless items.is_a? Array
-        items_str = []
-        items.each{ |x| items_str << x.to_s }
-        items_str.to_json
-      end
-
-      def self.to_id_list( ids_str )
-        return [] if ids_str == nil
-        ids_str = [ids_str] unless ids_str.is_a? Array
-        ids_i = []
-        ids_str.each{ |id| ids_i<<id.to_i }
-        ids_i
-      end
-
-      def self.make_type( params, map = @map)
-        '''
-        '''
-        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 )
-        '''
-        '''
-        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 != nil
-            end
-
-          params << param
-        end
-        return params
-      end
-
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-# -*- coding:utf-8 -*-
-require 'json'
-module PPC
-  module API
-    class Qihu
-      class Account < Qihu
-        Service = 'account'
-
-        @map = [
-                [ :id, :uid ],
-                [ :name, :userName ],
-                [ :email, :email],
-                [ :company, :companyName],
-                [ :industry1, :industry1],
-                [ :industry2, :industry2],
-                [ :balance, :balance],
-                [ :budget, :budget],
-                [ :resources, :resources],
-                [ :open_domains, :allowDomain]
-              ]
-        
-        def self.info( auth )
-          response = request( auth, Service, 'getInfo' )
-          process( response, '' ){ |x| reverse_type( x )[0]}
-        end
-
-        def self.update( auth, params )
-          '''
-          对奇虎两个update的在封装。如果所有操作成功，succ为true，否则为false
-          failure中以字符串方式返回失败的操作
-          '''
-          result = {}
-          result[:succ] = true
-          result[:failure] = []
-          result[:result] = []
-
-          if params[:budget] != nil
-            budget_result = update_budget( auth, params[:budget] )
-            result[:succ] = result[:succ] && budget_result[:succ]
-            result[:failure] << 'budget' unless budget_result[:succ]
-          end
-
-          if params[:exclude_ip] != nil
-            ip_result = update_exclude_ip( auth, params[:exclude_ip] )
-            result[:succ] = result[:succ] && ip_result[:succ]
-            result[:failure] << 'exclude_ip' unless budget_result[:succ]
-          end
-
-          return result
-        end
-
-        def self.get_all_object( auth, ids )
-          #文档上面写的输入类型是String？
-          body = { 'idList' =>  ids }
-          response = request( auth, Service, 'getAllObjects' )
-          process( response, 'account_getAllObjects_response' ){ |x| x }
-        end
-
-        def self.get_file_state( auth, id )
-          body = { 'fileId' => id }
-          response = request( auth, Service, 'getAllObjects' , body )
-          process( response, 'account_getFileState_response' ){ |x| x }
-        end
-
-        def self.get_exclude_ip( auth )
-          response = request( auth, Service, 'getExcludeIp' )
-          process( response, 'excludeIpList' ){ |x| x['item'] }
-        end
-
-        private
-        def self.update_budget( auth, budget )
-          response = request( auth, Service, 'updateBudget', { budget:budget })
-          process( response, 'affectedRecords' ){ | x | x.to_i==1?'success':'failure' }
-        end
-
-        private
-        def self.update_exclude_ip( auth, ips )
-          ips = to_json_string( ips )
-          response = request( auth, Service, 'updateExcludeIp', { excludeIpList: ips } )
-          process( response, 'excludeIpList' ){ | x | x }
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-# -*- coding:utf-8 -*-
-module PPC
-  module API
-    class Qihu
-      class Creative< Qihu
-        Service = 'creative'
-
-        @map = [
-                 [:id,:id] ,
-                 [:group_id, :groupId],
-                 [:title,:title],
-                 [:description1, :description1],
-                 [:description2, :description2],
-                 [:pc_destination, :destinationUrl],
-                 [:pc_display, :displayUrl]
-                ]
-
-        @status_map = [ 
-                        [:id,:id], 
-                        [:quality,:qualityScore],
-                        [:status,:status]
-                      ]
-
-        def self.get( auth, ids )
-          body  = { 'idList' => to_json_string( ids ) }
-          response = request( auth, Service, 'getInfoByIdList', body )
-          process( response, 'creativeList'){ |x| reverse_type( x['item'] ) }
-        end
-
-        def self.add( auth,  creatives )
-          creative_types = make_type( creatives ).to_json
-          body = { 'creatives' => creative_types}
-          response = request( auth, Service, 'add', body )
-          process( response, 'creativeIdList'){ |x| to_id_hash_list( x['item'] ) }
-        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, creatives )
-          creative_types = make_type( creatives ).to_json
-          body = { 'creatives' => creative_types}
-          response = request( auth, Service, 'update', body )
-          process( response, 'affectedRecords', 'failCreativeIds' ){ |x| x }        
-        end
-
-         # 对update的再封装实现activate方法,未测试
-        def self.activate( auth, ids )
-          creatives = []
-          ids.each{ |id| creatives << { id: id, status:'enable'} }
-          update( auth, creatives )
-        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
-
-        def self.status( auth, ids )
-          body = { idList: to_json_string( ids ) }
-          response = request( auth, Service, 'getStatusByIdList', body )
-          process( response, 'creativeList' ){ |x| reverse_type( x['item'], @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)
-          # 处理条件  
-          body = {}
-          body['status'] = status if status
-          body['groupId'] = id
-          response = request( auth, Service, 'getIdListByGroupId', body )
-          # 伪装成百度接口
-          process( response, 'creativeIdList' ){ 
-            |x|  
-            [ { group_id:id, creative_ids:to_id_list( x==nil ? nil: x['item'] ) } ] 
-          }     
-        end
-
-        # combine two methods to provide another mether
-        def self.search_by_group_id( auth, id )
-          creative_ids = search_id_by_group_id( auth, id )
-          response = get( auth , creative_ids )
-          # 伪装成百度接口
-          if response[:succ]
-            response[:result] = [ { group_id:id, creatives:response[:result ] } ]
-          end
-          return response
-        end
-
-      end
-    end
-  end
-end