ppc 1.3.0 → 1.3.2

data/lib/ppc/baidu.rb

@@ -1,152 +0,0 @@
-require 'ppc/baidu/account'
-require 'ppc/baidu/plan'
-require 'ppc/baidu/bulk'
-require 'ppc/baidu/group'
-require 'ppc/baidu/key'
-require 'ppc/baidu/report'
-require 'awesome_print'
-require 'net/http'
-require 'net/https'
-require 'json'
-# require 'savon'
-module PPC
-  class Baidu
-    include ::PPC
-
-    def initialize(params = {})
-      @service = params[:service] + 'Service'
-      @username = params[:username]
-      @password = params[:password]
-      @token = params[:token]
-      @debug = params[:debug] || false
-    end
-
-
-    def request(method,params = {}, with_header = false)
-      uri = URI("https://api.baidu.com/json/sms/v3/#{@service}/#{method}")
-      http_body = {
-        header: request_header,
-        body: params
-      }.to_json
-
-      http_header = {
-        'Content-Type' => 'application/json; charset=UTF-8'
-      }
-
-      http = Net::HTTP.new(uri.host, 443)
-      http.set_debug_output $stderr
-      http.use_ssl = true
-
-      response = http.post(uri.path, http_body, http_header)
-      response =  (JSON.parse response.body)
-      # if not needed, only return body
-      return response['body'] unless with_header else response
-    end
-
-    def operations
-    end
-
-    protected
-    def download(params = {})
-      bulk = ::PPC::Baidu::Bulk.new({
-                                      username: @username,
-                                      password: @password,
-                                      token:    @token,
-                                      debug:    @debug
-      })
-
-      params[:extended] = params[:extended] || 2
-
-      begin
-        file_id = bulk.file_id_of_all(params)
-        puts "file_id: #{file_id}" if @debug
-
-        loop do
-          state = bulk.state(file_id)
-          raise "invalid file state: #{state}" unless %w(1 2 3 null).include? state
-          break if state == '3'
-          puts "waiting for #{file_id} to be ready. current state:#{state}" if @debug
-          sleep 3
-        end
-        puts "#{file_id} is ready" if @debug
-        return bulk.path(file_id)
-      rescue
-        # @header   = bulk.header
-        # @oprs     = bulk.oprs
-        # @oprtime  = bulk.oprtime
-        # @quota    = bulk.quota
-        # @rquota   = bulk.rquota
-        # @status   = bulk.status
-
-        # @desc     = bulk.desc
-
-        # case @desc
-        # when 'success'
-        # when 'failure'
-        #   @code     = bulk.code
-        #   @message  = bulk.message
-        # when 'system failure'
-        #   @code     = bulk.code
-        #   @message  = bulk.message
-        # else
-        #   raise "unknown desc from baidu: #{@desc}"
-        # end
-        raise BulkException.new(file_id,bulk)
-      end
-
-      return false
-    end
-
-    private
-
-
-    def request_header
-      {
-        username:   @username,
-        password:   @password,
-        token:      @token
-      }
-    end
-
-    def example(operation,with_header=false)
-      operation = make_operation(operation)
-      if with_header
-        {
-          example_header: operation.example_header,
-          example_body:   operation.example_body
-        }
-      else
-        operation.example_body
-      end
-    end
-
-    def process_response(response)
-      body = response[:envelope]
-      print_debug(body,'response.envelope') if @debug
-      @header = body[:header]
-      res_header = header[:res_header]
-
-      @oprs     = res_header[:oprs]
-      @oprtime  = res_header[:oprtime]
-      @quota    = res_header[:quota]
-      @rquota   = res_header[:rquota]
-      @status   = res_header[:status]
-
-      @desc     = res_header[:desc]
-      case @desc
-      when 'success'
-      when 'failure'
-        failures  = res_header[:failures]
-        @code     = failures[:code]
-        @message  = failures[:message]
-      when 'system failure'
-        failures  = res_header[:failures]
-        @code     = failures[:code]
-        @message  = failures[:message]
-      else
-        raise "unknown desc from baidu: #{@desc}"
-      end
-    end
-
-  end
-end

data/lib/ppc/baidu/account.rb

