ppc 1.3.0 → 1.3.2

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

@@ -17,22 +17,22 @@ module PPC
                         [:reserved, :reserved]
                       ]
 
-        def self.ids(auth, debug = false )
+        def self.ids(auth )
           """
           @return : Array of campaignAdgroupIds
           """
           response = request( auth, Service , "getAllAdgroupId" )
-          process( response, 'campaignAdgroupIds', debug ){ |x| make_planGroupIds( x ) }
+          process( response, 'campaignAdgroupIds' ){ |x| make_planGroupIds( x ) }
         end
 
-        def self.get( auth, ids, debug = false )
+        def self.get( auth, ids )
           ids = [ ids ] unless ids.is_a? Array
           body = { adgroupIds: ids }
           response = request(auth, Service, "getAdgroupByAdgroupId",body )
-          process( response, 'adgroupTypes', debug ){ |x| reverse_type(x) }
+          process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
         end
 
-        def self.add( auth, groups, debug = false )
+        def self.add( auth, groups )
           """
           @ input : one or list of AdgroupType
           @ output : list of AdgroupType
@@ -42,10 +42,10 @@ module PPC
           body = {adgroupTypes:  adgrouptypes }
           
           response = request( auth, Service, "addAdgroup", body  )
-          process( response, 'adgroupTypes', debug ){ |x| reverse_type(x) }
+          process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
         end
 
-        def self.update( auth, groups, debug = false )
+        def self.update( auth, groups )
           """
           @ input : one or list of AdgroupType
           @ output : list of AdgroupType
@@ -54,31 +54,31 @@ module PPC
           body = {adgroupTypes: adgrouptypes}
           
           response = request( auth, Service, "updateAdgroup",body )
-          process( response, 'adgroupTypes', debug ){ |x| reverse_type(x) }
+          process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
         end
 
-        def self.delete( auth, ids, debug = false )
+        def self.delete( auth, ids )
           """
           delete group body has no message
           """
           ids = [ ids ] unless ids.is_a? Array
           body = { adgroupIds: ids }
           response = request( auth, Service,"deleteAdgroup", body )
-          process( response, 'nil', debug ){ |x|  x  }
+          process( response, 'nil' ){ |x|  x  }
         end
 
-        def self.search_by_plan_id( auth, ids, debug = false )
+        def self.search_by_plan_id( auth, ids )
           ids = [ ids ] unless ids.class == Array
           body = { campaignIds: ids }
           response = request( auth, Service ,"getAdgroupByCampaignId",  body )
-          process( response, 'campaignAdgroups', debug ){ |x| make_planGroups( x ) }
+          process( response, 'campaignAdgroups' ){ |x| make_planGroups( x ) }
         end
 
-        def self.search_id_by_plan_id( auth, ids, debug = false )
+        def self.search_id_by_plan_id( auth, ids )
           ids = [ ids ] unless ids.class == Array
           body = { campaignIds: ids }
           response = request( auth, Service ,"getAdgroupIdByCampaignId",  body )
-          process( response, 'campaignAdgroupIds', debug ){ |x| make_planGroupIds( x ) }
+          process( response, 'campaignAdgroupIds' ){ |x| make_planGroupIds( x ) }
         end
 
         private

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

@@ -5,85 +5,85 @@ module PPC
       class Keyword< Baidu
         Service = 'Keyword'
 
