hyper-max-sys 0.0.1

data/rails_admin-3.3.0/lib/rails_admin/adapters/mongoid/property.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    module Mongoid
+      class Property
+        STRING_TYPE_COLUMN_NAMES = %i[name title subject].freeze
+        attr_reader :property, :model
+
+        def initialize(property, model)
+          @property = property
+          @model = model
+        end
+
+        def name
+          (property.options[:as] || property.name).to_sym
+        end
+
+        def pretty_name
+          (property.options[:as] || property.name).to_s.tr('_', ' ').capitalize
+        end
+
+        def type
+          case property.type.to_s
+          when 'Array', 'Hash', 'Money'
+            :serialized
+          when 'BigDecimal'
+            :decimal
+          when 'Boolean', 'Mongoid::Boolean'
+            :boolean
+          when 'BSON::ObjectId', 'Moped::BSON::ObjectId'
+            :bson_object_id
+          when 'Date'
+            :date
+          when 'ActiveSupport::TimeWithZone', 'DateTime', 'Time'
+            :datetime
+          when 'Float'
+            :float
+          when 'Integer'
+            :integer
+          when 'Object'
+            object_field_type
+          when 'String'
+            string_field_type
+          when 'Symbol'
+            :string
+          else
+            :string
+          end
+        end
+
+        def length
+          (length_validation_lookup || 255) if type == :string
+        end
+
+        def nullable?
+          true
+        end
+
+        def serial?
+          name == :_id
+        end
+
+        def association?
+          false
+        end
+
+        def read_only?
+          model.readonly_attributes.include? property.name.to_s
+        end
+
+      private
+
+        def object_field_type
+          association = Association.new model.relations.values.detect { |r| r.try(:foreign_key).try(:to_sym) == name }, model
+          if %i[belongs_to referenced_in embedded_in].include?(association.macro)
+            :bson_object_id
+          else
+            :string
+          end
+        end
+
+        def string_field_type
+          if ((length = length_validation_lookup) && length < 256) || STRING_TYPE_COLUMN_NAMES.include?(name)
+            :string
+          else
+            :text
+          end
+        end
+
+        def length_validation_lookup
+          shortest = model.validators.select { |validator| validator.respond_to?(:attributes) && validator.attributes.include?(name.to_sym) && validator.kind == :length && validator.options[:maximum] }.min do |a, b|
+            a.options[:maximum] <=> b.options[:maximum]
+          end
+
+          shortest && shortest.options[:maximum]
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/adapters/mongoid.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+require 'mongoid'
+require 'rails_admin/config/sections/list'
+require 'rails_admin/adapters/mongoid/association'
+require 'rails_admin/adapters/mongoid/object_extension'
+require 'rails_admin/adapters/mongoid/property'
+require 'rails_admin/adapters/mongoid/bson'
+
+module RailsAdmin
+  module Adapters
+    module Mongoid
+      DISABLED_COLUMN_TYPES = %w[Range Moped::BSON::Binary BSON::Binary Mongoid::Geospatial::Point].freeze
+
+      def parse_object_id(value)
+        Bson.parse_object_id(value)
+      end
+
+      def new(params = {})
+        model.new(params).extend(ObjectExtension)
+      end
+
+      def get(id, scope = scoped)
+        object = scope.find(id)
+        return nil unless object
+
+        object.extend(ObjectExtension)
+      rescue StandardError => e
+        raise e if %w[
+          Mongoid::Errors::DocumentNotFound
+          Mongoid::Errors::InvalidFind
+          Moped::Errors::InvalidObjectId
+          BSON::InvalidObjectId
+          BSON::Error::InvalidObjectId
+        ].exclude?(e.class.to_s)
+      end
+
+      def scoped
+        model.scoped
+      end
+
+      def first(options = {}, scope = nil)
+        all(options, scope).first
+      end
+
+      def all(options = {}, scope = nil)
+        scope ||= scoped
+        scope = scope.includes(*options[:include]) if options[:include]
+        scope = scope.limit(options[:limit]) if options[:limit]
+        scope = scope.any_in(_id: options[:bulk_ids]) if options[:bulk_ids]
+        scope = query_scope(scope, options[:query]) if options[:query]
+        scope = filter_scope(scope, options[:filters]) if options[:filters]
+        scope = scope.send(Kaminari.config.page_method_name, options[:page]).per(options[:per]) if options[:page] && options[:per]
+        scope = sort_by(options, scope) if options[:sort]
+        scope
+      rescue NoMethodError => e
+        if /page/.match?(e.message)
+          e = e.exception <<~ERROR
+            #{e.message}
+            If you don't have kaminari-mongoid installed, add `gem 'kaminari-mongoid'` to your Gemfile.
+          ERROR
+        end
+        raise e
+      end
+
+      def count(options = {}, scope = nil)
+        all(options.merge(limit: false, page: false), scope).count
+      end
+
+      def destroy(objects)
+        Array.wrap(objects).each(&:destroy)
+      end
+
+      def primary_key
+        '_id'
+      end
+
+      def associations
+        model.relations.values.collect do |association|
+          Association.new(association, model)
+        end
+      end
+
+      def properties
+        fields = model.fields.reject { |_name, field| DISABLED_COLUMN_TYPES.include?(field.type.to_s) }
+        fields.collect { |_name, field| Property.new(field, model) }
+      end
+
+      def base_class
+        klass = model
+        klass = klass.superclass while klass.hereditary?
+        klass
+      end
+
+      def table_name
+        model.collection_name.to_s
+      end
+
+      def encoding
+        Encoding::UTF_8
+      end
+
+      def embedded?
+        associations.detect { |a| a.macro == :embedded_in }
+      end
+
+      def cyclic?
+        model.cyclic?
+      end
+
+      def adapter_supports_joins?
+        false
+      end
+
+    private
+
+      def build_statement(column, type, value, operator)
+        StatementBuilder.new(column, type, value, operator).to_statement
+      end
+
+      def make_field_conditions(field, value, operator)
+        conditions_per_collection = {}
+        field.searchable_columns.each do |column_infos|
+          collection_name, column_name = parse_collection_name(column_infos[:column])
+          statement = build_statement(column_name, column_infos[:type], value, operator)
+          next unless statement
+
+          conditions_per_collection[collection_name] ||= []
+          conditions_per_collection[collection_name] << statement
+        end
+        conditions_per_collection
+      end
+
+      def query_scope(scope, query, fields = config.list.fields.select(&:queryable?))
+        if config.list.search_by
+          scope.send(config.list.search_by, query)
+        else
+          statements = []
+
+          fields.each do |field|
+            value = parse_field_value(field, query)
+            conditions_per_collection = make_field_conditions(field, value, field.search_operator)
+            statements.concat make_condition_for_current_collection(field, conditions_per_collection)
+          end
+
+          scope.where(statements.any? ? {'$or' => statements} : {})
+        end
+      end
+
+      # filters example => {"string_field"=>{"0055"=>{"o"=>"like", "v"=>"test_value"}}, ...}
+      # "0055" is the filter index, no use here. o is the operator, v the value
+      def filter_scope(scope, filters, fields = config.list.fields.select(&:filterable?))
+        statements = []
+
+        filters.each_pair do |field_name, filters_dump|
+          filters_dump.each_value do |filter_dump|
+            field = fields.detect { |f| f.name.to_s == field_name }
+            next unless field
+
+            value = parse_field_value(field, filter_dump[:v])
+            conditions_per_collection = make_field_conditions(field, value, (filter_dump[:o] || 'default'))
+            field_statements = make_condition_for_current_collection(field, conditions_per_collection)
+            if field_statements.many?
+              statements << {'$or' => field_statements}
+            elsif field_statements.any?
+              statements << field_statements.first
+            end
+          end
+        end
+
+        scope.where(statements.any? ? {'$and' => statements} : {})
+      end
+
+      def parse_collection_name(column)
+        collection_name, column_name = column.split('.')
+        if associations.detect { |a| a.name == collection_name.to_sym }.try(:embeds?)
+          [table_name, column]
+        else
+          [collection_name, column_name]
+        end
+      end
+
+      def make_condition_for_current_collection(target_field, conditions_per_collection)
+        result = []
+        conditions_per_collection.each do |collection_name, conditions|
+          if collection_name == table_name
+            # conditions referring current model column are passed directly
+            result.concat conditions
+          else
+            # otherwise, collect ids of documents that satisfy search condition
+            result.concat perform_search_on_associated_collection(target_field.name, conditions)
+          end
+        end
+        result
+      end
+
+      def perform_search_on_associated_collection(field_name, conditions)
+        target_association = associations.detect { |a| a.name == field_name }
+        return [] unless target_association
+
+        model = target_association.klass
+        case target_association.type
+        when :belongs_to, :has_and_belongs_to_many
+          [{target_association.foreign_key.to_s => {'$in' => model.where('$or' => conditions).all.collect { |r| r.send(target_association.primary_key) }}}]
+        when :has_many, :has_one
+          [{target_association.primary_key.to_s => {'$in' => model.where('$or' => conditions).all.collect { |r| r.send(target_association.foreign_key) }}}]
+        end
+      end
+
+      def sort_by(options, scope)
+        return scope unless options[:sort]
+
+        case options[:sort]
+        when String
+          field_name, collection_name = options[:sort].split('.').reverse
+          raise 'sorting by associated model column is not supported in Non-Relational databases' if collection_name && collection_name != table_name
+        when Symbol
+          field_name = options[:sort].to_s
+        end
+        if options[:sort_reverse]
+          scope.asc field_name
+        else
+          scope.desc field_name
+        end
+      end
+
+      class StatementBuilder < RailsAdmin::AbstractModel::StatementBuilder
+      protected
+
+        def unary_operators
+          {
+            '_blank' => {@column => {'$in' => [nil, '']}},
+            '_present' => {@column => {'$nin' => [nil, '']}},
+            '_null' => {@column => nil},
+            '_not_null' => {@column => {'$ne' => nil}},
+            '_empty' => {@column => ''},
+            '_not_empty' => {@column => {'$ne' => ''}},
+          }
+        end
+
+      private
+
+        def build_statement_for_type
+          case @type
+          when :boolean                   then build_statement_for_boolean
+          when :integer, :decimal, :float then build_statement_for_integer_decimal_or_float
+          when :string, :text             then build_statement_for_string_or_text
+          when :enum                      then build_statement_for_enum
+          when :belongs_to_association, :bson_object_id then build_statement_for_belongs_to_association_or_bson_object_id
+          end
+        end
+
+        def build_statement_for_boolean
+          case @value
+          when 'false', 'f', '0'
+            {@column => false}
+          when 'true', 't', '1'
+            {@column => true}
+          end
+        end
+
+        def column_for_value(value)
+          {@column => value}
+        end
+
+        def build_statement_for_string_or_text
+          return if @value.blank?
+
+          @value =
+            case @operator
+            when 'not_like'
+              Regexp.compile("^((?!#{Regexp.escape(@value)}).)*$", Regexp::IGNORECASE)
+            when 'default', 'like'
+              Regexp.compile(Regexp.escape(@value), Regexp::IGNORECASE)
+            when 'starts_with'
+              Regexp.compile("^#{Regexp.escape(@value)}", Regexp::IGNORECASE)
+            when 'ends_with'
+              Regexp.compile("#{Regexp.escape(@value)}$", Regexp::IGNORECASE)
+            when 'is', '='
+              @value.to_s
+            else
+              return
+            end
+
+          {@column => @value}
+        end
+
+        def build_statement_for_enum
+          return if @value.blank?
+
+          {@column => {'$in' => Array.wrap(@value)}}
+        end
+
+        def build_statement_for_belongs_to_association_or_bson_object_id
+          {@column => @value} if @value
+        end
+
+        def range_filter(min, max)
+          if min && max && min == max
+            {@column => min}
+          elsif min && max
+            {@column => {'$gte' => min, '$lte' => max}}
+          elsif min
+            {@column => {'$gte' => min}}
+          elsif max
+            {@column => {'$lte' => max}}
+          end
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/config/actions/base.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'rails_admin/config/proxyable'
+require 'rails_admin/config/configurable'
+require 'rails_admin/config/hideable'
+
+module RailsAdmin
+  module Config
+    module Actions
+      class Base
+        include RailsAdmin::Config::Proxyable
+        include RailsAdmin::Config::Configurable
+        include RailsAdmin::Config::Hideable
+
+        register_instance_option :only do
+          nil
+        end
+
+        register_instance_option :except do
+          []
+        end
+
+        register_instance_option :show_in_navigation do
+          root?
+        end
+
+        register_instance_option :show_in_sidebar do
+          !show_in_navigation
+        end
+
+        register_instance_option :show_in_menu do
+          true
+        end
+
+        register_instance_option :sidebar_label do
+          nil
+        end
+
+        # http://getbootstrap.com/2.3.2/base-css.html#icons
+        register_instance_option :link_icon do
+          'fas fa-question'
+        end
+
+        # Should the action be visible
+        register_instance_option :visible? do
+          authorized?
+        end
+
+        register_instance_option :enabled? do
+          bindings[:abstract_model].nil? || (
+            (only.nil? || [only].flatten.collect(&:to_s).include?(bindings[:abstract_model].to_s)) &&
+            ![except].flatten.collect(&:to_s).include?(bindings[:abstract_model].to_s) &&
+            !bindings[:abstract_model].config.excluded?
+          ) && (!respond_to?(:writable?) || writable?)
+        end
+
+        register_instance_option :authorized? do
+          enabled? && (
+            bindings[:controller].try(:authorization_adapter).nil? || bindings[:controller].authorization_adapter.authorized?(authorization_key, bindings[:abstract_model], bindings[:object])
+          )
+        end
+
+        # Is the action acting on the root level (Example: /admin/contact)
+        register_instance_option :root? do
+          false
+        end
+
+        # Is the action on a model scope (Example: /admin/team/export)
+        register_instance_option :collection? do
+          false
+        end
+
+        # Is the action on an object scope (Example: /admin/team/1/edit)
+        register_instance_option :member? do
+          false
+        end
+
+        # Target window [_self, _blank]
+        register_instance_option :link_target do
+          nil
+        end
+
+        # Determines whether to navigate via Turbo Drive or not
+        register_instance_option :turbo? do
+          true
+        end
+
+        # This block is evaluated in the context of the controller when action is called
+        # You can access:
+        # - @objects if you're on a model scope
+        # - @abstract_model & @model_config if you're on a model or object scope
+        # - @object if you're on an object scope
+        register_instance_option :controller do
+          proc do
+            render action: @action.template_name
+          end
+        end
+
+        # Model scoped actions only. You will need to handle params[:bulk_ids] in controller
+        register_instance_option :bulkable? do
+          false
+        end
+
+        # View partial name (called in default :controller block)
+        register_instance_option :template_name do
+          key.to_sym
+        end
+
+        # For CanCanCan and the like
+        register_instance_option :authorization_key do
+          key.to_sym
+        end
+
+        # List of methods allowed. Note that you are responsible for correctly handling them in :controller block
+        register_instance_option :http_methods do
+          [:get]
+        end
+
+        # Url fragment
+        register_instance_option :route_fragment do
+          custom_key.to_s
+        end
+
+        # Controller action name
+        register_instance_option :action_name do
+          custom_key.to_sym
+        end
+
+        # I18n key
+        register_instance_option :i18n_key do
+          key
+        end
+
+        # User should override only custom_key (action name and route fragment change, allows for duplicate actions)
+        register_instance_option :custom_key do
+          key
+        end
+
+        # Breadcrumb parent
+        register_instance_option :breadcrumb_parent do
+          if root?
+            [:dashboard]
+          elsif collection?
+            [:index, bindings[:abstract_model]]
+          elsif member?
+            [:show, bindings[:abstract_model], bindings[:object]]
+          end
+        end
+
+        # Off API.
+
+        def key
+          self.class.key
+        end
+
+        def self.key
+          name.to_s.demodulize.underscore.to_sym
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/config/actions/bulk_delete.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Config
+    module Actions
+      class BulkDelete < RailsAdmin::Config::Actions::Base
+        RailsAdmin::Config::Actions.register(self)
+
+        register_instance_option :collection do
+          true
+        end
+
+        register_instance_option :http_methods do
+          %i[post delete]
+        end
+
+        register_instance_option :controller do
+          proc do
+            if request.post? # BULK DELETE
+              @objects = list_entries(@model_config, :destroy)
+
+              if @objects.blank?
+                flash[:error] = t('admin.flash.error', name: pluralize(0, @model_config.label), action: t('admin.actions.delete.done'))
+                redirect_to index_path
+              else
+                render @action.template_name
+              end
+
+            elsif request.delete? # BULK DESTROY
+
+              destroyed = nil
+              not_destroyed = nil
+
+              unless params[:bulk_ids].blank?
+                @objects = list_entries(@model_config, :destroy)
+                unless @objects.blank?
+                  processed_objects = @abstract_model.destroy(@objects)
+                  destroyed = processed_objects.select(&:destroyed?)
+                  not_destroyed = processed_objects - destroyed
+                  destroyed.each do |object|
+                    @auditing_adapter&.delete_object(object, @abstract_model, _current_user)
+                  end
+                end
+              end
+
+              if destroyed.nil?
+                flash[:error] = t('admin.flash.error', name: pluralize(0, @model_config.label), action: t('admin.actions.delete.done'))
+              else
+                flash[:success] = t('admin.flash.successful', name: pluralize(destroyed.count, @model_config.label), action: t('admin.actions.delete.done')) unless destroyed.empty?
+                flash[:error] = t('admin.flash.error', name: pluralize(not_destroyed.count, @model_config.label), action: t('admin.actions.delete.done')) unless not_destroyed.empty?
+              end
+              redirect_to back_or_index
+            end
+          end
+        end
+
+        register_instance_option :authorization_key do
+          :destroy
+        end
+
+        register_instance_option :bulkable? do
+          true
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/config/actions/dashboard.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Config
+    module Actions
+      class Dashboard < RailsAdmin::Config::Actions::Base
+        RailsAdmin::Config::Actions.register(self)
+
+        register_instance_option :root? do
+          true
+        end
+
+        register_instance_option :breadcrumb_parent do
+          nil
+        end
+
+        register_instance_option :auditing_versions_limit do
+          100
+        end
+
+        register_instance_option :controller do
+          proc do
+            @history = @auditing_adapter&.latest(@action.auditing_versions_limit) if @action.history?
+            if @action.statistics?
+              model_configs = RailsAdmin::Config.visible_models(controller: self)
+
+              @abstract_models = model_configs.map(&:abstract_model)
+              @most_recent_created = {}
+              @count = {}
+              @max = 0
+              model_configs.each do |config|
+                scope = @authorization_adapter&.query(:index, config.abstract_model)
+                current_count = config.abstract_model.count({}, scope)
+                @max = current_count > @max ? current_count : @max
+                name = config.abstract_model.model.name
+                @count[name] = current_count
+                @most_recent_created[name] = config.last_created_at
+              end
+            end
+            render @action.template_name, status: @status_code || :ok
+          end
+        end
+
+        register_instance_option :route_fragment do
+          ''
+        end
+
+        register_instance_option :link_icon do
+          'fas fa-home'
+        end
+
+        register_instance_option :statistics? do
+          true
+        end
+
+        register_instance_option :history? do
+          true
+        end
+      end
+    end
+  end
+end