mp_weixin 0.1.0

data/lib/config/mp_weixin_error.yml

@@ -0,0 +1,82 @@
+mp_weixin_errors:
+  '-1': 系统繁忙
+  '0': 请求成功
+  '40001': 获取access_token时AppSecret错误，或者access_token无效
+  '40002': 不合法的凭证类型
+  '40003': 不合法的OpenID
+  '40004': 不合法的媒体文件类型
+  '40005': 不合法的文件类型
+  '40006': 不合法的文件大小
+  '40007': 不合法的媒体文件id
+  '40008': 不合法的消息类型
+  '40009': 不合法的图片文件大小
+  '40010': 不合法的语音文件大小
+  '40011': 不合法的视频文件大小
+  '40012': 不合法的缩略图文件大小
+  '40013': 不合法的APPID
+  '40014': 不合法的access_token
+  '40015': 不合法的菜单类型
+  '40016': 不合法的按钮个数
+  '40017': 不合法的按钮个数
+  '40018': 不合法的按钮名字长度
+  '40019': 不合法的按钮KEY长度
+  '40020': 不合法的按钮URL长度
+  '40021': 不合法的菜单版本号
+  '40022': 不合法的子菜单级数
+  '40023': 不合法的子菜单按钮个数
+  '40024': 不合法的子菜单按钮类型
+  '40025': 不合法的子菜单按钮名字长度
+  '40026': 不合法的子菜单按钮KEY长度
+  '40027': 不合法的子菜单按钮URL长度
+  '40028': 不合法的自定义菜单使用用户
+  '40029': 不合法的oauth_code
+  '40030': 不合法的refresh_token
+  '40031': 不合法的openid列表
+  '40032': 不合法的openid列表长度
+  '40033': 不合法的请求字符，不能包含\uxxxx格式的字符
+  '40035': 不合法的参数
+  '40038': 不合法的请求格式
+  '40039': 不合法的URL长度
+  '40050': 不合法的分组id
+  '40051': 分组名字不合法
+  '41001': 缺少access_token参数
+  '41002': 缺少appid参数
+  '41003': 缺少refresh_token参数
+  '41004': 缺少secret参数
+  '41005': 缺少多媒体文件数据
+  '41006': 缺少media_id参数
+  '41007': 缺少子菜单数据
+  '41009': 缺少openid
+  '42001': access_token超时
+  '42002': refresh_token超时
+  '42003': oauth_code超时
+  '43001': 需要GET请求
+  '43002': 需要POST请求
+  '43003': 需要HTTPS请求
+  '43004': 需要接收者关注
+  '43005': 需要好友关系
+  '44001': 多媒体文件为空
+  '44002': POST的数据包为空
+  '44003': 图文消息内容为空
+  '44004': 文本消息内容为空
+  '45001': 多媒体文件大小超过限制
+  '45002': 消息内容超过限制
+  '45003': 标题字段超过限制
+  '45004': 描述字段超过限制
+  '45005': 链接字段超过限制
+  '45006': 图片链接字段超过限制
+  '45007': 语音播放时间超过限制
+  '45008': 图文消息超过限制
+  '45009': 接口调用超过限制
+  '45010': 创建菜单个数超过限制
+  '45015': 回复时间超过限制
+  '45016': 系统分组，不允许修改
+  '45017': 分组名字过长
+  '45018': 分组数量超过上限
+  '46001': 不存在媒体数据
+  '46002': 不存在的菜单版本
+  '46003': 不存在的菜单数据
+  '46004': 不存在的用户
+  '47001': 解析JSON/XML内容错误
+  '48001': api功能未授权
+  '50001': 用户未授权该api

data/lib/mp_weixin.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler/setup'
+
+if defined?(Bundler)
+  Bundler.require
+end
+
+require 'roxml'
+require 'multi_xml'
+require 'ostruct'
+
+require 'faraday'
+require 'active_model'
+require 'active_support/all'
+
+require 'support/active_model'
+
+require "mp_weixin/version"
+require "mp_weixin/config"
+require "mp_weixin/error"
+
+# require models
+
+# require client
+
+## require client dependence
+require "mp_weixin/response"
+require "mp_weixin/access_token"
+
+## require interface
+require "mp_weixin/interface/base"
+require "mp_weixin/interface/message"
+require "mp_weixin/interface/menu"
+require "mp_weixin/interface/promotion"
+require "mp_weixin/interface/group"
+require "mp_weixin/interface/user"
+
+require "mp_weixin/client"
+
+# require server
+require 'sinatra'
+require 'digest/md5'
+require 'rexml/document'
+
+# include base class Message
+# and some children class TextMessage, ImageMessage, LocationMessage,
+# LinkMessage, VoiceMessage, VideoMessage
+require 'mp_weixin/models/message'
+require 'mp_weixin/models/event'
+require 'mp_weixin/models/reply_message'
+# require 'mp_weixin/models/location_message'
+
+## require helpers
+require 'mp_weixin/server_helper'
+require 'mp_weixin/response_rule'
+
+require 'mp_weixin/server'

