mp_weixin 0.1.0

data/lib/mp_weixin/response_rule.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+module MpWeixin
+  module ResponseRule
+    # '接收普通消息', '接收事件推送', '接收语音识别结果'
+    #
+    def handle_request(request, &block)
+      request.body.rewind  # in case someone already read it
+      data = request.body.read
+      message = Message.from_xml(data)
+
+      logger.info "Hey, one request from '#{request.url}' been detected, and content is #{message.as_json}"
+
+      if message.present?
+        handle_message(request, message)
+        response_message(request, message, &block)
+      else
+        halt 400, 'unknown message'
+      end
+    end
+
+    # handle corrent data post from weixin
+    #
+    # please @rewrite me
+    def handle_message(request, message)
+      #
+    end
+
+    # 发送被动响应消息'
+    #
+    # please @rewrite me
+    #
+    #
+    # can rely with instance of those class eg, TextReplyMessage, ImageReplyMessage, VoiceReplyMessage
+    # VideoReplyMessage, MusicReplyMessage, NewsReplyMessage
+    # quickly generate reply content through call 'reply_#{msg_type}_message(attributes).to_xml' @see 'spec/mp_weixin/server_helper_spec.rb'
+    #
+    def response_message(request, message, &block)
+      if block_given?
+        block.call(request, message)
+      end
+
+      # reply with
+      # reply_#{msg_type}_message(attributes).to_xml
+    end
+  end
+end

data/lib/mp_weixin/server.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module MpWeixin
+  class Server < Sinatra::Base
+    configure :production, :development do
+      enable :logging
+
+      set :haml, { :ugly=>true }
+      set :clean_trace, true
+      Dir.mkdir('log') unless File.exist?('log')
+
+      file = File.new("./log/mp_weixin_#{settings.environment}.log", 'a+')
+      file.sync = true
+      use Rack::CommonLogger, file
+    end
+
+    helpers MpWeixin::ServerHelper, MpWeixin::ResponseRule
+
+
+    before '/' do
+      unless valid_signature?(signature = params[:signature], timestamp = params[:timestamp], nonce= params[:nonce] )
+        halt 401,{'Content-Type' => 'text/plain'}, 'go away!'
+      end
+    end
+
+    # 验证消息真实性
+    #
+    # 通过检验signature对请求进行校验（下面有校验方式）。若确认此次GET请求来自微信服务器，请原样返回echostr参数内容，则接入生效，成为开发者成功，否则接入失败
+    # eg curl http://localhost:4567/?nonce=121212121&signature=9dc548e8c7fe32ac53f887e834a8c719a73cafc3&timestamp=1388028695&echostr=22222222222222222
+    get '/' do
+      params[:echostr]
+    end
+
+    # '接收普通消息', '发送被动响应消息', '接收事件推送', '接收语音识别结果'
+    post "/" do
+      content_type 'text/xml'
+      handle_request(request)
+    end
+  end
+end

data/lib/mp_weixin/server_helper.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+module MpWeixin
+  module ServerHelper
+
+    # generate a signature string through sha1 encrypt token, timestamp, nonce .
+    #
+    # @param [String] token the token value
+    # @param [String] timestamp the timestamp value from weixin
+    # @param [String] nonce the random num from weixin
+    #
+    #    加密/校验流程如下：
+    #    1. 将token、timestamp、nonce三个参数进行字典序排序
+    #    2. 将三个参数字符串拼接成一个字符串进行sha1加密
+    #    3. 开发者获得加密后的字符串可与signature对比，标识该请求来源于微信
+    #
+    # @return [String]
+    def generate_signature(token, timestamp, nonce)
+      signature_content = [token.to_s, timestamp.to_s, nonce.to_s].sort.join("")
+      Digest::SHA1.hexdigest(signature_content)
+    end
+
+    # Whether or not the signature is eql with local_signature
+    #
+    # @param [String] signature the signature value need validate
+    # @param [String] timestamp the timestamp value from weixin
+    # @param [String] nonce the nonce value
+    #
+    # @return [Boolean]
+    def valid_signature?(signature, timestamp, nonce)
+      token = Config.token
+
+      local_signature = generate_signature(token,timestamp,nonce)
+      local_signature.eql? signature
+    end
+
+    # initialize an TextReplyMessage
+    # @param [Hash] attributes
+    # @see 'spec/mp_weixin/models/reply_message_spec.rb'
+    def reply_text_message(attributes = {})
+      MpWeixin::TextReplyMessage.new(attributes)
+    end
+
+    # initialize an ImageReplyMessage
+    # @param [Hash] attributes
+    # @see 'spec/mp_weixin/models/reply_message_spec.rb'
+    def reply_image_message(attributes = {}, &block)
+      reply_message = MpWeixin::ImageReplyMessage.new(attributes)
+      block.call(reply_message) if block_given?
+
+      reply_message
+    end
+
+    # initialize an VoiceReplyMessage
+    # @param [Hash] attributes
+    # @see 'spec/mp_weixin/models/reply_message_spec.rb'
+    def reply_voice_message(attributes = {}, &block)
+      reply_message = MpWeixin::VoiceReplyMessage.new(attributes)
+      block.call(reply_message) if block_given?
+
+      reply_message
+    end
+
+    # initialize an VideoReplyMessage
+    # @param [Hash] attributes
+    # @see 'spec/mp_weixin/models/reply_message_spec.rb'
+    def reply_video_message(attributes = {}, &block)
+      reply_message = MpWeixin::VideoReplyMessage.new(attributes)
+      block.call(reply_message) if block_given?
+
+      reply_message
+    end
+
+    # initialize an MusicReplyMessage
+    # @param [Hash] attributes
+    # @see 'spec/mp_weixin/models/reply_message_spec.rb'
+    def reply_music_message(attributes = {}, &block)
+      reply_message = MpWeixin::MusicReplyMessage.new(attributes)
+      block.call(reply_message) if block_given?
+
+      reply_message
+    end
+
+    # initialize an NewsReplyMessage
+    # @param [Hash] attributes
+    # @see 'spec/mp_weixin/models/reply_message_spec.rb'
+    def reply_news_message(attributes = {}, &block)
+      reply_message = MpWeixin::NewsReplyMessage.new(attributes)
+
+      block.call(reply_message) if block_given?
+
+      reply_message
+    end
+  end
+end

