rails_wechat 0.1.0 → 0.1.1

data/app/models/wechat/model/notice/public_notice.rb

@@ -0,0 +1,25 @@
+module Wechat
+  module Model::Notice::PublicNotice
+    BASE = 'https://api.weixin.qq.com/cgi-bin/'
+
+    def do_send
+      r = app.api.post 'message/template/send', **message_hash, base: BASE
+      if r['errcode'] == 0
+        self.update msg_id: r['msgid']
+        subscribe.update sending_at: Time.now if subscribe
+      else
+        r
+      end
+    end
+
+    def message_hash
+      {
+        touser: wechat_user.uid,
+        template_id: template.template_id,
+        url: link,
+        data: data
+      }
+    end
+
+  end
+end

data/app/models/wechat/model/notice.rb

@@ -0,0 +1,56 @@
+module Wechat
+  module Model::Notice
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :link, :string, default: 'index'
+      attribute :msg_id, :string
+      attribute :status, :string
+      attribute :type, :string
+      attribute :appid, :string
+      attribute :open_id, :string
+
+      belongs_to :notification
+      belongs_to :template
+      belongs_to :app, foreign_key: :appid, primary_key: :appid
+      belongs_to :wechat_user, class_name: 'OauthUser', foreign_key: :open_id, primary_key: :uid
+      belongs_to :subscribe, optional: true
+
+      before_validation do
+        self.link = notification.link
+        self.app ||= template.app
+        #self.subscribe = wechat_user.subscribe  todo  deal with
+      end
+      after_create_commit :do_send_later
+    end
+
+    def data
+      r = {}
+      template.data_mappings.each do |key, value|
+        if key == 'first' && value[:value].blank?
+          r.merge! first: { value: notification.title }
+        else
+          r.merge! key => {
+            value: notification.notifiable_detail[value[:value]]
+          }
+        end
+      end
+      r
+    end
+
+    def do_send_later
+      NoticeSendJob.perform_later(self)
+    end
+
+    def do_send
+      r = do_send
+      if r['errcode'] == 0
+        self.update msg_id: r['msgid']
+        subscribe.update sending_at: Time.current if subscribe
+      else
+        r
+      end
+    end
+
+  end
+end

data/app/models/wechat/model/oauth_user/program_user.rb

@@ -0,0 +1,29 @@
+module Wechat
+  module Model::OauthUser::ProgramUser
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :provider, :string, default: 'wechat_program'
+
+      belongs_to :app, foreign_key: :appid, primary_key: :appid
+    end
+
+    def get_phone_number(encrypted_data, iv, session_key)
+      r = Wechat::Cipher.program_decrypt(encrypted_data, iv, session_key)
+      if r['phoneNumber']
+        r['phoneNumber']
+      else
+        self.errors.add :base, "手机号获取失败，session_key 为：#{session_key}"
+        nil
+      end
+    end
+
+    def auth_token(session_key = nil)
+      at = authorized_tokens.valid.take || authorized_tokens.build
+      at.session_key = session_key if session_key.present?
+      at.save
+      at.token
+    end
+
+  end
+end

data/app/models/wechat/model/oauth_user/wechat_user.rb

@@ -0,0 +1,109 @@
+module Wechat
+  module Model::OauthUser::WechatUser
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :provider, :string, default: 'wechat'
+      attribute :remark, :string
+
+      belongs_to :request, optional: true
+      belongs_to :app, foreign_key: :app_id, primary_key: :appid, optional: true
+
+      has_many :requests, foreign_key: :open_id, primary_key: :uid
+      has_many :subscribes, dependent: :delete_all
+      has_many :user_tags, foreign_key: :open_id, primary_key: :uid, dependent: :destroy
+      has_many :tags, through: :user_tags
+      has_many :notices, foreign_key: :open_id, primary_key: :uid
+
+      after_save_commit :sync_remark_later, if: -> { saved_change_to_remark? }
+      after_save_commit :sync_user_info_later, if: -> { saved_change_to_access_token? && (attributes['name'].blank? && attributes['avatar_url'].blank?) }
+      after_save_commit :sync_inviter, if: -> { request && saved_change_to_request_id? }
+      after_create_commit :auto_link, if: -> { unionid.present? }
+    end
+
+    def name
+      super.blank? ? "Wechat #{id}" : super
+    end
+
+    def try_match
+      app.api.menu_trymatch(uid)
+    end
+
+    def auto_link
+      if self.unionid && self.same_oauth_user
+        self.account ||= same_oauth_user.account
+      end
+      self.save
+    end
+
+    def sync_inviter
+      inviter_id = request.body.delete_prefix 'invite_by_'
+      self.account&.update inviter_id: inviter_id
+      self.user&.update inviter_id: inviter_id
+    end
+
+    def sync_remark_later
+      WechatUserJob.perform_later(self)
+    end
+
+    def sync_remark_to_wechat
+      return unless app
+      app.api.user_update_remark(uid, remark)
+    rescue Wechat::WechatError => e
+      logger.info e.message
+    end
+
+    def sync_user_info_later
+      UserInfoJob.perform_later(self)
+    end
+
+    def sync_user_info
+      params = {
+        access_token: access_token,
+        openid: uid
+      }
+      user_response = HTTPX.get('https://api.weixin.qq.com/sns/userinfo', params: params)
+      res = JSON.parse(user_response.to_s)
+
+      if res['errcode'].present?
+        self.errors.add :base, "#{res['errcode']}, #{res['errmsg']}"
+      end
+
+      self.name = res['nickname']
+      self.avatar_url = res['headimgurl']
+      self.save
+      res
+    end
+
+    def refresh_access_token
+      params = {
+        appid: app_id,
+        grant_type: 'refresh_token',
+        refresh_token: refresh_token
+      }
+
+      response = HTTPX.get 'https://api.weixin.qq.com/sns/oauth2/refresh_token', params: params
+      res = JSON.parse(response.to_s)
+      self.assign_attributes res.slice('access_token', 'refresh_token')
+      self.expires_at = Time.current + res['expires_in'].to_i
+      self.save
+      res
+    end
+
+    def assign_info(oauth_params)
+      info_params = oauth_params.fetch('info', {})
+      self.name = info_params['nickname']
+      self.avatar_url = info_params['headimgurl']
+
+      raw_info = oauth_params.dig('extra', 'raw_info') || {}
+      self.unionid = raw_info['unionid']
+      self.app_id ||= raw_info['app_id']
+
+      credential_params = oauth_params.fetch('credentials', {})
+      self.access_token = credential_params['token']
+      self.refresh_token = credential_params['refresh_token']
+      self.expires_at = Time.current + credential_params['expires_in'].to_i
+    end
+
+  end
+end

