ppc 1.3.2 → 2.0.0

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

@@ -5,66 +5,69 @@ module PPC
       class Sublink< Qihu
         Service = 'sublink'
 
-        @map = [
-                 [:id,:id] ,
-                 [:group_id, :groupId],
-                 [:anchor,:text],
-                 [:url, :link],
-                 [:image, :image],
-                 [:status, :status]
-                ]
+        SublinkType = {
+          id:       :id,
+          group_id: :groupId,
+          anchor:   :text,
+          url:      :link,
+          image:    :image,
+          pause:    :sysStatus,
+          status:   :status,
+          add_time: :addTime,
+          update_time: :updateTime,
+          cause:    :cause,
+        }
+        @map = SublinkType
+
+        def self.info( auth, ids )
+          response = request( auth, Service, 'getInfoByIdList', { idList: ids } )
+          process( response, 'sublinkList'){ |x| reverse_type( x )[0] }
+        end
+
+        def self.all( auth, group_ids )
+          results = self.ids( auth, group_ids )
+          return results unless results[:succ]
+          self.get( auth , results[:result] )
+        end
+
+        def self.ids( auth, group_ids )
+          response = request( auth, Service, 'getIdListByGroupIdList', {groupIdList: group_ids} )
+          process( response, 'sublinkIdListList' ){ |x| x.map(&:to_i) }
+        end
 
         def self.get( auth, ids )
-          body  = { 'idList' => to_json_string( ids ) }
-          response = request( auth, Service, 'getInfoByIdList', body )
-          process( response, 'sublinkList'){ |x| reverse_type( x['item'] ) }
+          response = request( auth, Service, 'getInfoByIdList', { idList: ids } )
+          process( response, 'sublinkList'){ |x| reverse_type( x ) }
         end
 
         def self.add( auth, sublinks )
-          sublink_types = make_type( sublinks ).to_json
-          body = { 'sublinks' => sublink_types}
-          response = request( auth, Service, 'add', body )
-          process( response, 'sublinkIdList'){ |x| to_id_hash_list( x['item'] ) }
+          response = request( auth, Service, 'add', { sublinks: make_type( sublinks ) } )
+          process( response, 'sublinkIdList'){ |x| x.map{|id| {id: id} } }
         end
 
         def self.delete( auth, ids )
-          ids = to_json_string( ids )
-          body = { 'idList' => ids }
-          response = request( auth, Service, 'deleteByIdList', body )
+          response = request( auth, Service, 'deleteByIdList', { idList: ids } )
           process( response, 'affectedRecords' ){ |x|x }     
         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, sublinks )
-          sublink_types = make_type( sublinks ).to_json
-          body = { 'sublinks' => sublink_types}
-          response = request( auth, Service, 'update', body )
+          response = request( auth, Service, 'update', { sublinks: make_type( sublinks ) } )
           process( response, 'affectedRecords', 'failKeywordIds' ){ |x| x }        
         end
 
-         # 对update的再封装实现activate方法,未测试
-        def self.activate( auth, ids )
-          sublinks = []
-          ids.each{ |id| sublinks << { id: id, status:'enable'} }
-          update( auth, sublinks )
-        end       
-
         def self.delete( auth, ids )
-          ids = to_json_string( ids )
-          body = { 'idList' => ids }
-          response = request( auth, Service, 'deleteByIdList', body )
+          response = request( auth, Service, 'deleteByIdList', { idList: ids } )
           process( response, 'affectedRecords' ){ |x|x }     
         end
 
+        def self.enable( auth, ids )
+          self.update( auth, ids.map{ |id| { id: id, status: 'enable'} } )
+        end
+
+        def self.pause( auth, ids )
+          self.update( auth, ids.map{ |id| { id: id, status: 'pause'} } )
+        end
+
       end
     end
   end

data/lib/ppc/api/sm.rb

@@ -30,21 +30,12 @@ module PPC
         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[:result] = func[ response['body'][key] ] rescue nil
+        result[:no_quota] = (response['header']['failures']['code'] == '8501') rescue false
+        result[:rquota] = response["header"]["leftQuota"] rescue 0
         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

@@ -4,25 +4,27 @@ module PPC
       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]