data/lib/mp_weixin/version.rb

@@ -0,0 +1,3 @@
+module MpWeixin
+  VERSION = "0.1.0"
+end

data/lib/support/active_model.rb

@@ -0,0 +1,3 @@
+if ActiveModel::VERSION::MAJOR < 4
+  require 'support/active_model/model'
+end

data/lib/support/active_model/model.rb

@@ -0,0 +1,99 @@
+module ActiveModel
+
+  # == Active \Model Basic \Model
+  #
+  # Includes the required interface for an object to interact with
+  # <tt>ActionPack</tt>, using different <tt>ActiveModel</tt> modules.
+  # It includes model name introspections, conversions, translations and
+  # validations. Besides that, it allows you to initialize the object with a
+  # hash of attributes, pretty much like <tt>ActiveRecord</tt> does.
+  #
+  # A minimal implementation could be:
+  #
+  #   class Person
+  #     include ActiveModel::Model
+  #     attr_accessor :name, :age
+  #   end
+  #
+  #   person = Person.new(name: 'bob', age: '18')
+  #   person.name # => 'bob'
+  #   person.age  # => 18
+  #
+  # Note that, by default, <tt>ActiveModel::Model</tt> implements <tt>persisted?</tt>
+  # to return +false+, which is the most common case. You may want to override
+  # it in your class to simulate a different scenario:
+  #
+  #   class Person
+  #     include ActiveModel::Model
+  #     attr_accessor :id, :name
+  #
+  #     def persisted?
+  #       self.id == 1
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.persisted? # => true
+  #
+  # Also, if for some reason you need to run code on <tt>initialize</tt>, make
+  # sure you call +super+ if you want the attributes hash initialization to
+  # happen.
+  #
+  #   class Person
+  #     include ActiveModel::Model
+  #     attr_accessor :id, :name, :omg
+  #
+  #     def initialize(attributes={})
+  #       super
+  #       @omg ||= true
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.omg # => true
+  #
+  # For more detailed information on other functionalities available, please
+  # refer to the specific modules included in <tt>ActiveModel::Model</tt>
+  # (see below).
+  module Model
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        extend  ActiveModel::Naming
+        extend  ActiveModel::Translation
+        include ActiveModel::Validations
+        include ActiveModel::Conversion
+      end
+    end
+
+    # Initializes a new model with the given +params+.
+    #
+    #   class Person
+    #     include ActiveModel::Model
+    #     attr_accessor :name, :age
+    #   end
+    #
+    #   person = Person.new(name: 'bob', age: '18')
+    #   person.name # => "bob"
+    #   person.age  # => 18
+    def initialize(params={})
+      params.each do |attr, value|
+        self.public_send("#{attr}=", value)
+      end if params
+
+      super()
+    end
+
+    # Indicates if the model is persisted. Default is +false+.
+    #
+    #  class Person
+    #    include ActiveModel::Model
+    #    attr_accessor :id, :name
+    #  end
+    #
+    #  person = Person.new(id: 1, name: 'bob')
+    #  person.persisted? # => false
+    def persisted?
+      false
+    end
+  end
+end

