jdpay 0.1.1

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "jd_pay"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/jd_pay.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jd_pay/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jdpay"
+  spec.version       = JdPay::VERSION
+  spec.authors       = ["Genkin He"]
+  spec.email         = ["hemengzhi88@gmail.com"]
+  spec.summary       = %q{An unofficial simple jdpay gem.}
+  spec.description   = %q{An unofficial simple jdpay gem}
+  spec.homepage      = "https://github.com/genkin-he/jd_pay"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.test_files = Dir["test/**/*"]
+
+  spec.add_runtime_dependency "rest-client", '>= 2.0.0'
+  spec.add_runtime_dependency "activesupport", '>= 3.2'
+  spec.add_runtime_dependency "builder", '~> 3.2.2'
+
+  spec.add_development_dependency "bundler", '~> 1.3'
+  spec.add_development_dependency "rake", '~> 11.2'
+  spec.add_development_dependency "webmock", '~> 2.3'
+  spec.add_development_dependency "minitest", '~> 5'
+end

data/lib/jd_pay.rb

@@ -0,0 +1,24 @@
+require "jd_pay/version"
+require "jd_pay/des"
+require "jd_pay/result"
+require "jd_pay/service"
+require "jd_pay/sign"
+require "jd_pay/util"
+require "jd_pay/qr_service"
+
+module JdPay
+  @extra_rest_client_options = {}
+  @debug_mode = true
+
+  class << self
+    attr_accessor :mch_id, :md5_key, :des_key, :pri_key, :pub_key, :debug_mode,
+      :extra_rest_client_options, :qr_mch_id, :qr_des_key, :qr_pri_key
+    def public_key
+      self.pub_key ? self.pub_key : JdPay::Sign::JDPAY_RSA_PUBLIC_KEY
+    end
+
+    def debug_mode?
+      !!@debug_mode
+    end
+  end
+end

data/lib/jd_pay/des.rb

@@ -0,0 +1,66 @@
+module JdPay
+  module Des
+    class << self
+      def encrypt_3des(str, options = {})
+        des = OpenSSL::Cipher::Cipher.new('des-ede3')
+        str = format_str_data(str)
+        des.encrypt
+        des.key = decode_key(options)
+        des.iv = des.random_iv
+        str = des.update(str)
+        to_hex(str.bytes)
+      end
+
+      def decrypt_3des(encrypt_str, options = {})
+        encrypt_str = to_decimal(encrypt_str)
+        des2 = OpenSSL::Cipher::Cipher.new('des-ede3')
+        des2.decrypt
+        des2.key = decode_key(options)
+        des2.iv = des2.random_iv
+        des2.padding = 0
+        result = (des2.update(encrypt_str) + des2.final).bytes
+        result.first(valid_size(result.shift(4))).map(&:chr).join.force_encoding('utf-8').encode('utf-8')
+      end
+
+      private
+
+      def decode_key(options = {})
+        Base64.decode64(options[:des_key] || JdPay.des_key)
+      end
+
+      # 计算补位数据数组
+      def padding_array(num)
+        temp = (num + 4) % 8
+        Array.new(temp == 0 ? 0 : (8 - temp), 0x00)
+      end
+
+      # 有效数据长度数组
+      def valid_size_array(num)
+        size_array = [num >> 24 & 0xff, num >> 16 & 0xff, num >> 8 & 0xff, num & 0xff]
+      end
+
+      # 根据数组算出有效数据值
+      def valid_size(arr)
+        to_hex(arr).to_i(16)
+      end
+
+      # 格式化加密元数据
+      def format_str_data(str)
+        str_bytes = str.bytes
+        str_bytes_size = str_bytes.length
+        (valid_size_array(str_bytes_size) + str_bytes + padding_array(str_bytes_size)).map(&:chr).join
+      end
+
+      # 10进制string转16进制
+      def to_hex(arr)
+        arr.map { |num| "%02x" % num }.join
+      end
+
+      # 16进制string转10进制
+      def to_decimal(str)
+        # str.scan(/../).map{ |r| r.hex.chr }.join
+        Array(str).pack('H*')
+      end
+    end
+  end
+end

data/lib/jd_pay/qr_service.rb

