wechat 0.11.10 → 0.13.1

data/bin/wechat

@@ -6,13 +6,10 @@ $LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
 require 'thor'
 require 'wechat'
 require 'json'
-require 'active_support' # To support Rails 4.2.1, see #17936
-require 'active_support/dependencies/autoload'
 require 'active_support/core_ext'
 require 'active_support/json'
 require 'fileutils'
 require 'yaml'
-require 'wechat/api_loader'
 require 'cgi'
 
 class App < Thor
@@ -187,6 +184,11 @@ class App < Thor
       puts wechat_api.convert_to_openid(userid)
     end
 
+    desc 'convert_to_userid [OPENID]', 'openid转换成userid'
+    def convert_to_userid(openid)
+      puts wechat_api.convert_to_userid(openid)
+    end
+
     desc 'agent_list', '获取应用概况列表'
     def agent_list
       r = wechat_api.agent_list

data/lib/action_controller/wechat_responder.rb

@@ -38,37 +38,30 @@ module ActionController
       self.trusted_domain_fullname = opts[:trusted_domain_fullname] || cfg.trusted_domain_fullname
       self.oauth2_cookie_duration = opts[:oauth2_cookie_duration] || cfg.oauth2_cookie_duration.to_i.seconds
       self.timeout = opts[:timeout] || cfg.timeout
-      self.skip_verify_ssl = if opts.key?(:skip_verify_ssl)
-                               opts[:skip_verify_ssl]
-                             else
-                               cfg.skip_verify_ssl
-                             end
+      self.qcloud_token_lifespan = opts[:qcloud_token_lifespan] || cfg.qcloud_token_lifespan
+      self.skip_verify_ssl = opts.key?(:skip_verify_ssl) ? opts[:skip_verify_ssl] : cfg.skip_verify_ssl
 
       return Wechat.api if account == :default && opts.empty?
 
       access_token = opts[:access_token] || cfg.access_token
       jsapi_ticket = opts[:jsapi_ticket] || cfg.jsapi_ticket
+      qcloud_env = opts[:qcloud_env] || cfg.qcloud_env
+      qcloud_token = opts[:qcloud_token] || cfg.qcloud_token
 
-      if corpid.present?
-        corpsecret = opts[:corpsecret] || cfg.corpsecret
-        Wechat::CorpApi.new(corpid, corpsecret, access_token, \
-                            agentid, timeout, skip_verify_ssl, jsapi_ticket)
-      else
-        secret = opts[:secret] || cfg.secret
-        Wechat::Api.new(appid, secret, access_token, \
-                        timeout, skip_verify_ssl, jsapi_ticket)
-      end
-    end
-  end
+      api_type = opts[:type] || cfg.type
+      secret = corpid.present? ? opts[:corpsecret] || cfg.corpsecret : opts[:secret] || cfg.secret
 
-  if defined? Base
-    class << Base
-      include WechatResponder
+      get_wechat_api(api_type, corpid, appid, secret, access_token, agentid, timeout, skip_verify_ssl, jsapi_ticket, qcloud_env, qcloud_token, qcloud_token_lifespan)
     end
-  end
-  if defined? API
-    class << API
-      include WechatResponder
+
+    def get_wechat_api(api_type, corpid, appid, secret, access_token, agentid, timeout, skip_verify_ssl, jsapi_ticket, qcloud_env, qcloud_token, qcloud_token_lifespan)
+      if api_type && api_type.to_sym == :mp
+        Wechat::MpApi.new(appid, secret, access_token, timeout, skip_verify_ssl, jsapi_ticket, qcloud_env, qcloud_token, qcloud_token_lifespan)
+      elsif corpid.present?
+        Wechat::CorpApi.new(corpid, secret, access_token, agentid, timeout, skip_verify_ssl, jsapi_ticket)
+      else
+        Wechat::Api.new(appid, secret, access_token, timeout, skip_verify_ssl, jsapi_ticket)
+      end
     end
   end
 end

data/lib/generators/wechat/config_generator.rb

