rails_com 1.2.9 → 1.3.0

data/app/models/com/model/err.rb

@@ -0,0 +1,108 @@
+module Com
+  module Model::Err
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :path, :string
+      attribute :controller_name, :string
+      attribute :action_name, :string
+      attribute :exception, :string
+      attribute :exception_object, :string
+      attribute :exception_backtrace, :string, array: true, default: []
+      attribute :params, :json, default: {}
+      attribute :headers, :json, default: {}
+      attribute :cookie, :json, default: {}
+      attribute :session, :json, default: {}
+      attribute :ip, :string
+
+      default_scope -> { order(id: :desc) }
+
+      after_create_commit :send_message
+    end
+
+    def send_message
+      RailsCom.config.notify_bot.constantize.new(self).send_message
+    end
+
+    def user_info
+      token = session.dig('auth_token') || headers.dig('AUTH_TOKEN')
+      return {} unless defined? Auth::AuthorizedToken
+      at = Auth::AuthorizedToken.find_by token: token
+      if at&.user
+        at.user.as_json(only: [:id, :name], methods: [:account_identities])
+      elsif at&.account
+        at.account.as_json(only: [:id, :identity])
+      else
+        {}
+      end
+    end
+
+    def process_job
+      ErrJob.perform_later(self)
+    end
+
+    def record(payload)
+      self.path = payload[:path]
+      self.controller_name = payload[:controller]
+      self.action_name = payload[:action]
+      self.exception = payload[:exception].join("\r\n")[0..self.class.columns_limit['exception']]
+      self.exception_object = payload[:exception_object].class.to_s
+      self.exception_backtrace = payload[:exception_object].backtrace
+      self.params = self.class.filter_params(payload[:params])
+
+      raw_headers = payload.fetch(:headers, {})
+      self.headers = self.class.request_headers(raw_headers)
+      self.ip = raw_headers['action_dispatch.remote_ip'].to_s
+      self.cookie = raw_headers['rack.request.cookie_hash']
+      self.session = raw_headers['rack.session'].to_h
+    end
+
+    def record!(payload)
+      record(payload)
+      save
+      self
+    end
+
+    class_methods do
+      def record_to_log(controller, exp)
+        return if Rails.env.development? && RailsCom.config.disable_debug
+        request = controller.request
+
+        lc = self.new
+        payload = {
+          path: request.fullpath,
+          controller: controller.class.name,
+          action: controller.action_name,
+          params: request.filtered_parameters,
+          headers: request.headers,
+          exception: [exp.class.name, exp.message],
+          exception_object: exp
+        }
+        lc.record!(payload)
+      end
+
+      def request_headers(headers)
+        result = headers.select { |k, _| k.start_with?('HTTP_') && k != 'HTTP_COOKIE' }
+        result = result.collect { |pair| [pair[0].sub(/^HTTP_/, ''), pair[1]] }
+        result.sort.to_h
+      end
+
+      def filter_params(params)
+        params.deep_transform_values(&:to_s).except('controller', 'action')
+      end
+
+      def columns_limit
+        @columns_limit ||= self.columns_hash.slice(
+          'params',
+          'headers',
+          'cookie',
+          'session',
+          'exception',
+          'exception_object',
+          'exception_backtrace'
+        ).transform_values { |i| i.limit.nil? ? -1 : i.limit - 1 }
+      end
+    end
+
+  end
+end

data/app/models/com/model/info.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Com
+  module Model::Info
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :code, :string
+      attribute :value, :string
+      attribute :version, :string
+
+      enum platform: {
+        ios: 'ios',
+        android: 'android'
+      }
+
+      validates :code, presence: true
+    end
+
+    class_methods do
+
+      def verbose(q_params = nil)
+        r = Info.default_where(q_params).as_json(only: [:code, :value])
+        result = {}
+        r.map { |i| result[i['code']] = i['value'] }
+        result
+      end
+
+    end
+
+  end
+end

data/app/models/com/model/meta_action.rb

