admin_it 1.0.11 → 1.1.0

data/lib/admin_it/data/active_record/collection_context.rb

@@ -0,0 +1,47 @@
+module AdminIt
+  module ActiveRecordData
+    #
+    module CollectionContext
+      def entities=(value)
+        super(value)
+        @count = @entities.nil? ? 0 : @entities.count
+      end
+
+      protected
+
+      def load_entities
+        collection =
+          if AdminIt::Env.pundit?
+            controller.policy_scope(entity_class)
+          else
+            entity_class.all
+          end
+        if child?
+          collection = collection.where(parent.resource.name => parent.entity)
+        end
+        sort = {}
+        sorting.each do |_sort|
+          name, order = _sort.split(':')
+          sort[name.to_sym] = order.to_sym
+        end
+        unless collection.nil? || sort.empty?
+          collection = collection.order(sort)
+        end
+        collection
+      end
+    end
+
+    #
+    module TableContext
+      def entities
+        if @entities.count > page_size
+          # limit collection to current page
+          @entities = @entities
+            .offset(page_size * (page - 1))
+            .limit(page_size)
+        end
+        super
+      end
+    end
+  end
+end

data/lib/admin_it/data/active_record/field.rb

@@ -0,0 +1,64 @@
+module AdminIt
+  module ActiveRecordData
+    #
+    module Field
+      def self.included(base)
+        base.class_eval do
+          class << self
+            attr_accessor :assoc
+
+            protected
+
+            def default_display_name
+              entity_class.human_attribute_name(field_name)
+            end
+          end
+          class_attr_reader :assoc
+        end
+      end
+
+      protected
+
+      def read_value(entity)
+        value = entity.send(name)
+        if type == :relation
+          if assoc.collection?
+            value.nil? || value.empty? ? [] : value.map(&:id).to_json
+          else
+            value.nil? ? nil : value.id
+          end
+        else
+          value
+        end
+      end
+
+      def show_value(entity)
+        value = entity.send(name)
+        if type == :relation
+          resource = AdminIt.resources.values.find do |r|
+            r.entity_class == assoc.klass
+          end
+          return I18n.t('admin_it.relation.no_resource') if resource.nil?
+          context = resource.contexts.find { |c| c <= ShowContext }
+          return I18n.t('admin_it.relation.no_context') if context.nil?
+          if assoc.collection?
+            if value.count == 0
+              I18n.t('admin_it.collection.no_data')
+            else
+              v = context.read(value.first)
+              v.nil? ? '' : context.read(value.first) + ' ...'
+            end
+          else
+            context.read(value)
+          end
+        else
+          value
+        end
+      end
+
+      def write_value(entity, value)
+        entity.send("#{name}=", value)
+      end
+    end
+  end
+end

data/lib/admin_it/data/active_record/filter.rb

@@ -0,0 +1,36 @@
+module AdminIt
+  module ActiveRecordData
+    #
+    module ValueFilter
+      def all_values(collection = nil, &block)
+        enum = Enumerator.new do |yielder|
+          field
+            .entity_class
+            .select(self.class.field.field_name)
+            .group(self.class.field.field_name)
+            .count
+            .each do |v, c|
+              yielder << { value: v, count: c }
+            end
+        end
+        block_given? ? enum.each(&block) : enum
+      end
+
+      def apply(collection)
+        return collection if @values.empty?
+        binding = []
+        conditions = ''
+        if @values.size == 1 && @values[0].nil?
+          conditions = "#{field.field_name} IS NULL"
+        else
+          conditions = "#{field.field_name} IN (?)"
+          binding << @values.select { |v| !v.nil? }
+          if @values.any? { |v| v.nil? }
+            conditions += " OR #{field.field_name} IS NULL"
+          end
+        end
+        collection.where(conditions, *binding)
+      end
+    end
+  end
+end

data/lib/admin_it/data/active_record/resource.rb

