gfd_wechat 0.0.1

data/lib/generators/wechat/session_generator.rb

@@ -0,0 +1,36 @@
+require 'rails/generators/active_record'
+
+module Wechat
+  module Generators
+    class SessionGenerator < Rails::Generators::Base
+      include ::Rails::Generators::Migration
+
+      desc 'Enable wechat session support'
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_wechat_sessions_migration
+        migration_template(
+            'db/session_migration.rb.erb',
+            'db/migrate/create_wechat_sessions.rb',
+            {migration_version: migration_version}
+        )
+      end
+
+      def copy_wechat_session_model
+        template 'app/models/wechat_session.rb'
+      end
+
+      private
+
+      def self.next_migration_number(dirname)
+        ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def migration_version
+        if Rails.version >= '5.0.0'
+          "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+    end
+  end
+end

data/lib/generators/wechat/templates/MENU_README

@@ -0,0 +1,3 @@
+Run `wechat menu_create config\wechat_menu.yml` to uploading the default menu.
+Run `rails g wechat:menu --conditional` to generate one example of conditional menu.
+Run `wechat menu_addconditional config\wechat_menu_conditional.yml` to uploading the conditional menu.

data/lib/generators/wechat/templates/app/controllers/wechats_controller.rb

@@ -0,0 +1,12 @@
+<% if defined? ActionController::API -%>
+class WechatsController < ApplicationController
+<% else -%>
+class WechatsController < ActionController::Base
+<% end -%>
+  # For details on the DSL available within this file, see https://github.com/Eric-Guo/wechat#wechat_responder---rails-responder-controller-dsl
+  wechat_responder
+
+  on :text do |request, content|
+    request.reply.text "echo: #{content}" # Just echo
+  end
+end

data/lib/generators/wechat/templates/app/models/wechat_config.rb

@@ -0,0 +1,46 @@
+# Used by wechat gems, do not rename WechatConfig to other name,
+# Feel free to inherit from other class like ActiveModel::Model
+class WechatConfig < ActiveRecord::Base
+  validates :environment, presence: true
+  validates :account, presence: true, uniqueness: { scope: [:environment] }
+  validates :token, presence: true
+  validates :access_token, presence: true
+  validates :jsapi_ticket, presence: true
+  validates :encoding_aes_key, presence: { if: :encrypt_mode? }
+
+  validate :app_config_is_valid
+
+  ATTRIBUTES_TO_REMOVE = %w(environment account created_at updated_at enabled)
+
+  def self.get_all_configs(environment)
+    WechatConfig.where(environment: environment, enabled: true).inject({}) do |hash, config|
+      hash[config.account] = config.build_config_hash
+      hash
+    end
+  end
+
+  def build_config_hash
+    self.as_json(except: ATTRIBUTES_TO_REMOVE)
+  end
+
+  private
+
+  def app_config_is_valid
+    if self[:appid].present?
+      # public account
+      if self[:secret].blank?
+        errors.add(:secret, 'cannot be nil when appid is set')
+      end
+    elsif self[:corpid].present?
+      # corp account
+      if self[:corpsecret].blank?
+        errors.add(:corpsecret, 'cannot be nil when corpid is set')
+      end
+      if self[:agentid].blank?
+        errors.add(:agentid, 'cannot be nil when corpid is set')
+      end
+    else
+      errors[:base] << 'Either appid or corpid must be set'
+    end
+  end
+end

data/lib/generators/wechat/templates/app/models/wechat_session.rb

@@ -0,0 +1,17 @@
+# Used by wechat gems, do not rename WechatSession to other name,
+# Feel free to inherit from other class like ActiveModel::Model
+class WechatSession < ActiveRecord::Base
+  validates :openid, presence: true, uniqueness: true
+  serialize :hash_store, Hash
+
+  # called by wechat gems when user request session
+  def self.find_or_initialize_session(request_message)
+    find_or_initialize_by(openid: request_message[:from_user_name])
+  end
+
+  # called by wechat gems after response Techent server at controller#create
+  def save_session(_response_message)
+    touch unless new_record? # Always refresh updated_at even no change
+    save!
+  end
+end

data/lib/generators/wechat/templates/config/initializers/wechat_redis_store.rb

