ppc 0.3.0

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

@@ -0,0 +1,204 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Baidu
+      class Keyword< Baidu
+        Service = 'Keyword'
+
+        Match_type  = { 'exact' => 1, 'pharse' => 2, 'wide' => 3,1 => 'exact', 2=> 'pharse' , 3 => 'wide'  }
+        Device      = { 'pc' => 0, 'mobile' => 1, 'all' => 2 }
+        Type        = { 'plan' => 3, 'group' => 5, 'keyword' => 11 }
+        
+        @map  = [
+                  [:id,:keywordId],
+                  [:group_id,:adgroupId],
+                  [:keyword,:keyword],
+                  [:price,:price],
+                  [:pc_destination,:pcDestinationUrl],
+                  [:mobile_destination,:mobileDestinationUrl],
+                  [:match_type,:matchType],
+                  [:phrase_type,:phraseType],
+                  [:status,:status],
+                  [:pause,:pause]
+                ]
+
+        @quality10_map = [
+                          [ :id, :id ],
+                          [ :group_id, :adgroupId ],
+                          [ :plan_id, :Campaigned ],
+                          [ :pc_quality, :pcQuality ],
+                          [ :pc_reliable, :pcReliable ],
+                          [ :pc_reason, :pcReason ],
+                          [ :pc_scale, :pcScale ],
+                          [ :mobile_quality, :mobileQuality ],
+                          [ :mobile_reliable, :mobileReliable ],
+                          [ :mobile_reason, :mobileReason ],
+                          [ :mobile_scale, :mobileScale ]
+                          ]
+
+        # 后面改成info方法
+        def self.get( auth, ids )
+          '''
+          getKeywordByKeywordId
+          '''
+          ids = [ ids ] unless ids.is_a? Array
+          body = { keywordIds: ids}
+          response = request( auth, Service, 'getKeywordByKeywordId', body )
+          return process(response, 'keywordTypes' ){|x| reverse_type( x ) }
+        end
+
+        def self.add( auth, keywords )
+          '''
+          '''
+          keywordtypes = make_type( keywords ) 
+          body = { keywordTypes: keywordtypes }
+          response = request( auth, Service, "addKeyword", body )
+          return process(response, 'keywordTypes' ){|x| reverse_type(x)  }
+        end
+
+        def self.update( auth, keywords  )
+          '''
+          '''
+          keywordtypes = make_type( keywords ) 
+          body = { keywordTypes: keywordtypes }
+          response = request( auth, Service, "updateKeyword", body )
+          return process(response, 'keywordTypes' ){|x| reverse_type(x)  }
+        end
+
+        def self.delete( auth, ids )
+          """
+          """
+          ids = [ ids ] unless ids.is_a? Array
+          body = { keywordIds: ids}
+          response = request( auth, Service, 'deleteKeyword', body )
+          return process(response, 'result' ){|x| x }
+        end
+
+        def self.activate( auth, ids )
+          """
+          """
+          ids = [ ids ] unless ids.is_a? Array
+          body = { keywordIds: ids }
+          response = request( auth, Service, 'activateKeyword', body)
+          return process(response, 'keywordTypes' ){|x| reverse_type(x)  }
+        end
+
+        def self.search_by_group_id( auth, group_ids  )
+          """
+          getKeywordByGroupIds
+          @input: list of group id
+          @output:  list of groupKeyword
+          """
+          group_ids = [ group_ids ] unless group_ids.is_a? Array
+          body = { adgroupIds: group_ids }
+          response = request( auth, Service, "getKeywordByAdgroupId", body )
+          return process(response, 'groupKeywords' ){|x| make_groupKeywords( x ) }
+        end
+
+        def self.search_id_by_group_id( auth, group_ids  )
+          group_ids = [ group_ids ] unless group_ids.is_a? Array
+          body = { adgroupIds: group_ids }
+          response = request( auth, Service, "getKeywordIdByAdgroupId", body )
+          return process(response, 'groupKeywordIds' ){|x| make_groupKeywordIds( x ) }
+        end
+
+        # 下面三个操作操作对象包括计划，组和关键字
+        # 不知道放在这里合不合适
+        def self.status( auth, ids, type )
+          '''
+          Return [{ id: id, status: status } ... ]
+          '''
+          ids = [ ids ] unless ids.is_a? Array
+          body = { ids: ids, type: Type[type]}
+          response = request( auth, Service, 'getKeywordStatus', body )
+          return process(response, 'keywordStatus' ){  |statusTypes| 
+            statusTypes = [statusTypes] unless statusTypes.is_a? Array
+            status =[]
+
+            statusTypes.each do |statusType|
+              status << { id: statusType['id'], status: statusType['status'] }
+            end
+            return status
+           }
+        end
+
+        def self.quality( auth ,ids, type, device )
+          '''
+          Return 10Quanlity *Not the old Quality* of given ketword id
+          '''
+          ids = [ ids ] unless ids.is_a? Array
+          body = { ids: ids, type: Type[type], device:Device[device] }
+          response = request( auth, Service, 'getKeyword10Quality', body )
+          return process(response, 'keyword10Quality' ){|x| reverse_type( x, @quality10_map ) }
+        end
+
+        private
+        def self.make_groupKeywordIds( groupKeywordIds )
+          group_keyword_ids = []
+          groupKeywordIds.each do |groupKeywordId|
+            group_keyword_id = { }
+            group_keyword_id[:group_id] = groupKeywordId['adgroupIds']
+            group_keyword_id[:keyword_ids] = groupKeywordId['keywordIds']
+            group_keyword_ids << group_keyword_id
+          end
+          return group_keyword_ids
+        end
+
+        private
+        def self.make_groupKeywords( groupKeywords )
+          group_keywords = []
+          groupKeywords.each do |groupKeyword|
+            group_keyword = {}
+            group_keyword[:group_id] = groupKeyword['adgroupId']
+            group_keyword[:keywords] = reverse_type( groupKeyword['keywordTypes'] )
+            group_keywords << group_keyword
+          end
+          return group_keywords
+        end
+
+        # Override
+       def self.make_type( params, map = @map)
+          params = [ params ] unless params.is_a? Array
+          types = []
+          params.each do |param|
+            type = {}
+              map.each do |key|
+                # 增加对matchtype的自动转换
+                if key[0] == :match_type
+                   value = param[ key[0] ]
+                  type[ key[1] ] = Match_type[ value ] if value                 
+                else
+                  value = param[ key[0] ]
+                  type[ key[1] ] = value if value
+                end
+              end
+            types << type
+          end
+          return types
+        end
+
+        # Overwrite
+        def self.reverse_type( types, map = @map )
+          types = [ types ] unless types.is_a? Array
+          params = []
+          types.each do |type|
+            param = {}
+             # 增加对matchtype的自动转换
+              map.each do |key|
+                if key[0] == :match_type
+                   value = type[ key[1].to_s ]
+                  param[ key[0] ] = Match_type[ value ] if value                 
+                else
+                  value = type[ key[1].to_s ]
+                  param[ key[0] ] = value if value
+                end
+              end # map.each
+            params << param
+          end # types.each
+          return params
+        end
+
+      end # keyword
+    end # Baidu
+  end # API
+end # PPC

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

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

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

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