ppc 0.3.0 → 1.0.1

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

@@ -1,47 +0,0 @@
-module PPC
-  module API
-    class Baidu
-      class Account< Baidu
-        Service = 'Account'
-
-        @map = [
-                  [:id,:userid],            
-                  [:balance,:balance],         
-                  [:cost,:cost],               
-                  [:payment,:payment],                          
-                  [:status,:userStat],                            
-                  [:budget_type,:budgetType],                   
-                  [:budget,:budget],                              
-                  [:region,:regionTarget],                    
-                  [:exclude_ip,:excludeIp],                        
-                  [:isdynamic,:isDynamicCreative],         
-                  [:dynamic_param,:dynamicCreativeParam], 
-                  [:open_domains,:openDomains],                  
-                  [:reg_domain,:regDomain],                       
-                  [:offline_time,:budgetOfflineTime],         
-                  [:weekly_budget,:weeklyBudget],                
-                  [:opt,:opt]                                  
-                ]
-
-        def self.info( auth )
-          response = request(auth,Service,'getAccountInfo'  )
-          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,'updateAccountInfo', body)
-          return process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-module PPC
-  module API
-    class Baidu
-      class Bulk < Baidu
-        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 = {
-            campaignIds:              plan_ids              || []      ,
-            includeQuality:           params[:quality]      || true    ,
-            includeTemp:              params[:temp]         || false   ,
-            format:                   params[:format]       || 1       ,
-            newCreativeFiles:         params[:adcopy]       || 0       ,
-            includeTempNewCreatives:  params[:temp_adcopy]  || 0       ,
-            includePhraseType:        params[:phrase]       || 0       ,
-            extended:                 params[:extended]     || 0
-          }
-          response = request( auth, Service, 'getAllObjects',options )
-          response[:get_all_objects_response][:file_id]
-        end
-
-        def self.state( auth, id)
-          raise "empty id" if id.nil? or id.empty?
-          request(auth, Service, 'getFileState',{fileId:id})[:get_file_state_response][:is_generated]
-        end
-
-        def self.path( auth, id)
-          request( auth, Service, 'getFilePath',{fileId:id})[:get_file_path_response][:file_paths]
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-# -*- coding:utf-8 -*-
-module PPC
-  module API
-    class Baidu
-      class Creative< Baidu
-        Service = 'Creative'
-
-        @map =[
-                        [:id,:creativeId],
-                        [:group_id,:adgroupId],
-                        [:title,:title],
-                        [:description1,:description1],
-                        [:description2,:description2],
-                        [:pc_destination,:pcDestinationUrl],
-                        [:pc_display,:pcDisplayUrl],
-                        [:moile_destination,:mobileDestinationUrl],
-                        [:mobile_display,:mobileDisplayUrl],
-                        [:pause,:pause],
-                        [:preference,:devicePreference] 
-                      ]
-
-        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, getTemp = 0 )
-          '''
-          \'getCreativeByCreativeId\'
-          @ input : creative ids
-          @ output: creative informations
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { creativeIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCreativeByCreativeId', body )
-          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
-        end
-
-        def self.update( auth, creatives )
-          '''
-          根据实际使用情况，更新的时候creative title为必填选
-          '''
-          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 )
-          process( response, 'result' ){ |x| x }
-        end
-
-        def self.activate( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { creativeIds: ids }
-          response = request( auth, Service, 'activateCreative', body )
-          process( response, 'creativeTypes' ){ |x| reverse_type(x) }
-        end
-
-        def self.status( auth, ids, type )
-          ids = [ ids ] unless ids.is_a? Array
-          
-          type = case type
-            when  'plan'      then    3 
-            when  'group'     then    5
-            when  'creative'  then    7
-            else
-              Exception.new( 'type must among: \'plan\',\'group\' and \'key\' ')            
-          end
-
-          body = { ids: ids, type: type }
-          response = request( auth, Service, 'getCreativeStatus', body )
-          process( response, 'CreativeStatus' ){ |x| x }
-        end
-
-        def self.search_id_by_group_id( auth, ids, getTemp = 0 )
-          '''
-          \'getCreativeIdByAdgroupId\'
-          @ input: group ids
-          @ output:  groupCreativeIds
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { adgroupIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCreativeIdByAdgroupId', body )
-          process( response, 'groupCreativeIds' ){ |x| make_groupCreativeIds( x ) }
-        end
-
-        def self.search_by_group_id( auth, ids, getTemp = 0 )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { adgroupIds: ids, getTemp: getTemp }
-          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['adgroupIds']
-            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/baidu/group.rb

@@ -1,111 +0,0 @@
-# -*- coding:utf-8  -*-
-module PPC
-  module API
-    class Baidu
-      class Group< Baidu
-        Service = 'Adgroup'
-
-        @map =[
-                        [:plan_id, :campaignId],
-                        [:id, :adgroupId],
-                        [:name, :adgroupName],
-                        [:price, :maxPrice],
-                        [:negative, :negativeWords],
-                        [:exact_negative, :exactNegativeWords],
-                        [:pause, :pause],
-                        [:status, :status],
-                        [:reserved, :reserved]
-                      ]
-
-        def self.ids(auth )
-          """
-          @return : Array of campaignAdgroupIds
-          """
-          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 )
-          """
-          @ input : one or list of AdgroupType
-          @ output : list of AdgroupType
-          """
-          adgrouptypes = make_type( groups )
-
-          body = {adgroupTypes:  adgrouptypes }
-          
-          response = request( auth, Service, "addAdgroup", body  )
-          process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
-        end
-
-        def self.update( auth, groups )
-          """
-          @ input : one or list of AdgroupType
-          @ output : list of AdgroupType
-          """
-          adgrouptypes = make_type( groups )
-          body = {adgroupTypes: adgrouptypes}
-          
-          response = request( auth, Service, "updateAdgroup",body )
-          process( response, 'adgroupTypes' ){ |x| reverse_type(x) }
-        end
-
-        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' ){ |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

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