data/app/models/wechat/model/platform.rb

@@ -0,0 +1,87 @@
+module Wechat
+  module Model::Platform
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :appid, :string
+      attribute :secret, :string
+      attribute :token, :string
+      attribute :encoding_aes_key, :string
+      attribute :verify_ticket, :string
+      attribute :access_token, :string
+      attribute :access_token_expires_at, :datetime
+      attribute :pre_auth_code, :string
+      attribute :pre_auth_code_expires_at, :datetime
+
+      has_many :agencies
+      has_many :auths
+      has_many :receives, dependent: :nullify
+    end
+
+    def api
+      return @api if defined? @api
+      @api = Wechat::Api::Platform.new(self)
+    end
+
+    def refresh_pre_auth_code
+      token_hash = api.create_preauthcode
+      if token_hash.is_a?(Hash) && token_hash['pre_auth_code']
+        self.pre_auth_code = token_hash['pre_auth_code']
+        self.pre_auth_code_expires_at = Time.current + token_hash['expires_in'].to_i
+        self.save
+      else
+        raise Wechat::InvalidCredentialError, Hash(token_hash)['errmsg']
+      end
+    end
+
+    def access_token_valid?
+      return false unless access_token_expires_at.acts_like?(:time)
+      access_token_expires_at > Time.current
+    end
+
+    def pre_auth_code_valid?
+      return false unless pre_auth_code_expires_at.acts_like?(:time)
+      pre_auth_code_expires_at > 3.minutes.since
+    end
+
+    def refresh_access_token
+      r = api.component_token
+      store_access_token(r)
+    end
+
+    def store_access_token(token_hash)
+      self.access_token = token_hash['component_access_token']
+      self.access_token_expires_at = Time.current + token_hash['expires_in'].to_i
+      self.save
+    end
+
+    def auth_url
+      return if verify_ticket.blank?
+      refresh_pre_auth_code unless pre_auth_code_valid?
+      url = URI('https://mp.weixin.qq.com/dashboard/cgi-bin/componentloginpage')
+      url.query = {
+        component_appid: appid,
+        pre_auth_code: pre_auth_code,
+        redirect_uri: Rails.application.routes.url_for(controller: 'wechat/platforms', action: 'callback', id: self.id)
+      }.to_query
+      url.to_s
+    end
+
+    def click_auth_url
+      return if verify_ticket.blank?
+      refresh_pre_auth_code unless pre_auth_code_valid?
+      url = URI('https://mp.weixin.qq.com/safe/bindcomponent')
+      url.query = {
+        action: 'bindcomponent',
+        auth_type: 1,
+        no_scan: 1,
+        component_appid: appid,
+        pre_auth_code: pre_auth_code,
+        redirect_uri: Rails.application.routes.url_for(controller: 'wechat/platforms', action: 'callback', id: self.id)
+      }.to_query
+      url.to_s
+    end
+
+  end
+end

data/app/models/wechat/model/post.rb

@@ -0,0 +1,34 @@
+module Wechat
+  module Model::Post
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :thumb_media_id, :string
+    end
+
+    def to_wechat
+      r = app.api.material_add_news xx
+      if r['media_id']
+        post_sync = app.post_syncs.find_or_initialize_by(source_id: r['media_id'])
+        post_sync.post = self
+        post_sync.save
+      end
+    end
+
+    def app
+      return @app if defined? @app
+      @app = WechatApp.first
+    end
+
+    def xx
+      {
+        title: title,
+        thumb_media_id: thumb_media_id,
+        show_cover_pic: 0,
+        content: content,
+        content_source_url: 'https://one.work'
+      }
+    end
+
+  end
+end