data/mp_weixin.gemspec

@@ -0,0 +1,44 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mp_weixin/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mp_weixin"
+  spec.version       = MpWeixin::VERSION
+  spec.authors       = ["jhjguxin"]
+  spec.email         = ["864248765@qq.com"]
+  spec.description   = %q{A wrapper for weiXin MP platform}
+  spec.summary       = %q{A Ruby wrapper for weixin MP platform}
+  spec.homepage      = "https://github.com/jhjguxin/mp_weixin"
+  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_dependency "oauth2", [">= 0.5","<= 0.9"]
+  spec.add_dependency "sinatra", "~> 1.4.4"
+  spec.add_dependency "activemodel", [">= 3.0","<= 4"]
+  spec.add_dependency 'multi_json', '>= 1.7.9'
+  spec.add_dependency 'multi_xml', '>= 0.5.2'
+  spec.add_dependency 'roxml'
+  spec.add_dependency 'nestful'
+  # spec.add_dependency "data_mapper", "~> 1.2.0"
+  # spec.add_dependency "dm-sqlite-adapter", "~> 1.2.0"
+
+  spec.add_development_dependency "thin"
+  spec.add_development_dependency "debugger"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rack-test'
+  # Code coverage for Ruby 1.9+ with a powerful configuration library and automatic merging of coverage across test suites
+  spec.add_development_dependency 'simplecov'
+  # WebMock allows stubbing HTTP requests and setting expectations on HTTP requests.
+  spec.add_development_dependency 'webmock'
+  # A Ruby implementation of the Coveralls API.
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "travis-lint"
+end

data/spec/client_spec.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe MpWeixin::Client do
+  let(:client) { MpWeixin::Client.new }
+  let(:access_token) { 'ACCESS_TOKEN' }
+  let(:token_hash) { {"expires_in" => "7200", "access_token" => access_token} }
+
+
+  context "#initialize config" do
+    it "should have correct site" do
+      client.site.should eq("https://api.weixin.qq.com/")
+    end
+
+    # it "should have correct authorize url" do
+    #   client.options[:authorize_url].should eq('/oauth/authorize')
+    # end
+
+    it "should have correct token url" do
+      client.options[:token_url].should eq('/cgi-bin/token')
+    end
+
+    it 'is_authorized? should been false' do
+      expect(subject.is_authorized?).to eq(false)
+    end
+  end
+
+  context "#taken_code" do
+    let(:json_token) {MultiJson.encode(:expires_in => 7200, :access_token => 'salmon')}
+
+    let(:client) do
+      MpWeixin::Client.new do |builder|
+        builder.request :url_encoded
+        builder.adapter :test do |stub|
+          stub.get("/cgi-bin/token") do |env|
+             [200, {'Content-Type' => 'application/json'}, json_token]
+          end
+          stub.post('/cgi-bin/token') do |env|
+              [200, {'Content-Type' => 'application/json'}, json_token]
+          end
+        end
+      end
+    end
+
+    subject do
+      client.get_token
+      client
+    end
+
+
+    it "returns AccessToken with #token" do
+      expect(subject.token.token).to eq('salmon')
+    end
+
+    it 'is_authorized? should been true' do
+      expect(subject.is_authorized?).to eq(true)
+    end
+  end
+
+  context "get_token_from_hash" do
+    subject { client.get_token_from_hash(token_hash) }
+
+    it "return token the initalized AccessToken" do
+      expect(subject).to be_a(MpWeixin::AccessToken)
+    end
+
+    it "return token with provide access_token" do
+      expect(subject.token).to eq(access_token)
+    end
+  end
+
+  context "#from_hash" do
+    subject { MpWeixin::Client.from_hash(token_hash) }
+
+    it "return client the initalized Client" do
+      expect(subject).to be_a(MpWeixin::Client)
+    end
+
+    it "return token with provide access_token" do
+      expect(subject.token.token).to eq(access_token)
+    end
+
+    it 'is_authorized? should been true' do
+      expect(subject.is_authorized?).to eq(true)
+    end
+  end
+end

