rademade_admin 0.0.1

data/app/services/model_controller/linker.rb

@@ -0,0 +1,49 @@
+module RademadeAdmin
+  module Linker
+
+    def link(item)
+      if has_one_relation?
+        set_attribute(item, params[:parent_id])
+      else
+        old_data = get_attribute(item)
+        old_data << params[:parent_id]
+        set_attribute(item, old_data)
+      end
+
+    end
+
+    def unlink(item)
+      if has_one_relation?
+        set_attribute(item, nil)
+      else
+        old_data = get_attribute(item)
+        new_data = old_data - Array(params[:parent_id])
+        set_attribute(item, new_data)
+      end
+
+    end
+
+    private
+
+    def has_one_relation?
+      model_info.has_one.include? params[:parent]
+    end
+
+    def relation_suffix
+      has_one_relation? ? '_id' : '_ids'
+    end
+
+    def get_attribute(item)
+      item.send(relation_field)
+    end
+
+    def relation_field
+      params[:parent].downcase + relation_suffix
+    end
+
+    def set_attribute(item, new_value)
+      item.send(relation_field + '=', new_value)
+    end
+
+  end
+end

data/app/services/model_controller/model_options.rb

@@ -0,0 +1,39 @@
+module RademadeAdmin
+  module ModelOptions
+
+    def options(&options_block)
+      configuration.instance_eval &options_block
+    end
+
+    def model_name
+      configuration.model_name
+    end
+
+    def item_name
+      configuration.item_name
+    end
+
+    def parent_menu_item
+      configuration.parent_menu_item
+    end
+
+    def model_class
+      configuration.model_class
+    end
+
+    def model_info
+      @model_info ||= Model::Graph.instance.model_info(model_class)
+    end
+
+    def init_model_info(model_reflection)
+      Model::Info.new(model_reflection, configuration)
+    end
+
+    private
+    
+    def configuration
+      @configuration ||= Model::Configuration.new(controller_name)
+    end
+
+  end
+end

data/app/services/model_controller/notifier.rb

@@ -0,0 +1,40 @@
+module RademadeAdmin
+  module Notifier
+
+    def success_action
+      render :json => {
+        :message => 'ok'
+      }
+    end
+
+    def success_insert(item)
+      success_message(item, 'was inserted!', {
+        :form_action => admin_update_uri(item)
+      })
+    end
+
+    def success_update(item)
+      success_message(item, 'data was updated!')
+    end
+
+    def success_delete(item)
+      success_message(item, 'was deleted!')
+    end
+
+    def success_unlink(item)
+      success_message(item, 'was unlinked from entity!')
+    end
+
+    def success_link(item)
+      success_message(item, 'was linked to entity!')
+    end
+
+    def success_message(item, action_message, additional_data = {})
+      render :json => {
+        :data => item,
+        :message => "#{item_name.capitalize} #{action_message}"
+      }.merge(additional_data)
+    end
+
+  end
+end

data/app/services/model_controller/templates.rb

@@ -0,0 +1,27 @@
+module RademadeAdmin
+  module Templates
+
+    def native_template_folder
+      # 7 = "Admin::".length
+      # 11 = "Controller".length
+      # e.g. RademadeAdmin::QuestionAnswer::UsersController to "question_answer/users"
+      self.class.to_s[7..-11].underscore
+    end
+
+    def template_folder
+      #todo save in static variable
+      template_exists?('_form', "rademade_admin/#{native_template_folder}") ? native_template_folder : 'abstract'
+    end
+
+    def form_template_path(real = false)
+      "rademade_admin/#{template_folder}/" + (real ? '_' : '') + 'form'
+    end
+
+    def abstract_template(template)
+      #todo if template doesn't exist in user application => render abstract template (form or view)
+      "rademade_admin/abstract/#{template}"
+      #unless template_exists?(template, "admin/#{native_template_folder}")
+    end
+
+  end
+end

data/app/services/saver.rb

@@ -0,0 +1,69 @@
+module RademadeAdmin
+  class Saver
+
+    attr_reader :item
+
+    def initialize(model_info, params)
+      @model_info = model_info
+      @params = params
+    end
+
+    def create_model
+      @item = @model_info.model.new filter_data_params
+    end
+
+    def update_model
+      @item = @model_info.model.find(@params[:id])
+      item.update filter_data_params
+    end
+
+    def save_model
+      item.save @params
+    end
+
+    def save_aggregated_data
+      save_model_relations
+      save_model_uploads
+      item.save!
+    end
+
+    def errors
+      item.errors
+    end
+
+    private
+
+    def save_model_relations
+      data = @params[:data]
+      model_reflection = @model_info.model_reflection
+      model_reflection.relations.each do |name, rel|
+        assoc_key = model_reflection.association_foreign_key(rel)
+        if data.has_key? assoc_key
+          ids = data[assoc_key]
+          ids.reject! { |id| id.empty? } if ids.kind_of?(Array)
+          item.send(assoc_key + '=', ids)
+        end
+      end
+    end
+
+    def save_model_uploads
+      data = @params[:data]
+      @model_info.model_reflection.uploaders.each do |name, _|
+        if data.has_key?(name) and not data[name].blank?
+          image_path = CarrierWave.root + data[name].to_s
+          setter_method = (name.to_s + '=').to_sym
+          begin
+            item.send(setter_method, File.open(image_path))
+          rescue
+            #rm_todo clear image
+          end
+        end
+      end
+    end
+
+    def filter_data_params
+      @params.require(:data).permit(@model_info.save_form_fields)
+    end
+
+  end
+end

