gfd_wechat 0.0.1

data/lib/wechat/message.rb

@@ -0,0 +1,265 @@
+module Wechat
+  class Message
+    class << self
+      def from_hash(message_hash)
+        new(message_hash)
+      end
+
+      def to(to_users = '', towxname: nil, send_ignore_reprint: 0)
+        if towxname.present?
+          new(ToWxName: towxname, CreateTime: Time.now.to_i)
+        elsif send_ignore_reprint == 1
+          new(ToUserName: to_users, CreateTime: Time.now.to_i, send_ignore_reprint: send_ignore_reprint)
+        else
+          new(ToUserName: to_users, CreateTime: Time.now.to_i)
+        end
+      end
+
+      def to_mass(tag_id: nil, send_ignore_reprint: 0)
+        if tag_id
+          new(filter: { is_to_all: false, tag_id: tag_id }, send_ignore_reprint: send_ignore_reprint)
+        else
+          new(filter: { is_to_all: true }, send_ignore_reprint: send_ignore_reprint)
+        end
+      end
+    end
+
+    class ArticleBuilder
+      attr_reader :items
+      delegate :count, to: :items
+      def initialize
+        @items = []
+      end
+    end
+
+    class NewsArticleBuilder < ArticleBuilder
+      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
+
+    class MpNewsArticleBuilder < ArticleBuilder
+      def item(thumb_media_id:, title:, content:, author: nil, content_source_url: nil, digest: nil, show_cover_pic: '0')
+        items << { Thumb_Media_ID: thumb_media_id, Author: author, Title: title, ContentSourceUrl: content_source_url,
+                   Content: content, Digest: digest, ShowCoverPic: show_cover_pic }.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,
+        WechatSession: session
+      )
+    end
+
+    def session
+      return nil unless Wechat.config.have_session_class
+      @message_hash[:WechatSession] ||= WechatSession.find_or_initialize_session(underscore_hash_keys(message_hash))
+    end
+
+    def save_session
+      ws = message_hash.delete(:WechatSession)
+      ws.try(:save_session, underscore_hash_keys(message_hash))
+      @message_hash[:WechatSession] = ws
+    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).each_with_object({}) do |value, results|
+          results[value[0].to_s.underscore.to_sym] = value[1]
+        end
+      else
+        raise "Don't know how to parse message as #{type}"
+      end
+    end
+
+    def to(openid_or_userid)
+      update(ToUserName: openid_or_userid)
+    end
+
+    def agent_id(agentid)
+      update(AgentId: agentid)
+    end
+
+    def text(content)
+      update(MsgType: 'text', Content: content)
+    end
+
+    def transfer_customer_service(kf_account = nil)
+      if kf_account
+        update(MsgType: 'transfer_customer_service', TransInfo: { KfAccount: kf_account })
+      else
+        update(MsgType: 'transfer_customer_service')
+      end
+    end
+
+    def success
+      update(MsgType: 'success')
+    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 file(media_id)
+      update(MsgType: 'file', File: { MediaId: media_id })
+    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 = NewsArticleBuilder.new
+        collection.take(8).each_with_index { |item, index| yield(article, item, index) }
+        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 mpnews(collection, &_block)
+      if block_given?
+        article = MpNewsArticleBuilder.new
+        collection.take(8).each_with_index { |item, index| yield(article, item, index) }
+        items = article.items
+      else
+        items = collection.collect do |item|
+          camelize_hash_keys(item.symbolize_keys.slice(:thumb_media_id, :title, :content, :author, :content_source_url, :digest, :show_cover_pic).reject { |_k, v| v.nil? })
+        end
+      end
+
+      update(MsgType: 'mpnews', Articles: items.collect { |item| camelize_hash_keys(item) })
+    end
+
+    def ref_mpnews(media_id)
+      update(MsgType: 'ref_mpnews', MpNews: { MediaId: media_id })
+    end
+
+    TEMPLATE_KEYS = %i[template_id form_id page color
+                       emphasis_keyword topcolor url miniprogram data].freeze
+
+    def template(opts = {})
+      template_fields = opts.symbolize_keys.slice(*TEMPLATE_KEYS)
+      update(MsgType: 'template', Template: template_fields)
+    end
+
+    def to_xml
+      ws = message_hash.delete(:WechatSession)
+      xml = message_hash.to_xml(root: 'xml', children: 'item', skip_instruct: true, skip_types: true)
+      @message_hash[:WechatSession] = ws
+      xml
+    end
+
+    TO_JSON_KEY_MAP = {
+      'ToUserName'       => 'touser',
+      'ToWxName'         => 'towxname',
+      'MediaId'          => 'media_id',
+      'MpNews'           => 'mpnews',
+      'ThumbMediaId'     => 'thumb_media_id',
+      'TemplateId'       => 'template_id',
+      'FormId'           => 'form_id',
+      'ContentSourceUrl' => 'content_source_url',
+      'ShowCoverPic'     => 'show_cover_pic'
+    }.freeze
+
+    TO_JSON_ALLOWED = %w[touser msgtype content image voice video file
+                         music news articles template agentid filter
+                         send_ignore_reprint mpnews towxname].freeze
+
+    def to_json
+      keep_camel_case_key = message_hash[:MsgType] == 'template'
+      json_hash = deep_recursive(message_hash) do |key, value|
+        key = key.to_s
+        [(TO_JSON_KEY_MAP[key] || (keep_camel_case_key ? key : key.downcase)), value]
+      end
+      json_hash = json_hash.transform_keys(&:downcase).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 'mpnews'
+        json_hash = { 'articles' => json_hash['articles'] }
+      when 'ref_mpnews'
+        json_hash['msgtype'] = 'mpnews'
+        json_hash.delete('articles')
+      when 'template'
+        json_hash = { 'touser' => json_hash['touser'] }.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) unless key == :WechatSession
+        memo.merge!(key => value)
+      end
+    end
+  end
+end

