rademade_admin 0.0.3 → 0.1.0

data/lib/rademade_admin/model/adapter/data/mongoid.rb

@@ -0,0 +1,77 @@
+# -*- encoding : utf-8 -*-
+module RademadeAdmin
+  module Model
+    module Adapter
+      class Data
+
+        #
+        # Data adapter for Mongoid
+        #
+        class Mongoid < RademadeAdmin::Model::Adapter::Data
+
+          protected
+
+          def has_many_relations
+            [:embeds_many, :has_many, :has_and_belongs_to_many]
+          end
+
+          def has_one_relations
+            [:has_one, :embeds_one, :belongs_to]
+          end
+
+          def _map_fields
+            fields = {}
+            @model.fields.each do |name, field_data|
+              name = name.to_sym
+              getter = name.to_s
+              fields[name] = RademadeAdmin::Model::Info::Field.new({
+                :name => name,
+                :primary => name == :_id,
+                :getter => getter,
+                :setter => getter + '=',
+                :type => field_data.type,
+                :is_date_time => field_data.type == DateTime,
+                :localizable => field_data.localized?,
+                :relation_name => field_data.options[:metadata].try(:name)
+              })
+            end
+            fields
+          end
+
+          def _map_relations
+            relations = {}
+            @model.relations.each do |name, relation_info|
+              name = name.to_sym
+              type = relation_info.relation.macro
+              is_sortable = relation_info.sortable?
+              relations[name] = ::RademadeAdmin::Model::Info::Relation.new({
+                :name => name,
+                :from => @model,
+                :to => to_class(relation_info),
+                :getter => name.to_s,
+                :setter => relation_info.setter,
+                :type => type,
+                :many => type == :has_many,
+                :has_many => has_many_relations.include?(type),
+                :sortable => is_sortable,
+                :sortable_field => is_sortable ? relation_info.sortable_field : nil,
+                :foreign_key => relation_info.foreign_key.to_sym
+              })
+            end
+            relations
+          end
+
+          private
+
+          def to_class(relation_info)
+            RademadeAdmin::LoaderService.const_get(relation_info.class_name)
+          rescue
+            nil
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/{app/services/search/query_adapter/abstract.rb → lib/rademade_admin/model/adapter/query.rb}

@@ -1,19 +1,29 @@
 # -*- encoding : utf-8 -*-
 module RademadeAdmin
-  module Search
-    module QueryAdapter
-      class Abstract
+  module Model
+    module Adapter
+      class Query
 
         def initialize(model)
           @model = model
         end
 
-        def apply_conditions(search_conditions)
-          @params = search_conditions.params
+        def find(ids)
+          @model.find(ids)
+        end
+
+        #
+        # @param search_conditions [RademadeAdmin::Search::Conditions::Abstract]
+        #
+        def exec_query(search_conditions)
           @result = search_conditions.base_condition(@model)
+
+          return nil if @result.nil?
+
           search_conditions.conditions.each do |query_part, values|
             @result = self.send(query_part, values) unless values.nil?
           end
+
           @result
         end
 

data/lib/rademade_admin/model/adapter/query/active_record.rb

@@ -0,0 +1,50 @@
+# -*- encoding : utf-8 -*-
+module RademadeAdmin
+  module Model
+    module Adapter
+      class Query
+
+        class ActiveRecord < RademadeAdmin::Model::Adapter::Query
+
+          protected
+
+          def where(where_conditions)
+            @values = []
+            condition = collect_where_conditions(where_conditions)
+            @result.where([condition, *@values])
+          end
+
+          def order(order_conditions)
+            order_conditions.parts.each do |part|
+              if part.is_a? RademadeAdmin::Search::Part::Order
+                # todo
+              else
+                @result = @result.order(part[:field] => part[:value])
+              end
+            end
+            @result
+          end
+
+          def collect_where_conditions(where_conditions)
+            condition = ''
+            where_conditions.parts.each do |part|
+              condition += " #{where_conditions.type.to_s.capitalize} " unless condition.empty?
+              if part.is_a? RademadeAdmin::Search::Part::Where
+                condition += "(#{collect_where_conditions(part)})"
+              else
+                if part[:value].is_a? Array
+                  condition += "#{part[:field]} IN (?)"
+                else
+                  condition += "#{part[:field]} = ?"
+                end
+                @values << part[:value]
+              end
+            end
+            condition
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rademade_admin/model/adapter/query/mongoid.rb