@@ -1,204 +0,0 @@
-# -*- coding:utf-8 -*-
-module PPC
-  module API
-    class Baidu
-      class Keyword< Baidu
-        Service = 'Keyword'
-
-        Match_type  = { 'exact' => 1, 'pharse' => 2, 'wide' => 3,1 => 'exact', 2=> 'pharse' , 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],
-                  [: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 ]
-                          ]
-
-        # 后面改成info方法
-        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' ){|x| reverse_type( x ) }
-        end
-
-        def self.add( auth, keywords )
-          '''
-          '''
-          keywordtypes = make_type( keywords ) 
-          body = { keywordTypes: keywordtypes }
-          response = request( auth, Service, "addKeyword", body )
-          return process(response, 'keywordTypes' ){|x| reverse_type(x)  }
-        end
-
-        def self.update( auth, keywords  )
-          '''
-          '''
-          keywordtypes = make_type( keywords ) 
-          body = { keywordTypes: keywordtypes }
-          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 )
-          return process(response, 'result' ){|x| x }
-        end
-
-        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' ){|x| reverse_type(x)  }
-        end
-
-        def self.search_by_group_id( auth, group_ids  )
-          """
-          getKeywordByGroupIds
-          @input: list of group id
-          @output:  list of groupKeyword
-          """
-          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
-
-        # 下面三个操作操作对象包括计划，组和关键字
-        # 不知道放在这里合不合适
-        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' ){  |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 )
-          '''
-          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' ){|x| reverse_type( x, @quality10_map ) }
-        end
-
-        private
-        def self.make_groupKeywordIds( groupKeywordIds )
-          group_keyword_ids = []
-          groupKeywordIds.each do |groupKeywordId|
-            group_keyword_id = { }
-            group_keyword_id[:group_id] = groupKeywordId['adgroupIds']
-            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 # Baidu
-  end # API
-end # PPC