data/app/models/wechat/model/receive.rb

@@ -0,0 +1,120 @@
+module Wechat
+  module Model::Receive
+    # see: https://developers.weixin.qq.com/doc/offiaccount/Message_Management/Receiving_standard_messages.html
+    MSG_TYPE = {
+      'text' => 'Wechat::TextRequest',
+      'image' => 'Wechat::ImageRequest',
+      'voice' => 'Wechat::VoiceRequest',
+      'video' => 'Wechat::VideoRequest',
+      'shortvideo' => 'Wechat::ShortVideoRequest',
+      'location' => 'Wechat::LocationRequest',
+      'link' => 'Wechat::LinkRequest',
+      'event' => 'Wechat::EventRequest'
+    }.freeze
+    # https://developers.weixin.qq.com/doc/offiaccount/Message_Management/Receiving_event_pushes.html
+    # https://work.weixin.qq.com/api/doc/90000/90135/90240
+    EVENT = {
+      'subscribe' => 'Wechat::SubscribeRequest',
+      'unsubscribe' => 'Wechat::UnsubscribeRequest',
+      'LOCATION' => 'Wechat::LocationRequest', # 公众号与企业微信通用
+      'CLICK' => 'Wechat::ClickRequest',
+      'VIEW' => 'Wechat::ViewRequest',
+      'SCAN' => 'Wechat::ScanRequest',
+      'click' => 'Wechat::Request',
+      'view' => 'Wechat::Request',  # 企业微信使用
+      'scancode_push' => 'Wechat::Request',
+      'scancode_waitmsg' => 'Wechat::Request',
+      'pic_sysphoto' => 'Wechat::Request',
+      'pic_photo_or_album' => 'Wechat::Request',
+      'pic_weixin' => 'Wechat::Request',
+      'location_select' => 'Wechat::Request',
+      'enter_agent' => 'Wechat::Request',
+      'batch_job_result' => 'Wechat::Request'  # 企业微信使用
+    }.freeze
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :appid, :string, index: true
+      attribute :open_id, :string, index: true
+      attribute :msg_id, :string
+      attribute :msg_type, :string
+      attribute :content, :string
+      attribute :encrypt_data, :string
+      attribute :message_hash, :json
+
+      belongs_to :platform, optional: true
+      belongs_to :app, foreign_key: :appid, primary_key: :appid, optional: true
+      belongs_to :wechat_user, foreign_key: :open_id, primary_key: :uid, optional: true
+
+      has_one :request
+
+      before_save :decrypt_data, if: -> { encrypt_data_changed? && encrypt_data.present? }
+      before_save :parse_message_hash, if: -> { message_hash_changed? && message_hash.present? }
+      after_create :parse_content
+      after_create_commit :check_app
+    end
+
+    def decrypt_data
+      aes_key = platform ? platform.encoding_aes_key : app.encoding_aes_key
+      r = Wechat::Cipher.decrypt(Base64.decode64(encrypt_data), aes_key)
+      content, _ = Wechat::Cipher.unpack(r)
+
+      self.message_hash = Hash.from_xml(content).fetch('xml', {})
+    end
+
+    def parse_message_hash
+      self.open_id = message_hash['FromUserName']
+      self.msg_type = message_hash['MsgType']
+      self.msg_id = message_hash['MsgId']
+    end
+
+    def compute_type
+      if msg_type == 'event'
+        EVENT[message_hash['Event']]
+      else
+        MSG_TYPE[msg_type]
+      end
+    end
+
+    def parse_content
+      build_request(type: compute_type)
+      request.appid = appid
+      request.open_id = open_id
+      request.generate_wechat_user  # Should before get reply
+      request.msg_type = msg_type
+      request.raw_body = message_hash.except('ToUserName', 'FromUserName', 'CreateTime', 'MsgType')
+
+      case msg_type
+      when 'text'
+        request.body = message_hash['Content']
+      when 'event'
+        request.event = message_hash['Event']
+        request.event_key = message_hash['EventKey'] || message_hash.dig('ScanCodeInfo', 'ScanResult')
+        if request.event == 'subscribe'
+          request.body = request.event_key.delete_prefix('qrscene_')
+        else
+          request.body = request.event_key
+        end
+      when 'image'
+        request.body = message_hash['PicUrl']
+      when 'voice'
+        request.body = message_hash['Recognition'].presence || message_hash['MediaId']
+      when 'video', 'shortvideo'
+        request.body = message_hash['MediaId']
+      when 'location'
+        request.body = "#{message_hash['Location_X']}:#{message_hash['Location_Y']}"
+      when 'link'
+        request.body = message_hash['Url']
+      else
+        warn "Don't know how to parse message as #{message_hash['MsgType']}", uplevel: 1
+      end
+
+      self.save  # will auto save wechat request
+    end
+
+    def check_app
+      app.update user_name: message_hash['ToUserName'] if app
+    end
+
+  end
+end