ppc 1.3.2 → 2.0.0

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

@@ -5,116 +5,69 @@ module PPC
       class Group< Sogou
         Service = 'CpcGrp'
 
-        @map =[
-                [:plan_id, :cpcPlanId],
-                [:id, :cpcGrpId],
-                [:name, :cpcGrpName],
-                [:price, :maxPrice],
-                [:negative, :negativeWords],
-                [:exact_negative, :exactNegativeWords],
-                [:pause, :pause],
-                [:status, :status],
-                [:opt, :opt]
-              ]
+        GroupType = {
+          plan_id:        :cpcPlanId,
+          id:             :cpcGrpId,
+          name:           :cpcGrpName,
+          price:          :maxPrice,
+          negative:       :negativeWords,
+          exact_negative: :exactNegativeWords,
+          pause:          :pause,
+          status:         :status,
+          opt:            :opt,
+          "plan_id" =>    :cpc_plan_id,
+          "id" =>         :cpc_grp_id,
+          "plan_name" =>  :cpc_plan_name,
+          "name" =>       :cpc_grp_name,
+          "price" =>      :max_price,
+        }
+        @map = GroupType
 
-        def self.ids( auth )
-          """
-          @return : Array of cpcPlanGrpIdTypes
-          """
-          response = request( auth, Service , "getAllCpcGrpId" )
-          #此处返回值与key与开发文档不同
-          process( response, 'cpcPlanGrpIds' ){ |x| make_planGroupIds( x ) }
+        def self.info( auth, ids)
+          response = request(auth, Service, "getCpcGrpByCpcGrpId", {cpcGrpIds: ids} )
+          process( response, 'cpc_grp_types' ){ |x| reverse_type(x)[0] }
+        end
+
+        def self.all( auth, plan_ids )
+          response = request( auth, Service ,"getCpcGrpByCpcPlanId",  {cpcPlanIds: plan_ids} )
+          process( response, 'cpc_plan_grps' ){ |x| reverse_type( x[:cpc_grp_types] ) }
+        end
+
+        def self.ids( auth, plan_ids )
+          response = request( auth, Service ,"getCpcGrpIdByCpcPlanId",  {cpcPlanIds: plan_ids} )
+          process( response, 'cpcPlanGrpIds' ){ |x| reverse_type( x ) }
         end
 
         def self.get( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcGrpIds: ids }
-          response = request(auth, Service, "getCpcGrpByCpcGrpId",body )
-          process( response, 'cpcGrpTypes' ){ |x| reverse_type(x) }
+          response = request(auth, Service, "getCpcGrpByCpcGrpId", {cpcGrpIds: ids} )
+          process( response, 'cpc_grp_types' ){ |x| reverse_type(x) }
         end
 
         def self.add( auth, groups )
-          """
-          @ input : one or list of AdgroupType
-          @ output : list of AdgroupType
-          """
-          cpcGrpTypes = make_type( groups )
-
-          body = {cpcGrpTypes:  cpcGrpTypes }
-          
+          body = {cpcGrpTypes: make_type( groups ) }
           response = request( auth, Service, "addCpcGrp", body  )
-          process( response, 'cpcGrpTypes' ){ |x| reverse_type(x) }
+          process( response, 'cpc_grp_types' ){ |x| reverse_type(x) }
         end
 
         def self.update( auth, groups )
-          """
-          @ input : one or list of AdgroupType
-          @ output : list of AdgroupType
-          """
-          cpcGrpTypes = make_type( groups )
-          body = {cpcGrpTypes: cpcGrpTypes}
-          
+          body = {cpcGrpTypes: make_type( groups )}
           response = request( auth, Service, "updateCpcGrp",body )
-          process( response, 'cpcGrpTypes' ){ |x| reverse_type(x) }
+          process( response, 'cpc_grp_types' ){ |x| reverse_type(x) }
         end
 
         def self.delete( auth, ids )
