ppc 1.3.0 → 1.3.2

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

@@ -0,0 +1,132 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Sm
+      class Keyword < Sm
+        Service = 'keyword'
+
+        Match_type  = { 'exact' => 0, 'phrase' => 1, 'wide' => 2, 0 => 'exact', 1 => 'phrase' , 2 => 'wide'  }
+        
+        @map  = [
+                  [:id, :keywordId],
+                  [:group_id, :adgroupId],
+                  [:keyword, :keyword],
+                  [:price, :price],
+                  [:mobile_destination, :destinationUrl],
+                  [:match_type, :matchType],
+                  [:status, :status],
+                  [:pause, :pause]
+                ]
+
+        def self.get(auth, ids)
+          ids = [ids] unless ids.is_a? Array
+          body = {keywordIds: ids}
+          response = request(auth, Service, 'getKeywordByKeywordId', body)
+          return process(response, 'keywordTypes'){|x| reverse_type(x)}
+        end
+
+        def self.add(auth, keywords)
+          keyword_types = make_type(keywords) 
+          body = {keywordTypes: keyword_types}
+          response = request(auth, Service, "addKeyword", body)
+          return process(response, 'keywordTypes'){|x| reverse_type(x)}
+        end
+
+        def self.update(auth, keywords)
+          keyword_types = make_type(keywords) 
+          body = {keywordTypes: keyword_types}
+          response = request(auth, Service, "updateKeyword", body)
+          return process(response, 'keywordTypes'){|x| reverse_type(x)}
+        end
+
+        def self.delete(auth, ids)
+          ids = [ids] unless ids.is_a? Array
+          body = {keywordIds: ids}
+          response = request(auth, Service, 'deleteKeyword', body, 'delete')
+          return process(response, 'result'){|x| x }
+        end
+
+        def self.search_by_group_id(auth, group_ids)
+          group_ids = [group_ids] unless group_ids.is_a? Array
+          body = {adgroupIds: group_ids}
+          response = request(auth, Service, "getKeywordByAdgroupId", body)
+          return process(response, 'groupKeywords'){|x| make_groupKeywords(x)}
+        end
+
+        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'){|x| make_groupKeywordIds(x)}
+        end
+
+        private
+        def self.make_groupKeywordIds( groupKeywordIds )
+          group_keyword_ids = []
+          groupKeywordIds.each do |groupKeywordId|
+            group_keyword_id = { }
+            group_keyword_id[:group_id] = groupKeywordId['adgroupId']
+            group_keyword_id[:keyword_ids] = groupKeywordId['keywordIds']
+            group_keyword_ids << group_keyword_id
+          end
+          return group_keyword_ids
+        end
+
+        private
+        def self.make_groupKeywords( groupKeywords )
+          group_keywords = []
+          groupKeywords.each do |groupKeyword|
+            group_keyword = {}
+            group_keyword[:group_id] = groupKeyword['adgroupId']
+            group_keyword[:keywords] = reverse_type( groupKeyword['keywordTypes'] )
+            group_keywords << group_keyword
+          end
+          return group_keywords
+        end
+
+        # Override
+       def self.make_type( params, map = @map)
+          params = [ params ] unless params.is_a? Array
+          types = []
+          params.each do |param|
+            type = {}
+              map.each do |key|
+                # 增加对matchtype的自动转换
+                if key[0] == :match_type
+                   value = param[ key[0] ]
+                  type[ key[1] ] = Match_type[ value ] if value                 
+                else
+                  value = param[ key[0] ]
+                  type[ key[1] ] = value if value
+                end
+              end
+            types << type
+          end
+          return types
+        end
+
+        # Overwrite
+        def self.reverse_type( types, map = @map )
+          types = [ types ] unless types.is_a? Array
+          params = []
+          types.each do |type|
+            param = {}
+             # 增加对matchtype的自动转换
+              map.each do |key|
+                if key[0] == :match_type
+                   value = type[ key[1].to_s ]
+                  param[ key[0] ] = Match_type[ value ] if value                 
+                else
+                  value = type[ key[1].to_s ]
+                  param[ key[0] ] = value if value
+                end
+              end # map.each
+            params << param
+          end # types.each
+          return params
+        end
+
+      end # keyword
+    end # Sm
+  end # API
+end # PPC

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