@@ -31,7 +31,7 @@ module Wechat
       private
 
       def migration_version
-        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]" if Rails.version >= '5.0.0'
+        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
       end
     end
   end

data/lib/generators/wechat/session_generator.rb

@@ -31,7 +31,7 @@ module Wechat
       private
 
       def migration_version
-        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]" if Rails.version >= '5.0.0'
+        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
       end
     end
   end

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

@@ -35,7 +35,7 @@ class WechatConfig < ActiveRecord::Base
       errors.add(:corpsecret, 'cannot be nil when corpid is set') if self[:corpsecret].blank?
       errors.add(:agentid, 'cannot be nil when corpid is set') if self[:agentid].blank?
     else
-      errors[:base] << 'Either appid or corpid must be set'
+      errors.add(:base, 'Either appid or corpid must be set')
     end
   end
 end

data/lib/wechat.rb

@@ -1,24 +1,21 @@
 # frozen_string_literal: true
 
+require 'zeitwerk'
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/generators/**/*.rb")
+loader.setup
+
 require 'base64'
 require 'openssl/cipher'
-require 'wechat/api_loader'
-require 'wechat/api'
-require 'wechat/mp_api'
-require 'wechat/corp_api'
-require 'wechat/helpers'
-require 'action_controller/wechat_responder'
 
 module Wechat
-  autoload :Message, 'wechat/message'
-  autoload :Responder, 'wechat/responder'
-  autoload :Cipher, 'wechat/cipher'
-  autoload :ControllerApi, 'wechat/controller_api'
-
   class AccessTokenExpiredError < StandardError; end
+
   class InvalidCredentialError < StandardError; end
+
   class ResponseError < StandardError
     attr_reader :error_code
+
     def initialize(errcode, errmsg)
       @error_code = errcode
       super "#{errmsg}(#{error_code})"
@@ -47,8 +44,26 @@ module Wechat
     decrypted_data = Base64.decode64(encrypted_data)
     JSON.parse(cipher.update(decrypted_data) + cipher.final)
   rescue StandardError => e
-    { 'errcode': 41003, 'errmsg': e.message }
+    { errcode: 41003, errmsg: e.message }
   end
 end
 
 ActionView::Base.include Wechat::Helpers if defined? ActionView::Base
+require 'action_controller/wechat_responder' # To make wechat_api and wechat_responder available
+
+module ActionController
+  if defined? Base
+    ActiveSupport.on_load(:action_controller_base) do
+      class << Base
+        include WechatResponder
+      end
+    end
+  end
+  if defined? API
+    ActiveSupport.on_load(:action_controller_api) do
+      class << API
+        include WechatResponder
+      end
+    end
+  end
+end

data/lib/wechat/api.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-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
+    def initialize(appid, secret, token_file, timeout, skip_verify_ssl, jsapi_ticket_file)
+      super()
+      @client = HttpClient.new(Wechat::Api::API_BASE, timeout, skip_verify_ssl)
+      @access_token = Token::PublicAccessToken.new(@client, appid, secret, token_file)
+      @jsapi_ticket = Ticket::PublicJsapiTicket.new(@client, @access_token, jsapi_ticket_file)
+      @qcloud = nil
+    end
+
     include Concern::Common
 
     def template_message_send(message)

data/lib/wechat/api_base.rb

@@ -2,13 +2,14 @@
 
 module Wechat
   class ApiBase
-    attr_reader :access_token, :client, :jsapi_ticket
+    attr_reader :access_token, :client, :jsapi_ticket, :qcloud
 
     API_BASE = 'https://api.weixin.qq.com/cgi-bin/'
     MP_BASE = 'https://mp.weixin.qq.com/cgi-bin/'
     WXA_BASE = 'https://api.weixin.qq.com/wxa/'
     OAUTH2_BASE = 'https://api.weixin.qq.com/sns/'
     DATACUBE_BASE = 'https://api.weixin.qq.com/datacube/'
+    TCB_BASE = 'https://api.weixin.qq.com/tcb/'
     QYAPI_BASE = 'https://qyapi.weixin.qq.com/cgi-bin/'
 
     def callbackip