@@ -0,0 +1,66 @@
+module AdminIt
+  module ActiveRecordData
+    #
+    module Resource
+      protected
+
+      TYPE_MAPPING = {
+        primary_key: :integer,
+        string: :string,
+        text: :string,
+        integer: :integer,
+        float: :float,
+        decimal: :float,
+        datetime: :datetime,
+        timestamp: :datetime,
+        time: :time,
+        date: :date,
+        binary: :binary,
+        boolean: :boolean
+      }
+
+      def default_display_name
+        entity_class
+          .model_name
+          .human# (count: 0)
+          .split(' ')
+          .map { |s| s.mb_chars.capitalize }
+          .join(' ')
+      end
+
+      def default_fields(&block)
+        enum = Enumerator.new do |yielder|
+          exclude = []
+          entity_class.reflections.each do |name, a|
+            f = AdminIt::Field.create(name, entity_class, type: :relation)
+            f.assoc = a
+            yielder << f
+            exclude << "#{name}_id" if a.belongs_to?
+          end
+          entity_class.columns_hash.each do |name, c|
+            next if exclude.include?(name)
+            name = name.to_sym
+            opts = { type: TYPE_MAPPING[c.type] }
+            if name == :id
+              opts[:visible] = false
+              opts[:writable] = false
+            end
+            yielder << AdminIt::Field.create(name, entity_class, opts)
+          end
+        end
+        block_given? ? enum.each(&block) : enum
+      end
+
+      def default_filters
+        enum = Enumerator.new do |yielder|
+          fields.each do |field|
+            next if field.type == :relation
+            name = "#{field.field_name}_value"
+            yielder << AdminIt::ValueFilter.create(name, self, field)
+          end
+        end
+        block_given? ? enum.each(&block) : enum
+      end
+    end
+  end
+end

data/lib/admin_it/data/active_record/single_context.rb

@@ -0,0 +1,102 @@
+module AdminIt
+  module ActiveRecordData
+    #
+    module SingleContext
+      protected
+
+      def load_entity(identity: nil)
+        identity ||= controller.params[:id]
+        entity = entity_class.find(identity)
+        controller.authorize(entity, "#{name}?") if AdminIt::Env.pundit?
+        if child?
+          fields
+            .select { |f| f.type == :relation &&
+                          f.assoc.klass == parent.entity_class }
+            .each do |f|
+              if f.assoc.collection?
+                entity.send(f.name) << parent.entity
+              else
+                entity.send("#{f.name}=", parent.entity)
+              end
+            end
+        end
+        entity
+      end
+    end
+
+    #
+    module SavableSingleContext
+      protected
+
+      def do_save_entity
+        if AdminIt::Env.pundit?
+          controller.authorize(entity, "#{self.class.save_action}?")
+        end
+        params = controller.params[resource.name]
+        fields(scope: :writable).each do |field|
+          next unless params.key?(field.name)
+          next unless field.writable?
+          next if field.type == :relation
+          field.write(entity, params[field.name])
+        end
+        controller.redirect_to_default if entity.save
+      end
+
+      def add_child_context(for_resource, context_class: :table)
+        child_resource = AdminIt.resources[for_resource]
+        return nil if child_resource.nil?
+        child_resource[context_class].new(self)
+      end
+    end
+
+    #
+    module NewContext
+      def self.included(base)
+        base.after_initialize do
+          if child?
+            fields
+              .select { |f| f.type == :relation &&
+                            f.assoc.klass == parent.entity_class }
+              .each do |f|
+                if f.assoc.collection?
+                  entity.send(f.name) << parent.entity
+                else
+                  entity.send("#{f.name}=", parent.entity)
+                end
+                f.visible = false
+              end
+          end
+        end
+      end
+
+      protected
+
+      def load_entity(identity: nil)
+        entity = entity_class.new
+        controller.authorize(entity, "#{name}?") if AdminIt::Env.pundit?
+        entity
+      end
+    end
+
+    #
+    module ShowContext
+      def identity
+        entity.id
+      end
+
+      protected
+
+      def do_destroy_entity
+        controller.authorize(entity, :destroy?) if AdminIt::Env.pundit?
+        controller.redirect_to_default if entity.destroy
+      end
+    end
+
+    #
+    module EditContext
+      def identity
+        entity.id
+      end
+    end
+  end
+end

data/lib/admin_it/data/data_behavior.rb

@@ -1,4 +1,5 @@
 module AdminIt
+  #
   module DataBehavior
     private
 
@@ -11,6 +12,7 @@ module AdminIt
           import_module = @data_module.const_get(mod.name.split('::').last)
           include(import_module) if import_module.is_a?(Module)
         rescue NameError
+          nil
         end
       end
     end

data/lib/admin_it/data/hash.rb

@@ -1,10 +1,12 @@
 module AdminIt
   module HashData
