ppc 1.0.6 → 1.3.0

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

@@ -0,0 +1,65 @@
+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], 
+                          [:pause,:pause],
+                          [:status,:status],
+                        ]
+
+        def self.all( auth, debug = false )
+          response = request( auth, Service, 'getAllCampaign' )
+          process( response, 'campaignTypes' , debug ){ |x| reverse_type(x) }
+        end
+
+        def self.ids( auth, debug = false )
+          response = request( auth, Service, 'getAllCampaignId' )
+          process( response, 'campaignIds' , debug ){ |x| x }
+        end
+
+        def self.get( auth, ids, debug = false )
+          ids = [ ids ] unless ids.is_a? Array
+          body = { campaignIds: ids }
+          response = request( auth, Service, 'getCampaignByCampaignId', body)
+          process( response, 'campaignTypes' , debug ){ |x| reverse_type(x) }
+        end
+
+        def self.add( auth, plans, debug = false )
+          campaigntypes = make_type( plans )
+          body = { campaignTypes: campaigntypes }
+          response = request( auth, Service, 'addCampaign', body)
+          process( response, 'campaignTypes' , debug ){ |x| reverse_type(x) }
+        end
+
+        def self.update(auth,plans, debug = false )
+          campaigntypes = make_type( plans )
+          body = { campaignTypes: campaigntypes }
+          response = request( auth, Service, 'updateCampaign', body)
+          process( response, 'campaignTypes' , debug ){ |x| reverse_type(x) }
+        end
+
+        def self.delete(auth, ids, debug = false )
+          ids = [ ids ] unless ids.class == Array
+          body = { campaignIds: ids }
+          response = request( auth, 'Campaign', 'deleteCampaign', body)
+          process( response, 'result' , debug ){ |x| x }
+        end
+       
+      end # Service
+    end # baidu
+  end # API
+end # PPC

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

@@ -0,0 +1,124 @@
+# -*- 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 }
+        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 }
+
+        def self.get_realtime( auth, params, type = 'data', debug = false )
+          request = make_realtimerequest( params )[0]
+          body = { realTimeRequestTypes:  request }
+          response = request( auth, Service, 'getRealTimeData' ,body)
+          if debug
+            return response
+          end
+
+          response = case type
+            when 'data'     then    response['body']['realTimeResultTypes']
+            when 'query'  then   response['body']['realTimeQueryResultTypes']
+            when 'pair'      then    response['body']['realTimePairResultTypes']
+          end
+          return response                   
+        end
+
+
+        def self.get_id( auth, params, debug = false )
+          request = make_reportrequest( params )[0]
+          body =  { reportRequestType:  request }
+          response = request( auth, Service, 'getProfessionalReportId' ,body) 
+          process( response, 'reportId', debug ){ |x| x }
+        end
+
+        def self.get_status( auth, id, debug = false)
+          '''
+          input id should be string
+          '''
+          status = {1=>'Waiting' ,2=>'Opearting' ,3=>'Finished'}
+          body = { reportId:  id }
+          response = request( auth, Service, 'getReportState' ,body)
+          process( response, 'isGenerated', debug ){ |x| status[x] }
+        end
+
+        def self.get_file_url( auth, id, debug = false )
+          body = { reportId:  id }
+          response = request( auth, Service, 'getReportFileUrl' ,body)
+          process( response, 'reportFilePath', debug ){ |x| x }       
+        end
+
+        private
+        def self.get_date()
+         begin
+            startDate = DateTime.parse(params[:start]).iso8601
+            endDate = DateTime.parse(params[:end]).iso8601
+          rescue Exception => e
+            startDate = (Time.now - 2*24*3600).utc.iso8601
+            endDate = (Time.now - 24*3600).utc.iso8601
+          end
+          return startDate,endDate
+        end
+
+        private 
+        def self.make_realtimerequest( params )
+          '''
+          make RealTimeRequestType
+          没有封装关键字：attribute，order,statIds
+          '''
+          params = [ params ] unless params.is_a? Array
+          requesttypes = []
+          params.each do  |param|
+            requesttype = {}
+            startDate, endDate = get_date()
+
+            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[:number]                     =    param[:number]                         if  param[:number]
+            requesttype[:device]                        =    Device_map[ param[:device] ]  if param[:device]
+            requesttype[:startDate]                  =     startDate
+            requesttype[:endDate]                    =     endDate
+            requesttypes << requesttype
+          end
+          return requesttypes
+        end
+
+        private
+        def self.make_reportrequest( params )
+          '''
+          make RepoerRequestType
+          '''
+          params = [ params ] unless params.is_a? Array
+          requesttypes = []
+          params.each do  |param|
+            requesttype = {}
+            startDate, endDate = get_date()
+
+            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]                   =    startDate
+            requesttype[:endDate]                     =    endDate
+            requesttypes << requesttype
+          end
+          return requesttypes
+        end
+
+      end # Repost
+    end # Baidu
+  end # API
+end # PPC