@@ -0,0 +1,57 @@
+# -*- encoding : utf-8 -*-
+module RademadeAdmin
+  module Model
+    module Adapter
+      class Query
+
+        class Mongoid < RademadeAdmin::Model::Adapter::Query
+
+          protected
+
+          WHERE_METHOD_MAP = { :or => :or, :and => :where }.freeze
+
+          def where(where_conditions)
+            if defined?(::Mongoid::Paranoia) and @model.ancestors.include? ::Mongoid::Paranoia
+              where_condition = RademadeAdmin::Search::Part::Where.new(:and)
+              where_condition.add(:deleted_at, nil)
+              where_condition.sub_add(where_conditions) if where_conditions
+              where_conditions = where_condition
+            end
+            collect_where_condition(where_conditions, @result)
+          end
+
+          def order(order_conditions)
+            order_conditions.parts.each do |part|
+              if part.is_a? RademadeAdmin::Search::Part::Order
+                # todo
+              else
+                @result = @result.order_by(part[:field] => part[:value])
+              end
+            end
+            @result
+          end
+
+          def collect_where_condition(where_conditions, result)
+            where_method = WHERE_METHOD_MAP[where_conditions.type]
+            where_conditions.parts.each do |part|
+              if part.is_a? RademadeAdmin::Search::Part::Where
+                result = result.send(where_method, where_sub_condition(part))
+              else
+                field = part[:field]
+                field = field.in if part[:value].is_a? Array
+                result = result.send(where_method, field => part[:value])
+              end
+            end
+            result
+          end
+
+          def where_sub_condition(where_sub_conditions)
+            collect_where_condition(where_sub_conditions, @model.all).selector
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/rademade_admin/model/configuration.rb

@@ -3,31 +3,59 @@ module RademadeAdmin
   module Model
     class Configuration
 
-      attr_reader :parent_menu_item, :list_fields, :form_fields
+      attr_reader :controller, :parent_menu_item, :model_name
 
-      def initialize(controller_name)
-        @controller_name = controller_name
+      def initialize(controller)
+        @controller = controller
       end
 
-      def model_name
-        @model_name ||= @controller_name.classify
+      def item_name
+        @item_name ||= singular_name.pluralize
       end
 
-      def item_name
-        @item_name ||= model_name.underscore.gsub('/', '_').humanize
+      def singular_name
+        @singular_name ||= model_name.underscore.gsub('/', '_').humanize
       end
 
       def model_class
         @model_class ||= RademadeAdmin::LoaderService.const_get(model_name)
       end
 
-      private
+      # Return configured list info
+      #
+      # @return [RademadeAdmin::Model::Configuration::ListFields]
+      #
+      def list_fields
+        @list_fields ||= RademadeAdmin::Model::Configuration::ListFields.new
+      end
+
+      # Return configured fields info
+      #
+      # @return [RademadeAdmin::Model::Configuration::FormFields]
+      #
+      def form_fields
+        @form_fields ||= RademadeAdmin::Model::Configuration::FormFields.new
+      end
+
+      # Return configured fields info
+      #
+      # @return [RademadeAdmin::Model::Configuration::FieldsLabels]
+      #
+      def field_labels
+        @field_labels ||= RademadeAdmin::Model::Configuration::FieldsLabels.new
+      end
+
+      def all_field_names
+        @all_field_names ||= Set.new(list_fields.all.map(&:name) + form_fields.all.map(&:name))
+      end
 
       def model(model_name)
         @model_name = model_name
       end
 
-      def item(item_name)
+      private
+
+      def name(item_name)
         @item_name = item_name
       end
 
@@ -35,17 +63,16 @@ module RademadeAdmin
         @parent_menu_item = parent_menu_item
       end
 