@@ -0,0 +1,70 @@
+module Com
+  module Model::MetaAction
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :namespace_identifier, :string, default: '', null: false, index: true
+      attribute :business_identifier, :string, default: '', null: false, index: true
+      attribute :controller_path, :string, null: false, index: true
+      attribute :controller_name, :string, null: false
+      attribute :action_name, :string
+      attribute :path, :string
+      attribute :verb, :string
+      attribute :required_parts, :string, array: true
+      attribute :position, :integer
+      attribute :landmark, :boolean
+
+      belongs_to :meta_business, foreign_key: :business_identifier, primary_key: :identifier
+      belongs_to :meta_namespace, foreign_key: :namespace_identifier, primary_key: :identifier
+      belongs_to :meta_controller, foreign_key: :controller_path, primary_key: :controller_path
+
+      enum operation: {
+        list: 'list',
+        read: 'read',
+        add: 'add',
+        edit: 'edit',
+        remove: 'remove'
+      }, _default: 'read'
+
+      default_scope -> { order(position: :asc, id: :asc) }
+
+      acts_as_list scope: [:business_identifier, :namespace_identifier, :controller_path]
+
+      before_validation :sync_from_controller, if: -> { meta_controller && (controller_path_changed? || meta_controller.new_record?) }
+    end
+
+    def role_path
+      {
+        business_identifier.to_s => {
+          namespace_identifier.to_s => {
+            controller_path => { action_name => role_hash }
+          }
+        }
+      }
+    end
+
+    def role_hash
+      id
+    end
+
+    def identifier
+      [business_identifier, namespace_identifier, controller_path, (action_name.blank? ? '_' : action_name)].join('_')
+    end
+
+    def name
+      t1 = I18n.t "#{[business_identifier, namespace_identifier, controller_name, action_name].join('.')}.title", default: nil
+      return t1 if t1
+
+      t2 = self.class.enum_i18n :action_name, self.action_name
+      return t2 if t2
+
+      identifier
+    end
+
+    def sync_from_controller
+      self.business_identifier = meta_controller.business_identifier
+      self.namespace_identifier = meta_controller.namespace_identifier
+    end
+
+  end
+end

data/app/models/com/model/meta_business.rb

@@ -0,0 +1,66 @@
+module Com
+  module Model::MetaBusiness
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :identifier, :string, default: '', null: false, index: true
+      attribute :position, :integer
+
+      has_many :meta_controllers, foreign_key: :business_identifier, primary_key: :identifier
+      has_many :meta_actions, foreign_key: :business_identifier, primary_key: :identifier
+
+      has_one_attached :logo
+
+      validates :identifier, uniqueness: true
+
+      acts_as_list
+    end
+
+    def name
+      return super if super.present?
+
+      t = I18n.t "#{identifier}.title", default: nil
+      return t if t
+
+      identifier
+    end
+
+    def tr_id
+      "tr_#{identifier.blank? ? '_' : identifier}"
+    end
+
+    def meta_namespaces
+      MetaNamespace.where(identifier: MetaController.unscope(:order).select(:namespace_identifier).where(business_identifier: identifier).distinct.pluck(:namespace_identifier)).order(id: :asc)
+    end
+
+    def role_path
+      {
+        identifier => role_hash
+      }
+    end
+
+    def role_hash
+      meta_namespaces.each_with_object({}) { |i, h| h.merge! i.identifier => i.role_hash(identifier) }
+    end
+
+    class_methods do
+
+      def sync
+        existing = self.select(:identifier).distinct.pluck(:identifier)
+        business_keys = RailsExtend::Routes.businesses.keys
+
+        (business_keys - existing).each do |business|
+          b = self.find_or_initialize_by(identifier: business)
+          b.save
+        end
+
+        (existing - business_keys).each do |business|
+          self.find_by(identifier: business).destroy
+        end
+      end
+
+    end
+
+  end
+end

data/app/models/com/model/meta_column.rb