@@ -0,0 +1,42 @@
+module Wechat
+  def self.redis
+    # You can reuse existing redis connection and remove this method if require
+    @redis ||= Redis.new # more options see https://github.com/redis/redis-rb#getting-started
+  end
+
+  module Token
+    class AccessTokenBase
+      def read_token
+        JSON.parse(Wechat.redis.get(redis_key)) || {}
+      end
+
+      def write_token(token_hash)
+        Wechat.redis.set redis_key, token_hash.to_json
+      end
+
+      private
+
+      def redis_key
+        "my_app_wechat_token_#{self.appid}"
+      end
+    end
+  end
+
+  module Ticket
+    class JsapiBase
+      def read_ticket
+        JSON.parse(Wechat.redis.get(redis_key))  || {}
+      end
+
+      def write_ticket(ticket_hash)
+        Wechat.redis.set redis_key, ticket_hash.to_json
+      end
+
+      private
+
+      def redis_key
+        "my_app_wechat_ticket_#{self.access_token.appid}"
+      end
+    end
+  end
+end

data/lib/generators/wechat/templates/config/wechat.yml

@@ -0,0 +1,72 @@
+default: &default
+  corpid: "corpid"
+  corpsecret: "corpsecret"
+  agentid:  1
+# Or if using public account, only need above two line
+#  appid: "my_appid"
+#  secret: "my_secret"
+  token:    "my_token"
+  access_token: "C:/Users/[username]/wechat_access_token"
+  encrypt_mode: false # if true must fill encoding_aes_key
+  encoding_aes_key:  "my_encoding_aes_key"
+  jsapi_ticket: "C:/Users/[user_name]/wechat_jsapi_ticket"
+
+production:
+  corpid:     <%%= ENV['WECHAT_CORPID'] %>
+  corpsecret: <%%= ENV['WECHAT_CORPSECRET'] %>
+  agentid:    <%%= ENV['WECHAT_AGENTID'] %>
+# Or if using public account, only need above two line
+#  appid:      <%= ENV['WECHAT_APPID'] %>
+#  secret:     <%= ENV['WECHAT_APP_SECRET'] %>
+  token:      <%%= ENV['WECHAT_TOKEN'] %>
+  timeout:    30,
+  skip_verify_ssl: true
+  access_token:  <%%= ENV['WECHAT_ACCESS_TOKEN'] %>
+  encrypt_mode: false # if true must fill encoding_aes_key
+  encoding_aes_key:  <%%= ENV['WECHAT_ENCODING_AES_KEY'] %>
+  jsapi_ticket: <%%= ENV['WECHAT_JSAPI_TICKET'] %>
+  oauth2_cookie_duration: <%%= ENV['WECHAT_OAUTH2_COOKIE_DURATION'] %> # seconds
+
+development:
+  <<: *default
+  trusted_domain_fullname: "http://your_dev.proxy.qqbrowser.cc"
+
+test:
+  <<: *default
+
+# Multiple Accounts
+#
+# wx2_development:
+#  <<: *default
+#  appid: "my_appid"
+#  secret: "my_secret"
+#  access_token: "tmp/wechat_access_token2"
+#  jsapi_ticket: "tmp/wechat_jsapi_ticket2"
+#
+# wx2_test:
+#  <<: *default
+#  appid: "my_appid"
+#  secret: "my_secret"
+#
+# wx2_production:
+#  <<: *default
+#  appid: "my_appid"
+#  secret: "my_secret"
+#
+# wx3_development:
+#  <<: *default
+#  appid: "my_appid"
+#  secret: "my_secret"
+#  access_token: "tmp/wechat_access_token3"
+#  jsapi_ticket: "tmp/wechat_jsapi_ticket3"
+#
+# wx3_test:
+#  <<: *default
+#  appid: "my_appid"
+#  secret: "my_secret"
+#
+# wx3_production:
+#  <<: *default
+#  appid: "my_appid"
+#  secret: "my_secret"
+#

data/lib/generators/wechat/templates/config/wechat_menu.yml

@@ -0,0 +1,6 @@
+# More option see https://github.com/Eric-Guo/wechat#menu-create
+button:
+ -
+  type: "view"
+  name: "Testing"
+  url:  "http://xxxxx.proxy.qqbrowser.cc"

data/lib/generators/wechat/templates/config/wechat_menu_android.yml

@@ -0,0 +1,15 @@
+button:
+ -
+  type: "view"
+  name: "Testing Android"
+  url:  "http://xxxxx.proxy.qqbrowser.cc"
+
+# More match rule see http://mp.weixin.qq.com/wiki/0/c48ccd12b69ae023159b4bfaa7c39c20.html
+matchrule:
+#  group_id: 2
+#  sex: 1
+#  country: 中国
+#  province: 上海
+#  city: 杨浦
+  client_platform_type: 1
+#  language: zh_CN

data/lib/generators/wechat/templates/db/config_migration.rb.erb

