ppc 1.3.2 → 2.0.0

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

@@ -5,13 +5,14 @@ module PPC
       class Phone < Sm
         Service = 'NewCreative'
 
-        @map =[
-                [:id,:phoneId],
-                [:group_id,:adgroupId],
-                [:phone_num,:phoneNum],
-                [:pause,:pause],
-              ]     
-
+        PhoneType = {
+          id:         :phoneId,
+          group_id:   :adgroupId,
+          phone_num:  :phoneNum,
+          pause:      :pause,
+        }
+        @map = PhoneType
+               
         def self.update( auth, phones )
           '''
           根据实际使用情况，更新的时候creative title为必填选
@@ -21,7 +22,7 @@ module PPC
           process( response, 'phoneTypes' ){ |x| reverse_type(x) }
         end
 
-        def self.search_id_by_group_id( auth, ids, getTemp = 0 )
+        def self.ids( auth, ids, getTemp = 0 )
           '''
           \'getPhoneIdByAdgroupId\'
           @ input: group ids

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

@@ -4,20 +4,26 @@ module PPC
       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]
-               ]
+        PlanType = {
+          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,
+        }
+        @map = PlanType
+
+        def self.info( auth, ids )
+          response = request( auth, Service, 'getCampaignByCampaignId', {campaignIds: ids})
+          process( response, 'campaignTypes' ){ |x| reverse_type(x)[0] }
+        end
 
         def self.all( auth )
           response = request( auth, Service, 'getAllCampaign' )
@@ -30,32 +36,36 @@ module PPC
         end
 
         def self.get( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { campaignIds: ids }
-          response = request( auth, Service, 'getCampaignByCampaignId', body)
+          response = request( auth, Service, 'getCampaignByCampaignId', {campaignIds: ids})
           process( response, 'campaignTypes' ){ |x| reverse_type(x) }
         end
 
         def self.add( auth, plans )
-          campaign_types = make_type( plans )
-          body = { campaignTypes: campaign_types }
+          body = { campaignTypes: make_type( plans ) }
           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 }
+        def self.update( auth, plans )
+          body = { campaignTypes: make_type( plans ) }
           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")
+        def self.delete( auth, ids )
+          response = request( auth, Service, 'deleteCampaign', {campaignIds: ids}, "delete")
           process( response, 'result' ){ |x| x }
         end
+
+        def self.enable( auth, ids )
+          plans = ids.map{|id| {id: id, pause: false} }
+          self.update( auth, plans )
+        end
+
+        def self.pause( auth, ids )
+          plans = ids.map{|id| {id: id, pause: true} }
+          self.update( auth, plans )
+        end
        
       end # Service
     end # baidu

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

@@ -29,23 +29,17 @@ module PPC
         end
 
         def self.get_state( auth, id )
-          '''
-          input id should be string
-          '''
-          body = { taskId:  id }
-          response = request( auth, 'task' , 'getTaskState' ,body)
+          response = request( auth, 'task' , 'getTaskState' , {taskId: id} )
           process( response, 'status' ){ |x| x }
         end
 
         def self.get_fileId( auth,  id  )
-          body = { taskId:  id }
-          response = request( auth, 'task' , 'getTaskState' ,body)
+          response = request( auth, 'task' , 'getTaskState' , {taskId: id} )
           process( response, 'fileId' ){ |x| x }
         end
 
         def self.get_file( auth,  id  )
-          body = { fileId:  id }
-          response = request( auth, 'file' , 'download' ,body)
+          request( auth, 'file' , 'download' , {fileId: id} )
         end
 
         private
@@ -67,25 +61,12 @@ module PPC
           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[:startDate]         =     Date.parse( param[:startDate] ) rescue Date.today
+          requesttype[:endDate]           =     Date.parse( param[:endDate] ) rescue Date.today
           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 #
         #################################

data/lib/ppc/api/sogou.rb