@@ -1,88 +0,0 @@
-module PPC
-  class Baidu
-    class Account < ::PPC::Baidu
-      def initialize(params = {})
-        params[:service] = 'Account'
-        super(params)
-      end
-
-      def info
-        response = request('getAccountInfo')["accountInfoType"]
-      end
-
-      def all(params = {})
-        download(params)
-      end
-
-      def update( params = {} )
-        """
-        update account info
-        @ params : account_info_type
-        @return : account info_type
-        """
-        info = {
-          accountInfoType: {
-            budgetType:              params[:budget_type] ,
-            budget:                  params[:budget],
-            regionTarget:            params[:region],
-            excludeIp:               params[:excludeip] ,
-            isDynamicCreative:       params[:isdynamic],
-            dynamicCreativeParam:    params[:creativeparam]
-          }
-        }
-        # delete null symbol
-        info[:accountInfoType].each{
-          |pair|
-          key, value = pair
-          info[:accountInfoType].delete(key) if value == nil
-        }
-
-        request('updateAccountInfo', info)["accountInfoType"]
-      end
-
-      def query_report(params = {})
-        report = ::PPC::Baidu::Report.new({username: @username, password: @password, token: @token, debug: @debug})
-
-        begin
-          @file_id = report.file_id_of_query(params)
-          print_debug(@file_id,'file_id') if @debug
-
-          loop do
-            state = report.state(@file_id)
-            raise "invalid file state: #{state}" unless %w(1 2 3 null).include? state
-            break if state == '3'
-            print_debug(state,'file_id.state') if @debug
-            sleep 3
-          end
-
-          url = report.path(@file_id)
-          open(url).read.force_encoding('gb18030').encode('utf-8')
-        rescue Exception => e
-          raise ReportException.new(@file_id,report,e)
-        end
-      end
-
-      def cost_report(params = {})
-        report = ::PPC::Baidu::Report.new({username: @username, password: @password, token: @token, debug: @debug})
-        begin
-          @file_id = report.file_id_of_cost(params)
-          print_debug(@file_id,'file_id') if @debug
-
-          loop do
-            state = report.state(@file_id)
-            raise "invalid file state: #{state}" unless %w(1 2 3 null).include? state
-            break if state == '3'
-            print_debug(state,'file_id.state') if @debug
-            sleep 3
-          end
-
-          url = report.path(@file_id)
-          open(url).read.force_encoding('gb18030').encode('utf-8')
-        rescue Exception => e
-          raise ReportException.new(@file_id,report,e)
-        end
-      end
-
-    end
-  end
-end

data/lib/ppc/baidu/bulk.rb

