ppc 1.3.2 → 2.0.0

data/lib/ppc/api/qihu.rb

@@ -29,120 +29,16 @@ module PPC
       end
 
       def self.request_http_body(auth, params = {})
-        params["format"] = 'json'
-        params.map{|k,v| "#{k.to_s}=#{v.to_s}"}.join('&')
+        "format=json&" + params.map{|k,v| "#{k.to_s}=#{v.is_a?(Array) ? v.to_json : v}"}.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
+        result = {}
+        result[:succ]     = response['failures'].nil? || response['failures'].size.zero?
+        result[:failure]  = response['failures'] || response["failure_key"]
+        result[:result]   = (key.empty? ? func[response] : func[response[key]]) rescue nil
+        result[:no_quota] = (response['failures']['code'] == '90401') rescue false
+        result
       end
 
     end

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

@@ -6,18 +6,26 @@ module PPC
       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]
-              ]
+        AccountType = {
+          id:                 :uid,
+          name:               :userName,
+          email:              :email,
+          category:           :category,
+          company:            :companyName,
+          industry1:          :industry1,
+          industry2:          :industry2,
+          balance:            :balance,
+          budget:             :budget,
+          mv_budget:          :mvBudget,
+          resources:          :Resources,
+          "resources" =>      :resources,
+          status:             :status,
+          open_mobile_domain: :allowMobileDomain,
+          open_domains:       :allowDomain,
+          agency:             :agency,
+        }
+        @map = AccountType
+                
         
         def self.info( auth )
           response = request( auth, Service, 'getInfo' )