data/app/services/search/conditions/abstract.rb

@@ -0,0 +1,53 @@
+module RademadeAdmin
+  module Search
+    class Abstract
+
+      attr_reader :params
+
+      def initialize(params, origin_fields)
+        @params = params
+        @origin_fields = origin_fields
+      end
+
+      def conditions
+        @conditions ||= init_conditions
+      end
+
+      protected
+
+      def init_conditions
+        {
+          :where => where,
+          :order => order,
+          :page => page,
+          :per_page => per_page,
+          :limit => limit
+        }
+      end
+
+      def where
+        {
+          :or => {},
+          :and => {}
+        }
+      end
+
+      def order
+        {}
+      end
+
+      def page
+        nil
+      end
+
+      def per_page
+        nil
+      end
+
+      def limit
+        nil
+      end
+
+    end
+  end
+end

data/app/services/search/conditions/autocomplete.rb

@@ -0,0 +1,44 @@
+module RademadeAdmin
+  module Search
+    class AutocompleteConditions < Abstract
+
+      def initialize(params, origin_fields, filter_fields)
+        super(params, origin_fields)
+        @filter_fields = filter_fields
+      end
+
+      protected
+
+      def where
+        # todo hierarchical
+        @where_conditions = super
+        append_query_condition
+        append_search_params
+        @where_conditions
+      end
+
+      def limit
+        10
+      end
+
+      private
+
+      def append_query_condition
+        unless @params[:q].present?
+          @filter_fields.each do |field|
+            @where_conditions[:or][field] = /#{@params[:q]}/i
+          end
+        end
+      end
+
+      def append_search_params
+        if @params[:search].present?
+          @params[:search].each do |key, value|
+            @where_conditions[:and][key.to_sym] = value if @origin_fields.include? key.to_s
+          end
+        end
+      end
+
+    end
+  end
+end

data/app/services/search/conditions/list.rb

@@ -0,0 +1,35 @@
+module RademadeAdmin
+  module Search
+    class ListConditions < Abstract
+
+      protected
+
+      def where
+        where_conditions = super
+        where_conditions[:and] = @params.slice(*@origin_fields)
+        where_conditions
+      end
+
+      def order
+        field = @params[:sort] || default_order_field
+        direction = @params[:direction] || :asc
+        [{field => direction}]
+      end
+
+      def page
+        @params[:page] || 1
+      end
+
+      def per_page
+        @params[:paginate] || 20
+      end
+
+      private
+
+      def default_order_field
+        @origin_fields.include?('position') ? :position : :id
+      end
+
+    end
+  end
+end

data/app/services/search/query_adapter/abstract.rb

@@ -0,0 +1,54 @@
+module RademadeAdmin
+  module Search
+    class QueryAdapter
+
+      def initialize(model)
+        @model = model
+      end
+
+      def apply_conditions(search_conditions, is_related_list)
+        # todo something with is_related_list
+        @params = search_conditions.params
+        @result = is_related_list ? related_base_condition : base_condition
+        search_conditions.conditions.each do |query_part, values|
+          @result = self.send(query_part, values) unless values.nil?
+        end
+        @result
+      end
+
+      protected
+
+      def base_condition
+        @model.unscoped
+      end
+
+      def related_base_condition
+        parent_model = @params[:parent].constantize
+        parent_id = @params[:parent_id]
+        model_related_name = @model.to_s.demodulize.pluralize.downcase.to_sym
+        parent_model.find(parent_id).send(model_related_name).unscoped
+      end
+
+      def where(where_conditions)
+        @result
+      end
+
+      def order(order_conditions)
+        @result
+      end
+
+      def page(page_condition)
+        @result.page(page_condition)
+      end
+
+      def per_page(per_page_condition)
+        @result.per(per_page_condition)
+      end
+
+      def limit(limit_condition)
+        @result.limit(limit_condition)
+      end
+
+    end
+  end
+end

data/app/services/search/query_adapter/active_record.rb

@@ -0,0 +1,33 @@
+module RademadeAdmin
+  module Search
+    class ActiveRecord < Abstract
+
+      protected
+
+      def where(where_conditions)
+        values = []
+        condition = ''
+        where_conditions.each do |type, conditions|
+          conditions.each do |field, value|
+            condition += " #{type.to_s.capitalize} " unless condition.empty?
+            if value.is_a? Array
+              condition += "#{field} IN (?)"
+            else
+              condition += "#{field} = ?"
+            end
+            values << value
+          end
+        end
+        @result.where([condition, *values])
+      end
+
+      def order(order_conditions)
+        order_conditions.each do |order_condition|
+          @result = @result.order(order_condition)
+        end
+        @result
+      end
+      
+    end
+  end
+end