wechat 0.2.0

data/lib/wechat/client.rb

@@ -0,0 +1,79 @@
+require 'rest_client'
+
+module Wechat
+  class Client
+    attr_reader :base
+
+    def initialize(base)
+      @base = base
+    end
+
+    def get(path, header = {}, verify_ssl = true)
+      request(path, header) do |url, header|
+        if verify_ssl
+          RestClient.get(url, header)
+        else
+          RestClient::Request.execute(url: url, method: :get, headers: header, verify_ssl: OpenSSL::SSL::VERIFY_NONE)
+        end
+      end
+    end
+
+    def post(path, payload, header = {}, verify_ssl = true)
+      request(path, header) do |url, header|
+        if verify_ssl
+          RestClient.post(url, payload, header)
+        else
+          RestClient::Request.execute(url: url, method: :post, payload: payload, headers: header, verify_ssl: OpenSSL::SSL::VERIFY_NONE)
+        end
+      end
+    end
+
+    def request(path, header = {}, &block)
+      url = "#{header.delete(:base) || self.base}#{path}"
+      as = header.delete(:as)
+      header.merge!(:accept => :json)
+      response = yield(url, header)
+
+      raise "Request not OK, response code #{response.code}" if response.code != 200
+      parse_response(response, as || :json) do |parse_as, data|
+        break data unless parse_as == :json && data['errcode'].present?
+
+        case data['errcode']
+        when 0 # for request didn't expect results
+          data
+        when 42_001, 40_014 # 42001: access_token超时, 40014:不合法的access_token
+          raise AccessTokenExpiredError
+        else
+          raise ResponseError.new(data['errcode'], data['errmsg'])
+        end
+      end
+    end
+
+    private
+
+    def parse_response(response, as)
+      content_type = response.headers[:content_type]
+      parse_as = {
+        /^application\/json/ => :json,
+        /^image\/.*/ => :file
+      }.inject([]){ |memo, match| memo << match[1] if content_type =~ match[0]; memo }.first || as || :text
+
+      case parse_as
+      when :file
+        file = Tempfile.new('tmp')
+        file.binmode
+        file.write(response.body)
+        file.close
+        data = file
+
+      when :json
+        data = JSON.parse(response.body.gsub /[\u0000-\u001f]+/, '')
+
+      else
+        data = response.body
+      end
+
+      yield(parse_as, data)
+    end
+  end
+end

data/lib/wechat/corp_api.rb

@@ -0,0 +1,66 @@
+require 'wechat/client'
+require 'wechat/access_token'
+
+class Wechat::CorpAccessToken < Wechat::AccessToken
+  def refresh
+    data = client.get('gettoken', { params: { corpid: appid, corpsecret: secret }}, false)
+    data.merge!(created_at: Time.now.to_i)
+    File.open(token_file, 'w') { |f| f.write(data.to_json) } if valid_token(data)
+    @token_data = data
+  end
+end
+
+class Wechat::CorpApi
+  attr_reader :access_token, :client, :agentid
+
+  API_BASE = 'https://qyapi.weixin.qq.com/cgi-bin/'
+
+  def initialize(appid, secret, token_file, agentid)
+    @client = Wechat::Client.new(API_BASE)
+    @access_token = Wechat::CorpAccessToken.new(@client, appid, secret, token_file)
+    @agentid = agentid
+  end
+
+  def user(userid)
+    get('user/get', params: { userid: userid })
+  end
+
+  def menu
+    get('menu/get', params: { agentid: agentid })
+  end
+
+  def menu_delete
+    get('menu/delete', params: { agentid: agentid })
+  end
+
+  def menu_create(menu)
+    # 微信不接受7bit escaped json(eg \uxxxx), 中文必须UTF-8编码, 这可能是个安全漏洞
+    post 'menu/create', JSON.generate(menu), { params: { agentid: agentid } }
+  end
+
+  def message_send(message)
+    post 'message/send', message.agent_id(agentid).to_json, content_type: :json
+  end
+
+  protected
+
+  def get(path, headers = {})
+    with_access_token(headers[:params]) do |params|
+      client.get path, headers.merge(params: params), false
+    end
+  end
+
+  def post(path, payload, headers = {})
+    with_access_token(headers[:params]) do |params|
+      client.post path, payload, headers.merge(params: params), false
+    end
+  end
+
+  def with_access_token(params = {}, tries = 2)
+    params ||= {}
+    yield(params.merge(access_token: access_token.token))
+  rescue Wechat::AccessTokenExpiredError
+    access_token.refresh
+    retry unless (tries -= 1).zero?
+  end
+end

data/lib/wechat/jsapi_ticket.rb