@@ -54,64 +54,14 @@ module PPC
                                into snake_case symbol inside the method
         '''
         result = {}
-        result[:succ] = response[:header][:desc]=='success'? true : false
+        result[:succ]   = response[:header][:desc] == 'success'
         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
+        result[:no_quota] = (response[:header][:failures][:code] == '18') rescue false
+        result[:result] = func[ response[:body][ key.snake_case.to_sym ] ] rescue nil
+        result[:rquota] = response[:header][:rquota] if response[:header][:rquota]
+        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

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

@@ -4,22 +4,23 @@ module PPC
       class Account < Sogou
         Service = 'Account'
 
-        @map = [
-                [:id,:accountid],            
-                [:balance,:balance],         
-                [:cost,:totalCost],               
-                [:payment,:totalPay],                          
-                [:budget_type,:type],                   
-                [:budget,:budget],                              
-                [:region,:regions],                    
-                [:exclude_ip,:excludeIps],                        
-                [:open_domains,:domains],                  
-                [:offline_time,:budgetOfflineTime],         
-                [:opt,:opt]                                  
-              ]
+        AccountType = {
+          id:           :accountid,
+          balance:      :balance,
+          cost:         :total_cost,
+          payment:      :total_pay,
+          budget_type:  :type,
+          budget:       :budget,
+          region:       :regions,
+          exclude_ip:   :excludeIps,
+          open_domains: :domains,
+          offline_time: :budgetOfflineTime,
+          opt:          :opt,
+        }
+        @map = AccountType
 
-        def self.info(auth)
-          response = request(auth,Service,'getAccountInfo'  )
+        def self.info( auth )
+          response = request(auth,Service,'getAccountInfo' )
           process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
         end
 
@@ -30,8 +31,7 @@ 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,'updateAccountInfo', body)
           process( response, 'accountInfoType' ){ |x|reverse_type(x)[0] }
         end

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

@@ -5,25 +5,49 @@ module PPC
       class Creative< Sogou
         Service = 'CpcIdea'
 
-        @map =[
-          [:id,:cpcIdeaId],
-          [:group_id,:cpcGrpId],
-          [:title,:title],
-          [:description1,:description1],
-          [:description2,:description2],
-          [:pc_destination,:visitUrl],
-          [:pc_display,:showUrl],
-          [:moile_destination,:mobileVisitUrl],
-          [:mobile_display,:mobileShowUrl],
-          [:pause,:pause],
-          [:status,:status] 
-        ]
+        CreativeType = {
+          id:                 :cpcIdeaId,
+          group_id:           :cpcGrpId,
+          title:              :title,
+          description1:       :description1,
+          description2:       :description2,
+          pc_destination:     :visitUrl,
+          pc_display:         :showUrl,
+          moile_destination:  :mobileVisitUrl,
+          mobile_display:     :mobileShowUrl,
+          pause:              :pause,
+          status:             :status,
+          "group_id" =>       :cpc_grp_id,
+          "id" =>             :cpc_idea_id,
+          "pc_destination" => :visit_url,
+          "pc_display" =>     :show_url,
+          "mobile_display" => :mobile_show_url,
+          "creative_ids" =>   :cpc_idea_ids,
+        }
+        @map = CreativeType
 
-        @status_map = [
-          [:id,:cpcIdeaId],
-          [:status,:status]
-        ]
+        @status_map = {
+          id:      :cpcIdeaId,
+          status:  :status,
+        }
 
+        def self.info( auth, ids,  getTemp = 0 )
+          body = { cpcIdeaIds: ids, getTemp: getTemp }
+          response = request( auth, Service, 'getCpcIdeaByCpcIdeaId', body )
+          process( response, 'cpcIdeaTypes' ){ |x| reverse_type(x)[0] }
+        end
+
+        def self.all( auth, ids,  getTemp = 0 )
+          body = { cpcGrpIds: ids, getTemp: getTemp }
+          response = request( auth, Service, 'getCpcIdeaByCpcGrpId', body )
+          process( response, 'cpcGrpIdeas' ){ |x| ids.count == 1 ? reverse_type(x[:cpc_idea_types]) : x.map{|y| reverse_type(y[:cpc_idea_types])}.flatten }
+        end
+
+        def self.ids( auth, ids,  getTemp = 0 )
+          body = { cpcGrpIds: ids, getTemp: getTemp }
+          response = request( auth, Service, 'getCpcIdeaIdByCpcGrpId', body )
+          process( response, 'cpcGrpIdeaIds' ){ |x| reverse_type( x ) }
+        end
 
         def self.add( auth, creatives )
           body = { cpcIdeaTypes: make_type( creatives ) }
@@ -32,83 +56,36 @@ module PPC
         end
 
         def self.get( auth, ids,  getTemp = 0 )
-          '''
-          \'getCreativeByCreativeId\'
-          @ input : creative ids
-          @ output: creative informations
-          '''
-          ids = [ ids ] unless ids.is_a? Array
           body = { cpcIdeaIds: ids, getTemp: getTemp }
           response = request( auth, Service, 'getCpcIdeaByCpcIdeaId', body )
           process( response, 'cpcIdeaTypes' ){ |x| reverse_type(x) }
         end
 
         def self.update( auth, creatives )
-          '''
-          根据实际使用情况，更新的时候creative title为必填选
-          '''
           body = { cpcIdeaTypes: make_type( creatives ) }
           response = request( auth, Service, 'updateCpcIdea', body )
           process( response, 'cpcIdeaTypes' ){ |x| reverse_type(x) }
         end
 
         def self.delete( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcIdeaIds: ids }
-          response = request( auth, Service, 'deleteCpcIdea', body )
+          response = request( auth, Service, 'deleteCpcIdea', { cpcIdeaIds: ids } )
           process( response, '' ){ |x| x }
         end
 
-        def self.status( auth, ids, getTemp = 0 )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcIdeaIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCpcIdeaByCpcIdeaId', body )
-          process( response, 'cpcIdeaTypes' ){ |x| reverse_type(x, @status_map) }
+        def self.enable( auth, ids )
+          keywords = ids.map{|id| {id: id, pause: false} }
+          self.update( auth, keywords )
         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 = { cpcGrpIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCpcIdeaIdByCpcGrpId', body )
-          process( response, 'cpcGrpIdeaIds' ){ |x| make_groupCreativeIds( x ) }
-        end
-
-        def self.search_by_group_id( auth, ids,  getTemp = 0 )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcGrpIds: ids, getTemp: getTemp }
-          response = request( auth, Service, 'getCpcIdeaByCpcGrpId', body )
-          process( response, 'cpcGrpIdeas' ){ |x| make_groupCreatives( x ) }
+        def self.pause( auth, ids )
+          keywords = ids.map{|id| {id: id, pause: true} }
+          self.update( auth, keywords )
         end
 
-        private
-        def self.make_groupCreativeIds( cpcGrpIdeaIdTypes )
-          cpcGrpIdeaIdTypes = [cpcGrpIdeaIdTypes] unless cpcGrpIdeaIdTypes.is_a? Array
-          group_creative_ids = []
-          cpcGrpIdeaIdTypes.each do |cpcGrpIdeaIdType|
-            group_creative_id = { }
-            group_creative_id[:group_id] = cpcGrpIdeaIdType[:cpc_grp_id]
-            group_creative_id[:creative_ids] = cpcGrpIdeaIdType[:cpc_idea_ids]
-            group_creative_ids << group_creative_id
-          end
-          return group_creative_ids
-        end
-
-        private
-        def self.make_groupCreatives( cpcGrpIdeaTypes )
-          cpcGrpIdeaTypes = [cpcGrpIdeaTypes] unless cpcGrpIdeaTypes.is_a? Array
-          group_creatives = []
-          cpcGrpIdeaTypes.each do |cpcGrpIdeaType|
-            group_creative = {}
-            group_creative[:group_id] = cpcGrpIdeaType[:cpc_grp_id]
-            group_creative[:creatives] = reverse_type( cpcGrpIdeaType[:cpc_idea_types] )
-            group_creatives << group_creative
-          end
-          return group_creatives
+        def self.status( auth, ids, getTemp = 0 )
+          body = { cpcIdeaIds: ids, getTemp: getTemp }
+          response = request( auth, Service, 'getCpcIdeaByCpcIdeaId', body )
+          process( response, 'cpcIdeaTypes' ){ |x| reverse_type(x, @status_map) }
         end
 
       end