-          """
-          delete group body has no message
-          """
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcGrpIds: ids }
-          response = request( auth, Service,"deleteCpcGrp", body )
-          process( response, '' ){ |x|  x  }
-        end
-
-        def self.search_by_plan_id( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcPlanIds: ids }
-          response = request( auth, Service ,"getCpcGrpByCpcPlanId",  body )
-          # 此处key与开发文档不同
-          process( response, 'cpcPlanGrps' ){ |x| make_planGroups( x ) }
-        end
-
-        def self.search_id_by_plan_id( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcPlanIds: ids }
-          response = request( auth, Service ,"getCpcGrpIdByCpcPlanId",  body )
-          process( response, 'cpcPlanGrpIds' ){ |x| make_planGroupIds( x ) }
+          response = request( auth, Service,"deleteCpcGrp", {cpcGrpIds: ids} )
+          process( response, '' ){ |x| x }
         end
 
-        private
-        def self.make_planGroupIds( cpcPlanGrpIdTypes )
-          """
-          Transfer Sogou API to PPC API
-          Item: cpc_plan_group_ids
-          """
-          cpcPlanGrpIdTypes = [cpcPlanGrpIdTypes] unless cpcPlanGrpIdTypes.is_a? Array
-          planGroupIds = []
-          cpcPlanGrpIdTypes.each do |cpcPlanGrpIdType|
-            planGroupId = {}
-            planGroupId[:plan_id] = cpcPlanGrpIdType[:cpc_plan_id]
-            planGroupId[:group_ids] = cpcPlanGrpIdType[:cpc_grp_ids]
-            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( cpcPlanGrpTypes )
-          """
-          Transfer Sogou API to PPC API
-          """
-          # 多加一行change成array
-          cpcPlanGrpTypes = [cpcPlanGrpTypes] unless cpcPlanGrpTypes.is_a? Array
-          planGroups = []
-          cpcPlanGrpTypes.each do |cpcPlanGrpType|
-            planGroup = {}
-            planGroup[:plan_id] = cpcPlanGrpType[:cpc_plan_id]
-            planGroup[:groups] = reverse_type( cpcPlanGrpType[:cpc_grp_types] )
-            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/sogou/keyword.rb

@@ -8,178 +8,95 @@ module PPC
       class Keyword< Sogou
         Service = 'Cpc'
 
-        #Match_type  = { 'exact' => 0, 'wide' => 1,0 => 'exact', 1 => 'wide' } 
-        Match_type  = { 'exact' => 0, 'phrase' => 2, 'wide' => 1,'0' => 'exact', '2' => 'phrase', '1' => 'wide' } 
-                
-        @map  = [
-                  [:id,:cpcId],
-                  [:group_id,:cpcGrpId],
-                  [:keyword,:cpc],
-                  [:price,:price],
-                  [:pc_destination,:visitUrl],
-                  [:mobile_destination,:mobileVisitUrl],
-                  [:match_type,:matchType],
-                  [:pause,:pause],
-                  [:status,:status],
-                  [:quality,:cpcQuality]
-                ]
-        @quality_map = [
-                          [:id,:cpcId],
-                          [:quality,:cpcQuality]
-                        ]
+        Match_type  = { 'exact' => 0, 'phrase' => 2, 'wide' => 1,'0' => 'exact', '2' => 'phrase', '1' => 'wide' }
+        @match_types = Match_type
+        KeywordType = {
+          id:                 :cpcId,
+          group_id:           :cpcGrpId,
+          keyword:            :cpc,
+          price:              :price,
+          pc_destination:     :visitUrl,
+          mobile_destination: :mobileVisitUrl,
+          match_type:         :matchType,
+          pause:              :pause,
+          status:             :status,
+          quality:            :cpcQuality,
+          "group_id" =>       :cpc_grp_id,
+          "keyword_ids" =>    :cpc_ids,
+          "keywords" =>       :cpc_types,
+          "id" =>             :cpc_id,
+          "pc_destination" => :visit_url,
+          "quality" =>        :cpc_quality,
+          "mobile_destination" => :mobile_visit_url,
+        }
+        @map = KeywordType
 
