ppc 1.3.0 → 1.3.2

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

@@ -0,0 +1,135 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Shenma
+      class Report< Shenma
+        Service = 'Report'
+      
+        # 需要用到的映射集合
+        Type_map = { 'account' =>2, 'plan'=> 10, 'group'=> 11, 
+                      'keyword'=> 14, 'creative'=> 12, 'region'=> 3, 
+                       'query'=> 6, 'phone' => 22, 'app' => 23 }
+
+        Level_map = {  'account' => 2, 'plan' => 3, 'group' => 5, 
+                        'creative' => 7, 'keyword' => 11, 'phone' => 22,
+                         'app' => 23, 'pair' => 12 }
+
+        Unit_map = { 'day' => 5, 'month' => 3, 'default' => 8 }
+
+        def self.get_id( auth, params, debug = false )
+          request = make_reportrequest( params )
+          body =  { ReportRequestType: request }
+          response = request( auth, '/report/getReport' ,body) 
+          process( response, 'reportId', debug ){ |x| x }
+        end
+
+        def self.get_state( auth, id, debug = false)
+          '''
+          input id should be string
+          '''
+          status = {1=>'Waiting' ,2=>'Opearting' ,3=>'Finished'}
+          body = { taskId:  id }
+          response = request( auth, '/task/getTaskState' ,body)
+          process( response, 'isGenerated', debug ){ |x| status[x] }
+        end
+
+        # todo : rewrite method
+        def self.download( auth, id, debug = false )
+          body = { fileId:  id }
+          response = request( auth, '/file/download' ,body)
+          process( response, 'reportPath', debug ){ |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] 
+          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[:idOnly]             =     param[:id_only]   || false
+          requesttype[:statIds]            =     param[:ids] if param[:ids] != 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.to_s[0,10]
+        end
+
+        def download_report( auth, param, debug = false )
+          response = call('report').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 call('report').get_state( auth, id )[:result] == 'Finished'
+              p "Report is not generated, waiting..." if debug 
+            end
+            # need to rewrite the download method here.
+            url = call('report').get_url( auth, id )[:result]
+            return open(url).read.force_encoding('gb18030').encode('utf-8')
+          else
+            raise response[:failure][0]["message"]
+          end
+        end
+
+        ###########################
+        # intreface for Operation #
+        ###########################
+        def query_report( auth, param = nil, debug = false )
+          param = {} if not param
+          param[:type]   ||= 'query'
+          param[:fields] ||=  %w(click)
+          param[:level]  ||= 'pair'
+          param[:range]  ||= 'account'
+          param[:unit]   ||= 'day'
+          download_report( param, debug )
+        end
+
+        def creative_report( auth, param = nil, debug = false )
+          param = {} if not param
+          param[:type]   ||= 'creative'
+          param[:fields] ||=  %w( cost cpc click impression ctr )
+          param[:level]  ||= 'creative'
+          param[:range]  ||= 'creative'
+          param[:unit]   ||= 'day'
+          download_report( param, debug )
+        end
+
+        def keyword_report( auth, param = nil, debug = false )
+          param = {} if not param
+          param[:type]   ||= 'keyword'
+          param[:fields] ||=  %w( cost cpc click impression ctr )
+          param[:level]  ||= 'keywordid'
+          param[:range]  ||= 'keywordid'
+          param[:unit]   ||= 'day'
+          download_report( param, debug )
+        end
+
+      end # Repost
+    end # Baidu
+  end # API
+end # PPC

data/lib/ppc/api/sm.rb

@@ -0,0 +1,50 @@
+# -*- coding:utf-8 -*-
+require 'ppc/api/sm/account'
+require 'ppc/api/sm/plan'
+require 'ppc/api/sm/bulk'
+require 'ppc/api/sm/group'
+require 'ppc/api/sm/keyword'
+require 'ppc/api/sm/report'
+require 'ppc/api/sm/creative'
+module PPC
+  module API
+    class Sm
+
+      extend ::PPC::API
+
+      def self.request_uri(param = {})
+        URI("https://e.sm.cn/api/#{param[:service]}/#{param[:method]}")
+      end
+
+      def self.process( response, key, &func)
+        '''
+        Process Http response. If operation successes, return value of given keys.
+        You can process the result using function &func, or do nothing by passing 
+        block {|x|x}
+        =========================== 
+        @Output: resultType{ desc: boolean, failure: Array,  result: Array }
+
+        failure is the failures part of response\'s header
+        result is the processed response body.
+        '''
+        result = {}
+        result[:succ] = response['header']['desc'] =='success'
+        result[:failure] = response['header']['failures']
+        if !response['body'].nil? && response['body'][key]
+          result[:result] = func[ response['body'][key] ]
+        end
+        result[:no_quota] = is_no_quota(response['header']['failures'], '8501')
+        result
+      end # process
+
+      def self.reverse_type( types, maps = @map )
+        types = [ types ] unless types.is_a? Array
+        types.map do |item| 
+          maps.each{|m| item.filter_and_replace_key(m[0],m[1].to_s)}
+          item
+        end
+      end
+
+    end # Sm
+  end # API
+end # PPC

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