@@ -1,52 +0,0 @@
-module PPC
-  class Baidu
-    class BulkException < Exception
-      attr_reader :file_id,:bulk,:exception
-      def initialize(file_id,bulk,exception)
-        @file_id    = file_id
-        @bulk       = bulk
-        @exception  = exception
-      end
-    end
-
-    class Bulk < ::PPC::Baidu
-      def initialize(params = {})
-        params[:service] = 'BulkJob'
-        super(params)
-      end
-
-      def file_id_of_all(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('getAllObjects',options)
-
-        body = response[:envelope][:body]
-        raise "no result" if body.nil?
-        body[:get_all_objects_response][:file_id]
-      end
-
-      def state(id)
-        raise "empty id" if id.nil? or id.empty?
-        request('getFileState',{fileId:id})[:envelope][:body][:get_file_state_response][:is_generated]
-      end
-
-      def path(id)
-        request('getFilePath',{fileId:id})[:envelope][:body][:get_file_path_response][:file_paths]
-      end
-    end
-  end
-end

data/lib/ppc/baidu/group.rb

@@ -1,99 +0,0 @@
-module PPC
-  class Baidu
-    class Group < ::PPC::Baidu
-      def initialize(params = {})
-        params[:service] = 'Adgroup'
-        super(params)
-      end
-
-      def all()
-        """
-        @return : Array of campaignAdgroupIds
-        """
-        request( "getAllAdgroupId" )["campaignAdgroupIds"]
-      end
-
-      def add( params={}, test = false)
-        """
-        @ input : one or list of AdgroupType
-        @ output : list of AdgroupType
-        """       
-        params = [ params ] unless params.class == Array
-        adgroupType = []
-        
-        params.each{  | group_i |
-          adgroupType << make_adgrouptype( group_i ) 
-        }
-
-        body = {adgroupTypes: adgroupType}
-        response = request( "addAdgroup", body, test )
-        return response['adgroupTypes'] unless test else response
-      end
-
-      def update( params={}, test = false )
-        """
-        @ input : one or list of AdgroupType
-        @ output : list of AdgroupType
-        """
-        params = [ params ] unless params.class == Array
-        adgroupType = []
-        
-        params.each{  | group_i |
-          adgroupType << make_adgrouptype( group_i ) 
-        }
-
-        body = {adgroupTypes: adgroupType}
-        responses = request( "updateAdgroup", body, test )
-        return responses['adgroupTypes'] unless test else responses
-      end
-
-      def delete( ids )
-        # delete responses have no content therefore we 
-        #return header.desc to judge whether operation success
-        ids = [ ids ] unless ids.class == Array
-        
-        body = { adgroupIds: ids }
-        request( "deleteAdgroup", body, true )[ 'header' ][ 'desc' ]
-      end
-
-      def search_by_planid( ids, test = false )
-        ids = [ ids ] unless ids.class == Array
-        body = { campaignIds: ids }
-        responses = request("getAdgroupByCampaignId",  body, test )
-        return responses["campaignAdgroups"]  unless test else responses
-      end
-
-      def search_by_groupid( ids, test = false )
-        ids = [ ids ] unless ids.class == Array
-        body = { adgroupIds: ids }
-        responses = request("getAdgroupByAdgroupId",body, test )
-        return responses["adgroupTypes"]  unless test else responses
-      end
-
-      private 
-        def make_adgrouptype( params={} )
-          adgrouptype = {
-            campaignId:               params[:plan_id],
-            adgroupId:              params[:group_id],
-            adgroupName:              params[:name],
-            maxPrice:              params[:maxprice],
-            negativeWords:              params[:negative],
-            exactNegativeWords:              params[:exact_negative],
-            pause:              params[:pause],
-            status:              params[:status],
-            reserved:              params[:reserved]
-          }
-          # delete empty node
-          adgrouptype.each{
-            |pair|
-            key, value = pair
-            adgrouptype.delete(key) if value == nil
-          }
-          # delete invalid note according to request type
-          # unimplemented
-          return adgrouptype
-        end #make_adgrouptype
-
-    end # class group
-  end # class baidu 
-end # module

data/lib/ppc/baidu/key.rb

@@ -1,38 +0,0 @@
-module PPC
-  class Baidu
-    class Key < ::PPC::Baidu
-      def initialize(params = {})
-        params[:service] = 'Keyword'
-        @se_id = params[:se_id]
-        super(params)
-      end 
-
-      def add()
-      end
-
-      def update()
-      end
-
-      def delete()
-      end
-
-      def active()
-      end
-
-      def search_by_groupid( ids, return_id = false )
-      end
-
-      def search_by_keywordid( ids )
-      end
-
-      def get_status()
-      end
-
-      def get_quality()
-      end
-
-      def get_10quality()
-      end
-    end
-  end
-end

data/lib/ppc/baidu/plan.rb

@@ -1,85 +0,0 @@
-module PPC
-  class Baidu
-    class Plan < ::PPC::Baidu
-      def initialize(params = {})
-        params[:service] = 'Campaign'
-        @se_id = params[:se_id]
-        super(params)
-      end
-
-      def all(params = {})
-        params[:plan_ids] = [@se_id]
-        download(params)
-      end
-
-      def ids
-        request('getAllCampaignId')['campaignIds']
-      end
-
-      #add one or more plans
-      def add(plans)
-        if plans.class == Hash
-          plans = [plans]
-          single = true
-        end
-        campaignTypes = []
-
-        plans.each do |plan|
-          campaignTypes << {
-            campaignName: plan[:name],
-            negativeWords: plan[:negative],
-            exactNegativeWords: plan[:exact_negative]
-          }
-        end
-
-        options = {campaignTypes:  campaignTypes}
-        response = request('addCampaign',options)['campaignTypes']
-        if single
-          response.first
-        else
-          response
-        end
-      end
-
-      def get(ids)
-        if ids.class != Array
-          ids = [ids]
-          single = true
-        end
-
-        options = {campaignIds: ids}
-        response = request('getCampaignByCampaignId',options)['campaignTypes']
-
-        if single
-          response.first
-        else
-          response
-        end
-      end
-
-      # @todo needs testing
-      def updates(params)
-        params['campaignId'] = @se_id
-        options = {campaignTypes: [params]}
-        request('updateCampaign',options)['campaignTypes']
-      end
-
-      def update_by_id(id,params = {})
-        params['campaignId'] = id
-        options = {campaignTypes: [params]}
-        request('updateCampaign',options)['campaignTypes']
-      end
-
-      def update(plans)
-        options = {campaignTypes: plans}
-        request('updateCampaign',options)['campaignTypes']
-      end
-
-      def delete(ids)
-        ids = [ids] unless ids.class == Array
-        options = {campaignIds: ids}
-        request('deleteCampaign',options)['result'] == 1
-      end
-    end
-  end
-end