@@ -0,0 +1,40 @@
+class CreateWechatConfigs < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :wechat_configs do |t|
+      # config environment, typical values: production, development or test
+      t.string :environment, null: false, default: 'development'
+      # account name
+      t.string :account, null: false
+      # whether this config is activated
+      t.boolean :enabled, default: true
+
+      # public account
+      t.string :appid
+      t.string :secret
+
+      # corp account
+      t.string :corpid
+      t.string :corpsecret
+      t.integer :agentid
+
+      # when encrypt_mode is true, encoding_aes_key must be specified
+      t.boolean :encrypt_mode
+      t.string :encoding_aes_key
+
+      # app token
+      t.string :token, null: false
+      # path to access token storage file
+      t.string :access_token, null: false
+      # path to jsapi ticket storage file
+      t.string :jsapi_ticket, null: false
+      # set to false if RestClient::SSLCertificateNotVerified is thrown
+      t.boolean :skip_verify_ssl, default: true
+      t.integer :timeout, default: 20
+      t.string :trusted_domain_fullname
+
+      t.timestamps null: false
+    end
+
+    add_index :wechat_configs, [:environment, :account], unique: true, length: {environment: 20, account: 100}
+  end
+end

data/lib/generators/wechat/templates/db/session_migration.rb.erb

@@ -0,0 +1,10 @@
+class CreateWechatSessions < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :wechat_sessions do |t|
+      t.string :openid, null: false
+      t.string :hash_store
+      t.timestamps null: false
+    end
+    add_index :wechat_sessions, :openid, unique: true
+  end
+end

data/lib/wechat/api.rb

@@ -0,0 +1,54 @@
+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 Api < ApiBase
+    include Concern::Common
+    DEVICE_BASE = 'https://api.weixin.qq.com/device/'.freeze
+
+    def qrcode_create_scene_str(scene_id, expire_seconds = 604800)
+      post 'qrcode/create', JSON.generate(expire_seconds: expire_seconds,
+                                          action_name: 'QR_STR_SCENE',
+                                          action_info: { scene: { scene_str: scene_id } })
+    end
+
+    def template_message_send(message)
+      post 'message/template/send', message.to_json, content_type: :json
+    end
+
+    def list_message_template
+      get 'template/get_all_private_template'
+    end
+
+    def add_message_template(template_id_short)
+      post 'template/api_add_template', JSON.generate(template_id_short: template_id_short)
+    end
+
+    def del_message_template(template_id)
+      post 'template/del_private_template', JSON.generate(template_id: template_id)
+    end
+
+    def device_bind(open_id, device_id)
+      client.post 'compel_bind', JSON.generate(device_id: device_id,
+                                                openid:open_id), base: DEVICE_BASE, access_token: access_token.token
+    end
+
+    def device_unbind(open_id, device_id)
+      client.post 'compel_unbind', JSON.generate(device_id: device_id,
+                                                openid:open_id), base: DEVICE_BASE, access_token: access_token.token
+    end
+
+    def device_transmsg(device_type, open_id, device_id, content)
+      client.post 'transmsg', JSON.generate(device_type: device_type, open_id: open_id,
+                                            device_id: device_id, content: content), base: DEVICE_BASE, access_token: access_token.token
+    end
+
+    def device_authorize(device_num, device_list, op_type, product_id)
+      client.post 'authorize_device', JSON.generate(device_num: device_num, device_list: device_list,
+                                                    op_type: op_type, product_id: product_id), base: DEVICE_BASE, access_token: access_token.token
+    end
+  end
+end

data/lib/wechat/api_base.rb

@@ -0,0 +1,63 @@
+module Wechat
+  class ApiBase
+    attr_reader :access_token, :client, :jsapi_ticket
+
+    MP_BASE = 'https://mp.weixin.qq.com/cgi-bin/'.freeze
+
+    def callbackip
+      get 'getcallbackip'
+    end
+
+    def qrcode(ticket)
+      client.get 'showqrcode', params: { ticket: ticket }, base: MP_BASE, as: :file
+    end
+
+    def media(media_id)
+      get 'media/get', params: { media_id: media_id }, as: :file
+    end
+
+    def media_hq(media_id)
+      get 'media/get/jssdk', params: { media_id: media_id }, as: :file
+    end
+
+    def media_create(type, file)
+      post_file 'media/upload', file, params: { type: type }
+    end
+
+    def media_uploadimg(file)
+      post_file 'media/uploadimg', file
+    end
+
+    def media_uploadnews(mpnews_message)
+      post 'media/uploadnews', mpnews_message.to_json
+    end
+
+    protected
+
+    def get(path, headers = {})
+      with_access_token(headers[:params]) do |params|
+        client.get path, headers.merge(params: params)
+      end
+    end
+
+    def post(path, payload, headers = {})
+      with_access_token(headers[:params]) do |params|
+        client.post path, payload, headers.merge(params: params)
+      end
+    end
+
+    def post_file(path, file, headers = {})
+      with_access_token(headers[:params]) do |params|
+        client.post_file path, file, headers.merge(params: params)
+      end
+    end
+
+    def with_access_token(params = {}, tries = 2)
+      params ||= {}
+      yield(params.merge(access_token: access_token.token))
+    rescue AccessTokenExpiredError
+      access_token.refresh
+      retry unless (tries -= 1).zero?
+    end
+  end
+end