@@ -0,0 +1,36 @@
+module Com
+  module Model::MetaColumn
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :record_name, :string, index: true
+      attribute :column_name, :string
+      attribute :sql_type, :string
+      attribute :column_type, :string
+      attribute :column_limit, :integer
+      attribute :comment, :string
+      attribute :defined_db, :boolean, default: false
+      attribute :defined_model, :boolean, default: false
+      attribute :belongs_enable, :boolean, default: false
+      attribute :belongs_table, :string
+
+      belongs_to :meta_model, foreign_key: :record_name, primary_key: :record_name
+    end
+
+    def sync
+      unless record_class.column_names.include?(self.column_name)
+        record_class.connection.add_column(record_class.table_name, column_name, column_type)
+        record_class.reset_column_information
+      end
+    end
+
+    def test
+      record_class.update self.column_name => 'ss'
+    end
+
+    def record_class
+      record_name.constantize
+    end
+
+  end
+end

data/app/models/com/model/meta_controller.rb

@@ -0,0 +1,115 @@
+module Com
+  module Model::MetaController
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :namespace_identifier, :string, default: '', null: false, index: true
+      attribute :business_identifier, :string, default: '', null: false, index: true
+      attribute :controller_path, :string, null: false, index: true
+      attribute :controller_name, :string, null: false
+      attribute :position, :integer
+
+      belongs_to :meta_namespace, foreign_key: :namespace_identifier, primary_key: :identifier, optional: true
+      belongs_to :meta_business, foreign_key: :business_identifier, primary_key: :identifier, optional: true
+
+      has_many(
+        :meta_actions,
+        -> { order(position: :asc) },
+        foreign_key: :controller_path,
+        primary_key: :controller_path,
+        dependent: :destroy_async,
+        inverse_of: :meta_controller
+      )
+      accepts_nested_attributes_for :meta_actions, allow_destroy: true
+
+      default_scope -> { order(position: :asc, id: :asc) }
+
+      validates :controller_path, uniqueness: { scope: [:business_identifier, :namespace_identifier] }
+
+      acts_as_list scope: [:namespace_identifier, :business_identifier]
+    end
+
+    def identifier
+      [business_identifier, namespace_identifier, (controller_path.blank? ? '_' : controller_path)].join('_')
+    end
+
+    def business_name
+      t = I18n.t "#{business_identifier}.title", default: nil
+      return t if t
+
+      business_identifier
+    end
+
+    def namespace_name
+      t = I18n.t "#{business_identifier}.#{namespace_identifier}.title", default: nil
+      return t if t
+
+      namespace_identifier
+    end
+
+    def name
+      t = I18n.t "#{controller_path.to_s.split('/').join('.')}.index.title", default: nil
+      return t if t
+
+      controller_path
+    end
+
+    def role_path
+      {
+        business_identifier => {
+          namespace_identifier => { controller_path => role_hash }
+        }
+      }
+    end
+
+    def role_hash
+      meta_actions.each_with_object({}) { |i, h| h.merge! i.action_name => i.role_hash }
+    end
+
+    class_methods do
+
+      def actions
+        result = {}
+        MetaBusiness.all.includes(meta_controllers: :meta_actions).each do |meta_business|
+          result.merge! meta_business.identifier => meta_business.meta_controllers.group_by(&:namespace_identifier).transform_values!(&->(meta_controllers){
+            meta_controllers.each_with_object({}) { |meta_controller, h| h.merge! meta_controller.controller_name => meta_controller.meta_actions.pluck(:action_name) }
+          })
+        end
+        result
+      end
+
+      def sync
+        RailsExtend::Routes.actions.each do |business, namespaces|
+          namespaces.each do |namespace, controllers|
+            controllers.each do |controller, actions|
+              meta_controller = MetaController.find_or_initialize_by(business_identifier: business, namespace_identifier: namespace, controller_path: controller)
+              meta_controller.controller_name = controller.to_s.split('/')[-1]
+
+              actions.each do |action_name, action|
+                meta_action = meta_controller.meta_actions.find_or_initialize_by(action_name: action_name)
+                meta_action.controller_name = meta_controller.controller_name
+                meta_action.path = action[:path]
+                meta_action.verb = action[:verb]
+                meta_action.required_parts = action[:required_parts]
+              end
+
+              present_meta_actions = meta_controller.meta_actions.pluck(:action_name)
+              meta_controller.meta_actions.select(&->(i){ (present_meta_actions - actions.keys).include?(i.action_name) }).each do |meta_action|
+                meta_action.mark_for_destruction
+              end
+
+              meta_controller.save if meta_controller.meta_actions.length > 0
+            end
+
+            present_controllers = MetaController.where(business_identifier: business, namespace_identifier: namespace).pluck(:controller_path)
+            MetaController.where(business_identifier: business, namespace_identifier: namespace, controller_path: (present_controllers - controllers.keys)).each do |meta_controller|
+              meta_controller.destroy
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/app/models/com/model/meta_model.rb