+    #
     module Context
       def self.included(base)
         base.extend(ClassMethods)
       end
 
+      #
       module ClassMethods
         def load_fields
           []
@@ -12,6 +14,7 @@ module AdminIt
       end
     end
 
+    #
     module Field
       protected
 

data/lib/admin_it/data/mongoid.rb

@@ -0,0 +1,14 @@
+if AdminIt::Env.mongoid?
+  require 'mongoid'
+  require File.join %w(admin_it data mongoid resource)
+  require File.join %w(admin_it data mongoid field)
+#  require File.join %w(admin_it data monfo_id collection_context)
+#  require File.join %w(admin_it data monfo_id single_context)
+#  require File.join %w(admin_it data monfo_id field)
+#  require File.join %w(admin_it data monfo_id filter)
+
+  #
+  module AdminIt
+    register_data ::Mongoid::Document, AdminIt::MongoidData
+  end
+end

data/lib/admin_it/data/mongoid/field.rb

@@ -0,0 +1,58 @@
+module AdminIt
+  module MongoidData
+    #
+    module Field
+      def self.included(base)
+        base.class_eval do
+          class << self
+            attr_accessor :assoc
+          end
+          class_attr_reader :assoc
+        end
+      end
+
+      protected
+
+      def read_value(entity)
+        value = entity.send(name)
+        if type == :relation
+          if assoc.collection?
+            value.nil? || value.empty? ? [] : value.map(&:id).to_json
+          else
+            value.nil? ? nil : value.id
+          end
+        else
+          value
+        end
+      end
+
+      def show_value(entity)
+        value = entity.send(name)
+        if type == :relation
+          resource = AdminIt.resources.values.find do |r|
+            r.entity_class == assoc.klass
+          end
+          return I18n.t('admin_it.relation.no_resource') if resource.nil?
+          context = resource.contexts.find { |c| c <= ShowContext }
+          return I18n.t('admin_it.relation.no_context') if context.nil?
+          if assoc.collection?
+            if value.count == 0
+              I18n.t('admin_it.collection.no_data')
+            else
+              v = context.read(value.first)
+              v.nil? ? '' : context.read(value.first) + ' ...'
+            end
+          else
+            context.read(value)
+          end
+        else
+          value
+        end
+      end
+
+      def write_value(entity, value)
+        entity.send("#{name}=", value)
+      end
+    end
+  end
+end

data/lib/admin_it/data/mongoid/resource.rb

@@ -0,0 +1,67 @@
+require 'bson'
+require 'moped'
+
+module AdminIt
+  module MongoidData
+    #
+    module Resource
+      protected
+
+      TYPE_MAPPING = {
+        Array => :array,
+        BigDecimal => :float,
+        Boolean => :boolean,
+        Date => :date,
+        DateTime => :datetime,
+        Float => :float,
+        Hash => :hash,
+        Integer => :integer,
+        BSON::ObjectId => :integer,
+        BSON::Binary => :binary,
+        Range => :range,
+        Regexp => :regexp,
+        String => :string,
+        Symbol => :symbol,
+        Time => :time
+      }
+
+      NONFILTER_TYPES = %i(array hash binary range regexp relation)
+
+      def default_fields(&block)
+        enum = Enumerator.new do |yielder|
+          entity_class.fields.each do |name, field|
+            name = name.to_sym
+            opts = { type: TYPE_MAPPING[field.options[:type]] }
+            if name == :_id
+              name = :id
+              opts[:visible] = false
+              opts[:writable] = false
+            end
+            yielder << AdminIt::Field.create(name, entity_class, opts)
+          end
+          relations = entity_class.relations
+          relations.merge!(entity_class.embedded_relations)
+          relations.each do |name, rel|
+            name = name.to_sym
+            opts = { type: :relation }
+            field = AdminIt::Field.create(name, entity_class, opts)
+            field.assoc = rel
+            yielder << field
+          end
+        end
+        block_given? ? enum.each(&block) : enum
+      end
+
+      def default_filters
+        enum = Enumerator.new do |yielder|
+          fields.each do |field|
+            next if NONFILTER_TYPES.include?(field.type)
+            name = "#{field.field_name}_value"
+            yielder << AdminIt::ValueFilter.create(name, self, field)
+          end
+        end
+        block_given? ? enum.each(&block) : enum
+      end
+    end
+  end
+end