rails_wechat 0.1.0 → 0.1.1

data/app/controllers/wechat/admin/tags_controller.rb

@@ -0,0 +1,43 @@
+module Wechat
+  class Admin::TagsController < Admin::BaseController
+    before_action :set_app
+    before_action :set_tag, only: [:show, :edit, :update, :destroy]
+
+    def index
+      q_params = {}
+      q_params.merge! params.permit(:name)
+
+      @tags = @app.tags.default_where(q_params).order(id: :asc).page(params[:page])
+    end
+
+    def new
+      @tag = @app.tags.build
+    end
+
+    def create
+      @tag = @app.tags.build(tag_params)
+
+      unless @tag.save
+        render :new, locals: { model: @tag }, status: :unprocessable_entity
+      end
+    end
+
+    def sync
+      @app.sync_tags
+    end
+
+    private
+    def set_tag
+      @tag = @app.tags.find(params[:id])
+    end
+
+    def tag_params
+      params.fetch(:tag, {}).permit(
+        :name,
+        :tagging_type,
+        :tagging_id
+      )
+    end
+
+  end
+end

data/app/controllers/wechat/admin/templates_controller.rb

@@ -0,0 +1,48 @@
+module Wechat
+  class Admin::TemplatesController < Admin::BaseController
+    before_action :set_app
+    before_action :set_template, only: [:show, :edit, :update, :destroy]
+
+    def index
+      q_params = {}
+
+      @templates = @app.templates.default_where(q_params).page(params[:page])
+      template_config_ids = @templates.pluck(:template_config_id)
+      @template_configs = TemplateConfig.where.not(id: template_config_ids)
+    end
+
+    def create
+      @template = @app.templates.build(template_params)
+
+      unless @template.save
+        render :new, locals: { model: @template }, status: :unprocessable_entity
+      end
+    end
+
+    def sync
+      r = @app.sync_templates
+    end
+
+    private
+    def set_app
+      @app = App.default_where(default_params).find_by id: params[:app_id]
+    end
+
+    def set_template
+      @template = Template.find(params[:id])
+    end
+
+    def template_params
+      params.fetch(:template, {}).permit(
+        :app_id,
+        :template_config_id,
+        :template_id,
+        :title,
+        :content,
+        :example,
+        :template_type
+      )
+    end
+
+  end
+end

data/app/controllers/wechat/admin/wechat_users_controller.rb

@@ -0,0 +1,31 @@
+module Wechat
+  class Admin::WechatUsersController < Admin::BaseController
+    before_action :set_app
+    before_action :set_wechat_user, only: [:show, :edit, :update, :destroy]
+
+    def index
+      q_params = {}
+      q_params.merge! params.permit('wechat_user_tags.tag_id', :name)
+
+      @wechat_users = @app.wechat_users.default_where(q_params).order(id: :desc).page(params[:page])
+    end
+
+    def edit
+      @tags = @app.tags
+    end
+
+    private
+    def set_wechat_user
+      @wechat_user = @app.wechat_users.find params[:id]
+    end
+
+    def wechat_user_params
+      params.fetch(:wechat_user, {}).permit(
+        :name,
+        :remark,
+        tag_ids: []
+      )
+    end
+
+  end
+end

data/app/controllers/wechat/apps_controller.rb