data/lib/wechat/mp_api.rb

@@ -0,0 +1,46 @@
+require 'wechat/api_base'
+require 'wechat/http_client'
+require 'wechat/token/public_access_token'
+require 'wechat/ticket/public_jsapi_ticket'
+require 'wechat/concern/common'
+
+module Wechat
+  class MpApi < ApiBase
+    include Concern::Common
+
+    def template_message_send(message)
+      post 'message/wxopen/template/send', message.to_json, content_type: :json
+    end
+
+    def list_template_library(offset: 0, count: 20)
+      post 'wxopen/template/library/list', JSON.generate(offset: offset, count: count)
+    end
+
+    def list_template_library_keywords(id)
+      post 'wxopen/template/library/get', JSON.generate(id: id)
+    end
+
+    def add_message_template(id, keyword_id_list)
+      post 'wxopen/template/add', JSON.generate(id: id, keyword_id_list: keyword_id_list)
+    end
+
+    def list_message_template(offset: 0, count: 20)
+      post 'wxopen/template/list', JSON.generate(offset: offset, count: count)
+    end
+
+    def del_message_template(template_id)
+      post 'wxopen/template/del', JSON.generate(template_id: template_id)
+    end
+
+    def jscode2session(code)
+      params = {
+        appid: access_token.appid,
+        secret: access_token.secret,
+        js_code: code,
+        grant_type: 'authorization_code'
+      }
+
+      client.get 'jscode2session', params: params, base: OAUTH2_BASE
+    end
+  end
+end

data/lib/wechat/responder.rb