data/lib/wechat/api_loader.rb

@@ -9,9 +9,16 @@ module Wechat
       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)
+        if type == 'mp'
+          qcloud_env = options[:qcloud_env] || c.qcloud_env
+          qcloud_token_file = options[:qcloud_token_file] || c.qcloud_token_file.presence || '/var/tmp/qcloud_access_token'
+          qcloud_token_lifespan = options[:qcloud_token_lifespan] || c.qcloud_token_lifespan
+          Wechat::MpApi.new(c.appid, c.secret, token_file, c.timeout, c.skip_verify_ssl, js_token_file, qcloud_env, qcloud_token_file, qcloud_token_lifespan)
+        else
+          Wechat::Api.new(c.appid, c.secret, token_file, c.timeout, c.skip_verify_ssl, js_token_file)
+        end
       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
@@ -46,11 +53,13 @@ module Wechat
         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)
+          cfg[:qcloud_token] ||= Rails.root.try(:join, 'tmp/qcloud_token').try(:to_path)
         end
       end
 
       configs.each do |_, cfg|
         cfg[:timeout] ||= 20
+        cfg[:qcloud_token_lifespan] ||= 7200
         cfg[:have_session_class] = class_exists?('WechatSession')
         cfg[:oauth2_cookie_duration] ||= 1.hour
       end
@@ -135,6 +144,9 @@ module Wechat
                 skip_verify_ssl: ENV['WECHAT_SKIP_VERIFY_SSL'],
                 encoding_aes_key: ENV['WECHAT_ENCODING_AES_KEY'],
                 jsapi_ticket: ENV['WECHAT_JSAPI_TICKET'],
+                qcloud_env: ENV['WECHAT_QCLOUD_ENV'],
+                qcloud_token_file: ENV['WECHAT_QCLOUD_TOKEN'],
+                qcloud_token_lifespan: ENV['WECHAT_QCLOUD_TOKEN_LIFESPAN'],
                 trusted_domain_fullname: ENV['WECHAT_TRUSTED_DOMAIN_FULLNAME'] }
       { default: value }
     end

data/lib/wechat/cipher.rb

@@ -10,7 +10,7 @@ module Wechat
       cipher.encrypt
 
       cipher.padding = 0
-      key_data = Base64.decode64(encoding_aes_key + '=')
+      key_data = Base64.decode64("#{encoding_aes_key}=")
       cipher.key = key_data
       cipher.iv = [key_data].pack('H*')
 
@@ -22,7 +22,7 @@ module Wechat
       cipher.decrypt
 
       cipher.padding = 0
-      key_data = Base64.decode64(encoding_aes_key + '=')
+      key_data = Base64.decode64("#{encoding_aes_key}=")
       cipher.key = key_data
       cipher.iv = [key_data].pack('H*')
 
@@ -43,7 +43,7 @@ module Wechat
       msg = decode_padding(msg)
       msg_len = msg[16, 4].reverse.unpack1('V')
       content = msg[20, msg_len]
-      app_id = msg[(20 + msg_len)..-1]
+      app_id = msg[(msg_len + 20)..]
 
       [content, app_id]
     end

data/lib/wechat/concern/common.rb

@@ -3,12 +3,6 @@
 module Wechat
   module Concern
     module Common
-      def initialize(appid, secret, token_file, timeout, skip_verify_ssl, jsapi_ticket_file)
-        @client = HttpClient.new(Wechat::Api::API_BASE, timeout, skip_verify_ssl)
-        @access_token = Token::PublicAccessToken.new(@client, appid, secret, token_file)
-        @jsapi_ticket = Ticket::PublicJsapiTicket.new(@client, @access_token, jsapi_ticket_file)
-      end
-
       def groups
         get 'groups/get'
       end

