ppc 1.3.0 → 1.3.2

data/lib/ppc/api/qihu.rb

@@ -0,0 +1,150 @@
+# -*- 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 'ppc/api/qihu/sublink'
+require 'ppc/api/qihu/bulk'
+require 'ppc/api/qihu/rank'
+
+module PPC
+  module API
+    class Qihu
+
+      extend ::PPC::API
+
+      def self.request_uri(param = {})
+        URI("https://api.e.360.cn/2.0/#{param[:service]}/#{param[:method]}")
+      end
+
+      def self.request_http_header(auth)
+        {
+          'Content-Type' => 'application/x-www-form-urlencoded',
+          'apiKey' => auth[:api_key],
+          'accessToken' => auth[:token],
+          'serveToken' => Time.now.to_i.to_s
+        }
+      end
+
+      def self.request_http_body(auth, params = {})
+        params["format"] = 'json'
+        params.map{|k,v| "#{k.to_s}=#{v.to_s}"}.join('&')
+      end
+
+#      def self.request( auth, service, method, params = {} )
+#        p 123
+#        url = "https://api.e.360.cn/2.0/#{service}/#{method}"
+#        # 日后考虑将httpparty用Net/http代替
+#        response = HTTParty.post(url, 
+#                body: params,
+#                headers: {'apiKey' => auth[:api_key], 
+#                                'accessToken' => auth[:token], 
+#                                'serveToken' => Time.now.to_i.to_s  }
+#              )
+#        p response 
+#        response.parsed_response
+#      end
+
+      def self.process( response, key, failure_key = '', &func )
+        # special case solution
+        # 只有account getInfo 的key 为 '',因为其特殊逻辑,单独处理
+        result = { }
+        if response == []
+          result[:succ] = true
+          result[:failure] = nil
+          result[:result] = nil
+          result[:no_quota] = false
+          return result
+        end
+        if key == ''
+          if !response['failures'].nil?
+            result[:succ] = false
+            result[:result] = nil
+            result[:failure] = response['failures']
+            result[:no_quota] = is_no_quota(response['failures'], '90401')
+            return result
+          end
+          result[:succ] = true
+          result[:failure] = nil
+          result[:no_quota] = false
+          result[:result] = func[response]
+          return result
+        end
+        result[:result] = func[response[key]]
+        result[:failure] = response['failures']
+        result[:no_quota] = is_no_quota(response['failures'], '90401')
+        result[:succ] = response['failures'].nil? || response['failures'].size.zero?
+        #if response['failures'] != nil
+        #  result[:succ] = false
+        #  result[:failure] = response['failures']['item']
+        #  result[:result] = nil
+        #else
+        #  result[:succ] = true
+        #  result[:result] = func[ key==''? response : response[ key ] ]
+        #  result[:failure] = failure_key == ''? nil : response[ 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

@@ -0,0 +1,86 @@
+# -*- 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}
+        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, '' ){|x| x}
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# -*- coding:utf-8 -*-
+require 'json'
+module PPC
+  module API
+    class Qihu
+      class Bulk < Qihu
+        Service = 'account'
+
+        def self.get_all_object( auth, ids )
+          #文档上面写的输入类型是String？
+          body = nil
+          body = { 'idList' =>  to_json_string(ids) } if ids
+          response = request( auth, Service, 'getAllObjects', body )
+          process( response, 'fileId' ){ |x| x }
+        end
+
+        def self.get_file_state( auth, id )
+          body = { 'fileId' => id }
+          response = request( auth, Service, 'getFileState' , body )
+          process( response, '' ){ |x| x }
+        end
+
+        def self.download( auth, ids = nil)
+          result = get_all_object(auth, ids)
+          field_id = result[:result]
+          loop do 
+            status = get_file_state(auth, field_id)
+            return status if status[:result]['isGenerated'] == 'success'
+            sleep 15
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# -*- 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],
+          [:mobile_destination, :mobileDestinationUrl],
+          [:mobile_display, :mobileDisplayUrl]
+        ]
+
+        @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) }
+        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) }
+        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, @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) } ] 
+          }     
+        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

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

@@ -0,0 +1,96 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Qihu
+      class Group < Qihu
+        Service = 'group'
+
+        @map = [
+          [:id, :id ],
+          [:plan_id, :campaignId],
+          [:status, :status ],
+          [:name, :name ],
+          [:price, :price ],
+          # negateive为json格式，make_type要定制
+          [:add_time, :addTime],
+          [:update_time, :updateTime]
+        ]
+
+        # 再次封装提供all和ids
+        def self.ids( auth )
+          '''
+          接口与其他的相同，但是无论如何：succ均为true，不返回任何错误信息
+          因为是重复调用了search的接口，速度非常的慢，* 慎用 *
+          '''
+          plan_ids = ::PPC::API::Qihu::Plan::ids( auth )[:result]
+          plan_group_ids = []
+
+          plan_ids.each do |plan_id|
+            plan_group_id = {}
+            plan_group_id[:plan_id] = plan_id
+            plan_group_id[:group_ids] = search_id_by_plan_id( auth, plan_id )[:result]
+            plan_group_ids << plan_group_id
+          end
+          return { succ: true, failure:nil, result: plan_group_ids }
+        end
+
+        def self.all( auth )
+          '''
+          unimplemented due to ineffciency
+          '''
+          # unimplement
+        end
+
+        # 奇虎组服务不提供批量add,delete和update方法
+        def self.add( auth, group )
+          response = request( auth, Service, 'add', make_type( group )[0] )
+          # 保证接口一致性
+          process( response, 'id' ){ |x| [ { id:x.to_i } ]    }
+        end
+
+        def self.update( auth, group )
+          if group[:negative] || group[:exact_negative]
+            ng = {"exact" => group[:exact_negative], "phrase" => group[:negative]}.to_json
+          end
+          params = make_type(group)[0]
+          params.merge!({:negativeWords => ng}) if ng
+          response = request( auth, Service, 'update', params )
+          # 保证接口一致性
+          process( response, 'id' ){ |x|[ { id:x.to_i } ]  }
+        end
+
+        def self.get( auth, ids )
+          ids = to_json_string( ids )
+          body = { 'idList' => ids }
+          response = request( auth, Service, 'getInfoByIdList', body  )
+          process( response, 'groupList' ){ |x| reverse_type(x) }
+        end
+
+        def self.delete( auth, id )
+          response = request( auth, Service, 'deleteById', { id: id}  )
+          process( response, 'affectedRecords' ){ |x| x == '1' }
+        end
+
+        def self.search_id_by_plan_id( auth, id )
+          response = request( auth, Service, 'getIdListByCampaignId', { 'campaignId' => id.to_s })
+          #为了保持接口一致性，这里也是伪装成了百度的接口
+          process( response, 'groupIdList' ){ 
+            |x|
+            [ { plan_id:id, group_ids: to_id_list(x) } ]
+          }
+        end
+
+        # combine searchIdbyId and get to provide another method
+        def self.search_by_plan_id( auth, id )
+          group_ids = search_id_by_plan_id( auth, id )[:result][0][:group_ids]
+          response = get( auth, group_ids )
+          if response[:succ]
+            response[:result] = [ { plan_id:id, groups:response[:result]}]
+          end
+          return response
+        end
+
+      end
+    end
+  end
+end