yl_alipay 0.15.2

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/alipay.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'alipay/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "alipay"
+  spec.version       = Alipay::VERSION
+  spec.authors       = ["Rei"]
+  spec.email         = ["chloerei@gmail.com"]
+  spec.description   = %q{An unofficial simple alipay gem}
+  spec.summary       = %q{An unofficial simple alipay gem}
+  spec.homepage      = "https://github.com/chloerei/alipay"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "webmock"
+end

data/lib/alipay/app/service.rb

@@ -0,0 +1,57 @@
+module Alipay
+  module App
+    module Service
+      GATEWAY_URL = 'https://openapi.alipay.com/gateway.do'
+
+      ALIPAY_PREPARE_PARAMS_REQUIRED_PARAMS = %w( method )
+      def self.prepare_params(params, options = {})
+        params = Utils.stringify_keys(params)
+        Alipay::Service.check_required_params(params, ALIPAY_PREPARE_PARAMS_REQUIRED_PARAMS)
+        key = options[:key] || Alipay.key
+        sign_type = (options[:sign_type] || :rsa2).to_s.upcase
+        params = {
+            'method'         => params['method'],
+            'charset'        => 'utf-8',
+            'version'        => '1.0',
+            'timestamp'      => Time.now.utc.strftime('%Y-%m-%d %H:%M:%S').to_s,
+            'sign_type'      => sign_type
+        }.merge(params)
+
+        string = Alipay::App::Sign.params_to_sorted_string(params)
+        sign = case sign_type
+                 when 'RSA'
+                   ::Alipay::Sign::RSA.sign(key, string)
+                 when 'RSA2'
+                   ::Alipay::Sign::RSA2.sign(key, string)
+                 else
+                   raise ArgumentError, "invalid sign_type #{sign_type}, allow value: 'RSA', 'RSA2'"
+               end
+        params.merge('sign' => sign)
+      end
+
+      ALIPAY_TRADE_APP_PAY_REQUIRED_PARAMS = %w( app_id biz_content notify_url )
+      def self.alipay_trade_app_pay(params, options = {})
+        params = Utils.stringify_keys(params)
+        Alipay::Service.check_required_params(params, ALIPAY_TRADE_APP_PAY_REQUIRED_PARAMS)
+        params = params.merge('method' => 'alipay.trade.app.pay')
+        params = prepare_params(params, options)
+        Alipay::App::Sign.params_to_encoded_string params
+      end
+
+      ALIPAY_TRADE_REFUND_REQUIRED_PARAMS = %w( app_id biz_content )
+      def self.alipay_trade_refund_url(params, options = {})
+        params = Utils.stringify_keys(params)
+        Alipay::Service.check_required_params(params, ALIPAY_TRADE_REFUND_REQUIRED_PARAMS)
+        params = params.merge('method' => 'alipay.trade.refund')
+        params = prepare_params(params, options)
+        request_uri(params)
+      end
+
+      def self.request_uri(params)
+        uri = URI(GATEWAY_URL)
+        uri.query = URI.encode_www_form(params)
+        uri
+      end
+    end
+  end
+end

data/lib/alipay/app/sign.rb