data/lib/mp_weixin/access_token.rb

@@ -0,0 +1,172 @@
+module MpWeixin
+  class AccessToken
+    attr_reader :client, :token, :expires_in, :expires_at, :params
+    attr_accessor :options, :refresh_token
+
+    class << self
+      # Initializes an AccessToken from a Hash
+      #
+      # @param [Client] the MpWeixin::Client instance
+      # @param [Hash] a hash of AccessToken property values
+      # @return [AccessToken] the initalized AccessToken
+      def from_hash(client, hash)
+        self.new(client, hash.delete('access_token') || hash.delete(:access_token), hash)
+      end
+
+      # Initializes an AccessToken from a key/value application/x-www-form-urlencoded string
+      #
+      # @param [Client] client the MpWeixin::Client instance
+      # @param [String] kvform the application/x-www-form-urlencoded string
+      # @return [AccessToken] the initalized AccessToken
+      def from_kvform(client, kvform)
+        from_hash(client, Rack::Utils.parse_query(kvform))
+      end
+    end
+
+    # Initalize an AccessToken
+    #
+    # @param [Client] client the MpWeixin::Client instance
+    # @param [String] token the Access Token value
+    # @param [Hash] opts the options to create the Access Token with
+    # @option opts [String] :refresh_token (nil) the refresh_token value
+    # @option opts [FixNum, String] :expires_in (nil) the number of seconds in which the AccessToken will expire
+    # @option opts [FixNum, String] :expires_at (nil) the epoch time in seconds in which AccessToken will expire
+    # @option opts [Symbol] :mode (:header) the transmission mode of the Access Token parameter value
+    #    one of :header, :body or :query
+    # @option opts [String] :header_format ('Bearer %s') the string format to use for the Authorization header
+    # @option opts [String] :param_name ('access_token') the parameter name to use for transmission of the
+    #    Access Token value in :body or :query transmission mode
+    def initialize(client, token, opts={})
+      @client = client
+      @token = token.to_s
+      [:refresh_token, :expires_in, :expires_at].each do |arg|
+        instance_variable_set("@#{arg}", opts.delete(arg) || opts.delete(arg.to_s))
+      end
+      @expires_in ||= opts.delete('expires')
+      @expires_in &&= @expires_in.to_i
+      @expires_at &&= @expires_at.to_i
+      @expires_at ||= Time.now.to_i + @expires_in if @expires_in
+      @options = {:mode          => opts.delete(:mode) || :header,
+                  :header_format => opts.delete(:header_format) || 'Bearer %s',
+                  :param_name    => opts.delete(:param_name) || 'access_token'}
+      @params = opts
+    end
+
+    # Indexer to additional params present in token response
+    #
+    # @param [String] key entry key to Hash
+    def [](key)
+      @params[key]
+    end
+
+    # Whether or not the token expires
+    #
+    # @return [Boolean]
+    def expires?
+      !!@expires_at
+    end
+
+    # Whether or not the token is expired
+    #
+    # @return [Boolean]
+    def expired?
+      expires? && (expires_at < Time.now.to_i)
+    end
+
+    # Refreshes the current Access Token
+    #
+    # @return [AccessToken] a new AccessToken
+    # @note options should be carried over to the new AccessToken
+    def refresh!(params={})
+      raise "A refresh_token is not available" unless refresh_token
+      params.merge!(:client_id      => @client.id,
+                    :client_secret  => @client.secret,
+                    :grant_type     => 'client_credential'
+                   )
+      new_token = @client.get_token(params)
+      new_token.options = options
+      new_token.refresh_token = refresh_token unless new_token.refresh_token
+      new_token
+    end
+
+    # Convert AccessToken to a hash which can be used to rebuild itself with AccessToken.from_hash
+    #
+    # @return [Hash] a hash of AccessToken property values
+    def to_hash
+      params.merge({:access_token => token, :refresh_token => refresh_token, :expires_at => expires_at})
+    end
+
+    # Make a request with the Access Token
+    #
+    # @param [Symbol] verb the HTTP request method
+    # @param [String] path the HTTP URL path of the request
+    # @param [Hash] opts the options to make the request with
+    # @see Client#request
+    def request(verb, path, opts={}, &block)
+      set_token(opts)
+      @client.request(verb, path, opts, &block)
+    end
+
+    # Make a GET request with the Access Token
+    #
+    # @see AccessToken#request
+    def get(path, opts={}, &block)
+      request(:get, path, opts, &block)
+    end
+
+    # Make a POST request with the Access Token
+    #
+    # @see AccessToken#request
+    def post(path, opts={}, &block)
+      request(:post, path, opts, &block)
+    end
+
+    # Make a PUT request with the Access Token
+    #
+    # @see AccessToken#request
+    def put(path, opts={}, &block)
+      request(:put, path, opts, &block)
+    end
+
+    # Make a PATCH request with the Access Token
+    #
+    # @see AccessToken#request
+    def patch(path, opts={}, &block)
+      request(:patch, path, opts, &block)
+    end
+
+    # Make a DELETE request with the Access Token
+    #
+    # @see AccessToken#request
+    def delete(path, opts={}, &block)
+      request(:delete, path, opts, &block)
+    end
+
+    # Get the headers hash (includes Authorization token)
+    def headers
+      { 'Authorization' => options[:header_format] % token }
+    end
+
+  private
+    def set_token(opts)
+      case options[:mode]
+      when :header
+        opts[:headers] ||= {}
+        opts[:headers].merge!(headers)
+      when :query
+        opts[:params] ||= {}
+        opts[:params][options[:param_name]] = token
+      when :body
+        opts[:body] ||= {}
+        if opts[:body].is_a?(Hash)
+          opts[:body][options[:param_name]] = token
+        else
+          opts[:body] << "&#{options[:param_name]}=#{token}"
+        end
+        # @todo support for multi-part (file uploads)
+      else
+        raise "invalid :mode option of #{options[:mode]}"
+      end
+    end
+  end
+end

