ppc 0.3.0 → 1.0.1

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

@@ -1,113 +0,0 @@
-# -*- 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要定制
-                [:negative, :negativeWords ],
-                [: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 )
-          response = request( auth, Service, 'update', make_type( group )[0]  )
-          # 保证接口一致性
-          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['item'] ) }
-        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==nil ? nil: x['item'] ) } ]
-           }
-        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
-
-      # customize make type to convert negative word
-      def self.make_type( params, map = @map)
-        '''
-        '''
-        params = [ params ] unless params.is_a? Array
-
-        types = []
-        params.each do |param|
-          type = {}
-
-            map.each do |key|
-              # next line transfer negative param to json
-              key[0]==:negative&&param[:negative] ? value=param[:negative].to_json : value=param[key[0]]
-              type[ key[1] ] = value if value != nil
-            end
-
-          types << type
-        end
-        return types
-      end
-
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-# -*- coding:utf-8 -*-
-module PPC
-  module API
-    class Qihu
-      class Keyword< Qihu
-        Service = 'keyword'
-
-        @map = [
-                  [:id, :id],
-                  [:group_id, :groupId],
-                  [:keyword, :word],
-                  [:price, :price],
-                  [:match_type, :matchType],
-                  [:pc_destination, :destinationUrl],
-                  [:status, :status]
-                ]
-
-        @status_map = [ 
-                        [:id,:id], 
-                        [:quality,:qualityScore],
-                        [:status,:status]
-                      ]
-
-        def self.get( auth, ids )
-          ids = to_json_string( ids )
-          body  = { 'idList' => ids }
-          response = request( auth, Service, 'getInfoByIdList', body )
-          process( response, 'keywordList'){ |x| reverse_type( x['item'] ) }
-        end
-
-        def self.add( auth,  keywords )
-          keyword_types =  make_type( keywords ).to_json
-          body = { 'keywords' => keyword_types}
-          response = request( auth, Service, 'add', body )
-          process( response, 'keywordIdList'){ |x| to_id_hash_list( x['item'] )  }
-        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, keywords )
-          keyword_types = make_type( keywords ).to_json
-          body = { 'keywords' => keyword_types}
-          response = request( auth, Service, 'update', body )
-          process( response, 'affectedRecords', 'failKeywordIds' ){ |x| x }        
-        end
-
-        # 对update的再封装实现activate方法
-        def self.activate( auth, ids )
-          keywords = []
-          ids.each{ |id| keywords << { id: id, status:'enable'} }
-          update( auth, keywords )
-        end
-
-        def self.delete( auth, ids )
-          body = { 'idList' => to_json_string( 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, 'keywordList' ){ |x| reverse_type( x['item'], @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, match_type = nil )
-          # 处理条件  
-          body = {}
-          body['status'] = status if status
-          body['matchType'] = match_type if match_type
-          body['groupId'] = id
-          response = request( auth, Service, 'getIdListByGroupId', body )
-          # 伪装成百度接口
-          process( response, 'keywordIdList' ){ 
-            |x|
-            [ { group_id:id, keyword_ids:to_id_list( x==nil ? nil: x['item'] ) } ]
-          }     
-        end
-
-        # combine search_id and get to provide another method
-        def self.search_by_group_id( auth, id )
-          keyword_ids = search_id_by_group_id( auth, id )[:result][0][:keyword_ids]
-          response = get( auth, keyword_ids )
-          if response[:succ]
-            # 伪装成百度接口
-            response[:result] = [ { group_id:id, keywords:response[:result] } ]
-          end
-          return response
-        end
-
-        def self.getChangedIdList
-          # unimplemented
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-# -*- coding:utf-8 -*-
-module PPC
-  module API
-    class Qihu
-      class Plan < Qihu
-        Service = 'campaign'
-
-        @map = [
-                  [:id, :id],
-                  [:name,:name],
-                  [:budget, :budget],
-                  [:region, :region],
-                  [:schedule, :schedule],
-                  [:startDate, :startDate],
-                  [:endDate, :endDate ],
-                  [:status,:status], 
-                  [:extend_ad_type,:extendAdType]
-                ]
-
-
-        def self.get( auth, ids )
-          '''
-          :Type ids: ( Array of ) String or integer
-          '''
-          ids = to_json_string( ids )    
-          body = { ' idList' =>  ids  }
-          response = request( auth, Service, 'getInfoByIdList', body )
-          process( response, 'campaignList' ){ |x| reverse_type( x['item'] ) }
-        end
-
-        # move getCampaignId to plan module for operation call
-        def self.ids( auth )
-          response = request( auth, 'account', 'getCampaignIdList' )
-          process( response, 'campaignIdList' ){ |x| to_id_list( x['item'])}
-        end 
-
-        # combine two original method to provice new method
-        def self.all( auth )
-          plan_ids = ids( auth )[:result]
-          get( auth, plan_ids )
-        end
-        
-        # 奇虎计划API不提供批量服务
-        def self.add( auth, plan )
-          response = request( auth, Service, 'add', make_type( plan )[0])
-          # 这里将返回的简单int做一个array和hash的封装一保证接口和百度，搜狗的一致性
-          process( response, 'id' ){ |x| [ { id:x.to_i } ] }
-        end
-
-        def self.update( auth, plan ) 
-           response = request( auth, Service, 'update', make_type( plan )[0])
-           #同上，保证接口一致性
-           process( response, 'id' ){ |x| [ { id:x.to_i } ] }
-        end
-
-        def self.delete( auth, id )
-          response = request( auth, Service, 'deleteById', { id: id } )
-          process( response, 'affectedRecords' ){ |x|  x == '1'? 'success' : 'fail' }
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,159 +0,0 @@
-# -*- coding:utf-8 -*-
-require 'json'
-
-module PPC
-  module API
-    class Qihu
-      class Report< Qihu
-        Service = 'report'
-
-        @map =[
-                [:queryword,:queryword],
-                [:plan_id,:campaignId],
-                [:creative_id,:creativeId],
-                [:keyword,:keyword],
-                [:views,:views],
-                [:clicks,:clicks],
-                [:startDate,:startDate],
-                [:endDate,:endDate],
-                [:date,:date],
-                [:keyword_id,:keywordId],
-                [:group_id,:groupId],
-                [:cost,:totalCost],
-                [:position,:avgPosition],
-                [:total_num,:totalNumber],
-                [:total_page,:totalPage]
-              ]
-
-        ###################
-        # API abstraction #
-        ###################
-        def self.abstract( auth, type_name, method_name, key, param = nil, &func )
-          body = make_type( param )
-          response = request( auth, Service, method_name, body )
-          process( response, key ){ |x| func[ x ] }
-        end
-
-        type_list = ['keyword', 'query', 'creative', 'sublink']
-        type_list.each do |type|
-          # type
-          define_singleton_method type.to_sym do |auth, param|
-              abstract( auth, type, type, type+'List', param ){ |x| x['item']}
-          end
-          # typeCount
-          define_singleton_method (type+'_count').to_sym do |auth, param|
-              response = abstract( auth, type, type+'Count', '', param ){ |x| get_item(x) }
-              response[:result] = response[:result][0]
-              return response
-          end
-          # typeNow
-          define_singleton_method (type+'_now').to_sym do |auth, param|
-              abstract( auth, type, type+'Now', type+'List', param ){ |x| x['item']}
-          end
-          # typeNowCount
-          define_singleton_method (type+'_now_count').to_sym do |auth, param|
-              response = abstract( auth, type, type+'NowCount', '', param ){ |x| get_item(x) }
-              response[:result] = response[:result][0]
-              return response
-          end
-        end
-
-        ############################
-        # Interfaces for operation #
-        ############################
-        def self.keyword_report( auth, param, debug = false )
-          download_report(auth, 'keyword', param, debug )
-        end
-
-        def self.creative_report( auth, param, debug = false )
-          download_report(auth, 'creative', param, debug)
-        end
-        
-        def self.download_report(auth, type, param, debug = false)
-          # deal_with time
-          now = Time.now.to_s[0...10]
-          is_now = now==parse_date(param[:startDate])
-        
-          # get page num
-          if is_now
-            method = (type+'_now_count').to_sym
-            count = send(method, auth, param)[:result]
-            method = (type+'_now').to_sym
-          else
-            method = (type+'_count').to_sym
-            count = send(method, auth, param)[:result]
-            method = type.to_sym
-          end
-          
-          report = []
-          count[:total_page].to_i.times do | page_i|
-            p "Start downloading #{page_i+1}th page, totally #{count[:total_page]} pages"
-            param[:page] = page_i +1
-            report_i = send(method, auth, param)[:result]
-            report += report_i
-          end
-        
-          return report
-        end
-
-        ###################
-        # Helper Function #
-        ###################
-        # incase idlist == nil
-        private
-        def self.get_item( params )
-          return nil if params == nil
-          return reverse_type( params ) 
-        end
-
-        private 
-        def self.make_type( param )
-          type = {}
-          # add option
-          type[:level] = param[:level] || 'account'
-          type[:page] = param[:page] || 1
-          # add ids
-          if param[:ids] != nil
-            ids = param[:ids] 
-            ids = [ ids ] unless ids.is_a? Array
-            type[:IdList] = ids.to_json
-          end
-          # add date
-          if param[:startDate]==nil || param[:endDate]==nil
-            type[:startDate], type[:endDate] = get_date()
-          else
-            type[:startDate] = parse_date( param[:startDate] )
-            type[:endDate] = parse_date( param[:endDate] )
-          end
-
-          return type
-        end
-
-        private
-        def self.get_date()
-            endDate = Time.now.to_s[0,10]
-            startDate = (Time.now - 24*3600).to_s[0,10]
-          return startDate,endDate
-        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.to_s[0,10]
-        end
-
-      end # Report
-    end # Qihu
-  end # API
-end # PPC