@@ -0,0 +1,36 @@
+require 'erb'
+
+module Alipay
+  module App
+    module Sign
+      def self.verify?(params, options = {})
+        params = ::Alipay::Utils.stringify_keys(params)
+
+        sign_type = params.delete('sign_type').upcase
+        unless options[:sign_type].to_s.upcase == sign_type
+          raise "sign_type not match: params: #{params[:sign_type]} options: #{options[:sign_type]}"
+        end
+
+        sign = params.delete('sign')
+        string = ::Alipay::Sign.params_to_string(params)
+
+        case sign_type
+        when 'RSA'
+          ::Alipay::Sign::RSA.verify?(options[:key], string, sign)
+        when 'RSA2'
+          ::Alipay::Sign::RSA2.verify?(options[:key], string, sign)
+        else
+          false
+        end
+      end
+
+      def self.params_to_sorted_string(params)
+        params.sort.map { |key, value| %Q(#{key}=#{value.to_s}) }.join('&')
+      end
+
+      def self.params_to_encoded_string(params)
+        params.sort.map { |key, value| %Q(#{key}=#{ERB::Util.url_encode(value.to_s)}) }.join('&')
+      end
+    end
+  end
+end

data/lib/alipay/mobile/service.rb

@@ -0,0 +1,27 @@
+module Alipay
+  module Mobile
+    module Service
+      MOBILE_SECURITY_PAY_REQUIRED_PARAMS = %w( notify_url out_trade_no subject total_fee body )
+      def self.mobile_securitypay_pay_string(params, options = {})
+        params = Utils.stringify_keys(params)
+        Alipay::Service.check_required_params(params, MOBILE_SECURITY_PAY_REQUIRED_PARAMS)
+        sign_type = options[:sign_type] || Alipay.sign_type
+        key = options[:key] || Alipay.key
+        raise ArgumentError, "only support RSA sign_type" if sign_type != 'RSA'
+
+        params = {
+          'service'        => 'mobile.securitypay.pay',
+          '_input_charset' => 'utf-8',
+          'partner'        => options[:pid] || Alipay.pid,
+          'seller_id'      => options[:pid] || Alipay.pid,
+          'payment_type'   => '1'
+        }.merge(params)
+
+        string = Alipay::Mobile::Sign.params_to_string(params)
+        sign = CGI.escape(Alipay::Sign::RSA.sign(key, string))
+
+        %Q(#{string}&sign="#{sign}"&sign_type="RSA")
+      end
+    end
+  end
+end

data/lib/alipay/mobile/sign.rb

@@ -0,0 +1,9 @@
+module Alipay
+  module Mobile
+    module Sign
+      def self.params_to_string(params)
+        params.map { |key, value| %Q(#{key}="#{value}") }.join('&')
+      end
+    end
+  end
+end

data/lib/alipay/notify.rb

@@ -0,0 +1,19 @@
+module Alipay
+  module Notify
+    def self.verify?(params, options = {})
+      params = Utils.stringify_keys(params)
+      pid = options[:pid] || Alipay.pid
+      Sign.verify?(params, options) && verify_notify_id?(pid, params['notify_id'])
+    end
+
+    def self.verify_notify_id?(pid, notify_id)
+      uri = URI("https://mapi.alipay.com/gateway.do")
+      uri.query = URI.encode_www_form(
+        'service'   => 'notify_verify',
+        'partner'   => pid,
+        'notify_id' => notify_id
+      )
+      Net::HTTP.get(uri) == 'true'
+    end
+  end
+end

data/lib/alipay/service.rb

@@ -0,0 +1,239 @@
+module Alipay
+  module Service
+    GATEWAY_URL = 'https://mapi.alipay.com/gateway.do'
+
+    CREATE_PARTNER_TRADE_BY_BUYER_REQUIRED_PARAMS = %w( out_trade_no subject logistics_type logistics_fee logistics_payment price quantity )
+    def self.create_partner_trade_by_buyer_url(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_required_params(params, CREATE_PARTNER_TRADE_BY_BUYER_REQUIRED_PARAMS)
+
+      params = {
+        'service'        => 'create_partner_trade_by_buyer',
+        '_input_charset' => 'utf-8',
+        'partner'        => options[:pid] || Alipay.pid,
+        'seller_id'      => options[:pid] || Alipay.pid,
+        'payment_type'   => '1'
+      }.merge(params)
+
+      request_uri(params, options).to_s
+    end
+
+    TRADE_CREATE_BY_BUYER_REQUIRED_PARAMS = %w( out_trade_no subject logistics_type logistics_fee logistics_payment price quantity )
+    def self.trade_create_by_buyer_url(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_required_params(params, TRADE_CREATE_BY_BUYER_REQUIRED_PARAMS)
+
+      params = {
+        'service'        => 'trade_create_by_buyer',
+        '_input_charset' => 'utf-8',
+        'partner'        => options[:pid] || Alipay.pid,
+        'seller_id'      => options[:pid] || Alipay.pid,
+        'payment_type'   => '1'
+      }.merge(params)
+
+      request_uri(params, options).to_s
+    end
+
+    CREATE_DIRECT_PAY_BY_USER_REQUIRED_PARAMS = %w( out_trade_no subject )
+    def self.create_direct_pay_by_user_url(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_required_params(params, CREATE_DIRECT_PAY_BY_USER_REQUIRED_PARAMS)
+
+      if Alipay.debug_mode? and params['total_fee'].nil? and (params['price'].nil? || params['quantity'].nil?)
+        warn("Alipay Warn: total_fee or (price && quantity) must be set")
+      end
+
+      params = {
+        'service'        => 'create_direct_pay_by_user',
+        '_input_charset' => 'utf-8',
+        'partner'        => options[:pid] || Alipay.pid,
+        'seller_id'      => options[:pid] || Alipay.pid,
+        'payment_type'   => '1'
+      }.merge(params)
+
+      request_uri(params, options).to_s
+    end
+
+    CREATE_DIRECT_PAY_BY_USER_WAP_REQUIRED_PARAMS = %w( out_trade_no subject total_fee )
+    def self.create_direct_pay_by_user_wap_url(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_required_params(params, CREATE_DIRECT_PAY_BY_USER_WAP_REQUIRED_PARAMS)
+
+      params = {
+        'service'        => 'alipay.wap.create.direct.pay.by.user',
+        '_input_charset' => 'utf-8',
+        'partner'        => options[:pid] || Alipay.pid,
+        'seller_id'      => options[:pid] || Alipay.pid,
+        'payment_type'   => '1'
+      }.merge(params)
+
+      request_uri(params, options).to_s
+    end
+
+    CREATE_REFUND_URL_REQUIRED_PARAMS = %w( batch_no data notify_url )
+    def self.refund_fastpay_by_platform_pwd_url(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_required_params(params, CREATE_REFUND_URL_REQUIRED_PARAMS)
+
+      data = params.delete('data')
+      detail_data = data.map do|item|
+        item = Utils.stringify_keys(item)
+        "#{item['trade_no']}^#{item['amount']}^#{item['reason']}"
+      end.join('#')
+
+      params = {
+        'service'        => 'refund_fastpay_by_platform_pwd',
+        '_input_charset' => 'utf-8',
+        'partner'        => options[:pid] || Alipay.pid,
+        'seller_user_id' => options[:pid] || Alipay.pid,
+        'refund_date'    => Time.now.strftime('%Y-%m-%d %H:%M:%S'),
+        'batch_num'      => data.size,
+        'detail_data'    => detail_data
+      }.merge(params)
+
+      request_uri(params, options).to_s
+    end
+
+    CREATE_FOREX_SINGLE_REFUND_URL_REQUIRED_PARAMS = %w( out_return_no out_trade_no return_amount currency reason )
+    def self.forex_refund_url(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_required_params(params, CREATE_FOREX_SINGLE_REFUND_URL_REQUIRED_PARAMS)
+
+      params = {
+        'service'        => 'forex_refund',
+        'partner'        => options[:pid] || Alipay.pid,
+        '_input_charset' => 'utf-8',
+        'gmt_return'     => Time.now.getlocal('+08:00').strftime('%Y%m%d%H%M%S')
+      }.merge(params)
+
+      request_uri(params, options).to_s
+    end
+
+    SEND_GOODS_CONFIRM_BY_PLATFORM_REQUIRED_PARAMS = %w( trade_no logistics_name )
+    SEND_GOODS_CONFIRM_BY_PLATFORM_OPTIONAL_PARAMS = %w( transport_type create_transport_type )
+    def self.send_goods_confirm_by_platform(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_required_params(params, SEND_GOODS_CONFIRM_BY_PLATFORM_REQUIRED_PARAMS)
+      check_optional_params(params, SEND_GOODS_CONFIRM_BY_PLATFORM_OPTIONAL_PARAMS)
+
+      params = {
+        'service'        => 'send_goods_confirm_by_platform',
+        'partner'        => options[:pid] || Alipay.pid,
+        '_input_charset' => 'utf-8'
+      }.merge(params)
+
+      Net::HTTP.get(request_uri(params, options))
+    end
+
+    CREATE_FOREX_TRADE_REQUIRED_PARAMS = %w( notify_url subject out_trade_no currency )
+    CREATE_FOREX_TRADE_OPTIONAL_PARAMS = %w( total_fee rmb_fee )
+    def self.create_forex_trade_url(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_required_params(params, CREATE_FOREX_TRADE_REQUIRED_PARAMS)
+      check_optional_params(params, CREATE_FOREX_TRADE_OPTIONAL_PARAMS)
+
+      params = {
+        'service'         => 'create_forex_trade',
+        '_input_charset'  => 'utf-8',
+        'partner'         => options[:pid] || Alipay.pid,
+      }.merge(params)
+
+      request_uri(params, options).to_s
+    end
+
+    CLOSE_TRADE_REQUIRED_OPTIONAL_PARAMS = %w( trade_no out_order_no )
+    def self.close_trade(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_optional_params(params, CLOSE_TRADE_REQUIRED_OPTIONAL_PARAMS)
+
+      params = {
+        'service'        => 'close_trade',
+        '_input_charset' => 'utf-8',
+        'partner'        => options[:pid] || Alipay.pid
+      }.merge(params)
+
+      Net::HTTP.get(request_uri(params, options))
+    end
+
+    SINGLE_TRADE_QUERY_OPTIONAL_PARAMS = %w( trade_no out_trade_no )
+    def self.single_trade_query(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_optional_params(params, SINGLE_TRADE_QUERY_OPTIONAL_PARAMS)
+
+      params =   {
+        "service"         => 'single_trade_query',
+        "_input_charset"  => "utf-8",
+        "partner"         => options[:pid] || Alipay.pid,
+      }.merge(params)
+
+      Net::HTTP.get(request_uri(params, options))
+    end
+
+    def self.account_page_query(params, options = {})
+      params = {
+        service: 'account.page.query',
+        _input_charset: 'utf-8',
+        partner: options[:pid] || Alipay.pid,
+      }.merge(params)
+
+      Net::HTTP.get(request_uri(params, options))
+    end
+
+    BATCH_TRANS_NOTIFY_REQUIRED_PARAMS = %w( notify_url account_name detail_data batch_no batch_num batch_fee email )
+    def self.batch_trans_notify_url(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_required_params(params, BATCH_TRANS_NOTIFY_REQUIRED_PARAMS)
+
+      params = {
+        'service'        => 'batch_trans_notify',
+        '_input_charset' => 'utf-8',
+        'partner'        => options[:pid] || Alipay.pid,
+        'pay_date'       => Time.now.strftime("%Y%m%d")
+      }.merge(params)
+
+      request_uri(params, options).to_s
+    end
+
+    CREATE_FOREX_TRADE_WAP_REQUIRED_PARAMS = %w( out_trade_no subject merchant_url currency )
+    def self.create_forex_trade_wap_url(params, options = {})
+      params = Utils.stringify_keys(params)
+      check_required_params(params, CREATE_FOREX_TRADE_WAP_REQUIRED_PARAMS)
+
+      params = {
+        'service'        => 'create_forex_trade_wap',
+        '_input_charset' => 'utf-8',
+        'partner'        => options[:pid] || Alipay.pid,
+        'seller_id'      => options[:pid] || Alipay.pid
+      }.merge(params)
+
+      request_uri(params, options).to_s
+    end
+
+    def self.request_uri(params, options = {})
+      uri = URI(GATEWAY_URL)
+      uri.query = URI.encode_www_form(sign_params(params, options))
+      uri
+    end
+
+    def self.sign_params(params, options = {})
+      params.merge(
+        'sign_type' => (options[:sign_type] || Alipay.sign_type),
+        'sign'      => Alipay::Sign.generate(params, options)
+      )
+    end
+
+    def self.check_required_params(params, names)
+      return if !Alipay.debug_mode?
+
+      names.each do |name|
+        warn("Alipay Warn: missing required option: #{name}") unless params.has_key?(name)
+      end
+    end
+
+    def self.check_optional_params(params, names)
+      return if !Alipay.debug_mode?
+
+      warn("Alipay Warn: must specify either #{names.join(' or ')}") if names.all? {|name| params[name].nil? }
+    end
+  end
+end

data/lib/alipay/sign/dsa.rb

@@ -0,0 +1,13 @@
+module Alipay
+  module Sign
+    class DSA
+      def self.sign(key, string)
+        raise NotImplementedError, 'DSA sign is not implemented'
+      end
+
+      def self.verify?(string, sign)
+        raise NotImplementedError, 'DSA verify is not implemented'
+      end
+    end
+  end
+end

data/lib/alipay/sign/md5.rb

@@ -0,0 +1,15 @@
+require 'digest/md5'
+
+module Alipay
+  module Sign
+    class MD5
+      def self.sign(key, string)
+        Digest::MD5.hexdigest("#{string}#{key}")
+      end
+
+      def self.verify?(key, string, sign)
+        sign == sign(key, string)
+      end
+    end
+  end
+end

data/lib/alipay/sign/rsa.rb

@@ -0,0 +1,18 @@
+require 'openssl'
+require 'base64'
+
+module Alipay
+  module Sign
+    class RSA
+      def self.sign(key, string)
+        rsa = OpenSSL::PKey::RSA.new(key)
+        Base64.strict_encode64(rsa.sign('sha1', string))
+      end
+
+      def self.verify?(key, string, sign)
+        rsa = OpenSSL::PKey::RSA.new(key)
+        rsa.verify('sha1', Base64.strict_decode64(sign), string)
+      end
+    end
+  end
+end

data/lib/alipay/sign/rsa2.rb

@@ -0,0 +1,18 @@
+require 'openssl'
+require 'base64'
+
+module Alipay
+  module Sign
+    class RSA2
+      def self.sign(key, string)
+        rsa = OpenSSL::PKey::RSA.new(key)
+        Base64.strict_encode64(rsa.sign('sha256', string))
+      end
+
+      def self.verify?(key, string, sign)
+        rsa = OpenSSL::PKey::RSA.new(key)
+        rsa.verify('sha256', Base64.strict_decode64(sign), string)
+      end
+    end
+  end
+end

data/lib/alipay/sign.rb

@@ -0,0 +1,54 @@
+module Alipay
+  module Sign
+    def self.generate(params, options = {})
+      params = Utils.stringify_keys(params)
+      sign_type = options[:sign_type] || Alipay.sign_type
+      key = options[:key] || Alipay.key
+      string = params_to_string(params)
+
+      case sign_type
+      when 'MD5'
+        MD5.sign(key, string)
+      when 'RSA'
+        RSA.sign(key, string)
+      when 'DSA'
+        DSA.sign(key, string)
+      else
+        raise ArgumentError, "invalid sign_type #{sign_type}, allow value: 'MD5', 'RSA', 'DSA'"
+      end
+    end
+
+    ALIPAY_RSA_PUBLIC_KEY = <<-EOF
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCnxj/9qwVfgoUh/y2W89L6BkRA
+FljhNhgPdyPuBV64bfQNN1PjbCzkIM6qRdKBoLPXmKKMiFYnkd6rAoprih3/PrQE
+B/VsW8OoM8fxn67UDYuyBTqA23MML9q1+ilIZwBC2AQ2UBVOrFXfFl75p6/B5Ksi
+NG9zpgmLCUYuLkxpLQIDAQAB
+-----END PUBLIC KEY-----
+    EOF
+
+    def self.verify?(params, options = {})
+      params = Utils.stringify_keys(params)
+
+      sign_type = params.delete('sign_type')
+      sign = params.delete('sign')
+      string = params_to_string(params)
+
+      case sign_type
+      when 'MD5'
+        key = options[:key] || Alipay.key
+        MD5.verify?(key, string, sign)
+      when 'RSA'
+        RSA.verify?(ALIPAY_RSA_PUBLIC_KEY, string, sign)
+      when 'DSA'
+        DSA.verify?(string, sign)
+      else
+        false
+      end
+    end
+
+    def self.params_to_string(params)
+      params.sort.map { |item| item.join('=') }.join('&')
+    end
+  end
+end

data/lib/alipay/utils.rb

@@ -0,0 +1,19 @@
+module Alipay
+  module Utils
+    def self.stringify_keys(hash)
+      new_hash = {}
+      hash.each do |key, value|
+        new_hash[(key.to_s rescue key) || key] = value
+      end
+      new_hash
+    end
+
+    # 退款批次号，支付宝通过此批次号来防止重复退款操作，所以此号生成后最好直接保存至数据库，不要在显示页面的时候生成
+    # 共 24 位(8 位当前日期 + 9 位纳秒 + 1 位随机数)
+    def self.generate_batch_no
+      t = Time.now
+      batch_no = t.strftime('%Y%m%d%H%M%S') + t.nsec.to_s
+      batch_no.ljust(24, rand(10).to_s)
+    end
+  end
+end

data/lib/alipay/version.rb

@@ -0,0 +1,3 @@
+module Alipay
+  VERSION = "0.15.2"
+end

data/lib/alipay/wap/notify.rb

@@ -0,0 +1,13 @@
+module Alipay
+  module Wap
+    module Notify
+      def self.verify?(params, options = {})
+        params = Utils.stringify_keys(params)
+        pid = options[:pid] || Alipay.pid
+        notify_id = params['notify_data'].scan(/\<notify_id\>(.*)\<\/notify_id\>/).flatten.first
+
+        Sign.verify?(params, options) && ::Alipay::Notify.verify_notify_id?(pid, notify_id)
+      end
+    end
+  end
+end

data/lib/alipay/wap/service.rb

@@ -0,0 +1,84 @@
+module Alipay
+  module Wap
+    module Service
+      GATEWAY_URL = 'https://wappaygw.alipay.com/service/rest.htm'
+
+      TRADE_CREATE_DIRECT_TOKEN_REQUIRED_PARAMS = %w( req_data )
+      REQ_DATA_REQUIRED_PARAMS = %w( seller_account_name subject out_trade_no total_fee call_back_url )
+      def self.trade_create_direct_token(params, options = {})
+        params = Utils.stringify_keys(params)
+        Alipay::Service.check_required_params(params, TRADE_CREATE_DIRECT_TOKEN_REQUIRED_PARAMS)
+
+        req_data = Utils.stringify_keys(params.delete('req_data'))
+        Alipay::Service.check_required_params(req_data, REQ_DATA_REQUIRED_PARAMS)
+
+        xml = req_data.map {|k, v| "<#{k}>#{v.encode(:xml => :text)}</#{k}>" }.join
+        req_data_xml = "<direct_trade_create_req>#{xml}</direct_trade_create_req>"
+
+        # About req_id: http://club.alipay.com/read-htm-tid-10078020-fpage-2.html
+        params = {
+          'service'  => 'alipay.wap.trade.create.direct',
+          'req_data' => req_data_xml,
+          'partner'  => options[:pid] || Alipay.pid,
+          'req_id'   => Time.now.strftime('%Y%m%d%H%M%s'),
+          'format'   => 'xml',
+          'v'        => '2.0'
+        }.merge(params)
+
+        xml = Net::HTTP.get(request_uri(params, options))
+        CGI.unescape(xml).scan(/\<request_token\>(.*)\<\/request_token\>/).flatten.first
+      end
+
+      AUTH_AND_EXECUTE_REQUIRED_PARAMS = %w( request_token )
+      def self.auth_and_execute_url(params, options = {})
+        params = Utils.stringify_keys(params)
+        Alipay::Service.check_required_params(params, AUTH_AND_EXECUTE_REQUIRED_PARAMS)
+
+        req_data_xml = "<auth_and_execute_req><request_token>#{params.delete('request_token')}</request_token></auth_and_execute_req>"
+
+        params = {
+          'service'  => 'alipay.wap.auth.authAndExecute',
+          'req_data' => req_data_xml,
+          'partner'  => options[:pid] || Alipay.pid,
+          'format'   => 'xml',
+          'v'        => '2.0'
+        }.merge(params)
+
+        request_uri(params, options).to_s
+      end
+
+      def self.security_risk_detect(params, options)
+        params = Utils.stringify_keys(params)
+
+        params = {
+          'service' => 'alipay.security.risk.detect',
+          '_input_charset' => 'utf-8',
+          'partner' => options[:pid] || Alipay.pid,
+          'timestamp' => Time.now.strftime('%Y-%m-%d %H:%M:%S'),
+          'scene_code' => 'PAYMENT'
+        }.merge(params)
+
+        sign_params(params, options)
+
+        Net::HTTP.post_form(URI(GATEWAY_URL), params)
+      end
+
+      def self.request_uri(params, options = {})
+        uri = URI(GATEWAY_URL)
+        uri.query = URI.encode_www_form(sign_params(params, options))
+        uri
+      end
+
+      SIGN_TYPE_TO_SEC_ID = {
+        'MD5' => 'MD5',
+        'RSA' => '0001'
+      }
+
+      def self.sign_params(params, options = {})
+        sign_type = (options[:sign_type] ||= Alipay.sign_type)
+        params = params.merge('sec_id' => SIGN_TYPE_TO_SEC_ID[sign_type])
+        params.merge('sign' => Alipay::Sign.generate(params, options))
+      end
+    end
+  end
+end