@@ -0,0 +1,51 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Sm
+      class Phone < Sm
+        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/sm/plan.rb

@@ -0,0 +1,63 @@
+module PPC
+  module API
+    class Sm
+      class Plan < Sm
+        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],   
+                [:pause,:pause],
+                [:status,:status]
+               ]
+
+        def self.all( auth )
+          response = request( auth, Service, 'getAllCampaign' )
+          process( response, 'campaignTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.ids( auth )
+          response = request( auth, Service, 'getAllCampaignID' )
+          process( response, 'campaignIds' ){ |x| x }
+        end
+
+        def self.get( auth, ids )
+          ids = [ ids ] unless ids.is_a? Array
+          body = { campaignIds: ids }
+          response = request( auth, Service, 'getCampaignByCampaignId', body)
+          process( response, 'campaignTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.add( auth, plans )
+          campaign_types = make_type( plans )
+          body = { campaignTypes: campaign_types }
+          response = request( auth, Service, 'addCampaign', body)
+          process( response, 'campaignTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.update(auth,plans )
+          campaign_types = make_type( plans )
+          body = { campaignTypes: campaign_types }
+          response = request( auth, Service, 'updateCampaign', body)
+          process( response, 'campaignTypes' ){ |x| reverse_type(x) }
+        end
+
+        def self.delete(auth, ids )
+          ids = [ ids ] unless ids.is_a? Array
+          body = { campaignIds: ids }
+          response = request( auth, Service, 'deleteCampaign', body, "delete")
+          process( response, 'result' ){ |x| x }
+        end
+       
+      end # Service
+    end # baidu
+  end # API
+end # PPC

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

@@ -0,0 +1,136 @@
+# -*- coding:utf-8 -*-
+module PPC
+  module API
+    class Sm
+      class Report< Sm
+        Service = 'Report'
+
+        # 需要用到的映射集合
+        Type_map = { 'account' => 2, 'plan'=> 10, 'group'=> 11,
+                      'keyword'=> 14, 'creative'=> 12,
+                       'region'=> 3, 'query'=>6, 'trail' => 21, "tel" => 22,
+                       "app" => 23, "none" => 24}
+
+        Level_map = {  'account' => 2, 'plan' => 3, 'group' => 5,
+                        'creative'=> 7, 'keywordid' => 11, 'trail' => 21, "tel" => 22,
+                         "app" => 23, 'query_creative' => 12}
+
+        Device_map = { 'all' => 0, 'pc' => 1, 'mobile' => 2 }
+
+        Unit_map = { 'day' => 5, 'month' => 3, 'range' => 8 }
+
+        ########################
+        # API wraping function #
+        ########################
+        def self.get_id( auth, params  )
+          body = make_reportrequest( params )
+          response = request( auth, 'report' , 'getReport' ,body)
+          process( response, 'taskId' ){ |x| x }
+        end
+
+        def self.get_state( auth, id )
+          '''
+          input id should be string
+          '''
+          body = { taskId:  id }
+          response = request( auth, 'task' , 'getTaskState' ,body)
+          process( response, 'status' ){ |x| x }
+        end
+
+        def self.get_fileId( auth,  id  )
+          body = { taskId:  id }
+          response = request( auth, 'task' , 'getTaskState' ,body)
+          process( response, 'fileId' ){ |x| x }
+        end
+
+        def self.get_file( auth,  id  )
+          body = { fileId:  id }
+          response = request( auth, 'file' , 'download' ,body)
+        end
+
+        private
+        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 cost cpc ctr)
+          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] )
+          requesttype[:statIds]           =     param[:statIds] if param[:type] == "keyword" && param[:range] != "account"
+          return requesttype
+        end
+
+        private
+        def self.parse_date( date )
+          """
+          Cast string to time:
+          'YYYYMMDD' => Time
+          """
+          if date
+            date = Date.parse(date)
+          else
+            date = Date.today
+          end
+        end
+
+        #################################
+        # useful function for operation #
+        #################################
+        def self.query_report( auth, param = {}, debug = false )
+          param[:type]   ||= 'query'
+          param[:fields] ||=  %w(click impression)
+          param[:range]  ||= 'account'
+          param[:unit]   ||= 'day'
+          download_report( auth, param, debug )
+        end
+
+        def self.creative_report( auth, param = {}, debug = false )
+          param[:type]   ||= 'creative'
+          param[:fields] ||=  %w(click impression)
+          param[:range]  ||= 'account'
+          param[:unit]   ||= 'day'
+          download_report( auth, param, debug )
+        end
+
+        def self.keyword_report( auth, param = {}, debug = false )
+          param[:type]   ||= 'keyword'
+          param[:fields] ||=  %w(click impression cost cpc ctr)
+          param[:range]  ||= 'account'
+          param[:unit]   ||= 'day'
+          download_report( auth, param, debug )
+        end
+
+        def self.download_report( auth, param, debug = false )
+          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] == 'FINISHED'
+              p "Report is not generated, waiting..." if debug
+            end
+            fileId = get_fileId(auth, id)[:result]
+            return get_file(auth, fileId).force_encoding("utf-8")
+          else
+            raise response[:failure][0]["message"]
+          end
+        end
+
+      end # Repost
+    end # Sm
+  end # API
+end # PPC