data/lib/wechat/api_loader.rb

@@ -0,0 +1,145 @@
+module Wechat
+  module ApiLoader
+    def self.with(options)
+      account = options[:account] || :default
+      c = ApiLoader.config(account)
+
+      token_file = options[:token_file] || c.access_token.presence || '/var/tmp/wechat_access_token'
+      js_token_file = options[:js_token_file] || c.jsapi_ticket.presence || '/var/tmp/wechat_jsapi_ticket'
+      type = options[:type] || c.type
+      if c.appid && c.secret && token_file.present?
+        wx_class = (type == 'mp') ? Wechat::MpApi : Wechat::Api
+        wx_class.new(c.appid, c.secret, token_file, c.timeout, c.skip_verify_ssl, js_token_file)
+      elsif c.corpid && c.corpsecret && token_file.present?
+        Wechat::CorpApi.new(c.corpid, c.corpsecret, token_file, c.agentid, c.timeout, c.skip_verify_ssl, js_token_file)
+      else
+        raise "Need create ~/.wechat.yml with wechat appid and secret or running at rails root folder so wechat can read config/wechat.yml"
+      end
+    end
+
+    @configs = nil
+
+    def self.config(account = :default)
+      account = :default if account.nil?
+      @configs ||= loading_config!
+      @configs[account.to_sym] || raise("Wechat configuration for #{account} is missing.")
+    end
+
+    def self.reload_config!
+      @configs = loading_config!
+    end
+
+    private_class_method def self.loading_config!
+      configs = config_from_file || config_from_environment
+      configs.merge!(config_from_db)
+
+      configs.symbolize_keys!
+      configs.each do |key, cfg|
+        if cfg.is_a?(Hash)
+          cfg.symbolize_keys!
+        else
+          raise "wrong wechat configuration format for #{key}"
+        end
+      end
+
+      if defined?(::Rails)
+        configs.each do |_, cfg|
+          cfg[:access_token] ||= Rails.root.try(:join, 'tmp/access_token').try(:to_path)
+          cfg[:jsapi_ticket] ||= Rails.root.try(:join, 'tmp/jsapi_ticket').try(:to_path)
+        end
+      end
+
+      configs.each do |_, cfg|
+        cfg[:timeout] ||= 20
+        cfg[:have_session_class] = class_exists?('WechatSession')
+        cfg[:oauth2_cookie_duration] ||= 1.hour
+      end
+
+      # create config object using raw config data
+      cfg_objs = {}
+      configs.each do |account, cfg|
+        cfg_objs[account] = OpenStruct.new(cfg)
+      end
+      cfg_objs
+    end
+
+    private_class_method def self.config_from_db
+      unless class_exists?('WechatConfig')
+        return {}
+      end
+
+      environment = defined?(::Rails) ? Rails.env.to_s : ENV['RAILS_ENV'] || 'development'
+      WechatConfig.get_all_configs(environment)
+    end
+
+    private_class_method def self.config_from_file
+      if defined?(::Rails)
+        config_file = ENV['WECHAT_CONF_FILE'] || Rails.root.join('config/wechat.yml')
+        return resovle_config_file(config_file, Rails.env.to_s)
+      else
+        rails_config_file = ENV['WECHAT_CONF_FILE'] || File.join(Dir.getwd, 'config/wechat.yml')
+        application_config_file = File.join(Dir.getwd, 'config/application.yml')
+        home_config_file = File.join(Dir.home, '.wechat.yml')
+        if File.exist?(rails_config_file)
+          rails_env = ENV['RAILS_ENV'] || 'development'
+          if File.exist?(application_config_file) && !defined?(::Figaro)
+            require 'figaro'
+            Figaro::Application.new(path: application_config_file, environment: rails_env).load
+          end
+          config = resovle_config_file(rails_config_file, rails_env)
+          if config.present? && (default = config[:default])  && (default['appid'] || default['corpid'])
+            puts "Using rails project #{ENV['WECHAT_CONF_FILE'] || "config/wechat.yml"} #{rails_env} setting..."
+            return config
+          end
+        end
+        if File.exist?(home_config_file)
+          return resovle_config_file(home_config_file, nil)
+        end
+      end
+    end
+
+    private_class_method def self.resovle_config_file(config_file, env)
+      if File.exist?(config_file)
+        raw_data = YAML.load(ERB.new(File.read(config_file)).result)
+        configs = {}
+        if env
+          # Process multiple accounts when env is given
+          raw_data.each do |key, value|
+            if key == env
+              configs[:default] = value
+            elsif m = /(.*?)_#{env}$/.match(key)
+              configs[m[1].to_sym] = value
+            end
+          end
+        else
+          # Treat is as one account when env is omitted
+          configs[:default] = raw_data
+        end
+        configs
+      end
+    end
+
+    private_class_method def self.config_from_environment
+      value = { appid: ENV['WECHAT_APPID'],
+        secret: ENV['WECHAT_SECRET'],
+        corpid: ENV['WECHAT_CORPID'],
+        corpsecret: ENV['WECHAT_CORPSECRET'],
+        agentid: ENV['WECHAT_AGENTID'],
+        token: ENV['WECHAT_TOKEN'],
+        access_token: ENV['WECHAT_ACCESS_TOKEN'],
+        encrypt_mode: ENV['WECHAT_ENCRYPT_MODE'],
+        timeout: ENV['WECHAT_TIMEOUT'],
+        skip_verify_ssl: ENV['WECHAT_SKIP_VERIFY_SSL'],
+        encoding_aes_key: ENV['WECHAT_ENCODING_AES_KEY'],
+        jsapi_ticket: ENV['WECHAT_JSAPI_TICKET'],
+        trusted_domain_fullname: ENV['WECHAT_TRUSTED_DOMAIN_FULLNAME'] }
+      {default: value}
+    end
+
+    private_class_method def self.class_exists?(class_name)
+      return Module.const_get(class_name).present?
+    rescue NameError
+      return false
+    end
+  end
+end