@@ -0,0 +1,86 @@
+require 'digest/sha1'
+
+module Wechat
+  class JsapiTicket
+    attr_reader :client, :access_token, :jsapi_ticket_file, :jsapi_ticket_data
+
+    def initialize(client, access_token, jsapi_ticket_file)
+      @client = client
+      @access_token = access_token
+      @jsapi_ticket_file = jsapi_ticket_file
+    end
+
+    #  获取微信 jssdk 签名所需的 jsapi_ticket, 返回具有如下结构的 hash:
+    #  {
+    #    "errcode":0,
+    #    "errmsg":"ok",
+    #    "ticket":"bxLdikRXVbTPdHSM05e5u5sUoXNKd8-41ZO3MhKoyN5OfkWITDGgnr2fwJ0m9E8NYzWKVZvdVtaUgWvsdshFKA",
+    #    "expires_in":7200
+    #  }
+    def ticket
+      begin
+        @jsapi_ticket_data ||= JSON.parse(File.read(jsapi_ticket_file))
+        created_at = jsapi_ticket_data['created_at'].to_i
+        expires_in = jsapi_ticket_data['expires_in'].to_i
+        if Time.now.to_i - created_at >= expires_in - 3 * 60
+          raise 'jsapi_ticket may be expired'
+        end
+      rescue
+        refresh
+      end
+      valid_ticket(@jsapi_ticket_data)
+    end
+
+    # 刷新 jsapi_ticket
+    def refresh
+      data = client.get('ticket/getticket', params: { access_token: access_token.token, type: 'jsapi' })
+      data.merge!(created_at: Time.now.to_i)
+      File.open(jsapi_ticket_file, 'w') { |f| f.write(data.to_json) } if valid_ticket(data)
+      @jsapi_ticket_data = data
+    end
+
+    # 获取 jssdk 签名及注册所需其他参数, 返回具有如下结构的 hash:
+    #  params = {
+    #    noncestr: noncestr,
+    #    timestamp: timestamp,
+    #    jsapi_ticket: ticket,
+    #    url: url,
+    #    signature: signature
+    #  }
+    def signature(url)
+      timestamp = Time.now.to_i
+      noncestr = generate_noncestr
+      params = {
+        noncestr: noncestr,
+        timestamp: timestamp,
+        jsapi_ticket: ticket,
+        url: url
+      }
+      pairs = params.keys.sort.map do |key|
+        "#{key}=#{params[key]}"
+      end
+      result = Digest::SHA1.hexdigest pairs.join('&')
+      params.merge(signature: result)
+    end
+
+    private
+
+    def valid_ticket(jsapi_ticket_data)
+      ticket = jsapi_ticket_data['ticket'] || jsapi_ticket_data[:ticket]
+      raise "Response didn't have ticket" if  ticket.blank?
+      ticket
+    end
+
+    # 生成随机字符串
+    # @param  Integer length 长度, 默认为16
+    # @return String
+    def generate_noncestr(length = 16)
+      chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+      str = ''
+      1.upto(length) do |i|
+        str += chars[rand(chars.length)]
+      end
+      str
+    end
+  end
+end

data/lib/wechat/message.rb