@@ -0,0 +1,44 @@
+module PPC
+  module API
+    class Sm
+      class Account < Sm
+        Service = 'account'
+
+        @map = [
+                  [:id,:userId],
+                  [:balance,:balance],
+                  [:cost,:cost],
+                  [:payment,:payment],
+                  [:budget_type,:budgetType],
+                  [:budget,:budget],
+                  [:region,:regionTarget],
+                  [:exclude_ip,:excludeIp],
+                  [:open_domains,:openDomains],
+                  [:reg_domain,:regDomain],
+                  [:offline_time,:budgetOfflineTime],
+                  [:weekly_budget,:weeklyBudget]
+                ]
+
+        def self.info( auth )
+          response = request(auth, Service, 'getAccount', {requestData: ["account_all"]})
+          p response
+          return process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
+        end
+
+        def self.update(auth, param = {} )
+          """
+          update account info
+          @ params : account_info_type
+          @return : account info_type
+          """
+          # for account service, there is not bulk operation
+          infoType = make_type( param )[0]
+          body = { accountInfoType: infoType }
+          response = request(auth, Service, 'updateAccount', body)
+          return process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module PPC
+  module API
+    class Sm
+      class Bulk < Sm
+        Service = 'bulkJob'
+
+        def self.get_all_object( auth,params = {})
+          
+          plan_ids = params[:plan_ids]
+
+          unless plan_ids.nil?
+            plan_ids = plan_ids.class == Array ? plan_ids : [plan_ids]
+          end
+
+          options = {
+            bulkJobRequestType: {
+              campaignIds:              plan_ids              || []      
+            }
+          }
+          response = request( auth, Service, 'getAllObjects',options )
+          process( response, 'taskId'){ |x| x }
+        end
+
+        def self.get_file_id( auth, id)
+          raise "empty id" if id.nil?
+          response = request(auth, 'task', 'getTaskState',{taskId: id})
+          process( response, 'fileId'){ |x| x }
+        end
+
+        def self.do_download(auth, id)
+          request(auth, 'file', 'download',{fileId: id})
+        end
+
+        ###########################
+        # interface for operation #
+        ###########################
+        def self.download( auth, params = {} )
+          """
+          """
+          begin
+            result = get_all_object( auth, params )
+            if result[:succ]
+              task_id = result[:result]
+            else
+              raise "获取task id 失败"
+            end
+
+            puts "task_id: #{task_id}" if @debug
+
+            loop do
+              file_id = get_file_id( auth, task_id )[:result]
+              if file_id.nil?
+                sleep 15
+                next
+              end
+              File.open("sm_#{file_id}.zip", "w") do |f|
+                f.puts do_download(auth, file_id)
+              end
+              return
+            end
+          rescue => e
+            p "Error encounter:#{e.to_s}"
+          end  
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Sm
+      class Creative< Sm
+        Service = 'creative'
+
+        @map =[
+                [:id, :creativeId],
+                [:group_id, :adgroupId],
+                [:title, :title],
+                [:description1, :description1],
+                [:pause, :pause],
+                [:mobile_destination, :destinationUrl],
+                [:mobile_display, :displayUrl],
+                [:status, :status]
+              ]     
+
+        def self.add(auth, creatives)
+          body = {creativeTypes: make_type(creatives)}
+          response = request(auth, Service, 'addCreative', body)
+          process(response, 'creativeTypes'){|x| reverse_type(x)}
+        end
+
+        def self.get(auth, ids)
+          ids = [ids] unless ids.is_a? Array
+          body = {creativeIds: ids}
+          response = request(auth, Service, 'getCreativeByCreativeId', body)
+          process(response, 'creativeTypes'){|x| reverse_type(x)}
+        end
+
+        def self.update(auth, creatives)
+          body = {creativeTypes: make_type(creatives)}
+          response = request(auth, Service, 'updateCreative', body)
+          process(response, 'creativeTypes'){|x| reverse_type(x)}
+        end
+
+        def self.delete(auth, ids)
+          ids = [ids] unless ids.is_a? Array
+          body = {creativeIds: ids}
+          response = request(auth, Service, 'deleteCreative', body, 'delete')
+          process(response, 'result'){|x| x}
+        end
+
+        def self.search_id_by_group_id(auth, ids)
+          ids = [ids] unless ids.is_a? Array
+          body = {adgroupIds: ids}
+          response = request(auth, Service, 'getCreativeIdByAdgroupId', body)
+          process(response, 'groupCreativeIds'){|x| make_groupCreativeIds(x)}
+        end
+
+        def self.search_by_group_id(auth, ids)
+          ids = [ids] unless ids.is_a? Array
+          body = {adgroupIds: ids}
+          response = request(auth, Service, 'getCreativeByAdgroupId', body)
+          process(response, 'groupCreatives'){|x| make_groupCreatives(x)}
+        end
+
+        private
+        def self.make_groupCreativeIds( groupCreativeIds )
+          group_creative_ids = []
+          groupCreativeIds.each do |groupCreativeId|
+            group_creative_id = { }
+            group_creative_id[:group_id] = groupCreativeId['adgroupId']
+            group_creative_id[:creative_ids] = groupCreativeId['creativeIds']
+            group_creative_ids << group_creative_id
+          end
+          return group_creative_ids
+        end
+
+        private
+        def self.make_groupCreatives( groupCreatives )
+          group_creatives = []
+          groupCreatives.each do |groupCreative |
+            group_creative = {}
+            group_creative[:group_id] = groupCreative['adgroupId']
+            group_creative[:creatives] = reverse_type( groupCreative['creativeTypes'] )
+            group_creatives << group_creative
+          end
+          return group_creatives
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# -*- coding:utf-8  -*-
+module PPC
+  module API
+    class Sm
+      class Group < Sm
+        Service = 'adgroup'
+
+        @map =[
+               [:plan_id, :campaignId],
+               [:id, :adgroupId],
+               [:name, :adgroupName],
+               [:price, :maxPrice],
+               [:negative, :negativeWords],
+               [:exact_negative, :exactNegativeWords],
+               [:pause, :pause],
+               [:status, :status],
+               [:os, :adPlatformOS]
+              ]
+
+        def self.ids( auth )
+          response = request(auth, Service, "getAllAdgroupId")
+          process(response, 'campaignAdgroupIds'){|x| make_planGroupIds(x)}
+        end
+
+        def self.get(auth, ids)
+          ids = [ ids ] unless ids.is_a? Array
+          body = {adgroupIds: ids}
+          response = request(auth, Service, "getAdgroupByAdgroupId", body)
+          process(response, 'adgroupTypes'){|x| reverse_type(x)}
+        end
+
+        def self.add(auth, groups)
+          adgroup_types = make_type(groups)
+          body = {adgroupTypes: adgroup_types}
+          response = request(auth, Service, "addAdgroup", body)
+          process(response, 'adgroupTypes'){|x| reverse_type(x)}
+        end
+
+        def self.update(auth, groups)
+          adgroup_types = make_type(groups)
+          body = {adgroupTypes: adgroup_types}
+          response = request(auth, Service, "updateAdgroup", body)
+          process(response, 'adgroupTypes'){|x| reverse_type(x)}
+        end
+
+        def self.delete(auth, ids)
+          ids = [ids] unless ids.is_a? Array
+          body = {adgroupIds: ids}
+          response = request(auth, Service, "deleteAdgroup", body, "delete")
+          process(response, 'result'){ |x|  x  }
+        end
+
+        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' ){ |x| make_planGroups( x ) }
+        end
+
+        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'){ |x| make_planGroupIds( x ) }
+        end
+
+        private
+        def self.make_planGroupIds( campaignAdgroupIds )
+          planGroupIds = []
+          campaignAdgroupIds.each do |campaignAdgroupId|
+            planGroupId = { }
+            planGroupId[:plan_id] = campaignAdgroupId['campaignId']
+            planGroupId[:group_ids] = campaignAdgroupId['adgroupIds']
+            planGroupIds << planGroupId
+          end
+          return planGroupIds
+        end
+
+        private
+        def self.make_planGroups( campaignAdgroups )
+          planGroups = []
+          campaignAdgroups.each do |campaignAdgroup|
+            planGroup = {}
+            planGroup[:plan_id] = campaignAdgroup['campaignId']
+            planGroup[:groups] = reverse_type( campaignAdgroup['adgroupTypes'] )
+            planGroups << planGroup
+          end
+          return planGroups
+        end
+
+      end # class group
+    end # class baidu
+  end # API
+end # module