data/lib/wechat/cipher.rb

@@ -0,0 +1,66 @@
+module Wechat
+  module Cipher
+    BLOCK_SIZE = 32
+    CIPHER = 'AES-256-CBC'.freeze
+
+    def encrypt(plain, encoding_aes_key)
+      cipher = OpenSSL::Cipher.new(CIPHER)
+      cipher.encrypt
+
+      cipher.padding = 0
+      key_data = Base64.decode64(encoding_aes_key + '=')
+      cipher.key = key_data
+      cipher.iv = [key_data].pack('H*')
+
+      cipher.update(plain) + cipher.final
+    end
+
+    def decrypt(msg, encoding_aes_key)
+      cipher = OpenSSL::Cipher.new(CIPHER)
+      cipher.decrypt
+
+      cipher.padding = 0
+      key_data = Base64.decode64(encoding_aes_key + '=')
+      cipher.key = key_data
+      cipher.iv = [key_data].pack('H*')
+
+      plain = cipher.update(msg) + cipher.final
+      decode_padding(plain)
+    end
+
+    # app_id or corp_id
+    def pack(content, app_id)
+      random = SecureRandom.hex(8)
+      text = content.force_encoding('ASCII-8BIT')
+      msg_len = [text.length].pack('N')
+
+      encode_padding("#{random}#{msg_len}#{text}#{app_id}")
+    end
+
+    def unpack(msg)
+      msg = decode_padding(msg)
+      msg_len = msg[16, 4].reverse.unpack('V')[0]
+      content = msg[20, msg_len]
+      app_id = msg[(20 + msg_len)..-1]
+
+      [content, app_id]
+    end
+
+    private
+
+    def encode_padding(data)
+      length = data.bytes.length
+      amount_to_pad = BLOCK_SIZE - (length % BLOCK_SIZE)
+      amount_to_pad = BLOCK_SIZE if amount_to_pad == 0
+      padding = ([amount_to_pad].pack('c') * amount_to_pad)
+      data + padding
+    end
+
+    def decode_padding(plain)
+      pad = plain.bytes[-1]
+      # no padding
+      pad = 0 if pad < 1 || pad > BLOCK_SIZE
+      plain[0...(plain.length - pad)]
+    end
+  end
+end