@@ -0,0 +1,176 @@
+module Wechat
+  class Message
+    class << self
+      def from_hash(message_hash)
+        new(message_hash)
+      end
+
+      def to(to_user)
+        new(ToUserName: to_user, CreateTime: Time.now.to_i)
+      end
+    end
+
+    class ArticleBuilder
+      attr_reader :items
+      delegate :count, to: :items
+      def initialize
+        @items = []
+      end
+
+      def item(title: 'title', description: nil, pic_url: nil, url: nil)
+        items << { Title: title, Description: description, PicUrl: pic_url, Url: url }.reject { |_k, v| v.nil? }
+      end
+    end
+
+    attr_reader :message_hash
+
+    def initialize(message_hash)
+      @message_hash = message_hash || {}
+    end
+
+    def [](key)
+      message_hash[key]
+    end
+
+    def reply
+      Message.new(
+        ToUserName: message_hash[:FromUserName],
+        FromUserName: message_hash[:ToUserName],
+        CreateTime: Time.now.to_i
+      )
+    end
+
+    def as(type)
+      case type
+      when :text
+        message_hash[:Content]
+
+      when :image, :voice, :video
+        Wechat.api.media(message_hash[:MediaId])
+
+      when :location
+        message_hash.slice(:Location_X, :Location_Y, :Scale, :Label).inject({}) { |results, value|
+          results[value[0].to_s.underscore.to_sym] = value[1]; results }
+      else
+        raise "Don't know how to parse message as #{type}"
+      end
+    end
+
+    def to(openid)
+      update(ToUserName: openid)
+    end
+
+    def agent_id(agentid)
+      update(AgentId: agentid)
+    end
+
+    def text(content)
+      update(MsgType: 'text', Content: content)
+    end
+
+    def image(media_id)
+      update(MsgType: 'image', Image: { MediaId: media_id })
+    end
+
+    def voice(media_id)
+      update(MsgType: 'voice', Voice: { MediaId: media_id })
+    end
+
+    def video(media_id, opts = {})
+      video_fields = camelize_hash_keys({ media_id: media_id }.merge(opts.slice(:title, :description)))
+      update(MsgType: 'video', Video: video_fields)
+    end
+
+    def music(thumb_media_id, music_url, opts = {})
+      music_fields = camelize_hash_keys(opts.slice(:title, :description, :HQ_music_url).merge(music_url: music_url, thumb_media_id: thumb_media_id))
+      update(MsgType: 'music', Music: music_fields)
+    end
+
+    def news(collection, &block)
+      if block_given?
+        article = ArticleBuilder.new
+        collection.each { |item| yield(article, item) }
+        items = article.items
+      else
+        items = collection.collect do |item|
+          camelize_hash_keys(item.symbolize_keys.slice(:title, :description, :pic_url, :url).reject { |_k, v| v.nil? })
+        end
+      end
+
+      update(MsgType: 'news', ArticleCount: items.count,
+             Articles: items.collect { |item| camelize_hash_keys(item) })
+    end
+
+    def template(opts = {})
+      template_fields = camelize_hash_keys(opts.symbolize_keys.slice(:template_id, :topcolor, :url, :data))
+      update(MsgType: 'template', Template: template_fields)
+    end
+
+    def to_xml
+      message_hash.to_xml(root: 'xml', children: 'item', skip_instruct: true, skip_types: true)
+    end
+
+    TO_JSON_KEY_MAP = {
+      'ToUserName' => 'touser',
+      'MediaId' => 'media_id',
+      'ThumbMediaId' => 'thumb_media_id',
+      'TemplateId' => 'template_id'
+    }
+
+    TO_JSON_ALLOWED = %w(touser msgtype content image voice video music news articles template agentid)
+
+    def to_json
+      json_hash = deep_recursive(message_hash) do |key, value|
+        key = key.to_s
+        [(TO_JSON_KEY_MAP[key] || key.downcase), value]
+      end
+
+      json_hash = json_hash.select { |k, _v| TO_JSON_ALLOWED.include? k }
+      case json_hash['msgtype']
+      when 'text'
+        json_hash['text'] = { 'content' => json_hash.delete('content') }
+      when 'news'
+        json_hash['news'] = { 'articles' => json_hash.delete('articles') }
+      when 'template'
+        json_hash.merge! json_hash['template']
+      end
+      JSON.generate(json_hash)
+    end
+
+    def save_to!(model_class)
+      model = model_class.new(underscore_hash_keys(message_hash))
+      model.save!
+      self
+    end
+
+    private
+
+    def camelize_hash_keys(hash)
+      deep_recursive(hash) { |key, value| [key.to_s.camelize.to_sym, value] }
+    end
+
+    def underscore_hash_keys(hash)
+      deep_recursive(hash) { |key, value| [key.to_s.underscore.to_sym, value] }
+    end
+
+    def update(fields = {})
+      message_hash.merge!(fields)
+      self
+    end
+
+    def deep_recursive(hash, &block)
+      hash.inject({}) do |memo, val|
+        key, value = *val
+        case value.class.name
+        when 'Hash'
+          value = deep_recursive(value, &block)
+        when 'Array'
+          value = value.collect { |item| item.is_a?(Hash) ? deep_recursive(item, &block) : item }
+        end
+
+        key, value = yield(key, value)
+        memo.merge!(key => value)
+      end
+    end
+  end
+end

data/lib/wechat/responder.rb