@@ -0,0 +1,58 @@
+module Com
+  module Model::MetaModel
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :record_name, :string, index: true
+      attribute :description, :string
+      attribute :defined_db, :boolean, default: false
+      attribute :customizable, :boolean, default: false, comment: '是否允许用户定制'
+
+      has_many :meta_columns, foreign_key: :record_name, primary_key: :record_name, inverse_of: :meta_model
+    end
+
+    def record_class
+      record_name.constantize
+    end
+
+    class_methods do
+
+      def sync
+        RailsExtend::Models.models.each do |model|
+          next unless model.table_exists?
+          meta_model = self.find_or_initialize_by(record_name: model.name)
+          meta_model.defined_db = true
+
+          model.columns.each do |column|
+            meta_column = meta_model.meta_columns.find_or_initialize_by(column_name: column.name)
+            meta_column.column_type = column.type
+            meta_column.sql_type = column.sql_type
+            meta_column.column_limit = column.limit
+            meta_column.comment = column.comment
+            meta_column.defined_db = true
+            meta_column.defined_model = true if model.attributes_to_define_after_schema_loads.keys.include?(column.name)
+
+            present_meta_columns = meta_model.meta_columns.pluck(:column_name)
+            meta_model.meta_columns.select(&->(i){ (present_meta_columns - model.column_names).include?(i.column_name) }).each do |needless_column|
+              needless_column.mark_for_destruction
+            end
+          end
+          meta_model.save if meta_model.meta_columns.length > 0
+
+          present_models = self.pluck(:record_name)
+          self.where(record_name: (present_models - RailsExtend::Models.model_names)).each do |needless_model|
+            needless_model.destroy
+          end
+        end
+      end
+
+      # todo 导出为 json 配置
+      def dump
+
+      end
+
+    end
+
+  end
+end

data/app/models/com/model/meta_namespace.rb

@@ -0,0 +1,61 @@
+module Com
+  module Model::MetaNamespace
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :identifier, :string, default: '', null: false, index: true
+      attribute :verify_organ, :boolean, default: false
+      attribute :verify_member, :boolean, default: false
+      attribute :verify_user, :boolean, default: false
+
+      has_many :meta_controllers, foreign_key: :namespace_identifier, primary_key: :identifier
+      has_many :meta_actions, foreign_key: :namespace_identifier, primary_key: :identifier
+
+      validates :identifier, uniqueness: true
+    end
+
+    def name
+      if super.present?
+        super
+      else
+        identifier
+      end
+    end
+
+    def tr_id(business_identifier)
+      "tr_#{business_identifier}_#{identifier.blank? ? '_' : identifier}"
+    end
+
+    def role_path(business_identifier = '')
+      {
+        business_identifier.to_s => {
+          identifier => role_hash(business_identifier)
+        }
+      }
+    end
+
+    def role_hash(business_identifier = '')
+      meta_controllers = MetaController.includes(:meta_actions).where(business_identifier: business_identifier.to_s, namespace_identifier: identifier)
+      meta_controllers.each_with_object({}) { |i, h| h.merge! i.controller_path => i.role_hash }
+    end
+
+    class_methods do
+
+      def sync
+        existing = self.select(:identifier).distinct.pluck(:identifier)
+        namespace_keys = RailsExtend::Routes.namespaces.keys
+        (namespace_keys - existing).each do |namespace|
+          n = self.find_or_initialize_by(identifier: namespace)
+          n.save
+        end
+
+        (existing - namespace_keys).each do |namespace|
+          self.find_by(identifier: namespace).destroy
+        end
+      end
+
+    end
+
+  end
+end