-        Match_type  = { 'exact' => 1, 'pharse' => 2, 'wide' => 3 }
-        Match_type_r  = { 1 => 'exact', 2=> 'pharse' , 3 => 'wide' }
-        
-        Device          = { 'pc' => 0, 'mobile' => 1, 'all' => 2 }
-        Type              = { 'plan' => 3, 'group' => 5, 'keyword' => 11 }
+        Match_type  = { 'exact' => 1, 'phrase' => 2, 'wide' => 3,1 => 'exact', 2=> 'phrase' , 3 => 'wide'  }
+        Device      = { 'pc' => 0, 'mobile' => 1, 'all' => 2 }
+        Type        = { 'plan' => 3, 'group' => 5, 'keyword' => 11 }
         
         @map  = [
-                            [:id,:keywordId],
-                            [:group_id,:adgroupId],
-                            [:keyword,:keyword],
-                            [:price,:price],
-                            [:pc_destination,:pcDestinationUrl],
-                            [:mobile_destination,:mobileDestinationUrl],
-                            [:match_type,:matchType],
-                            [:phrase_type,:phraseType]
-                        ]
+                  [:id,:keywordId],
+                  [:group_id,:adgroupId],
+                  [:keyword,:keyword],
+                  [:price,:price],
+                  [:pc_destination,:pcDestinationUrl],
+                  [:mobile_destination,:mobileDestinationUrl],
+                  [:match_type,:matchType],
+                  [:phrase_type,:phraseType],
+                  [:status,:status],
+                  [:pause,:pause]
+                ]
 
         @quality10_map = [
-                                          [ :id, :id ],
-                                          [ :group_id, :adgroupId ],
-                                          [ :plan_id, :Campaigned ],
-                                          [ :pc_quality, :pcQuality ],
-                                          [ :pc_reliable, :pcReliable ],
-                                          [ :pc_reason, :pcReason ],
-                                          [ :pc_scale, :pcScale ],
-                                          [ :mobile_quality, :mobileQuality ],
-                                          [ :mobile_reliable, :mobileReliable ],
-                                          [ :mobile_reason, :mobileReason ],
-                                          [ :mobile_scale, :mobileScale ]
-                                        ]
+                          [ :id, :id ],
+                          [ :group_id, :adgroupId ],
+                          [ :plan_id, :Campaigned ],
+                          [ :pc_quality, :pcQuality ],
+                          [ :pc_reliable, :pcReliable ],
+                          [ :pc_reason, :pcReason ],
+                          [ :pc_scale, :pcScale ],
+                          [ :mobile_quality, :mobileQuality ],
+                          [ :mobile_reliable, :mobileReliable ],
+                          [ :mobile_reason, :mobileReason ],
+                          [ :mobile_scale, :mobileScale ]
+                          ]
 
         # 后面改成info方法
-        def self.get( auth, ids, debug = false )
+        def self.get( auth, ids )
           '''
           getKeywordByKeywordId
           '''
           ids = [ ids ] unless ids.is_a? Array
           body = { keywordIds: ids}
           response = request( auth, Service, 'getKeywordByKeywordId', body )
-          return process(response, 'keywordTypes', debug){|x| reverse_type( x ) }
+          return process(response, 'keywordTypes' ){|x| reverse_type( x ) }
         end
 
-        def self.add( auth, keywords, debug = false )
+        def self.add( auth, keywords )
           '''
           '''
           keywordtypes = make_type( keywords ) 
           body = { keywordTypes: keywordtypes }
           response = request( auth, Service, "addKeyword", body )
-          return process(response, 'keywordTypes', debug){|x| reverse_type(x)  }
+          return process(response, 'keywordTypes' ){|x| reverse_type(x)  }
         end
 
-        def self.update( auth, keywords, debug = false  )
+        def self.update( auth, keywords  )
           '''
           '''
           keywordtypes = make_type( keywords ) 
           body = { keywordTypes: keywordtypes }
           response = request( auth, Service, "updateKeyword", body )
-          return process(response, 'keywordTypes', debug){|x| reverse_type(x)  }
+          return process(response, 'keywordTypes' ){|x| reverse_type(x)  }
         end
 
-        def self.delete( auth, ids, debug = false )
+        def self.delete( auth, ids )
           """
           """
           ids = [ ids ] unless ids.is_a? Array
           body = { keywordIds: ids}
           response = request( auth, Service, 'deleteKeyword', body )
-          return process(response, 'result', debug){|x| x }
+          return process(response, 'result' ){|x| x }
         end
 
-        def self.activate( auth, ids, debug =false )
+        def self.activate( auth, ids )
           """
           """
           ids = [ ids ] unless ids.is_a? Array
           body = { keywordIds: ids }
           response = request( auth, Service, 'activateKeyword', body)
-          return process(response, 'keywordTypes', debug){|x| reverse_type(x)  }
+          return process(response, 'keywordTypes' ){|x| reverse_type(x)  }
         end
 