@@ -0,0 +1,308 @@
+require 'English'
+require 'wechat/signature'
+
+module Wechat
+  module Responder
+    extend ActiveSupport::Concern
+    include Wechat::ControllerApi
+    include Cipher
+
+    included do
+      # Rails 5 remove before_filter and skip_before_filter
+      if respond_to?(:skip_before_action)
+        if respond_to?(:verify_authenticity_token)
+          skip_before_action :verify_authenticity_token
+        else
+          # Rails 5 API mode won't define verify_authenticity_token
+          # https://github.com/rails/rails/blob/v5.0.0.beta3/actionpack/lib/abstract_controller/callbacks.rb#L66
+          # https://github.com/rails/rails/blob/v5.0.0.beta3/activesupport/lib/active_support/callbacks.rb#L640
+          skip_before_action :verify_authenticity_token, raise: false
+        end
+
+        before_action :config_account, only: [:show, :create]
+        before_action :verify_signature, only: [:show, :create]
+      else
+        skip_before_filter :verify_authenticity_token
+        before_filter :config_account, only: [:show, :create]
+        before_filter :verify_signature, only: [:show, :create]
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :account_from_request
+
+      def on(message_type, with: nil, respond: nil, &block)
+        raise 'Unknow message type' unless [:text, :image, :voice, :video, :shortvideo, :link, :event, :click, :view, :scan, :batch_job, :location, :label_location, :fallback].include?(message_type)
+        config = respond.nil? ? {} : { respond: respond }
+        config[:proc] = block if block_given?
+
+        if with.present?
+          raise 'Only text, event, click, view, scan and batch_job can having :with parameters' unless [:text, :event, :click, :view, :scan, :batch_job].include?(message_type)
+          config[:with] = with
+          if message_type == :scan
+            if with.is_a?(String)
+              self.known_scan_key_lists = with
+            else
+              raise 'on :scan only support string in parameter with, detail see https://github.com/Eric-Guo/wechat/issues/84'
+            end
+          end
+        else
+          raise 'Message type click, view, scan and batch_job must specify :with parameters' if [:click, :view, :scan, :batch_job].include?(message_type)
+        end
+
+        case message_type
+        when :click
+          user_defined_click_responders(with) << config
+        when :view
+          user_defined_view_responders(with) << config
+        when :batch_job
+          user_defined_batch_job_responders(with) << config
+        when :scan
+          user_defined_scan_responders << config
+        when :location
+          user_defined_location_responders << config
+        when :label_location
+          user_defined_label_location_responders << config
+        else
+          user_defined_responders(message_type) << config
+        end
+
+        config
+      end
+
+      def user_defined_click_responders(with)
+        @click_responders ||= {}
+        @click_responders[with] ||= []
+      end
+
+      def user_defined_view_responders(with)
+        @view_responders ||= {}
+        @view_responders[with] ||= []
+      end
+
+      def user_defined_batch_job_responders(with)
+        @batch_job_responders ||= {}
+        @batch_job_responders[with] ||= []
+      end
+
+      def user_defined_scan_responders
+        @scan_responders ||= []
+      end
+
+      def user_defined_location_responders
+        @location_responders ||= []
+      end
+
+      def user_defined_label_location_responders
+        @label_location_responders ||= []
+      end
+
+      def user_defined_responders(type)
+        @responders ||= {}
+        @responders[type] ||= []
+      end
+
+      def responder_for(message)
+        message_type = message[:MsgType].to_sym
+        responders = user_defined_responders(message_type)
+
+        case message_type
+        when :text
+          yield(* match_responders(responders, message[:Content]))
+        when :event
+          if 'click' == message[:Event] && !user_defined_click_responders(message[:EventKey]).empty?
+            yield(* user_defined_click_responders(message[:EventKey]), message[:EventKey])
+          elsif 'view' == message[:Event] && !user_defined_view_responders(message[:EventKey]).empty?
+            yield(* user_defined_view_responders(message[:EventKey]), message[:EventKey])
+          elsif 'click' == message[:Event]
+            yield(* match_responders(responders, message[:EventKey]))
+          elsif known_scan_key_lists.include?(message[:EventKey]) && %w(scan subscribe scancode_push scancode_waitmsg).freeze.include?(message[:Event])
+            yield(* known_scan_with_match_responders(user_defined_scan_responders, message))
+          elsif 'batch_job_result' == message[:Event]
+            yield(* user_defined_batch_job_responders(message[:BatchJob][:JobType]), message[:BatchJob])
+          elsif 'location' == message[:Event]
+            yield(* user_defined_location_responders, message)
+          else
+            yield(* match_responders(responders, message[:Event]))
+          end
+        when :location
+          yield(* user_defined_label_location_responders, message)
+        else
+          yield(responders.first)
+        end
+      end
+
+      private
+
+      def match_responders(responders, value)
+        matched = responders.each_with_object({}) do |responder, memo|
+          condition = responder[:with]
+
+          if condition.nil?
+            memo[:general] ||= [responder, value]
+            next
+          end
+
+          if condition.is_a? Regexp
+            memo[:scoped] ||= [responder] + $LAST_MATCH_INFO.captures if value =~ condition
+          else
+            memo[:scoped] ||= [responder, value] if value == condition
+          end
+        end
+        matched[:scoped] || matched[:general]
+      end
+
+      def known_scan_with_match_responders(responders, message)
+        matched = responders.each_with_object({}) do |responder, memo|
+          if %w(scan subscribe).freeze.include?(message[:Event]) && message[:EventKey] == responder[:with]
+            memo[:scaned] ||= [responder, message[:Ticket]]
+          elsif %w(scancode_push scancode_waitmsg).freeze.include?(message[:Event]) && message[:EventKey] == responder[:with]
+            memo[:scaned] ||= [responder, message[:ScanCodeInfo][:ScanResult], message[:ScanCodeInfo][:ScanType]]
+          end
+        end
+        matched[:scaned]
+      end
+
+      def known_scan_key_lists
+        @known_scan_key_lists ||= []
+      end
+
+      def known_scan_key_lists=(qrscene_value)
+        @known_scan_key_lists ||= []
+        @known_scan_key_lists << qrscene_value
+      end
+    end
+
+    def show
+      if @we_corpid.present?
+        echostr, _corp_id = unpack(decrypt(Base64.decode64(params[:echostr]), @we_encoding_aes_key))
+        if Rails::VERSION::MAJOR >= 4
+          render plain: echostr
+        else
+          render text: echostr
+        end
+      else
+        if Rails::VERSION::MAJOR >= 4
+          render plain: params[:echostr]
+        else
+          render text: params[:echostr]
+        end
+      end
+    end
+
+    def create
+      request_msg = Wechat::Message.from_hash(post_xml)
+      response_msg = run_responder(request_msg)
+
+      if response_msg.respond_to? :to_xml
+        if Rails::VERSION::MAJOR >= 4
+          render plain: process_response(response_msg)
+        else
+          render text: process_response(response_msg)
+        end
+      else
+        head :ok, content_type: 'text/html'
+      end
+
+      response_msg.save_session if response_msg.is_a?(Wechat::Message) && Wechat.config.have_session_class
+
+      ActiveSupport::Notifications.instrument 'wechat.responder.after_create', request: request_msg, response: response_msg
+    end
+
+    private
+
+    def config_account
+      account = self.class.account_from_request&.call(request)
+      config = account ? Wechat.config(account) : nil
+
+      @we_encrypt_mode = config&.encrypt_mode || self.class.encrypt_mode
+      @we_encoding_aes_key = config&.encoding_aes_key || self.class.encoding_aes_key
+      @we_token = config&.token || self.class.token
+      @we_corpid = config&.corpid || self.class.corpid
+    end
+
+    def verify_signature
+      if @we_encrypt_mode
+        signature = params[:signature] || params[:msg_signature]
+        msg_encrypt = params[:echostr] || request_encrypt_content
+      else
+        signature = params[:signature]
+      end
+
+      msg_encrypt = nil unless @we_corpid.present?
+
+      render plain: 'Forbidden', status: 403 if signature != Signature.hexdigest(@we_token,
+                                                                                 params[:timestamp],
+                                                                                 params[:nonce],
+                                                                                 msg_encrypt)
+    end
+
+    def post_xml
+      data = request_content
+
+      if @we_encrypt_mode && request_encrypt_content.present?
+        content, @we_app_id = unpack(decrypt(Base64.decode64(request_encrypt_content), @we_encoding_aes_key))
+        data = Hash.from_xml(content)
+      end
+
+      data_hash = data.fetch('xml', {}).merge(openid: data[:openid])
+      if Rails::VERSION::MAJOR >= 5
+        data_hash = data_hash.to_unsafe_hash if data_hash.instance_of?(ActionController::Parameters)
+        HashWithIndifferentAccess.new(data_hash).tap do |msg|
+          msg[:Event].downcase! if msg[:Event]
+        end
+      else
+        HashWithIndifferentAccess.new_from_hash_copying_default(data_hash).tap do |msg|
+          msg[:Event].downcase! if msg[:Event]
+        end
+      end
+    end
+
+    def run_responder(request)
+      self.class.responder_for(request) do |responder, *args|
+        responder ||= self.class.user_defined_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]
+          number_of_block_parameter = responder[:proc].arity
+          send(:process, *args.unshift(request).take(number_of_block_parameter))
+        else
+          next
+        end
+      end
+    end
+
+    def process_response(response)
+      msg = response[:MsgType] == 'success' ? 'success' : response.to_xml
+
+      if @we_encrypt_mode
+        encrypt = Base64.strict_encode64(encrypt(pack(msg, @we_app_id), @we_encoding_aes_key))
+        msg = gen_msg(encrypt, params[:timestamp], params[:nonce])
+      end
+
+      msg
+    end
+
+    def gen_msg(encrypt, timestamp, nonce)
+      msg_sign = Signature.hexdigest(@we_token, timestamp, nonce, encrypt)
+
+      { Encrypt: encrypt,
+        MsgSignature: msg_sign,
+        TimeStamp: timestamp,
+        Nonce: nonce
+      }.to_xml(root: 'xml', children: 'item', skip_instruct: true, skip_types: true)
+    end
+
+    def request_encrypt_content
+      request_content&.dig('xml', 'Encrypt')
+    end
+
+    def request_content
+      params[:xml].nil? ? Hash.from_xml(request.raw_post) : { 'xml' => params[:xml] }.merge(openid: params[:openid])
+    end
+  end
+end

data/lib/wechat/signature.rb

@@ -0,0 +1,10 @@
+module Wechat
+  module Signature
+    def self.hexdigest(token, timestamp, nonce, msg_encrypt)
+      array = [token, timestamp, nonce]
+      array << msg_encrypt unless msg_encrypt.nil?
+      dev_msg_signature = array.compact.collect(&:to_s).sort.join
+      Digest::SHA1.hexdigest(dev_msg_signature)
+    end
+  end
+end

data/lib/wechat/ticket/corp_jsapi_ticket.rb

@@ -0,0 +1,14 @@
+require 'wechat/ticket/jsapi_base'
+
+module Wechat
+  module Ticket
+    class CorpJsapiTicket < JsapiBase
+      def refresh
+        data = client.get('get_jsapi_ticket', params: { access_token: access_token.token })
+        data['oauth2_state'] = SecureRandom.hex(16)
+        write_ticket_to_store(data)
+        read_ticket_from_store
+      end
+    end
+  end
+end