ppc 0.3.0

data/lib/ppc.rb

@@ -0,0 +1,17 @@
+require 'ppc/api'
+require 'ppc/operation'
+require 'ppc/ext'
+module PPC
+  VERSION = "0.3.0"
+
+  protected
+  def print_debug(var,varname=nil)
+    puts '=' * 10 + varname.to_s + '=' * 10
+    if var.is_a? String
+      puts var
+    else
+      ap var
+    end
+    puts '=' * 10 + varname.to_s + '=' * 10
+  end
+end

data/lib/ppc/api.rb

@@ -0,0 +1,10 @@
+require 'ppc/api/baidu'
+require 'ppc/api/sogou'
+require 'ppc/api/qihu'
+
+module PPC
+  module API
+    attr_reader :header,:body,:rquota,:quota,:status,:desc,:oprs,:oprtime,:code,:message
+    attr_accessor :username,:password,:token,:debug
+  end
+end

data/lib/ppc/api/baidu.rb

@@ -0,0 +1,138 @@
+# -*- coding:utf-8 -*-
+require 'ppc/api/baidu/account'
+require 'ppc/api/baidu/plan'
+require 'ppc/api/baidu/bulk'
+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'
+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, 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'
+        }
+
+        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.
+        '''
+        result = {}
+        result[:succ] = response['header']['desc']=='success'? true : false
+        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 != nil
+          end
+
+          types << type
+        end
+        return types
+      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  
+        '''
+        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 # Baidu
+  end # API
+end # PPC

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