data/app/models/com/model/meta_operation.rb

@@ -0,0 +1,18 @@
+module Com
+  module Model::MetaOperation
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :action_name, :string
+
+      enum operation: {
+        list: 'list',
+        read: 'read',
+        add: 'add',
+        edit: 'edit',
+        remove: 'remove'
+      }, _default: 'read'
+    end
+
+  end
+end

data/app/models/com/model/meta_permission.rb

@@ -0,0 +1,10 @@
+module Com
+  module Model::MetaPermission
+    extend ActiveSupport::Concern
+
+    included do
+
+    end
+
+  end
+end

data/app/models/com/model/meta_relation.rb

@@ -0,0 +1,6 @@
+module Com
+  module Model::MetaRelation
+    extend ActiveSupport::Concern
+
+  end
+end

data/app/models/com/model/meta_route.rb

@@ -0,0 +1,10 @@
+module Com
+  module Model::MetaRoute
+    extend ActiveSupport::Concern
+
+    included do
+
+    end
+
+  end
+end

data/app/models/com.rb

@@ -0,0 +1,11 @@
+module Com
+
+  def self.use_relative_model_naming?
+    true
+  end
+
+  def self.table_name_prefix
+    'com_'
+  end
+
+end

data/app/models/concerns/feishu_bot.rb

@@ -0,0 +1,15 @@
+class FeishuBot < LogRecordBot
+
+  def send_message
+    url = "https://open.feishu.cn/open-apis/bot/hook/#{RailsCom.config.notify_key}"
+    HTTPX.post(url, json: body)
+  end
+
+  def body
+    {
+      title: '收到错误通知',
+      text: content
+    }
+  end
+
+end

data/app/models/concerns/log_record_bot.rb

@@ -0,0 +1,40 @@
+class LogRecordBot
+  attr_reader :content
+
+  def initialize(log_record)
+    @log_record = log_record
+    @content = ''
+    set_content
+  end
+
+  def set_content
+    @log_record.as_json(only: [:path, :controller_name, :action_name, :params, :session, :headers, :ip]).each do |k, v|
+      add_column @log_record.class.human_attribute_name(k), v unless v.blank?
+    end
+    add_column '用户信息', @log_record.user_info.inspect
+    add_paragraph(@log_record.exception)
+    add_paragraph(@log_record.exception_backtrace[0])
+    link_more('详细点击', Rails.application.routes.url_for(controller: 'com/panel/errs', action: 'show', id: @log_record.id))
+  end
+
+  def add_paragraph(content)
+    @content << "#{content}\n"
+  end
+
+  def add_section(header, paragraph, level: 3)
+    @content << "#{'#' * level} #{header}\n"
+    @content << "#{paragraph}\n"
+  end
+
+  def add_column(title, content)
+    @content << "**#{title}：**#{content}\n"
+  end
+
+  def link_more(name, url)
+    text = "\n[#{name}](#{url})"
+    truncate_length = 4096 - text.bytesize
+
+    @content = @content.truncate_bytes(truncate_length) + text
+  end
+
+end

data/app/models/concerns/work_wechat_bot.rb

@@ -0,0 +1,18 @@
+class WorkWechatBot < LogRecordBot
+
+  def send_message
+    url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=#{RailsCom.config.notify_key}"
+
+    HTTPX.post(url, json: body)
+  end
+
+  def body
+    {
+      msgtype: 'markdown',
+      markdown: {
+        content: content
+      }
+    }
+  end
+
+end