data/lib/ppc/api/sogou.rb

@@ -0,0 +1,118 @@
+require 'ppc/api/sogou/account'
+require 'ppc/api/sogou/plan'
+require 'ppc/api/sogou/group'
+require 'ppc/api/sogou/keyword'
+require 'ppc/api/sogou/report'
+require 'ppc/api/sogou/creative'
+require 'ppc/api/sogou/bulk'
+
+module PPC
+  module API
+    class Sogou
+
+      extend ::PPC::API
+
+      def self.request( auth, service, method, params = {})
+        '''
+        ps. in savon3, .hash method will turn CamelXML to snake hash
+        preprocess response, extract 
+        '''
+
+        service = service + "Service"
+        client = Savon.new( "http://api.agent.sogou.com:8080/sem/sms/v1/#{service}?wsdl" )
+        operation = client.operation( service, service, method )
+
+        operation.header = { 
+          AuthHeader:{
+          username:   auth[:username],
+          password:   auth[:password],
+          token:      auth[:token]
+        }
+        }
+        operation.body = {  (method+'Request').to_sym => params }
+        # debug print
+        debug_print( operation ) if @debug
+        result = operation.call.hash[:envelope]
+        #extract header and body
+        response = { }
+        response[:header] = result[:header][:res_header]
+        response[:body] = result[:body][ (method + "Response").snake_case.to_sym ]
+        # debug print
+        puts response if @debug
+        return response
+      end
+
+      def self.debug_print( operation )
+        puts '{:header=>' + operation.header.to_s + ',  :body=>' + operation.body.to_s + '}'
+      end
+
+      def self.process( response, key, &func )
+        '''
+        @input
+        : type key : string
+        : param key : type name, we will transfer camel string 
+                               into snake_case symbol inside the method
+        '''
+        result = {}
+        result[:succ] = response[:header][:desc]=='success'? true : false
+        result[:failure] = response[:header][:failures]
+        result[:no_quota] = is_no_quota(response[:header][:failures], '18')
+        unless response[:body].nil? or response[:body][key.snake_case.to_sym].nil?
+          result[:result] = func[ response[:body][ key.snake_case.to_sym ] ]
+        end
+        return result
+      end
+
+      #      def self.make_type( params, map = @map)
+      #        '''
+      #        For more info visit ::PPC::API::sogou:make_type
+      #        '''
+      #        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, 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.snake_case.to_sym)}
+          item
+        end
+      end
+
+      #      def self.reverse_type( types, map = @map )
+      #        '''
+      #        For more info visit ::PPC::API::sogou:reverse_type
+      #        Here, the camel key will be turn into snake key
+      #        '''
+      #        types = [ types ] unless types.is_a? Array
+      #
+      #        params = []
+      #        types.each do |type|
+      #          param = {}
+      #
+      #          map.each do |key|
+      #            # 这里做两次转换并不是十分高效的方法，考虑maintain两张map
+      #            value = type[ key[1].to_s.snake_case.to_sym ]
+      #            param[ key[0] ] = value if value != nil
+      #          end
+
+      #          params << param
+      #        end
+      #        return params
+      #      end
+
+    end
+  end
+end
+