@@ -0,0 +1,62 @@
+module Wechat
+  class AppsController < BaseController
+    before_action :set_app, only: [:show, :login]
+    before_action :set_scene, only: [:login]
+
+    def show
+      @oauth_user = @app.generate_wechat_user(params[:code])
+      if @oauth_user.account.nil? && current_account
+        @oauth_user.account = current_account
+      end
+      @oauth_user.save
+
+      if @oauth_user.user
+        login_by_oauth_user(@oauth_user)
+        redirect_to session[:return_to] || RailsAuth.config.default_return_path
+        session.delete :return_to
+      else
+        url_options = {}
+        url_options.merge! params.except(:controller, :action, :id, :business, :namespace, :code, :state).permit!
+        url_options.merge! host: URI(session[:return_to]).host if session[:return_to]
+
+        redirect_to url_for(controller: 'auth/sign', action: 'sign', uid: @oauth_user.uid, **url_options)
+      end
+    end
+
+    def login
+      @oauth_user = @app.generate_wechat_user(params[:code])
+      if @oauth_user.account.nil? && current_account
+        @oauth_user.account = current_account
+      end
+      @oauth_user.save
+
+      if @oauth_user.user
+        login_by_oauth_user(@oauth_user)
+        Com::SessionChannel.broadcast_to(params[:state], auth_token: current_authorized_token.token)
+      else
+        url_options = {}
+        url_options.merge! params.except(:controller, :action, :id, :business, :namespace, :code, :state).permit!
+        url_options.merge! host: URI(session[:return_to]).host if session[:return_to]
+
+        redirect_to url_for(controller: 'auth/sign', action: 'sign', uid: @oauth_user.uid, **url_options)
+      end
+    end
+
+    def create
+    end
+
+    private
+    def set_app
+      @app = App.find params[:id]
+    end
+
+    def set_scene(prefix = 'invite_form_scan')
+      @scene = Scene.find_or_initialize_by(appid: @app.appid, match_value: "#{prefix}")
+      @scene.expire_seconds ||= 2592000
+      @scene.organ_id = @app.organ_id
+      @scene.save
+      @scene
+    end
+
+  end
+end

data/app/controllers/wechat/base_controller.rb

@@ -0,0 +1,5 @@
+module Wechat
+  class BaseController < BaseController
+    include Controller::Application
+  end
+end

data/app/controllers/wechat/controller/application.rb

@@ -0,0 +1,78 @@
+# Should order after RailsAuth::Application
+module Wechat
+  module Controller::Application
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :current_wechat_app
+    end
+
+    def require_login(return_to: nil)
+      return if current_user
+      return super unless request.variant.any?(:wechat)
+      store_location(return_to)
+
+      if current_wechat_user && current_wechat_user.user.nil?
+        redirect_url = sign_url(uid: current_wechat_user.uid)
+      elsif current_wechat_app && current_wechat_app.respond_to?(:oauth2_url)
+        redirect_url = current_wechat_app.oauth2_url(host: request.host, port: request.port, protocol: request.protocol)
+      else
+        redirect_url = sign_url
+      end
+
+      if redirect_url
+        logger.debug "  \e[35mRedirect to: #{redirect_url}\e[0m"
+      end
+
+      redirect_to redirect_url
+    end
+
+    def current_wechat_app
+      return @current_wechat_app if defined?(@current_wechat_app)
+      @current_wechat_app = current_organ_domain&.wechat_app
+      logger.debug "  \e[35mCurrent Wechat App is #{@current_wechat_app&.id}\e[0m"
+      @current_wechat_app
+    end
+
+    def current_wechat_user
+      return @current_wechat_user if defined?(@current_wechat_user)
+      @current_wechat_user = current_account&.wechat_user
+    end
+
+    # 需要微信授权获取openid, 但并不需要注册为用户
+    def require_wechat_user(return_to: nil)
+      return if current_oauth_user
+      store_location(return_to)
+
+      redirect_url = '/auth/wechat?skip_register=true'
+
+      render 'wechat_require_login', locals: { redirect_url: redirect_url, message: '请允许获取您的微信信息' }, status: 401
+    end
+
+    def bind_to_wechat(request)
+      key = request[:EventKey].delete_prefix?('qrscene_')
+      wechat_user = WechatUser.find_by(open_id: request[:FromUserName])
+      session[:wechat_open_id] ||= request[:FromUserName]
+
+      user = User.find_by id: key
+      if wechat_user && user
+        old_user = wechat_user.user
+        if old_user&.id == user.id
+          request.reply.text "您的微信账号已经绑定到账号 #{user.member_name} 了"
+        elsif old_user
+          wechat_user.update(user_id: key, state: :change_bind)
+          request.reply.text "您的微信账号已更换绑定账号, 之前绑定的账号是#{old_user.member_name}, 已经绑定到#{user.member_name}"
+        else
+          wechat_user.update(user_id: key, state: :bind)
+          request.reply.text "您的微信账号绑定至账号 #{user.member_name} 成功"
+        end
+      elsif user
+        user.wechat_users.create(open_id: request[:FromUserName], state: :bind)
+        request.reply.text "已成功绑定,账号 #{user.member_name}"
+      else
+        request.reply.text '未找到当前用户,绑定失败'
+      end
+    end
+
+  end
+end