@@ -0,0 +1,17 @@
+require 'rest_client'
+require 'active_support/core_ext/hash/conversions'
+module JdPay
+  module QrService
+    USABLE_METHODS = %i(qrcode_pay refund query revoke notify_verify)
+    def self.method_missing(method, *args)
+
+      super unless USABLE_METHODS.include?(method)
+      qr_service_default_config = {
+        mch_id: JdPay.qr_mch_id, des_key: JdPay.qr_des_key, pri_key: JdPay.qr_pri_key
+      }
+      args[1] = {} if args[1].nil?
+      args[1] = qr_service_default_config.merge(args[1])
+      JdPay::Service.public_send(method, *args)
+    end
+  end
+end

data/lib/jd_pay/result.rb

@@ -0,0 +1,28 @@
+module JdPay
+  class Result < ::Hash
+    SUCCESS_FLAG = '000000'.freeze
+
+    def initialize(result, options = {})
+      super nil
+
+      self['jdpay'] = result['jdpay']
+
+      if result['jdpay'].class == Hash && (decrypt = self.decrypt_verify(options = {})).class == Hash
+        self['jdpay'] = decrypt['jdpay']
+      end
+    end
+
+    def success?
+      self['jdpay']['result']['code'] == SUCCESS_FLAG
+    end
+
+    def decrypt_verify(options = {})
+      if self.success?
+        content_hash = Hash.from_xml JdPay::Des.decrypt_3des(Base64.decode64(self['jdpay']['encrypt']), options)
+        JdPay::Sign.rsa_verify?(content_hash, options) ? content_hash : (raise "JdPay_verify_err:#{content_hash}")
+      else
+        raise "JdPay::Result#decrypt_verify_err:#{self}"
+      end
+    end
+  end
+end

data/lib/jd_pay/service.rb