-        def self.search_by_group_id( auth, group_ids, debug = false  )
+        def self.search_by_group_id( auth, group_ids  )
           """
           getKeywordByGroupIds
           @input: list of group id
@@ -92,33 +92,44 @@ module PPC
           group_ids = [ group_ids ] unless group_ids.is_a? Array
           body = { adgroupIds: group_ids }
           response = request( auth, Service, "getKeywordByAdgroupId", body )
-          return process(response, 'groupKeywords', debug){|x| make_groupKeywords( x ) }
+          return process(response, 'groupKeywords' ){|x| make_groupKeywords( x ) }
         end
 
-        def self.search_id_by_group_id( auth, group_ids, debug = false  )
+        def self.search_id_by_group_id( auth, group_ids  )
           group_ids = [ group_ids ] unless group_ids.is_a? Array
           body = { adgroupIds: group_ids }
           response = request( auth, Service, "getKeywordIdByAdgroupId", body )
-          return process(response, 'groupKeywordIds', debug){|x| make_groupKeywordIds( x ) }
+          return process(response, 'groupKeywordIds' ){|x| make_groupKeywordIds( x ) }
         end
 
         # 下面三个操作操作对象包括计划，组和关键字
         # 不知道放在这里合不合适
-        def self.status( auth, ids, type, debug = false )
+        def self.status( auth, ids, type )
+          '''
+          Return [{ id: id, status: status } ... ]
+          '''
           ids = [ ids ] unless ids.is_a? Array
           body = { ids: ids, type: Type[type]}
           response = request( auth, Service, 'getKeywordStatus', body )
-          return process(response, 'keywordStatus', debug){|x| reverse_type( x ) }
+          return process(response, 'keywordStatus' ){  |statusTypes| 
+            statusTypes = [statusTypes] unless statusTypes.is_a? Array
+            status =[]
+
+            statusTypes.each do |statusType|
+              status << { id: statusType['id'], status: statusType['status'] }
+            end
+            return status
+           }
         end
 
-        def self.quality( auth ,ids, type, device, debug = false )
+        def self.quality( auth ,ids, type, device )
           '''
           Return 10Quanlity *Not the old Quality* of given ketword id
           '''
           ids = [ ids ] unless ids.is_a? Array
           body = { ids: ids, type: Type[type], device:Device[device] }
           response = request( auth, Service, 'getKeyword10Quality', body )
-          return process(response, 'keyword10Quality', debug){|x| reverse_type( x, @quality10_map ) }
+          return process(response, 'keyword10Quality' ){|x| reverse_type( x, @quality10_map ) }
         end
 
         private
@@ -176,7 +187,7 @@ module PPC
               map.each do |key|
                 if key[0] == :match_type
                    value = type[ key[1].to_s ]
-                  param[ key[0] ] = Match_type_r[ value ] if value                 
+                  param[ key[0] ] = Match_type[ value ] if value                 
                 else
                   value = type[ key[1].to_s ]
                   param[ key[0] ] = value if value
@@ -190,4 +201,4 @@ module PPC
       end # keyword
     end # Baidu
   end # API
-end # PPC
+end # PPC

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

@@ -0,0 +1,51 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Baidu
+      class Phone < Baidu
+        Service = 'NewCreative'
+
+        @map =[
+                [:id,:phoneId],
+                [:group_id,:adgroupId],
+                [:phone_num,:phoneNum],
+                [:pause,:pause],
+              ]     
+
+        def self.update( auth, phones )
+          '''
+          根据实际使用情况，更新的时候creative title为必填选
+          '''
+          body = { phoneTypes: make_type( phones ) }
+          response = request( auth, Service, 'updatePhone', body )
+          process( response, 'phoneTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.search_id_by_group_id( auth, ids, getTemp = 0 )
+          '''
+          \'getPhoneIdByAdgroupId\'
+          @ input: group ids
+          @ output:  groupPhoneIds
+          '''
+          ids = [ ids ] unless ids.is_a? Array
+          body = { adgroupIds: ids, getTemp: getTemp }
+          response = request( auth, Service, 'getPhoneIdByAdgroupId', body )
+          process( response, 'groupPhoneIds' ){ |x| make_groupPhoneIds( x ) }
+        end
+
+        private
+        def self.make_groupPhoneIds( groupPhoneIds )
+          group_phone_ids = []
+          groupPhoneIds.each do |phone_id|
+            group_phone_id = { }
+            group_phone_id[:group_id] = phone_id['adgroupId']
+            group_phone_id[:phone_ids] = phone_id['phoneIds']
+            group_phone_ids << group_phone_id
+          end
+          return group_phone_ids
+        end
+
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,23 @@
+module PPC
+  module API
+    class Baidu
+      class Rank< Baidu
+        Service = 'Rank'
+
+        def self.get_rank(auth, keyword, device)
+          body = {:keyWords => [keyword], :device => 0, :region => 1000, :page => 0, :display => 0}
+          response = request(auth, Service, 'getPreview', body)
+          result = process(response, 'previewInfos' ){|x| x }
+          p result
+          data = result[:result][0]["data"]
+          plain = Base64.decode64(data)
+          gz = Zlib::GzipReader.new(StringIO.new(plain))
+          html_result = gz.read
+          gz.close
+          puts html_result
+        end
+
+      end # keyword
+    end # Baidu
+  end # API
+end # PPC

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

@@ -7,115 +7,134 @@ module PPC
       
         # 需要用到的映射集合
         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 }
+                      'keyword'=> 14, 'creative'=> 12, 'pair'=> 15, 
+                       'region'=> 3, 'wordid'=> 9 , 'query'=>6 }
 
-        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
+        Level_map = {  'account' => 2, 'plan' => 3, 'group' => 5, 
+                        'creative'=> 7, 'keywordid' => 11, 'pair' => 12, 
+                         'wordid' => 6 }
 
-          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
+        Device_map = { 'all' => 0, 'pc' => 1, 'mobile' => 2 }
 
+        Unit_map = { 'day' => 5, 'week' => 4, 'month' => 3, 'year' => 1, 'hour' => 7 }
 
-        def self.get_id( auth, params, debug = false )
-          request = make_reportrequest( params )[0]
+        ########################
+        # API wraping function #
+        ########################
+        def self.get_id( auth, params  )
+          request = make_reportrequest( params )
           body =  { reportRequestType:  request }
           response = request( auth, Service, 'getProfessionalReportId' ,body) 
-          process( response, 'reportId', debug ){ |x| x }
+          process( response, 'reportId' ){ |x| x }
         end
 
-        def self.get_status( auth, id, debug = false)
+        def self.get_state( auth, id )
           '''
           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] }
+          process( response, 'isGenerated' ){ |x| status[x] }
         end
 
-        def self.get_file_url( auth, id, debug = false )
+        def self.get_url( auth, id  )
           body = { reportId:  id }
           response = request( auth, Service, 'getReportFileUrl' ,body)
-          process( response, 'reportFilePath', debug ){ |x| x }       
+          process( response, 'reportFilePath' ){ |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
+        def self.make_reportrequest( param )
+          """
+          make RepoerRequestType
+          ==============
+          @Input : :fields,:type,:level,:range,:unit,:device,:id_only,:startDate:endDate
+          ==============
+          Note:
+            We cast [ type, level, range, unit,device ] from int to string.
+          For more information please see those map at the begining of the file
+          """
+          requesttype = {}
+          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]         =     parse_date( param[:startDate] )
+          requesttype[:endDate]           =     parse_date( param[:endDate] )
+          return requesttype
         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
+        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
-          return requesttypes
+          date
         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()
+        #################################
+        # useful function for operation #
+        #################################
+        def self.query_report( auth, param = nil, debug = false )
+          param = {} if not param
+          param[:type]   ||= 'query'
+          param[:fields] ||=  %w(click impression)
+          param[:level]  ||= 'pair'
+          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(impression click cpc cost ctr cpm position conversion)
+          param[:level]  ||= 'creative'
+          param[:range]  ||= 'creative'
+          param[:unit]   ||= 'day'
+          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(impression click cpc cost ctr cpm position conversion)
+          param[:level]  ||= 'keywordid'
+          param[:range]  ||= 'keywordid'
+          param[:unit]   ||= 'day'
+          download_report( auth, param, debug )
+        end
+   
+        def self.download_report( auth, param, debug = false )
+          p param
+          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].to_s[/(Finished|3)/]
+              p "Report is not generated, waiting..." if debug 
+            end
 
-            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
+            url = get_url( auth, id )[:result]
+            return open(url).read.force_encoding('gb18030').encode('utf-8')
+          else
+            raise response[:failure][0]["message"]
           end
-          return requesttypes
         end
 
       end # Repost