data/spec/mp_weixin/access_token_spec.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe MpWeixin::AccessToken do
+  let(:token) {'ACCESS_TOKEN'}
+  let(:refresh_token) {'REFRESH_TOKEN'}
+  let(:token_body) {MultiJson.encode(:access_token => 'ACCESS_TOKEN', :expires_in => 7200)}
+  let(:client) do
+    MpWeixin::Client.new do |builder|
+      builder.request :url_encoded
+      builder.adapter :test do |stub|
+        stub.send(:get, "/cgi-bin/token") {|env| [200, {'Content-Type' => 'application/json'}, token_body]}
+        stub.send(:post, "/cgi-bin/token") {|env| [200, {'Content-Type' => 'application/json'}, token_body]}
+
+        # stub.post('/sns/oauth2/access_token') {|env| [200, {'Content-Type' => 'application/json'}, refresh_body]}
+      end
+    end
+  end
+
+  subject {MpWeixin::AccessToken.new(client, token)}
+
+  describe "#initialize" do
+    it "assigns client and token" do
+      expect(subject.client).to eq(client)
+      expect(subject.token).to  eq(token)
+    end
+
+    it "assigns extra params" do
+      target = MpWeixin::AccessToken.new(client, token, 'foo' => 'bar')
+      expect(target.params).to include('foo')
+      expect(target.params['foo']).to eq('bar')
+    end
+
+    def assert_initialized_token(target)
+      expect(target.token).to eq(token)
+      expect(target).to be_expires
+      expect(target.params.keys).to include('foo')
+      expect(target.params['foo']).to eq('bar')
+    end
+
+    it "initializes with a Hash" do
+      hash = {:access_token => token, :expires_in => Time.now.to_i + 200, 'foo' => 'bar'}
+      target = MpWeixin::AccessToken.from_hash(client, hash)
+      assert_initialized_token(target)
+    end
+
+    it "initializes with a string expires_in" do
+      hash = {:access_token => token, :expires_in => '1361396829', 'foo' => 'bar'}
+      target = MpWeixin::AccessToken.from_hash(client, hash)
+      assert_initialized_token(target)
+      expect(target.expires_in).to be_a(Integer)
+    end
+  end
+
+  describe "#request" do
+
+    context ":mode => :body" do
+      before do
+        subject.options[:mode] = :body
+      end
+
+      it "sends the token in the Authorization header for a GET request" do
+        expect(subject.post("/cgi-bin/token").body).to include(token)
+      end
+
+      it "sends the token in the Authorization header for a POST request" do
+        expect(subject.post("/cgi-bin/token").body).to include(token)
+      end
+    end
+  end
+
+  describe "#expires?" do
+    it "is false if there is no expires_at" do
+      expect(MpWeixin::AccessToken.new(client, token)).not_to be_expires
+    end
+
+    it "is true if there is an expires_in" do
+      expect(MpWeixin::AccessToken.new(client, token, :refresh_token => 'REFRESH_TOKEN', :expires_in => 600)).to be_expires
+    end
+
+  end
+
+  describe "#expired?" do
+    it "is false if there is no expires_in or expires_at" do
+      expect(MpWeixin::AccessToken.new(client, token)).not_to be_expired
+    end
+
+    it "is false if expires_in is in the future" do
+      expect(MpWeixin::AccessToken.new(client, token, :refresh_token => 'REFRESH_TOKEN', :expires_in => 10800)).not_to be_expired
+    end
+
+    it "is true if expires_at is in the past" do
+      access = MpWeixin::AccessToken.new(client, token, :refresh_token => 'REFRESH_TOKEN', :expires_in => 7200)
+      @now = Time.now + 10800
+
+      # You can't double a constance by either allow or double. Instead you need to use stub_const
+      # https://www.relishapp.com/rspec/rspec-mocks/v/2-14/docs/mutating-constants
+
+      # Make a mock of Notifier at first
+      stub_const "Time", Time
+      # Then stub the methods of Notifier
+      Time.stub(:now) { @now }
+
+      expect(access).to be_expired
+    end
+
+  end
+
+  describe "#refresh!" do
+    let(:access) {
+      MpWeixin::AccessToken.new(client, token, :refresh_token  => 'REFRESH_TOKEN',
+                                     :expires_in     => 7200,
+                                     :param_name     => 'o_param')
+    }
+
+    it "returns a refresh token with appropriate values carried over" do
+      refreshed = access.refresh!
+      expect(access.client).to eq(refreshed.client)
+      expect(access.options[:param_name]).to eq(refreshed.options[:param_name])
+    end
+
+    context "with a nil refresh_token in the response" do
+      let(:refresh_body) { MultiJson.encode(:access_token => 'refreshed_foo', :expires_in => 600, :refresh_token => nil) }
+
+      it "copies the refresh_token from the original token" do
+        refreshed = access.refresh!
+
+        expect(refreshed.refresh_token).to eq(access.refresh_token)
+      end
+    end
+  end
+
+  describe '#to_hash' do
+    it 'return a hash equals to the hash used to initialize access token' do
+      hash = {:access_token => token, :refresh_token => 'foobar', :expires_at => Time.now.to_i + 200, 'foo' => 'bar'}
+      access_token = MpWeixin::AccessToken.from_hash(client, hash.dup)
+      expect(access_token.to_hash).to eq(hash)
+    end
+  end
+end