@@ -0,0 +1,180 @@
+require 'rest_client'
+require 'active_support/core_ext/hash/conversions'
+
+module JdPay
+  module Service
+    UNIORDER_URL = 'https://paygate.jd.com/service/uniorder'
+    QUERY_URL = 'https://paygate.jd.com/service/query'
+    REFUND_URL = 'https://paygate.jd.com/service/refund'
+    H5_PAY_URL = 'https://h5pay.jd.com/jdpay/saveOrder'
+    PC_PAY_URL = 'https://wepay.jd.com/jdpay/saveOrder'
+    REVOKE_URL = 'https://paygate.jd.com/service/revoke'
+    QRCODE_PAY_URL = 'https://paygate.jd.com/service/fkmPay'
+    USER_RELATION_URL = 'https://paygate.jd.com/service/getUserRelation'
+    CANCEL_USER_URL = 'https://paygate.jd.com/service/cancelUserRelation'
+
+    class << self
+      # the difference between pc and h5 is just request url
+      def pc_pay(params, options = {})
+        web_pay(params, PC_PAY_URL, options = {})
+      end
+
+      def h5_pay(params, options = {})
+        web_pay(params, H5_PAY_URL, options = {})
+      end
+
+      WEB_PAY_REQUIRED_FIELDS = [:tradeNum, :tradeName, :amount, :orderType, :notifyUrl, :callbackUrl, :userId]
+      def web_pay(params, url, options = {})
+        params = {
+          version: "V2.0",
+          merchant: options[:mch_id] || JdPay.mch_id,
+          tradeTime: Time.now.strftime("%Y%m%d%H%M%S"),
+          currency: "CNY"
+        }.merge(params)
+
+        check_required_options(params, WEB_PAY_REQUIRED_FIELDS)
+        sign = JdPay::Sign.rsa_encrypt(JdPay::Util.to_uri(params), options)
+        skip_encrypt_params = %i(version merchant)
+        params.each do |k, v|
+          params[k] = skip_encrypt_params.include?(k) ? v : JdPay::Des.encrypt_3des(v)
+        end
+        params[:sign] = sign
+        JdPay::Util.build_pay_form(url, params)
+      end
+
+      UNIORDER_REQUIRED_FIELDS = [:tradeNum, :tradeName, :amount, :orderType, :notifyUrl, :userId]
+      def uniorder(params, options = {})
+        params = {
+          version: "V2.0",
+          merchant: options[:mch_id] || JdPay.mch_id,
+          tradeTime: Time.now.strftime("%Y%m%d%H%M%S"),
+          currency: "CNY"
+        }.merge(params)
+
+        check_required_options(params, UNIORDER_REQUIRED_FIELDS)
+        params[:sign] = JdPay::Sign.rsa_encrypt(JdPay::Util.to_xml(params), options)
+
+        JdPay::Result.new(Hash.from_xml(invoke_remote(UNIORDER_URL, make_payload(params), options)), options)
+      end
+
+      QRCODE_REQUIRED_FIELDS = [:tradeNum, :tradeName, :amount, :device, :token]
+      def qrcode_pay(params, options = {})
+        params = {
+          version: "V2.0",
+          merchant: options[:mch_id] || JdPay.mch_id,
+          tradeTime: Time.now.strftime("%Y%m%d%H%M%S"),
+          currency: "CNY"
+        }.merge(params)
+
+        check_required_options(params, QRCODE_REQUIRED_FIELDS)
+        params[:sign] = JdPay::Sign.rsa_encrypt(JdPay::Util.to_xml(params), options)
+
+        JdPay::Result.new(Hash.from_xml(invoke_remote(QRCODE_PAY_URL, make_payload(params), options)), options)
+      end
+
+      USER_RELATION_REQUIRED_FIELDS = [:useId]
+      def user_relation(params, options = {})
+        params = {
+          version: "V2.0",
+          merchant: options[:mch_id] || JdPay.mch_id,
+        }.merge(params)
+
+        check_required_options(params, USER_RELATION_REQUIRED_FIELDS)
+        params[:sign] = JdPay::Sign.rsa_encrypt(JdPay::Util.to_xml(params), options)
+
+        JdPay::Result.new(Hash.from_xml(invoke_remote(USER_RELATION_URL, make_payload(params), options)), options)
+      end
+
+      def cancel_user(params, options = {})
+        params = {
+          version: "V2.0",
+          merchant: options[:mch_id] || JdPay.mch_id,
+        }.merge(params)
+
+        check_required_options(params, USER_RELATION_REQUIRED_FIELDS)
+        params[:sign] = JdPay::Sign.rsa_encrypt(JdPay::Util.to_xml(params), options)
+
+        JdPay::Result.new(Hash.from_xml(invoke_remote(CANCEL_USER_URL, make_payload(params), options)), options)
+      end
+
+      REFUND_REQUIRED_FIELDS = [:tradeNum, :oTradeNum, :amount, :notifyUrl]
+      def refund(params, options = {})
+        params = {
+          version: "V2.0",
+          merchant: options[:mch_id] || JdPay.mch_id,
+          tradeTime: Time.now.strftime("%Y%m%d%H%M%S"),
+          currency: "CNY"
+        }.merge(params)
+
+        check_required_options(params, REFUND_REQUIRED_FIELDS)
+        params[:sign] = JdPay::Sign.rsa_encrypt(JdPay::Util.to_xml(params), options)
+
+        JdPay::Result.new(Hash.from_xml(invoke_remote(REFUND_URL, make_payload(params), options)), options)
+      end
+
+      QUERY_REQUIRED_FIELDS = [:tradeNum, :tradeType]
+      def query(params, options = {})
+        params = {
+          version: "V2.0",
+          merchant: options[:mch_id] || JdPay.mch_id,
+          tradeType: '0'
+        }.merge(params)
+
+        check_required_options(params, QUERY_REQUIRED_FIELDS)
+        params[:sign] = JdPay::Sign.rsa_encrypt(JdPay::Util.to_xml(params), options)
+
+        JdPay::Result.new(Hash.from_xml(invoke_remote(QUERY_URL, make_payload(params), options)), options)
+      end
+
+      REVOKE_REQUIRED_FIELDS = [:tradeNum, :oTradeNum, :amount]
+      def revoke(params, options = {})
+        params = {
+          version: "V2.0",
+          merchant: options[:mch_id] || JdPay.mch_id,
+          tradeTime: Time.now.strftime("%Y%m%d%H%M%S"),
+          currency: "CNY"
+        }.merge(params)
+
+        check_required_options(params, REVOKE_REQUIRED_FIELDS)
+        params[:sign] = JdPay::Sign.rsa_encrypt(JdPay::Util.to_xml(params), options)
+
+        JdPay::Result.new(Hash.from_xml(invoke_remote(REVOKE_URL, make_payload(params), options)), options)
+      end
+
+      def notify_verify(xml_str, options = {})
+        JdPay::Result.new(Hash.from_xml(xml_str), options)
+      end
+
+      private
+
+      def check_required_options(options, names)
+        return unless JdPay.debug_mode?
+        names.each do |name|
+          warn("JdPay Warn: missing required option: #{name}") unless options.has_key?(name)
+        end
+      end
+
+      def make_payload(params, options = {})
+        request_hash = {
+          "version" => "V2.0",
+          "merchant" => options[:mch_id] || JdPay.mch_id,
+          "encrypt" => Base64.strict_encode64(JdPay::Des.encrypt_3des JdPay::Util.to_xml(params))
+        }
+        JdPay::Util.to_xml(request_hash)
+      end
+
+      def invoke_remote(url, payload, options = {})
+        options = JdPay.extra_rest_client_options.merge(options)
+
+        RestClient::Request.execute(
+          {
+            method: :post,
+            url: url,
+            payload: payload,
+            headers: { content_type: 'application/xml' }
+          }.merge(options)
+        )
+      end
+    end
+  end
+end