data/lib/mp_weixin/client.rb

@@ -0,0 +1,199 @@
+# encoding: utf-8
+module MpWeixin
+  # The MpWeixin::Client class
+  # reference to The OAuth2::Client class
+  class Client
+    attr_reader :id, :secret, :site
+    attr_accessor :options, :token
+    attr_writer :connection
+
+    # Instantiate a new client using the
+    # Client ID and Client Secret registered to your
+    # weixin mp account.
+    #
+    # @param [String] app_id the app_id value
+    # @param [String] app_secret the app_secret value
+    # @param [Hash] opts the options to create the client with
+    # @option opts [String] :site the site host provider to connection
+    # @option opts [String] :authorize_url ('/oauth/authorize') absolute or relative URL path to the Authorization endpoint
+    # @option opts [String] :token_url ('/oauth/token') absolute or relative URL path to the Token endpoint
+    # @option opts [Hash] :connection_opts ({}) Hash of connection options to pass to initialize Faraday with
+    # @option opts [Boolean] :raise_errors (true) whether or not to raise an MpWeixin::Error
+    #  on responses with 400+ status codes
+    # @yield [builder] The Faraday connection builder
+    def initialize(app_id = nil, app_secret = nil, opts={}, &block)
+      _opts = opts.dup
+      @id = app_id || Config.app_id
+      @secret = app_secret || Config.app_secret
+      @site = _opts.delete(:site) || "https://api.weixin.qq.com/"
+      ssl = _opts.delete(:ssl)
+      @options = {:authorize_url    => '/oauth/authorize',
+                  :token_url        => '/cgi-bin/token',
+                  :token_method     => :post,
+                  :connection_opts  => {},
+                  :connection_build => block,
+                  :raise_errors     => true}.merge(_opts)
+      @options[:connection_opts][:ssl] = ssl if ssl
+    end
+
+    # Whether or not the client is authorized
+    #
+    # @return [Boolean]
+    def is_authorized?
+      !!token && !token.expired?
+    end
+
+    # Set the site host
+    #
+    # @param [String] the MpWeixin provider site host
+    def site=(value)
+      @connection = nil
+      @site = value
+    end
+
+    # The Faraday connection object
+    def connection
+      @connection ||= begin
+        conn = Faraday.new(site, options[:connection_opts])
+        conn.build do |b|
+          options[:connection_build].call(b)
+        end if options[:connection_build]
+        conn
+      end
+    end
+
+    # Makes a request relative to the specified site root.
+    #
+    # @param [Symbol] verb one of :get, :post, :put, :delete
+    # @param [String] url URL path of request
+    # @param [Hash] opts the options to make the request with
+    # @option opts [Hash] :params additional query parameters for the URL of the request
+    # @option opts [Hash, String] :body the body of the request
+    # @option opts [Hash] :headers http request headers
+    # @option opts [Boolean] :raise_errors whether or not to raise an MpWeixin::Error on 400+ status
+    def request(verb, url, opts={})
+      url = self.connection.build_url(url, opts[:params]).to_s
+
+      response = connection.run_request(verb, url, opts[:body], opts[:headers]) do |req|
+        yield(req) if block_given?
+      end
+      response = Response.new(response, :parse => opts[:parse])
+
+      case response.status
+      when 301, 302, 303, 307
+        opts[:redirect_count] ||= 0
+        opts[:redirect_count] += 1
+        return response if opts[:redirect_count] > options[:max_redirects]
+        if response.status == 303
+          verb = :get
+          opts.delete(:body)
+        end
+        request(verb, response.headers['location'], opts)
+      when 200..299, 300..399
+        # on non-redirecting 3xx statuses, just return the response
+        response
+      when 400..599
+        e = Error.new(response)
+        raise e if opts.fetch(:raise_errors, options[:raise_errors])
+        response.error = e
+        response
+      else
+        raise Error.new(response), "Unhandled status code value of #{response.status}"
+      end
+    end
+
+    # The authorize endpoint URL of the MpWeixin provider
+    #
+    # @param [Hash] params additional query parameters
+    def authorize_url(params=nil)
+      connection.build_url(options[:authorize_url], params).to_s
+    end
+
+    # The token endpoint URL of the MpWeixin provider
+    #
+    # @param [Hash] params additional query parameters
+    def token_url(params=nil)
+      connection.build_url(options[:token_url], params).to_s
+    end
+
+    # Initializes an AccessToken by making a request to the token endpoint
+    #
+    # @param [Hash] params a Hash of params for the token endpoint
+    # @param [Hash] access token options, to pass to the AccessToken object
+    # @param [Class] class of access token for easier subclassing MpWeixin::AccessToken
+    # @return [AccessToken] the initalized AccessToken
+    def get_token(params = {}, access_token_opts = {}, access_token_class = AccessToken)
+      params = ActiveSupport::HashWithIndifferentAccess.new(params)
+      params.reverse_merge!(grant_type: "client_credential", appid: id, secret: secret)
+
+      opts = {:raise_errors => options[:raise_errors], :parse => params.delete(:parse)}
+      if options[:token_method] == :post
+        headers = params.delete(:headers)
+        opts[:body] = params
+        opts[:headers] =  {'Content-Type' => 'application/x-www-form-urlencoded'}
+        opts[:headers].merge!(headers) if headers
+      else
+        opts[:params] = params
+      end
+      response = request(options[:token_method], token_url, opts)
+      raise Error.new(response) if options[:raise_errors] && !(response.parsed.is_a?(Hash) && response.parsed['access_token'])
+      @token = access_token_class.from_hash(self, response.parsed.merge(access_token_opts))
+    end
+
+    # Initializes an AccessToken from a hash
+    #
+    # @param [Hash] hash a Hash contains access_token and expires
+    # @return [AccessToken] the initalized AccessToken
+    def get_token_from_hash(hash)
+      access_token = hash.delete('access_token') || hash.delete(:access_token) || hash.delete('oauth_token') || hash.delete(:oauth_token)
+      opts = {:expires_at => hash["expires"] || hash[:expires],
+              :header_format => "OAuth2 %s",
+              :param_name => "access_token"}
+
+      @token = AccessToken.new(self, access_token, opts)
+    end
+
+    # Initializes a new Client from a hash
+    #
+    # @param [Hash] a Hash contains access_token and expires
+    # @param [Hash] opts the options to create the client with
+    # @option opts [Hash] :connection_opts ({}) Hash of connection options to pass to initialize Faraday with
+    # @option opts [FixNum] :max_redirects (5) maximum number of redirects to follow
+    # @yield [builder] The Faraday connection builder
+    def self.from_hash(hash, opts={}, &block)
+      client = self.new(opts, &block)
+      client.get_token_from_hash(hash)
+
+      client
+    end
+
+    #
+    # APIs
+    #
+
+    # assocation an Interface::Message instance to client
+    def message
+      @message ||= Interface::Message.new(self)
+    end
+
+    # assocation an Interface::Menu instance to client
+    def menu
+      @menu ||= Interface::Menu.new(self)
+    end
+
+    # assocation an Interface::Promotion instance to client
+    def promotion
+      @promotion ||= Interface::Promotion.new(self)
+    end
+
+    # assocation an Interface::Group instance to client
+    def group
+      @group ||= Interface::Group.new(self)
+    end
+
+    # assocation an Interface::User instance to client
+    def user
+      @user ||= Interface::User.new(self)
+    end
+  end
+end