@@ -0,0 +1,177 @@
+require 'English'
+
+module Wechat
+  module Responder
+    extend ActiveSupport::Concern
+    include Cipher
+
+    included do
+      skip_before_filter :verify_authenticity_token
+      before_filter :verify_signature, only: [:show, :create]
+      #delegate :wechat, to: :class
+    end
+
+    module ClassMethods
+      attr_accessor :wechat, :token, :corpid, :agentid, :encrypt_mode, :encoding_aes_key
+
+      def on(message_type, with: nil, respond: nil, &block)
+        raise 'Unknow message type' unless message_type.in? [:text, :image, :voice, :video, :location, :link, :event, :fallback]
+        config = respond.nil? ? {} : { respond: respond }
+        config.merge!(proc: block) if block_given?
+
+        if with.present? && !message_type.in?([:text, :event])
+          raise 'Only text and event message can take :with parameters'
+        else
+          config.merge!(with: with) if with.present?
+        end
+
+        responders(message_type) << config
+        config
+      end
+
+      def responders(type)
+        @responders ||= {}
+        @responders[type] ||= []
+      end
+
+      def responder_for(message, &block)
+        message_type = message[:MsgType].to_sym
+        responders = responders(message_type)
+
+        case message_type
+        when :text
+          yield(* match_responders(responders, message[:Content]))
+
+        when :event
+          if message[:Event] == 'click'
+            yield(* match_responders(responders, message[:EventKey]))
+          else
+            yield(* match_responders(responders, message[:Event]))
+          end
+        else
+          yield(responders.first)
+        end
+      end
+
+      private
+
+      def match_responders(responders, value)
+        matched = responders.inject({ scoped: nil, general: nil }) do |matched, responder|
+          condition = responder[:with]
+
+          if condition.nil?
+            matched[:general] ||= [responder, value]
+            next matched
+          end
+
+          if condition.is_a? Regexp
+            matched[:scoped] ||= [responder] + $LAST_MATCH_INFO.captures if value =~ condition
+          else
+            matched[:scoped] ||= [responder, value] if value == condition
+          end
+          matched
+        end
+        matched[:scoped] || matched[:general]
+      end
+    end
+
+    def show
+      if self.class.corpid.present?
+        echostr, _corp_id = unpack(decrypt(Base64.decode64(params[:echostr]), self.class.encoding_aes_key))
+        render text: echostr
+      else
+        render text: params[:echostr]
+      end
+    end
+
+    def create
+      request = Wechat::Message.from_hash(post_xml)
+      response = self.class.responder_for(request) do |responder, *args|
+        responder ||= self.class.responders(:fallback).first
+
+        next if responder.nil?
+        case
+        when responder[:respond]
+          request.reply.text responder[:respond]
+        when responder[:proc]
+          define_singleton_method :process, responder[:proc]
+          send(:process, *args.unshift(request))
+        else
+          next
+        end
+      end
+
+      if response.respond_to? :to_xml
+        render xml: process_response(response)
+      else
+        render nothing: true, status: 200, content_type: 'text/html'
+      end
+    end
+
+    private
+
+    def verify_signature
+      array = [self.class.token, params[:timestamp], params[:nonce]]
+      signature = params[:signature]
+
+      # 默认使用明文方式验证, 企业号验证加密签名
+      if params[:signature].blank? && params[:msg_signature]
+        signature = params[:msg_signature]
+        if params[:echostr]
+          array << params[:echostr]
+        else
+          array << request_content['xml']['Encrypt']
+        end
+      end
+
+      str = array.compact.collect(&:to_s).sort.join
+      render text: 'Forbidden', status: 403 if signature != Digest::SHA1.hexdigest(str)
+    end
+
+    def post_xml
+      data = request_content
+
+      # 如果是加密模式解密
+      if self.class.encrypt_mode || self.class.corpid.present?
+        encrypt_msg = data['xml']['Encrypt']
+        if encrypt_msg.present?
+          content, @app_id = unpack(decrypt(Base64.decode64(encrypt_msg), self.class.encoding_aes_key))
+          data = Hash.from_xml(content)
+        end
+      end
+
+      HashWithIndifferentAccess.new_from_hash_copying_default(data.fetch('xml', {})).tap do |msg|
+        msg[:Event].downcase! if msg[:Event]
+      end
+    end
+
+    def process_response(response)
+      msg = response.to_xml
+
+      # 返回加密消息
+      if self.class.encrypt_mode || self.class.corpid.present?
+        data = request_content
+        if data['xml']['Encrypt']
+          encrypt = Base64.strict_encode64 encrypt(pack(msg, @app_id), self.class.encoding_aes_key)
+          msg = gen_msg(encrypt, params[:timestamp], params[:nonce])
+        end
+      end
+
+      msg
+    end
+
+    def gen_msg(encrypt, timestamp, nonce)
+      msg_sign = Digest::SHA1.hexdigest [self.class.token, encrypt, timestamp, nonce].compact.collect(&:to_s).sort.join
+
+      { Encrypt: encrypt,
+        MsgSignature: msg_sign,
+        TimeStamp: timestamp,
+        Nonce: nonce
+      }.to_xml(root: 'xml', children: 'item', skip_instruct: true, skip_types: true)
+    end
+
+    def request_content
+      params[:xml].nil? ? Hash.from_xml(request.raw_post) : { 'xml' => params[:xml] }
+    end
+  end
+end