@@ -0,0 +1,47 @@
+module PPC
+  module API
+    class Baidu
+      class Account< Baidu
+        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]                                  
+                ]
+
+        def self.info( auth )
+          response = request(auth,Service,'getAccountInfo'  )
+          return process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
+        end
+
+        def self.update(auth, param = {} )
+          """
+          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' ){ |x|reverse_type(x)[0] }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module PPC
+  module API
+    class Baidu
+      class Bulk < Baidu
+        Service = 'BulkJob'
+
+        def self.get_all_object( auth,params = {})
+          
+          plan_ids = params[:plan_ids]
+
+          unless plan_ids.nil?
+            plan_ids = plan_ids.class == Array ? plan_ids : [plan_ids]
+          end
+
+          options = {
+            campaignIds:              plan_ids              || []      ,
+            includeQuality:           params[:quality]      || true    ,
+            includeTemp:              params[:temp]         || false   ,
+            format:                   params[:format]       || 1       ,
+            newCreativeFiles:         params[:adcopy]       || 0       ,
+            includeTempNewCreatives:  params[:temp_adcopy]  || 0       ,
+            includePhraseType:        params[:phrase]       || 0       ,
+            extended:                 params[:extended]     || 0
+          }
+          response = request( auth, Service, 'getAllObjects',options )
+          response[:get_all_objects_response][:file_id]
+        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]
+        end
+
+        def self.path( auth, id)
+          request( auth, Service, 'getFilePath',{fileId:id})[:get_file_path_response][:file_paths]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Baidu
+      class Creative< Baidu
+        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] 
+                      ]
+
+        def self.add( auth, creatives )
+          body = { creativeTypes: make_type( creatives ) }
+          response = request( auth, Service, 'addCreative', body )
+          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.get( auth, ids, getTemp = 0 )
+          '''
+          \'getCreativeByCreativeId\'
+          @ input : creative ids
+          @ output: creative informations
+          '''
+          ids = [ ids ] unless ids.is_a? Array
+          body = { creativeIds: ids, getTemp: getTemp }
+          response = request( auth, Service, 'getCreativeByCreativeId', body )
+          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.update( auth, creatives )
+          '''
+          根据实际使用情况，更新的时候creative title为必填选
+          '''
+          body = { creativeTypes: make_type( creatives ) }
+          response = request( auth, Service, 'updateCreative', body )
+          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.delete( auth, ids )
+          ids = [ ids ] unless ids.is_a? Array
+          body = { creativeIds: ids }
+          response = request( auth, Service, 'deleteCreative', body )
+          process( response, 'result' ){ |x| x }
+        end
+
+        def self.activate( auth, ids )
+          ids = [ ids ] unless ids.is_a? Array
+          body = { creativeIds: ids }
+          response = request( auth, Service, 'activateCreative', body )
+          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
+        end
+
+        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
+            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' ){ |x| x }
+        end
+
+        def self.search_id_by_group_id( auth, ids, getTemp = 0 )
+          '''
+          \'getCreativeIdByAdgroupId\'
+          @ input: group ids
+          @ output:  groupCreativeIds
+          '''
+          ids = [ ids ] unless ids.is_a? Array
+          body = { adgroupIds: ids, getTemp: getTemp }
+          response = request( auth, Service, 'getCreativeIdByAdgroupId', body )
+          process( response, 'groupCreativeIds' ){ |x| make_groupCreativeIds( x ) }
+        end
+
+        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' ){ |x| make_groupCreatives( x ) }
+        end
+
+        private
+        def self.make_groupCreativeIds( groupCreativeIds )
+          group_creative_ids = []
+          groupCreativeIds.each do |groupCreativeId|
+            group_creative_id = { }
+            group_creative_id[:group_id] = groupCreativeId['adgroupIds']
+            group_creative_id[:creative_ids] = groupCreativeId['creativeIds']
+            group_creative_ids << group_creative_id
+          end
+          return group_creative_ids
+        end
+
+        private
+        def self.make_groupCreatives( groupCreatives )
+          group_creatives = []
+          groupCreatives.each do |groupCreative |
+            group_creative = {}
+            group_creative[:group_id] = groupCreative['adgroupId']
+            group_creative[:creatives] = reverse_type( groupCreative['creativeTypes'] )
+            group_creatives << group_creative
+          end
+          return group_creatives
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# -*- coding:utf-8  -*-
+module PPC
+  module API
+    class Baidu
+      class Group< Baidu
+        Service = 'Adgroup'
+
+        @map =[
+                        [:plan_id, :campaignId],
+                        [:id, :adgroupId],
+                        [:name, :adgroupName],
+                        [:price, :maxPrice],
+                        [:negative, :negativeWords],
+                        [:exact_negative, :exactNegativeWords],
+                        [:pause, :pause],
+                        [:status, :status],
+                        [:reserved, :reserved]
+                      ]
+
+        def self.ids(auth )
+          """
+          @return : Array of campaignAdgroupIds
+          """
+          response = request( auth, Service , "getAllAdgroupId" )
+          process( response, 'campaignAdgroupIds' ){ |x| make_planGroupIds( x ) }
+        end
+
+        def self.get( auth, ids )
+          ids = [ ids ] unless ids.is_a? Array
+          body = { adgroupIds: ids }
+          response = request(auth, Service, "getAdgroupByAdgroupId",body )
+          process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.add( auth, groups )
+          """
+          @ input : one or list of AdgroupType
+          @ output : list of AdgroupType
+          """
+          adgrouptypes = make_type( groups )
+
+          body = {adgroupTypes:  adgrouptypes }
+          
+          response = request( auth, Service, "addAdgroup", body  )
+          process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.update( auth, groups )
+          """
+          @ input : one or list of AdgroupType
+          @ output : list of AdgroupType
+          """
+          adgrouptypes = make_type( groups )
+          body = {adgroupTypes: adgrouptypes}
+          
+          response = request( auth, Service, "updateAdgroup",body )
+          process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.delete( auth, ids )
+          """
+          delete group body has no message
+          """
+          ids = [ ids ] unless ids.is_a? Array
+          body = { adgroupIds: ids }
+          response = request( auth, Service,"deleteAdgroup", body )
+          process( response, 'nil' ){ |x|  x  }
+        end
+
+        def self.search_by_plan_id( auth, ids )
+          ids = [ ids ] unless ids.class == Array
+          body = { campaignIds: ids }
+          response = request( auth, Service ,"getAdgroupByCampaignId",  body )
+          process( response, 'campaignAdgroups' ){ |x| make_planGroups( x ) }
+        end
+
+        def self.search_id_by_plan_id( auth, ids )
+          ids = [ ids ] unless ids.class == Array
+          body = { campaignIds: ids }
+          response = request( auth, Service ,"getAdgroupIdByCampaignId",  body )
+          process( response, 'campaignAdgroupIds' ){ |x| make_planGroupIds( x ) }
+        end
+
+        private
+        def self.make_planGroupIds( campaignAdgroupIds )
+          planGroupIds = []
+          campaignAdgroupIds.each do |campaignAdgroupId|
+            planGroupId = { }
+            planGroupId[:plan_id] = campaignAdgroupId['campaignId']
+            planGroupId[:group_ids] = campaignAdgroupId['adgroupIds']
+            planGroupIds << planGroupId
+          end
+          return planGroupIds
+        end
+
+        private
+        def self.make_planGroups( campaignAdgroups )
+          planGroups = []
+          campaignAdgroups.each do |campaignAdgroup|
+            planGroup = {}
+            planGroup[:plan_id] = campaignAdgroup['campaignId']
+            planGroup[:groups] = reverse_type( campaignAdgroup['adgroupTypes'] )
+            planGroups << planGroup
+          end
+          return planGroups
+        end
+
+      end # class group
+    end # class baidu
+  end # API
+end # module