@@ -29,36 +37,35 @@ module PPC
           对奇虎两个update的在封装。如果所有操作成功，succ为true，否则为false
           failure中以字符串方式返回失败的操作
           '''
-          result = {}
-          result[:succ] = true
-          result[:failure] = []
-          result[:result] = []
+          result = {
+            succ:     true,
+            failure:  [],
+            result:   [],
+          }
 
-          if params[:budget] != nil
+          if params[:budget]
             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
+          if params[:exclude_ip]
             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
+          result
         end
 
         def self.get_all_object( auth, ids )
           #文档上面写的输入类型是String？
-          body = { 'idList' =>  ids }
-          response = request( auth, Service, 'getAllObjects' )
+          response = request( auth, Service, 'getAllObjects', { idList:  ids } )
           process( response, 'account_getAllObjects_response' ){ |x| x }
         end
 
         def self.get_file_state( auth, id )
-          body = { 'fileId' => id }
-          response = request( auth, Service, 'getAllObjects' , body )
+          response = request( auth, Service, 'getAllObjects' , { fileId: id } )
           process( response, 'account_getFileState_response' ){ |x| x }
         end
 
@@ -69,13 +76,12 @@ module PPC
 
         private
         def self.update_budget( auth, budget )
-          response = request( auth, Service, 'updateBudget', { budget: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

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

@@ -8,8 +8,7 @@ module PPC
 
         def self.get_all_object( auth, ids )
           #文档上面写的输入类型是String？
-          body = nil
-          body = { 'idList' =>  to_json_string(ids) } if ids
+          body = { 'idList' =>  ids.map(&:to_s) }
           response = request( auth, Service, 'getAllObjects', body )
           process( response, 'fileId' ){ |x| x }
         end

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

@@ -5,101 +5,84 @@ module PPC
       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]
-        ]
+        CreativeType = {
+          id:                 :id,
+          plan_id:            :campaignId,
+          group_id:           :groupId,
+          title:              :title,
+          description1:       :description1,
+          description2:       :description2,
+          description3:       :descSecondLine,
+          pc_destination:     :destinationUrl,
+          pc_display:         :displayUrl,
+          mobile_destination: :mobileDestinationUrl,
+          mobile_display:     :mobileDisplayUrl,
+          pause:              :status,
+          mobile_pause:       :mobileStatus,
+          add_time:           :addTime,
+          updateTime:         :updateTime,
+        }
+        @map = CreativeType
 
-        @status_map = [ 
-          [:id,:id], 
-          [:quality,:qualityScore],
-          [:status,:status]
-        ]
+        @status_map = {
+          id:       :id,
+          quality:  :qualityScore,
+          pause:    :status,
+        }
+
+        def self.info( auth, ids )
+          response = request( auth, Service, 'getInfoByIdList', { idList: ids } )
+          process( response, 'creativeList'){ |x| reverse_type(x)[0] }
+        end
+
+        # combine two methods to provide another mether
+        def self.all( auth, group_id )
+          results = self.ids( auth, group_id )
+          return results unless results[:succ]
+          self.get( auth , results[:result] )
+        end
+
+        def self.ids( auth, group_id )
+          response = request( auth, Service, 'getIdListByGroupId', {"groupId" => group_id[0]} )
+          process( response, 'creativeIdList' ){ |x| x.map(&:to_i) }
+        end
 
         def self.get( auth, ids )
-          body  = { 'idList' => to_json_string( ids ) }
-          response = request( auth, Service, 'getInfoByIdList', body )
+          response = request( auth, Service, 'getInfoByIdList', { idList: ids } )
           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
+          response = request( auth, Service, 'add', { creatives: make_type( creatives ) } )
+          process( response, 'creativeIdList'){ |x| x.map{|tmp| { id: i.to_i } } }
         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 }        
+          response = request( auth, Service, 'update', { creatives: make_type( creatives ) } )
+          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 }     
+          response = request( auth, Service, 'deleteByIdList', { idList: ids } )
+          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 ) }     
+        def self.enable( auth, ids )
+          self.update( auth, ids.map{ |id| { id: id, pause: "enable"} } )
         end
 
-        # quality 本质上和 status 在一个方法里面
-        def self.quality( auth, ids )
-          status( auth, ids)
+        def self.pause( auth, ids )
+          self.update( auth, ids.map{ |id| { id: id, pause: "pause"} } )
         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) } ] 
-          }     
+        def self.status( auth, ids )
+          response = request( auth, Service, 'getStatusByIdList', { idList: ids } )
+          process( response, 'creativeList' ){ |x| reverse_type( x, @status_map ) }
         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
+        # quality 本质上和 status 在一个方法里面
+        def self.quality( auth, ids )
+          self.status( auth, ids)
         end
 
       end

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

@@ -5,89 +5,66 @@ module PPC
       class Group < Qihu
         Service = 'group'
 
-        @map = [
-          [:id, :id ],
-          [:plan_id, :campaignId],
-          [:status, :status ],
-          [:name, :name ],
-          [:price, :price ],
+        GroupType = {
+          id:             :id,
+          plan_id:        :campaignId,
+          pause:          :status,
+          name:           :name,
+          price:          :price,
           # negateive为json格式，make_type要定制
-          [:add_time, :addTime],
-          [:update_time, :updateTime]
-        ]
+          negative:       :negativeWords,
+          exact_negative: :exactNegativeWords,
+          add_time:       :addTime,
+          update_time:    :updateTime,
+          from_time:      :fromTime,
+        }
+        @map = GroupType
 
-        # 再次封装提供all和ids
-        def self.ids( auth )
-          '''
-          接口与其他的相同，但是无论如何：succ均为true，不返回任何错误信息
-          因为是重复调用了search的接口，速度非常的慢，* 慎用 *
-          '''
-          plan_ids = ::PPC::API::Qihu::Plan::ids( auth )[:result]
-          plan_group_ids = []
+        def self.info( auth, ids )
+          response = request( auth, Service, 'getInfoByIdList', { idList: ids } )
+          process( response, 'groupList' ){ |x| reverse_type(x)[0] }
+        end
+
+        def self.all( auth, plan_id )
+          group_ids = self.ids( auth, plan_id )[:result][:group_ids]
+          self.get( auth, group_ids )
+        end
 
-          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 }
+        def self.ids( auth, plan_id )
+          response = request( auth, Service, 'getIdListByCampaignId', { campaignId: plan_id[0] } )
+          process( response, 'groupIdList' ){ |x| { plan_id: plan_id[0], group_ids: x.map(&:to_i) } }
         end
 
-        def self.all( auth )
-          '''
-          unimplemented due to ineffciency
-          '''
-          # unimplement
+        def self.get( auth, ids )
+          response = request( auth, Service, 'getInfoByIdList', { idList: ids } )
+          process( response, 'groupList' ){ |x| reverse_type(x) }
         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 } ]    }
+        def self.add( auth, groups )
+          groups.each{ |group| group[:negative] = {exact: group.delete(:exact_negative), phrase: group.delete(:negative)} if group[:exact_negative] || group[:negative] }
+          response = request( auth, Service, 'batchAdd', {groups: make_type( groups )} )
+          process( response, 'groupIdList' ){ |x| x.map.with_index{|id, index| {id: id, name: groups[index][:name]}} }
         end
 
+        # 奇虎组服务不提供批量delete和update方法
         def self.update( auth, group )
-          if group[:negative] || group[:exact_negative]
-            ng = {"exact" => group[:exact_negative], "phrase" => group[:negative]}.to_json
-          end
+          group[0][:negative] = {exact: group[0].delete(:exact_negative), phrase: group[0].delete(:negative)}.to_json if group[0][:exact_negative] || group[0][:negative]
           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) }
+          process( response, 'id' ){ |x| [{id: x, name: group[0][:name]}] }
         end
 
         def self.delete( auth, id )
-          response = request( auth, Service, 'deleteById', { id: id}  )
+          response = request( auth, Service, 'deleteById', {id: id[0]}  )
           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) } ]
-          }
+        def self.enable( auth, id )
+          self.update(auth, [{id: id[0], pause: "enable"}])
         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
+        def self.pause( auth, id )
+          self.update(auth, [{id: id[0], pause: "pause"}])
         end
 
       end