-        @status_map = [
-                        [:id,:cpcId],
-                        [:status,:status]
-                      ]
+        @quality_map = {
+          id:       :cpcId,
+          quality:  :cpcQuality,
+        }
+
+        @status_map = {
+          id:     :cpcId,
+          status: :status,
+        }
+
+        def self.info( auth, ids )
+          response = request( auth, Service, 'getCpcByCpcId', {cpcIds: ids} )
+          process(response, 'cpcTypes'){|x| reverse_type( x )[0] }
+        end
+
+        def self.all( auth, ids )
+          response = request( auth, Service, "getCpcByCpcGrpId", {cpcGrpIds: ids} )
+          process(response, 'cpcGrpCpcs'){|x| ids.count == 1 ? reverse_type(x[:cpc_types]) : x.map{|y| reverse_type(y[:cpc_types])}.flatten }
+        end
+
+        def self.ids( auth, ids )
+          response = request( auth, Service, "getCpcIdByCpcGrpId", {cpcGrpIds: ids} )
+          process(response, 'cpcGrpCpcIds'){|x| reverse_type( x ) }
+        end
 
-        # 后面改成info方法
         def self.get( auth, ids )
-          '''
-          getCpcByCpcId
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcIds: ids}
-          response = request( auth, Service, 'getCpcByCpcId', body )
+          response = request( auth, Service, 'getCpcByCpcId', {cpcIds: ids} )
           process(response, 'cpcTypes'){|x| reverse_type( x ) }
         end
 
         def self.add( auth, keywords )
-          '''
-          '''
-          cpcTypes = make_type( keywords ) 
-          body = { cpcTypes: cpcTypes }
+          body = { cpcTypes: make_type( keywords )  }
           response = request( auth, Service, "addCpc", body )
           process(response, 'cpcTypes'){|x| reverse_type(x)  }
         end
 
         def self.update( auth, keywords )
-          '''
-          '''
-          cpcTypes = make_type( keywords ) 
-          body = { cpcTypes: cpcTypes }
+          body = { cpcTypes: make_type( keywords )  }
           response = request( auth, Service, "updateCpc", body )
           process(response, 'cpcTypes'){|x| reverse_type(x)  }
         end
 
         def self.delete( auth, ids )
-          """
-          """
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcIds: ids}
-          response = request( auth, Service, 'deleteCpc', body )
+          response = request( auth, Service, 'deleteCpc', {cpcIds: ids} )
           process(response, ''){|x| 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 = { cpcGrpIds: group_ids }
-          response = request( auth, Service, "getCpcByCpcGrpId", body )
-          process(response, 'cpcGrpCpcs'){|x| make_groupKeywords( x ) }
+        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, group_ids )
-          group_ids = [ group_ids ] unless group_ids.is_a? Array
-          body = { cpcGrpIds: group_ids }
-          response = request( auth, Service, "getCpcIdByCpcGrpId", body )
-          process(response, 'cpcGrpCpcIds'){|x| make_groupKeywordIds( x ) }
+        def self.pause( auth, ids )
+          keywords = ids.map{|id| {id: id, pause: true} }
+          self.update( auth, keywords )
         end
 
         # sogou的keyword服务不提供质量度和状态，从getInfo方法中查询
         def self.status( auth, ids )
-          '''
-          Return [ { id: id, status: status} ... ]
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcIds: ids}
-          response = request( auth, Service, 'getCpcByCpcId', body )
-          process(response, 'cpcTypes'){  |x|  reverse_type(x, @status_map) }
+          response = request( auth, Service, 'getCpcByCpcId', {cpcIds: ids} )
+          process(response, 'cpcTypes'){|x|  reverse_type(x, @status_map) }
         end
 
         def self.quality( auth ,ids )