data/lib/jd_pay/sign.rb

@@ -0,0 +1,47 @@
+require 'digest/md5'
+require "base64"
+
+module JdPay
+  module Sign
+
+    JDPAY_RSA_PUBLIC_KEY = <<EOF
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCKE5N2xm3NIrXON8Zj19GNtLZ8
+xwEQ6uDIyrS3S03UhgBJMkGl4msfq4Xuxv6XUAN7oU1XhV3/xtabr9rXto4Ke3d6
+WwNbxwXnK5LSgsQc1BhT5NcXHXpGBdt7P8NMez5qGieOKqHGvT0qvjyYnYA29a8Z
+4wzNR7vAVHp36uD5RwIDAQAB
+-----END PUBLIC KEY-----
+EOF
+
+    class << self
+      # params:
+      #  :orderId
+      def md5_sign(order_id, options = {})
+        Digest::MD5.hexdigest(
+          "merchant=#{options[:mch_id] || JdPay.mch_id}" +
+          "&orderId=#{order_id}&key=#{options[:md5_key] || JdPay.md5_key}"
+        )
+      end
+
+      def rsa_encrypt(str, options = {})
+        private_key = OpenSSL::PKey::RSA.new(options[:pri_key] || JdPay.pri_key)
+        Base64.strict_encode64(private_key.private_encrypt Digest::SHA256.hexdigest(str))
+      end
+
+      def rsa_decrypt(sign_str, options = {})
+        public_key = OpenSSL::PKey::RSA.new(options[:pub_key] || JdPay.public_key)
+        public_key.public_decrypt(Base64.decode64(sign_str))
+      end
+
+      def rsa_verify?(params, options = {})
+        params = params['jdpay'].dup
+        sign_str = params.delete('sign')
+        xml_without_sign = JdPay::Util.to_xml(params, root: 'jdpay')
+        ori_datas = [xml_without_sign, xml_without_sign.gsub("?>", " ?>")].map do |xml|
+          Digest::SHA256.hexdigest(xml)
+        end
+        ori_datas.include? rsa_decrypt(sign_str, options)
+      end
+    end
+  end
+end

data/lib/jd_pay/util.rb

@@ -0,0 +1,34 @@
+module JdPay
+  module Util
+    class << self
+      def to_xml(params, options = {})
+        options[:root] = options[:root] || 'jdpay'
+        denilize(params).to_xml(options).gsub(/>[[:space:]]+/, ">")
+      end
+
+      def to_uri(params)
+        params.sort.map do |k, v|
+          "#{k}=#{v}"
+        end.compact.join('&')
+      end
+
+      def denilize(h)
+        h.each_with_object({}) { | (k, v), g |
+        g[k] = (Hash === v) ? denilize(v) : v ? v : '' }
+      end
+
+      def build_pay_form(url, form_attributes)
+        inputs = ''
+        "<html>
+          <body onload=document.getElementById('payForm').submit(); style='display: none;'>
+              <form action=#{url} method='post' id='payForm'>
+                #{form_attributes.each do |k, v|
+                inputs << "<input type='text' name=#{k} value=#{v}>"
+              end and inputs}
+              </form>
+            </body>
+        </html>".gsub(/>[[:space:]]+/, ">")
+      end
+    end
+  end
+end