data/lib/ppc/api/baidu.rb

@@ -0,0 +1,132 @@
+# -*- 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
+
+      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.set_debug_output $stderr
+        http.use_ssl = true
+
+        response = http.post(uri.path, http_body, http_header)
+        response = JSON.parse response.body
+
+        # return response if with_header else response['body']
+      end
+
+      def self.process( response, key , debug = false ,  &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.
+        '''
+        # 保留 debug 功能
+        return response if debug
+
+        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
+            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
+            end
+
+          params << param
+        end
+        return params
+      end
+
+      end # Baidu
+  end # API
+end # PPC

data/lib/ppc/api.rb

@@ -0,0 +1,8 @@
+require 'ppc/api/baidu'
+
+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/baidu/account.rb

@@ -6,17 +6,42 @@ module PPC
         super(params)
       end
 
+      def info
+        response = request('getAccountInfo')["accountInfoType"]
+      end
+
       def all(params = {})
         download(params)
       end
 
+      def update( params = {} )
+        """
+        update account info
+        @ params : account_info_type
+        @return : account info_type
+        """
+        info = {
+          accountInfoType: {
+            budgetType:              params[:budget_type] ,
+            budget:                  params[:budget],
+            regionTarget:            params[:region],
+            excludeIp:               params[:excludeip] ,
+            isDynamicCreative:       params[:isdynamic],
+            dynamicCreativeParam:    params[:creativeparam]
+          }
+        }
+        # delete null symbol
+        info[:accountInfoType].each{
+          |pair|
+          key, value = pair
+          info[:accountInfoType].delete(key) if value == nil
+        }
+
+        request('updateAccountInfo', info)["accountInfoType"]
+      end
+
       def query_report(params = {})
-        report = ::PPC::Baidu::Report.new({
-                                            username: @username,
-                                            password: @password,
-                                            token: @token,
-                                            debug: @debug
-        })
+        report = ::PPC::Baidu::Report.new({username: @username, password: @password, token: @token, debug: @debug})
 
         begin
           @file_id = report.file_id_of_query(params)
@@ -30,31 +55,34 @@ module PPC
             sleep 3
           end
 
+          url = report.path(@file_id)
+          open(url).read.force_encoding('gb18030').encode('utf-8')
+        rescue Exception => e
+          raise ReportException.new(@file_id,report,e)
+        end
+      end
+
+      def cost_report(params = {})
+        report = ::PPC::Baidu::Report.new({username: @username, password: @password, token: @token, debug: @debug})
+        begin
+          @file_id = report.file_id_of_cost(params)
+          print_debug(@file_id,'file_id') if @debug
+
+          loop do
+            state = report.state(@file_id)
+            raise "invalid file state: #{state}" unless %w(1 2 3 null).include? state
+            break if state == '3'
+            print_debug(state,'file_id.state') if @debug
+            sleep 3
+          end
 
-          return report.path(@file_id)
+          url = report.path(@file_id)
+          open(url).read.force_encoding('gb18030').encode('utf-8')
         rescue Exception => e
-          # @header   = bulk.header
-          # @oprs     = bulk.oprs
-          # @oprtime  = bulk.oprtime
-          # @quota    = bulk.quota
-          # @rquota   = bulk.rquota
-          # @status   = bulk.status
-
-          # @desc     = bulk.desc
-
-          # case @desc
-          # when 'success'
-          # when 'failure'
-          #   @code     = bulk.code
-          #   @message  = bulk.message
-          # when 'system failure'
-          #   @code     = bulk.code
-          #   @message  = bulk.message
-          # else
-            raise ReportException.new(@file_id,report,e)#,"unknown desc from baidu: #{@desc}"
-          # end
+          raise ReportException.new(@file_id,report,e)
         end
       end
+
     end
   end
 end

data/lib/ppc/baidu/group.rb

@@ -0,0 +1,99 @@
+module PPC
+  class Baidu
+    class Group < ::PPC::Baidu
+      def initialize(params = {})
+        params[:service] = 'Adgroup'
+        super(params)
+      end
+
+      def all()
+        """
+        @return : Array of campaignAdgroupIds
+        """
+        request( "getAllAdgroupId" )["campaignAdgroupIds"]
+      end
+
+      def add( params={}, test = false)
+        """
+        @ input : one or list of AdgroupType
+        @ output : list of AdgroupType
+        """       
+        params = [ params ] unless params.class == Array
+        adgroupType = []
+        
+        params.each{  | group_i |
+          adgroupType << make_adgrouptype( group_i ) 
+        }
+
+        body = {adgroupTypes: adgroupType}
+        response = request( "addAdgroup", body, test )
+        return response['adgroupTypes'] unless test else response
+      end
+
+      def update( params={}, test = false )
+        """
+        @ input : one or list of AdgroupType
+        @ output : list of AdgroupType
+        """
+        params = [ params ] unless params.class == Array
+        adgroupType = []
+        
+        params.each{  | group_i |
+          adgroupType << make_adgrouptype( group_i ) 
+        }
+
+        body = {adgroupTypes: adgroupType}
+        responses = request( "updateAdgroup", body, test )
+        return responses['adgroupTypes'] unless test else responses
+      end
+
+      def delete( ids )
+        # delete responses have no content therefore we 
+        #return header.desc to judge whether operation success
+        ids = [ ids ] unless ids.class == Array
+        
+        body = { adgroupIds: ids }
+        request( "deleteAdgroup", body, true )[ 'header' ][ 'desc' ]
+      end
+
+      def search_by_planid( ids, test = false )
+        ids = [ ids ] unless ids.class == Array
+        body = { campaignIds: ids }
+        responses = request("getAdgroupByCampaignId",  body, test )
+        return responses["campaignAdgroups"]  unless test else responses
+      end
+
+      def search_by_groupid( ids, test = false )
+        ids = [ ids ] unless ids.class == Array
+        body = { adgroupIds: ids }
+        responses = request("getAdgroupByAdgroupId",body, test )
+        return responses["adgroupTypes"]  unless test else responses
+      end
+
+      private 
+        def make_adgrouptype( params={} )
+          adgrouptype = {
+            campaignId:               params[:plan_id],
+            adgroupId:              params[:group_id],
+            adgroupName:              params[:name],
+            maxPrice:              params[:maxprice],
+            negativeWords:              params[:negative],
+            exactNegativeWords:              params[:exact_negative],
+            pause:              params[:pause],
+            status:              params[:status],
+            reserved:              params[:reserved]
+          }
+          # delete empty node
+          adgrouptype.each{
+            |pair|
+            key, value = pair
+            adgrouptype.delete(key) if value == nil
+          }
+          # delete invalid note according to request type
+          # unimplemented
+          return adgrouptype
+        end #make_adgrouptype
+
+    end # class group
+  end # class baidu 
+end # module

data/lib/ppc/baidu/key.rb

@@ -0,0 +1,38 @@
+module PPC
+  class Baidu
+    class Key < ::PPC::Baidu
+      def initialize(params = {})
+        params[:service] = 'Keyword'
+        @se_id = params[:se_id]
+        super(params)
+      end 
+
+      def add()
+      end
+
+      def update()
+      end
+
+      def delete()
+      end
+
+      def active()
+      end
+
+      def search_by_groupid( ids, return_id = false )
+      end
+
+      def search_by_keywordid( ids )
+      end
+
+      def get_status()
+      end
+
+      def get_quality()
+      end
+
+      def get_10quality()
+      end
+    end
+  end
+end

data/lib/ppc/baidu/plan.rb

@@ -11,6 +11,75 @@ module PPC
         params[:plan_ids] = [@se_id]
         download(params)
       end
+
+      def ids
+        request('getAllCampaignId')['campaignIds']
+      end
+
+      #add one or more plans
+      def add(plans)
+        if plans.class == Hash
+          plans = [plans]
+          single = true
+        end
+        campaignTypes = []
+
+        plans.each do |plan|
+          campaignTypes << {
+            campaignName: plan[:name],
+            negativeWords: plan[:negative],
+            exactNegativeWords: plan[:exact_negative]
+          }
+        end
+
+        options = {campaignTypes:  campaignTypes}
+        response = request('addCampaign',options)['campaignTypes']
+        if single
+          response.first
+        else
+          response
+        end
+      end
+
+      def get(ids)
+        if ids.class != Array
+          ids = [ids]
+          single = true
+        end
+
+        options = {campaignIds: ids}
+        response = request('getCampaignByCampaignId',options)['campaignTypes']
+
+        if single
+          response.first
+        else
+          response
+        end
+      end
+
+      # @todo needs testing
+      def updates(params)
+        params['campaignId'] = @se_id
+        options = {campaignTypes: [params]}
+        request('updateCampaign',options)['campaignTypes']
+      end
+
+      def update_by_id(id,params = {})
+        params['campaignId'] = id
+        options = {campaignTypes: [params]}
+        request('updateCampaign',options)['campaignTypes']
+      end
+
+      def update(plans)
+        options = {campaignTypes: plans}
+        request('updateCampaign',options)['campaignTypes']
+      end
+
+      def delete(ids)
+        ids = [ids] unless ids.class == Array
+        options = {campaignIds: ids}
+        request('deleteCampaign',options)['result'] == 1
+      end
     end
   end
 end