-          '''
-          Return [ { id: id, quality: quality} ... ]
-          '''
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcIds: ids}
-          response = request( auth, Service, 'getCpcByCpcId', { cpcIds: ids} )
-          process(response, 'cpcTypes'){  |x| reverse_type(x, @quality_map) }
-        end
-
-        private
-        def self.make_groupKeywordIds( cpcGrpCpcIdTypes )
-          """
-          Transfer Sogou API to PPC API
-          """
-          cpcGrpCpcIdTypes = [cpcGrpCpcIdTypes] unless cpcGrpCpcIdTypes.is_a? Array
-          group_keyword_ids = []
-          cpcGrpCpcIdTypes.each do |cpcGrpCpcIdType|
-            group_keyword_id = { }
-            group_keyword_id[:group_id] = cpcGrpCpcIdType[:cpc_grp_id]
-            group_keyword_id[:keyword_ids] = cpcGrpCpcIdType[:cpc_ids]
-            group_keyword_ids << group_keyword_id
-          end
-          return group_keyword_ids
-        end
-
-        private
-        def self.make_groupKeywords( cpcGrpCpcTypes )
-          cpcGrpCpcTypes = [cpcGrpCpcTypes] unless cpcGrpCpcTypes.is_a? Array 
-          group_keywords = []
-          cpcGrpCpcTypes.each do |cpcGrpCpcType|
-            group_keyword = {}
-            group_keyword[:group_id] = cpcGrpCpcType[:cpc_grp_id]
-            group_keyword[:keywords] = reverse_type( cpcGrpCpcType[:cpc_types] )
-            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 != nil
-                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.snake_case.to_sym]
-                  param[ key[0] ] = Match_type[ value ] if value                 
-                else
-                  value = type[ key[1].to_s.snake_case.to_sym ]
-                  param[ key[0] ] = value if value != nil
-                end
-              end # map.each
-            params << param
-          end # types.each
-          return params
+          response = request( auth, Service, 'getCpcByCpcId', {cpcIds: ids} )
+          process(response, 'cpcTypes'){|x| reverse_type(x, @quality_map) }
         end
 
       end # keyword

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

@@ -4,23 +4,31 @@ module PPC
       class Plan< Sogou
         Service = 'CpcPlan'
 
-        @map = [
-                          [:id,:cpcPlanId],
-                          [:name,:cpcPlanName],
-                          [:budget,:budget], 
-                          [:region,:regions],
-                          [:ip,:excludeIps] ,
-                          [:negative,:negativeWords],
-                          [:exact_negative,:exactNegativeWords],
-                          [:schedule,:schedule], 
-                          [:budget_offline_time,:budgetOfflineTime],
-                          [:show_prob,:showProb],   
-                          [:join_union ,:joinUnion],
-                          [:device,:device],
-                          [:price_ratio,:mobilePriceRate ], 
-                          [:pause,:pause],
-                          [:status,:status],
-                        ]
+        PlanType = {
+          id:                   :cpcPlanId,
+          name:                 :cpcPlanName,
+          budget:               :budget, 
+          region:               :regions,
+          ip:                   :excludeIps,
+          negative:             :negativeWords,
+          exact_negative:       :exactNegativeWords,
+          schedule:             :schedule, 
+          budget_offline_time:  :budgetOfflineTime,
+          show_prob:            :showProb,  
+          join_union:           :joinUnion,
+          device:               :device,
+          price_ratio:          :mobilePriceRate,
+          pause:                :pause,
+          status:               :status,
+          "id" =>               :cpc_plan_id,
+          "name" =>             :cpc_plan_name,
+        }
+        @map = PlanType
+
+        def self.info( auth, ids )
+          response = request( auth, Service, 'getCpcPlanByCpcPlanId', {cpcPlanIds: ids} )
+          process( response, 'cpcPlanTypes' ){ |x| reverse_type(x)[0] }
+        end
 
         def self.all( auth )
           response = request( auth, Service, 'getAllCpcPlan' )
@@ -33,9 +41,7 @@ module PPC
         end
 
         def self.get( auth, ids )
-          ids = [ ids ] unless ids.is_a? Array
-          body = { cpcPlanIds: ids }
-          response = request( auth, Service, 'getCpcPlanByCpcPlanId', body)
+          response = request( auth, Service, 'getCpcPlanByCpcPlanId', {cpcPlanIds: ids} )
           process( response, 'cpcPlanTypes' ){ |x| reverse_type(x) }
         end
 
@@ -54,11 +60,19 @@ module PPC
         end
 
         def self.delete(auth, ids )
-          ids = [ ids ] unless ids.class == Array
-          body = { cpcPlanIds: ids }
-          response = request( auth, Service, 'deleteCpcPlan', body)
+          response = request( auth, Service, 'deleteCpcPlan', {cpcPlanIds: ids} )
           process( response, '' ){ |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