-                ]
+        AccountType = {
+          id:             :userId,
+          name:           :userName,
+          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,
+          status:         :userStat,
+        }
+        @map = AccountType
 
         def self.info( auth )
           response = request(auth, Service, 'getAccount', {requestData: ["account_all"]})
-          p response
-          return process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
+          process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
         end
 
         def self.update(auth, param = {} )
@@ -32,10 +34,9 @@ module PPC
           @return : account info_type
           """
           # for account service, there is not bulk operation
-          infoType = make_type( param )[0]
-          body = { accountInfoType: infoType }
+          body = { accountInfoType: make_type( param )[0] }
           response = request(auth, Service, 'updateAccount', body)
-          return process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
+          process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
         end
 
       end

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

@@ -5,16 +5,34 @@ module PPC
       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]
-              ]     
+        CreativeType = {
+          id:                 :creativeId,
+          group_id:           :adgroupId,
+          title:              :title,
+          description1:       :description1,
+          pause:              :pause,
+          mobile_destination: :destinationUrl,
+          mobile_display:     :displayUrl,
+          status:             :status,
+          creative_ids:       :creativeIds,
+          creatives:          :creativeTypes,
+        }
+        @map = CreativeType
+
+        def self.info(auth, ids)
+          response = request(auth, Service, 'getCreativeByCreativeId', {creativeIds: ids})
+          process(response, 'creativeTypes'){|x| reverse_type(x)[0]}
+        end
+
+        def self.all(auth, ids)
+          response = request(auth, Service, 'getCreativeByAdgroupId', {adgroupIds: ids})
+          process(response, 'groupCreatives'){|x| x.map{|y| y["creativeTypes"].map{|z| reverse_type(z)}}.flatten }
+        end
+
+        def self.ids(auth, ids)
+          response = request(auth, Service, 'getCreativeIdByAdgroupId', {adgroupIds: ids})
+          process(response, 'groupCreativeIds'){|x| reverse_type(x)}
+        end
 
         def self.add(auth, creatives)
           body = {creativeTypes: make_type(creatives)}
@@ -23,9 +41,7 @@ module PPC
         end
 
         def self.get(auth, ids)
-          ids = [ids] unless ids.is_a? Array
-          body = {creativeIds: ids}
-          response = request(auth, Service, 'getCreativeByCreativeId', body)
+          response = request(auth, Service, 'getCreativeByCreativeId', {creativeIds: ids})
           process(response, 'creativeTypes'){|x| reverse_type(x)}
         end
 
@@ -36,48 +52,18 @@ module PPC
         end
 
         def self.delete(auth, ids)
-          ids = [ids] unless ids.is_a? Array
-          body = {creativeIds: ids}
-          response = request(auth, Service, 'deleteCreative', body, 'delete')
+          response = request(auth, Service, 'deleteCreative', {creativeIds: ids}, '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
+        def self.enable( auth, ids )
+          creatives = ids.map{|id| {id: id, pause: false} }
+          self.update( auth, creatives )
         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
+        def self.pause( auth, ids )
+          creatives = ids.map{|id| {id: id, pause: true} }
+          self.update( auth, creatives )
         end
 
       end

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

@@ -5,87 +5,66 @@ module PPC
       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]
-              ]
+        GroupType = {
+          plan_id:        :campaignId,
+          id:             :adgroupId,
+          name:           :adgroupName,
+          price:          :maxPrice,
+          negative:       :negativeWords,
+          exact_negative: :exactNegativeWords,
+          pause:          :pause,
+          status:         :status,
+          os:             :adPlatformOS,
+          group_ids:      :adgroupIds,
+          groups:         :adgroupTypes,
+        }
+        @map = GroupType
 
-        def self.ids( auth )
-          response = request(auth, Service, "getAllAdgroupId")
-          process(response, 'campaignAdgroupIds'){|x| make_planGroupIds(x)}
+        def self.info(auth, ids)
+          response = request(auth, Service, "getAdgroupByAdgroupId", {adgroupIds: ids} )
+          process(response, 'adgroupTypes'){|x| reverse_type(x)[0] }
+        end
+
+        def self.all( auth, plan_ids )
+          response = request(auth, Service, "getAdgroupByCampaignId", {campaignIds: plan_ids} )
+          process(response, 'campaignAdgroups' ){ |x| reverse_type(x.map{|temp| temp["adgroupTypes"]}.flatten) }
+        end
+
+        def self.ids( auth, plan_ids )
+          response = request(auth, Service, "getAdgroupIdByCampaignId", {campaignIds: plan_ids} )
+          process(response, 'campaignAdgroupIds'){ |x| reverse_type( 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)}
+          response = request(auth, Service, "getAdgroupByAdgroupId", {adgroupIds: ids} )
+          process(response, 'adgroupTypes'){|x| reverse_type(x) }
         end
 
         def self.add(auth, groups)
-          adgroup_types = make_type(groups)
-          body = {adgroupTypes: adgroup_types}
+          body = {adgroupTypes: make_type(groups)}
           response = request(auth, Service, "addAdgroup", body)
-          process(response, 'adgroupTypes'){|x| reverse_type(x)}
+          process(response, 'adgroupTypes'){|x| reverse_type(x) }
         end
 
         def self.update(auth, groups)
-          adgroup_types = make_type(groups)
-          body = {adgroupTypes: adgroup_types}
+          body = {adgroupTypes: make_type(groups)}
           response = request(auth, Service, "updateAdgroup", body)
-          process(response, 'adgroupTypes'){|x| reverse_type(x)}
+          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")
+          response = request(auth, Service, "deleteAdgroup", {adgroupIds: ids} , "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
+        def self.enable( auth, ids )
+          groups = ids.map{|id| {id: id, pause: false} }
+          self.update( auth, groups )
         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
+        def self.pause( auth, ids )
+          groups = ids.map{|id| {id: id, pause: true} }
+          self.update( auth, groups )
         end
 
       end # class group

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

@@ -4,126 +4,68 @@ module PPC
     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]
-                ]
+        Match_type  = { 'exact' => 0, 'phrase' => 1, 'wide' => 2, 0 => 'exact', 1 => 'phrase' , 2 => 'wide'  }
+        @match_types = Match_type
+        KeywordType = {
+          id:                 :keywordId,
+          group_id:           :adgroupId,
+          keyword:            :keyword,
+          price:              :price,
+          mobile_destination: :destinationUrl,
+          match_type:         :matchType,
+          status:             :status,
+          pause:              :pause,
+          keyword_ids:        :keywordIds,
+          keywords:           :keywordTypes,
+        }
+        @map = KeywordType
 
-        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)}
+        def self.info(auth, ids)
+          response = request(auth, Service, 'getKeywordByKeywordId', {keywordIds: ids})
+          process(response, 'keywordTypes'){|x| reverse_type(x)[0] }
         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)}
+        def self.all(auth, group_ids)
+          response = request(auth, Service, "getKeywordByAdgroupId", {adgroupIds: group_ids} )
+          process(response, 'groupKeywords'){|x| reverse_type( x.map{|temp| temp["keywordTypes"]}.flatten ) }
         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)}
+        def self.ids(auth, group_ids)
+          response = request(auth, Service, "getKeywordIdByAdgroupId", {adgroupIds: group_ids} )
+          process(response, 'groupKeywordIds'){|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)}
+        def self.get(auth, ids)
+          response = request(auth, Service, 'getKeywordByKeywordId', {keywordIds: ids})
+          process(response, 'keywordTypes'){|x| reverse_type(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)}
+        def self.add(auth, keywords)
+          body = {keywordTypes: make_type(keywords) }
+          response = request(auth, Service, "addKeyword", body)
+          process(response, 'keywordTypes'){|x| reverse_type(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
+        def self.update(auth, keywords)
+          body = {keywordTypes: make_type(keywords) }
+          response = request(auth, Service, "updateKeyword", body)
+          process(response, 'keywordTypes'){|x| reverse_type(x)}
         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
+        def self.delete(auth, ids)
+          response = request(auth, Service, 'deleteKeyword', {keywordIds: ids}, 'delete')
+          process(response, 'result'){|x| x }
         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
+        def self.enable( auth, ids )
+          keywords = ids.map{|id| {id: id, pause: false} }
+          self.update( auth, keywords )
         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
+        def self.pause( auth, ids )
+          keywords = ids.map{|id| {id: id, pause: true} }
+          self.update( auth, keywords )
         end
 
       end # keyword