ppc 1.3.0 → 1.3.2

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

@@ -0,0 +1,66 @@
+module PPC
+  module API
+    class Sogou
+      class Plan< Sogou
+        Service = 'CpcPlan'
+
+        @map = [
+                          [:id,:cpcPlanId],
+                          [:name,:cpcPlanName],
+                          [:budget,:budget], 
+                          [:region,:regions],
+                          [:ip,:excludeIps] ,
+                          [:negative,:negativeWords],
+                          [:exact_negative,:exactNegativeWords],
+                          [:schedule,:schedule], 
+                          [:budget_offline_time,:budgetOfflineTime],
+                          [:show_prob,:showProb],   
+                          [:join_union ,:joinUnion],
+                          [:device,:device],
+                          [:price_ratio,:mobilePriceRate ], 
+                          [:pause,:pause],
+                          [:status,:status],
+                        ]
+
+        def self.all( auth )
+          response = request( auth, Service, 'getAllCpcPlan' )
+          process( response, 'cpcPlanTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.ids( auth )
+          response = request( auth, Service, 'getAllCpcPlanId' )
+          process( response, 'cpcPlanIds' ){ |x| x }
+        end
+
+        def self.get( auth, ids )
+          ids = [ ids ] unless ids.is_a? Array
+          body = { cpcPlanIds: ids }
+          response = request( auth, Service, 'getCpcPlanByCpcPlanId', body)
+          process( response, 'cpcPlanTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.add( auth, plans )
+          cpcPlanTypes = make_type( plans )
+          body = { cpcPlanTypes: cpcPlanTypes }
+          response = request( auth, Service, 'addCpcPlan', body)
+          process( response, 'cpcPlanTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.update( auth, plans )
+          cpcPlanTypes = make_type( plans )
+          body = { cpcPlanTypes: cpcPlanTypes }
+          response = request( auth, Service, 'updateCpcPlan', body)
+          process( response, 'cpcPlanTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.delete(auth, ids )
+          ids = [ ids ] unless ids.class == Array
+          body = { cpcPlanIds: ids }
+          response = request( auth, Service, 'deleteCpcPlan', body)
+          process( response, '' ){ |x| x }
+        end
+       
+      end # Service
+    end # baidu
+  end # API
+end # PP

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

@@ -0,0 +1,129 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Sogou
+      class Report< Sogou
+        Service = 'Report'
+      
+        # 需要用到的映射集合
+        Type_map = { 'account' => 1, 'plan'=> 2, 'group'=> 3, 
+                      'keyword'=> 5, 'creative'=> 4, 'pair'=> 15, 
+                       'query'=> 3 }
+
+        Range_map = {  'account' => 1, 'plan' => 2, 'group' => 3, 
+                        'creative' => 4, 'keyword' => 5 }
+
+        Device_map = { 'all' => 0, 'pc' => 1, 'mobile' => 2 }
+
+        Unit_map = { 'day' => 1, 'week' => 2, 'month' => 3 }
+
+        def self.get_id( auth, params )
+          request = make_reportrequest( params )
+          body =  { reportRequestType: request }
+          response = request( auth, Service, 'getReportId' ,body) 
+          process( response, 'reportId' ){ |x| x }
+        end
+
+        def self.get_state( auth, id )
+          '''
+          input id should be string
+          '''
+          status = {'-1'=>'Waiting' ,'0'=>'Opearting' ,'1'=>'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, 'getReportPath' ,body)
+          process( response, 'reportFilePath' ){ |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] || %w(click)
+          requesttype[:reportType]         =     Type_map[ param[:type] ]        if  param[:type] 
+          requesttype[:statRange]          =     Range_map[ param[:range] ]      if param[:range]
+          requesttype[:unitOfTime]         =     Unit_map[ param[:unit] ]        if param[:unit] 
+          requesttype[:platform]           =     Device_map[ param[:device] ]    if param[:device]
+          requesttype[:idOnly]             =     param[:id_only]                 if param[:id_only]!=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.utc.iso8601
+        end
+
+        ###########################
+        # intreface for Operation #
+        ###########################
+        def self.download_report( auth, param, debug = false )
+          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]
+            ActiveSupport::Gzip.decompress( open(url).read ).force_encoding('gb18030').encode('utf-8')
+          else
+            raise response[:failure][:message]
+          end
+        end
+
+        def self.query_report( auth, param = nil, debug = false )
+          param = {} if not param
+          param[:type]   ||= 'query'
+          param[:fields] ||=  %w(click)
+          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( cost cpc click impression ctr )
+          param[:range]  ||= 'account'
+          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( cost cpc click impression ctr )
+          param[:range]  ||= 'account'
+          download_report( auth, param, debug )
+        end
+
+      end # Repost
+    end # Baidu
+  end # API
+end # PPC

data/lib/ppc/ext.rb

@@ -0,0 +1,17 @@
+class String
+  def snake_case
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end
+class Hash
+  def filter_and_replace_key(key_new, key_old)
+    return self if key_new == key_old
+    value = self.delete(key_old)
+    self[key_new] = value unless value.nil?
+    self
+  end
+end

data/lib/ppc/operation.rb

@@ -3,55 +3,67 @@ module PPC
 
     attr_accessor :id
     
-    def initialize(params)
-      @id   = params[:id]
-      @se   = params[:se]
+    def initialize( params )
+      
+      if params[:se] == nil
+        raise 'please specific a search engine'
+      else 
+        @se = params[:se]
+      end
+      @id = params[:id]
       @auth = {
         username: params[:username],
         password: params[:password],
-        token:    params[:token]
+        # 在qihu360的api中，apikey就是auth[:token]
+        token:    params[:token],
+        target:   params[:target]
       }
+      # add support for qihu360
+      if @se == 'qihu'
+        raise "you are using qihu service, please enter api_key" if params[:api_key].nil?
+        @auth[:api_key] = params[:api_key]
+      end
+      if @se == 'qihu' && params[:token].nil? 
+        raise "you are using qihu service, please enter api_secret" if params[:api_secret].nil?
+        @auth[:api_secret] = params[:api_secret]
+        @auth[:token] = qihu_refresh_token
+      end
     end
 
-    def call(service)
-      eval "::PPC::API::#{@se.capitalize}::#{service.capitalize}"
+    def qihu_refresh_token
+        cipher_aes = OpenSSL::Cipher::AES.new(128, :CBC)
+        cipher_aes.encrypt
+        cipher_aes.key = @auth[:api_secret][0,16]
+        cipher_aes.iv = @auth[:api_secret][16,16]
+        encrypted = (cipher_aes.update(Digest::MD5.hexdigest(@auth[:password])) + cipher_aes.final).unpack('H*').join
+        url = "https://api.e.360.cn/account/clientLogin"
+        response = HTTParty.post(url,
+          :body => {
+          :username => @auth[:username],
+          :passwd => encrypted[0,64]
+          },
+          :headers => {'apiKey' => @auth[:api_key] }
+        )
+        data = response.parsed_response
+        data["account_clientLogin_response"]["accessToken"]
     end
 
-    def download(params = {})
-      bulk = ::PPC::Baidu::Bulk.new({
-                                      username: @username,
-                                      password: @password,
-                                      token:    @token,
-                                      debug:    @debug
-      })
-
-      params[:extended] = params[:extended] || 2
-
-      begin
-        file_id = bulk.file_id_of_all(params)
-        puts "file_id: #{file_id}" if @debug
-
-        loop do
-          state = bulk.state(file_id)
-          raise "invalid file state: #{state}" unless %w(1 2 3 null).include? state
-          break if state == '3'
-          puts "waiting for #{file_id} to be ready. current state:#{state}" if @debug
-          sleep 3
-        end
-        puts "#{file_id} is ready" if @debug
-        return bulk.path(file_id)
-      rescue
-        raise BulkException.new(file_id,bulk)
-      end  
+    def download( param = nil )
+        """
+        download all objs of an account
+        """
+        eval("::PPC::API::#{@se.capitalize}::Bulk").download( @auth, param )
+    end
 
-      return false
+    def call(service)
+      eval "::PPC::API::#{@se.capitalize}::#{service.capitalize}"
     end
 
     # ++++++++ #
     # Lazy Code #
     # ++++++++ #
 
-    # auxilary fucntion
+    # helper fucntion
     def get_obj( ids, service )
         '''
         Return service object. 
@@ -68,7 +80,7 @@ module PPC
           objs << class_obj.new( param )
         end
 
-        return objs[0] if objs.length == 1 else objs 
+        return objs.length == 1 ? objs[0] : objs 
     end
 
     # +++++ Plan opeartion funcitons +++++ #
@@ -154,8 +166,10 @@ end # PPC
 # because if we load files before defining the 
 # module ::PPC::Operation. Errors of 'uninitialized constance'
 # will occur
+require 'ppc/operation/report'
 require 'ppc/operation/account'
 require 'ppc/operation/group'
 require 'ppc/operation/plan'
 require 'ppc/operation/keyword'
-require 'ppc/operation/creative'
+require 'ppc/operation/creative'
+

data/lib/ppc/operation/account.rb

@@ -1,12 +1,12 @@
-require 'ppc/operation'
 module PPC
   module Operation
     class Account
       include ::PPC::Operation
 
+      # self operations
       def info
         info = call('account').info(@auth)
-        @id = info[:result][0][:id] if @id == nil
+        @id = info[:result][:id] if @id == nil
         return info
       end
 
@@ -14,7 +14,7 @@ module PPC
         call('account').update(@auth,account)
       end
 
-      # plan methods
+      # subobject(plan) operations
       def plans
         call('plan').all(@auth)
       end
@@ -22,19 +22,31 @@ module PPC
       def plan_ids
         call('plan').ids(@auth)
       end
+      
+      # some useful keyword operations
+      def keywords(group_id)
+        call( 'keyword' ).search_by_group_id( @auth, group_id )
+      end
 
-      # plan operation
+      def keyword_ids(group_id)
+        call( 'keyword' ).search_id_by_group_id( @auth, group_id )
+      end
+      
+      # plan operations
       include ::PPC::Operation::Plan_operation
 
-      # group opeartion
+      # group opeartions
       include ::PPC::Operation::Group_operation
 
-      # keyword opeartion
+      # keyword opeartions
       include ::PPC::Operation::Keyword_operation
 
-      # creative opeartion
+      # creative opeartions
       include ::PPC::Operation::Creative_operation
 
+      # report operations
+      include ::PPC::Operation::Report
+
     end
   end
 end

data/lib/ppc/operation/creative.rb

@@ -4,25 +4,25 @@ module PPC
       include ::PPC::Operation
 
       def info()
-        ::PPC::API::Baidu::Creative::get( @auth, @id )
+        call( 'creative' ).get( @auth, @id )
       end
 
-      def update( keywordType )
-        ::PPC::API::Baidu::Keyword::update( @auth, keywordType )
+      def update( type )
+        call( 'creative' ).update( @auth, type.merge( id:@id) )
       end
 
       def activate()
-        ::PPC::API::Baidu::Creative::activate( @auth, @id )
+        call( 'creative' ).activate( @auth, @id )
       end
 
       def status()
-        ::PPC::API::Baidu::Creative::status( @auth, @id )
+        call( 'creative' ).status( @auth, @id )
       end
 
       def delete()
-        ::PPC::API::Baidu::Creative::delete( @auth, @id )
+        call( 'creative' ).delete( @auth, @id )
       end
 
     end
   end
-end
+end

data/lib/ppc/operation/group.rb

@@ -8,7 +8,7 @@ module PPC
       end
 
       def update( info )
-        info[:id] = @id unless info[:id]
+        info[:id] = @id if (info.is_a? Hash) && info[:id].nil?
         call('group').update(@auth, info)
       end
 
@@ -56,4 +56,4 @@ module PPC
 
     end # Group
   end # Operation
-end # PPC
+end # PPC

data/lib/ppc/operation/keyword.rb

@@ -4,29 +4,32 @@ module PPC
       include ::PPC::Operation
 
       def info()
-        ::PPC::API::Baidu::Keyword::get( @auth, @id )
+        call( 'keyword' ).get( @auth, @id )
       end
 
       def update( type )
-        ::PPC::API::Baidu::Keyword::update( @auth, type.merge( id:@id) )
+        type.merge(id: @id) if type.is_a? Hash
+        call( 'keyword' ).update( @auth, type )
       end
 
+      # Todo: Implement Activate method in Sogou API
       def activate()
-        ::PPC::API::Baidu::Keyword::activate( @auth, @id )
+        call( 'keyword' ).activate( @auth, @id )
       end
       
       def status()
-        ::PPC::API::Baidu::Keyword::status( @auth, @id )
+        call( 'keyword' ).status( @auth, @id )
       end
 
       def quality()
-        ::PPC::API::Baidu::Keyword::quality( @auth, @id )
+        call( 'keyword' ).quality( @auth, @id )
       end
 
-      def delete()
-        ::PPC::API::Baidu::Keyword::delete( @auth, @id )
+      def delete( ids = nil )
+        ids ||= @id
+        call( 'keyword' ).delete( @auth, ids )
       end
 
     end
   end
-end
+end