data/lib/wechat/concern/qcloud.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Wechat
+  module Concern
+    module Qcloud
+      def invoke_cloud_function(function_name, post_body_params)
+        post 'invokecloudfunction', JSON.generate(post_body_params), params: { env: qcloud.qcloud_env, name: function_name }, base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_migrate_import(collection_name, file_path, file_type: Wechat::Qcloud::FILE_TYPE_JSON, stop_on_error: false, conflict_mode: Wechat::Qcloud::CONFLICT_MODE_UPSERT)
+        import_params_hash = { env: qcloud.qcloud_env,
+                               collection_name: collection_name,
+                               file_path: file_path,
+                               file_type: file_type,
+                               stop_on_error: stop_on_error,
+                               conflict_mode: conflict_mode }
+        post 'databasemigrateimport', JSON.generate(import_params_hash), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_migrate_export(query, file_path, file_type: Wechat::Qcloud::FILE_TYPE_JSON)
+        export_params_hash = { env: qcloud.qcloud_env,
+                               file_path: file_path,
+                               file_type: file_type,
+                               query: query }
+        post 'databasemigrateexport', JSON.generate(export_params_hash), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_migrate_query(job_id)
+        query_info_hash = { env: qcloud.qcloud_env,
+                            job_id: job_id }
+
+        post 'databasemigratequeryinfo', JSON.generate(query_info_hash), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_update_index(collection_name, create_indexes: [], drop_indexes: [])
+        update_index_params_hash = { env: qcloud.qcloud_env,
+                                     collection_name: collection_name,
+                                     create_indexes: create_indexes,
+                                     drop_indexes: drop_indexes }
+        post 'updateindex', JSON.generate(update_index_params_hash), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_collection_add(collection_name)
+        collection_add_params_hash = { env: qcloud.qcloud_env,
+                                       collection_name: collection_name }
+        post 'databasecollectionadd', JSON.generate(collection_add_params_hash), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_collection_delete(collection_name)
+        collection_delete_params_hash = { env: qcloud.qcloud_env,
+                                          collection_name: collection_name }
+        post 'databasecollectiondelete', JSON.generate(collection_delete_params_hash), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_collections(limit: 10, offset: 0)
+        get_collections_params_hash = { env: qcloud.qcloud_env,
+                                        limit: limit,
+                                        offset: offset }
+        post 'databasecollectionget', JSON.generate(get_collections_params_hash), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_add(add_query)
+        post 'databaseadd', JSON.generate(env: qcloud.qcloud_env, query: add_query), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_delete(delete_query)
+        post 'databasedelete', JSON.generate(env: qcloud.qcloud_env, query: delete_query), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_update(update_query)
+        post 'databaseupdate', JSON.generate(env: qcloud.qcloud_env, query: update_query), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_query(query)
+        post 'databasequery', JSON.generate(env: qcloud.qcloud_env, query: query), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_aggregate(aggregate_query)
+        post 'databaseaggregate', JSON.generate(env: qcloud.qcloud_env, query: aggregate_query), base: Wechat::Api::TCB_BASE
+      end
+
+      def qdb_count(count_query)
+        post 'databasecount', JSON.generate(env: qcloud.qcloud_env, query: count_query), base: Wechat::Api::TCB_BASE
+      end
+
+      def tcb_delete_files(fileid_list)
+        post 'batchdeletefile', JSON.generate(env: qcloud.qcloud_env, fileid_list: fileid_list), base: Wechat::Api::TCB_BASE
+      end
+
+      def tcb_download_files(file_list)
+        post 'batchdownloadfile', JSON.generate(env: qcloud.qcloud_env, file_list: file_list), base: Wechat::Api::TCB_BASE
+      end
+
+      def tcb_preflight_upload_file(q_path)
+        post 'uploadfile', JSON.generate(env: qcloud.qcloud_env, path: q_path), base: Wechat::Api::TCB_BASE
+      end
+
+      def tcb_do_upload_file(q_path, upload_url, signature, x_cos_security_token, x_cos_meta_fileid, file)
+        form_file = file.is_a?(HTTP::FormData::File) ? file : HTTP::FormData::File.new(file)
+        form_data = HTTP::FormData.create({ key: q_path,
+                                            Signature: signature,
+                                            "x-cos-security-token": x_cos_security_token,
+                                            'x-cos-meta-fileid': x_cos_meta_fileid,
+                                            file: form_file })
+        client.httprb.post(upload_url, form: form_data, ssl_context: client.ssl_context)
+      end
+
+      def tcb_upload_file(q_path, file)
+        res = tcb_preflight_upload_file(q_path)
+        tcb_do_upload_file(q_path, res['url'], res['authorization'], res['token'], res['cos_file_id'], file)
+        res
+      end
+    end
+  end
+end