data/app/controllers/wechat/my/base_controller.rb

@@ -0,0 +1,4 @@
+module Wechat
+  class My::BaseController < MyController
+  end
+end

data/app/controllers/wechat/my/medias_controller.rb

@@ -0,0 +1,56 @@
+module Wechat
+  class My::MediasController < My::BaseController
+    before_action :set_media, only: [:show, :edit, :update, :destroy]
+
+    def index
+      @media = Media.page(params[:page])
+    end
+
+    def new
+      @media = Media.new
+    end
+
+    def create
+      @media = Media.new(media_params)
+      @media.appid = current_wechat_app.appid
+      @media.user_id = current_user.id
+
+      unless @media.save
+        render :new, locals: { model: @media }, status: :unprocessable_entity
+      end
+    end
+
+    def show
+    end
+
+    def edit
+    end
+
+    def update
+      @media.assign_attributes(media_params)
+
+      unless @media.save
+        render :edit, locals: { model: @media }, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @media.destroy
+    end
+
+    private
+    def set_media
+      @media = Media.find(params[:id])
+    end
+
+    def media_params
+      params.fetch(:media, {}).permit(
+        :source_type,
+        :source_id,
+        :media_id,
+        :attachment_name
+      )
+    end
+
+  end
+end

data/app/controllers/wechat/my/registers_controller.rb

@@ -0,0 +1,74 @@
+module Wechat
+  class My::RegistersController < My::BaseController
+    before_action :set_register, only: [:show, :edit, :edit_code, :update, :destroy]
+
+    def index
+      @registers = current_user.registers
+
+      if @registers.blank?
+        new_register
+        render :new
+      else
+        render 'index'
+      end
+    end
+
+    def new
+      new_register
+    end
+
+    def create
+      new_register
+
+      if @register.save
+        render 'create', locals: { return_to: my_registers_url }
+      else
+        render :new, locals: { model: @register }, status: :unprocessable_entity
+      end
+    end
+
+    def show
+    end
+
+    def edit
+    end
+
+    def edit_code
+    end
+
+    def update
+      @register.assign_attributes(register_params)
+
+      if @register.save
+        render 'update', locals: { return_to: my_registers_url }
+      else
+        render :edit, locals: { model: @register }, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @register.destroy
+    end
+
+    private
+    def new_register
+      @register = current_user.registers.build(register_params)
+      @register.mobile ||= current_account.identity if current_account.is_a?(::Auth::MobileAccount)
+    end
+
+    def set_register
+      @register = Register.find(params[:id])
+    end
+
+    def register_params
+      p = params.fetch(:register, {}).permit(
+        :id_name,
+        :id_number,
+        :mobile,
+        :mobile_code
+      )
+      p.merge! default_form_params
+    end
+
+  end
+end

data/app/controllers/wechat/my/subscribes_controller.rb

@@ -0,0 +1,18 @@
+module Wechat
+  class My::SubscribesController < My::BaseController
+
+    def create
+      r = subscribes_params.to_h.map do |k, v|
+        next if k.blank?
+        template = current_wechat_user.app.templates.find_by template_id: k
+        subscribe = current_wechat_user.subscribes.build(status: v)
+        subscribe.template = template
+        subscribe.save
+        subscribe
+      end
+
+      render json: r.as_json
+    end
+
+  end
+end

data/app/controllers/wechat/my/users_controller.rb

@@ -0,0 +1,18 @@
+module Wechat
+  class My::UsersController < My::BaseController
+
+    def invite_qrcode
+      @scene = current_user.invite_scene(current_wechat_app)
+    end
+
+    def requests
+      @scene = current_user.invite_scene(current_wechat_app)
+      if @scene.tag
+        @requests =  @scene.tag.requests.includes(:wechat_user).page(params[:page])
+      else
+        @requests = Request.none.page(params[:page])
+      end
+    end
+
+  end
+end