-      def list(*field_options, &block)
-        @list_fields = fields(*field_options, &block)
+      def labels(*field_options, &block)
+        field_labels.configure(*field_options, &block)
       end
 
-      def form(*field_options, &block)
-        @form_fields = fields(*field_options, &block)
+      def list(*field_options, &block)
+        list_fields.configure(*field_options, &block)
       end
 
-      def fields(*field_options, &block)
-        model_fields = block_given? ? Fields.init_from_block(&block) : Fields.init_from_options(field_options)
-        model_fields.fields
+      def form(*field_options, &block)
+        form_fields.configure(*field_options, &block)
       end
 
     end

data/lib/rademade_admin/model/configuration/field_label.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module RademadeAdmin
+  module Model
+    class Configuration
+      class FieldLabel
+
+        attr_accessor :name, :label
+
+        def initialize(name, label)
+          @name, @label = name, label
+        end
+
+      end
+    end
+  end
+end

data/lib/rademade_admin/model/configuration/fields.rb

@@ -1,34 +1,60 @@
 # -*- encoding : utf-8 -*-
 module RademadeAdmin
   module Model
-    class Fields
+    class Configuration
+      class Fields
 
-      attr_reader :fields
+        def find(name)
+          name = name.to_sym
+          field = @fields.select { |field| field.name == name }.first
+          return nil if field.nil?
+          yield(field) if block_given?
+          field
+        end
 
-      def self.init_from_block(&block)
-        model_fields = self.new
-        model_fields.instance_eval(&block)
-        model_fields
-      end
+        def find_with_index(name)
+          found_field, found_index = nil, nil
+          @fields.each_with_index do |field, index|
+            if field.name == name
+              found_field, found_index = field, index
+              break
+            end
+          end
+          return nil if found_field.nil?
+          yield(found_field, found_index) if block_given?
+          { :field => found_field, :index => found_index }
+        end
 
-      def self.init_from_options(field_options)
-        model_fields = self.new(field_options)
-        model_fields
-      end
+        def all
+          @fields
+        end
 
-      def initialize(fields = [])
-        @fields = fields
-      end
+        def method_missing(name, *arguments)
+          @fields << field_class.new(name.to_sym, *arguments)
+        end
 
-      def method_missing(name, *arguments)
-        if arguments.empty?
-          field = name.to_sym
-        else
-          field = { name.to_sym => arguments.first }
+        def configure(*options, &block)
+          block_given? ? instance_eval(&block) : _init_from_options(*options)
         end
-        @fields << field
-      end
 
+        protected
+
+        def initialize
+          @fields = []
+        end
+
+        def field_class
+          raise NotImplementedError, 'Field class for {CLASS} fields not defined'
+        end
+
+        def _init_from_options(*options)
+          options.each do |option|
+            #todo add validation
+            @fields << field_class.new(option.to_sym)
+          end
+        end
+
+      end
     end
   end
 end

data/lib/rademade_admin/model/configuration/fields_labels.rb

@@ -0,0 +1,31 @@
+# -*- encoding : utf-8 -*-
+require 'rademade_admin/model/configuration/fields'
+
+module RademadeAdmin
+  module Model
+    class Configuration
+      class FieldsLabels < Fields
+
+        def label_for(name)
+          field = find(name)
+          if field.nil?
+            name.to_s.humanize
+          else
+            field.label
+          end
+        end
+
+        protected
+
+        def field_class
+          RademadeAdmin::Model::Configuration::FieldLabel
+        end
+
+        def _init_from_options(*options)
+          raise "Can't init labels from options"
+        end
+
+      end
+    end
+  end
+end

data/lib/rademade_admin/model/configuration/form_field.rb

@@ -0,0 +1,27 @@
+# -*- encoding : utf-8 -*-
+module RademadeAdmin
+  module Model
+    class Configuration
+      class FormField
+
+        attr_accessor :name, :params
+
+        def initialize(name, params = {})
+          @name = name
+          init_params(params)
+        end
+
+        private
+
+        def init_params(params)
+          if params.is_a? Hash
+            @params = params
+          else
+            @params = { :as => params }
+          end
+        end
+
+      end
+    end
+  end
+end