data/lib/wechat/controller_api.rb

@@ -5,7 +5,7 @@ module Wechat
     extend ActiveSupport::Concern
 
     module ClassMethods
-      attr_accessor :wechat_api_client, :wechat_cfg_account, :token, :appid, :corpid, :agentid, :encrypt_mode, :timeout,
+      attr_accessor :wechat_api_client, :wechat_cfg_account, :token, :appid, :corpid, :agentid, :encrypt_mode, :timeout, :qcloud_token_lifespan,
                     :skip_verify_ssl, :encoding_aes_key, :trusted_domain_fullname, :oauth2_cookie_duration
     end
 
@@ -58,7 +58,7 @@ module Wechat
         cookies.signed_or_encrypted[:we_access_token] = { value: access_info['access_token'], expires: self.class.oauth2_cookie_duration.from_now }
         yield access_info['openid'], access_info
       else
-        Rails::VERSION::MAJOR >= 6 ? (redirect_to generate_oauth2_url(oauth2_params), allow_other_host: true) : (redirect_to generate_oauth2_url(oauth2_params))
+        redirect_to generate_oauth2_url(oauth2_params), allow_other_host: true
       end
     end
 
@@ -73,7 +73,7 @@ module Wechat
         cookies.signed_or_encrypted[:we_deviceid] = { value: userinfo['DeviceId'], expires: self.class.oauth2_cookie_duration.from_now }
         yield userinfo['UserId'], userinfo
       else
-        Rails::VERSION::MAJOR >= 6 ? (redirect_to generate_oauth2_url(oauth2_params), allow_other_host: true) : (redirect_to generate_oauth2_url(oauth2_params))
+        redirect_to generate_oauth2_url(oauth2_params), allow_other_host: true
       end
     end
 

data/lib/wechat/corp_api.rb

@@ -1,19 +1,16 @@
 # frozen_string_literal: true
 
-require 'wechat/api_base'
-require 'wechat/http_client'
-require 'wechat/token/corp_access_token'
-require 'wechat/ticket/corp_jsapi_ticket'
-
 module Wechat
   class CorpApi < ApiBase
     attr_reader :agentid
 
     def initialize(appid, secret, token_file, agentid, timeout, skip_verify_ssl, jsapi_ticket_file)
+      super()
       @client = HttpClient.new(QYAPI_BASE, timeout, skip_verify_ssl)
       @access_token = Token::CorpAccessToken.new(@client, appid, secret, token_file)
       @agentid = agentid
       @jsapi_ticket = Ticket::CorpJsapiTicket.new(@client, @access_token, jsapi_ticket_file)
+      @qcloud = nil
     end
 
     def agent_list
@@ -45,6 +42,10 @@ module Wechat
       post 'user/convert_to_openid', JSON.generate(userid: userid, agentid: agentid)
     end
 
+    def convert_to_userid(openid)
+      post 'user/convert_to_userid', JSON.generate(openid: openid)
+    end
+
     def invite_user(userid)
       post 'invite/send', JSON.generate(userid: userid)
     end
@@ -90,7 +91,7 @@ module Wechat
     end
 
     def department_update(departmentid, name = nil, parentid = nil, order = nil)
-      post 'department/update', JSON.generate({ id: departmentid, name: name, parentid: parentid, order: order }.reject { |_k, v| v.nil? })
+      post 'department/update', JSON.generate({ id: departmentid, name: name, parentid: parentid, order: order }.compact)
     end
 
     def department(departmentid = 1)