rademade_admin 0.0.3 → 0.1.0

data/app/controllers/rademade_admin/model_controller.rb

@@ -3,18 +3,20 @@ module RademadeAdmin
   class ModelController < RademadeAdmin::AbstractController
 
     extend RademadeAdmin::ModelOptions
+
     include RademadeAdmin::InstanceOptions
     include RademadeAdmin::Templates
     include RademadeAdmin::Notifier
 
     before_filter :load_options
+    before_filter :sortable_service, :only => [:index]
 
     def create
       authorize! :create, model_class
-      saver = Saver.new(model_info, params)
+      saver = RademadeAdmin::Saver.new(model_info, params)
       saver.create_model
       if saver.save_model
-        saver.save_aggregated_data
+        saver.save_aggregated_data #rm_todo glue methods
         @item = saver.item
         success_insert @item
       else
@@ -24,9 +26,9 @@ module RademadeAdmin
 
     def update
       authorize! :update, model_class
-      saver = Saver.new(model_info, params)
+      saver = RademadeAdmin::Saver.new(model_info, params)
       if saver.update_model
-        saver.save_aggregated_data
+        saver.save_aggregated_data #rm_todo glue methods
         @item = saver.item
         success_update @item
       else
@@ -36,39 +38,36 @@ module RademadeAdmin
 
     def destroy
       authorize! :destroy, model_class
-      @item = find_item(params[:id])
+      @item = model.find(params[:id])
       @item.delete if @item
       success_delete @item
     end
 
     def autocomplete
       authorize! :read, model_class
-      init_search Search::Conditions::Autocomplete.new(params, origin_fields, model_info.filter_fields)
+      conditions = Search::Conditions::Autocomplete.new(params, model_info.data_items)
+      @items = Search::Searcher.new(model_info).search(conditions)
       render :json => Autocomplete::BaseSerializer.new(@items)
     end
 
     def link_autocomplete
       authorize! :read, model_class
-      init_search Search::Conditions::Autocomplete.new(params, origin_fields, model_info.filter_fields)
-      render :json => Autocomplete::LinkSerializer.new(@items, params[:parent], params[:parent_id])
+
+      relation_service = RademadeAdmin::RelationService.new
+      @related_model_info = relation_service.related_model_info(model_info, params[:relation])
+
+      conditions = Search::Conditions::Autocomplete.new(params, @related_model_info.data_items)
+      @items = Search::Searcher.new(@related_model_info).search(conditions)
+      render :json => Autocomplete::LinkSerializer.new(@items, model.find(params[:id]), params[:relation])
     end
 
     def index
       authorize! :read, model_class
-      init_search Search::Conditions::List.new(params, origin_fields)
-      init_sortable_service
-      respond_to do |format|
-        format.html { render_template }
-        format.json { render :json => @items }
-      end
-    end
+      list_breadcrumbs
+
+      conditions = Search::Conditions::List.new(params, model_info.data_items)
+      @items = Search::Searcher.new(model_info).search(conditions)
 
-    def related_index
-      authorize! :read, model_class
-      init_search Search::Conditions::RelatedList.new(params, origin_fields)
-      init_sortable_service
-      @parent_model_info = RademadeAdmin::Model::Graph.instance.model_info(params[:parent])
-      @parent = @parent_model_info.model.find(params[:parent_id])
       respond_to do |format|
         format.html { render_template }
         format.json { render :json => @items }
@@ -77,27 +76,59 @@ module RademadeAdmin
 
     def new
       authorize! :create, model_class
-      @item = model_info.model.new
+      new_breadcrumbs
+
+      @item = model.new
       render_template
     end
 
     def edit
       authorize! :update, model_class
-      @item = find_item(params[:id])
+      @item = model.find(params[:id])
+
+      edit_breadcrumbs
       render_template
     end
 
-    def link_relation
-      process_link :link
+    def related
+      authorize! :read, model_class
+
+      #rm_todo extract relation service
+      relation_service = RademadeAdmin::RelationService.new
+      @related_model_info = relation_service.related_model_info(model_info, params[:relation])
+
+      @item = model.find(params.delete(:id))
+      conditions = Search::Conditions::RelatedList.new(@item, params, @related_model_info.data_items)
+      @items = Search::Searcher.new(@related_model_info).search(conditions)
+
+      @sortable_service = RademadeAdmin::SortableService.new(@related_model_info, params)
+
+      respond_to do |format|
+        format.html {
+          related_breadcrumbs
+          render_template
+        }
+        format.json { render :json => Autocomplete::BaseSerializer.new(@items) }
+      end
     end
 
-    def unlink_relation
-      process_link :unlink
+    def related_add
+      @item = model.find(params[:id])
+      linker = Linker.new(model_info, @item, params[:relation])
+      linker.link(params[:related_id])
+      success_link
+    end
+
+    def related_destroy
+      @item = model.find(params[:id])
+      linker = Linker.new(model_info, @item, params[:relation])
+      linker.unlink(params[:related_id])
+      success_unlink
     end
 
     def show
       authorize! :read, model_class
-      @item = find_item(params[:id])
+      @item = model.find(params[:id])
       respond_to do |format|
         format.html { redirect_to :action => 'index' }
         format.json { render :json => @item }
@@ -106,39 +137,27 @@ module RademadeAdmin
 
     def form
       authorize! :read, model_class
-      @item = params[:id].blank? ? model_info.model.new : find_item(params[:id])
+      @item = params[:id].blank? ? model.new : model.find(params[:id])
       render form_template_path(true), :layout => false
     end
 
-    def re_sort
-      init_sortable_service
-      @sortable_service.re_sort_items
+    def sort
+      sortable_service.sort_items
       success_action
     end
 
     protected
 
-    def find_item(id)
-      model_info.model.find(id)
+    def model
+      @model ||= model_info.model
     end
 
     def render_template(template = action_name)
       render abstract_template(template)
     end
 
-    def init_search(search_conditions)
-      @searcher = Search::Searcher.new model_info
-      @items = @searcher.search search_conditions
-    end
-
-    def init_sortable_service
-      @sortable_service = RademadeAdmin::SortableService.new(model_info, params)
-    end
-
-    def process_link(method)
-      linker = Linker.new(model_info, params[:parent], params[:parent_id])
-      linker.send(method, params[:id])
-      send("success_#{method}", find_item(params[:id]))
+    def sortable_service
+      @sortable_service ||= RademadeAdmin::SortableService.new(model_info, params)
     end
 
   end

data/app/controllers/rademade_admin/sessions_controller.rb

@@ -4,10 +4,10 @@ module RademadeAdmin
 
     skip_before_action :require_login
 
-    def create
+    def login
       begin
         user = RademadeAdmin::Login.admin(params)
-        sign_in user
+        session[:user_id] = user.id.to_s
         render :json => user, :status => :ok
       rescue RademadeAdmin::Login::Error => e
         render :json => {:errors => e.field_messages}, :status => :precondition_failed
@@ -15,7 +15,7 @@ module RademadeAdmin
     end
 
     def logout
-      sign_out current_user
+      session.delete(:user_id)
       redirect_to :controller => 'dashboard', :action => 'login'
     end
 

data/app/helpers/rademade_admin/field_helper.rb

@@ -1,29 +1,27 @@
 # -*- encoding : utf-8 -*-
 module RademadeAdmin::FieldHelper
 
-  def field_to_label(field)
-    if configured_field?(field) and field.values.first[:label].present?
-      field.values.first[:label]
-    else
-      field.to_s.humanize
-    end
-  end
-
-  def field_name(field)
-    configured_field?(field) ? field.keys.first : field
-  end
-
-  def field_value(field, item)
-    if configured_field?(field)
-      if field.values.first[:method].present?
-        method_name = field.values.first[:method]
+  # Display the field of given item
+  #
+  # @param item [Object]
+  # @param data_item [RademadeAdmin::Model::Info::DataItem]
+  #
+  # @return [String]
+  #
+  def display_item_value(item, data_item)
+    value = item.send(data_item.preview_accessor)
+    if data_item.has_relation?
+      # rm_todo extract method
+      if data_item.relation.has_many?
+        link_to data_item.label, admin_related_item(item, data_item.getter)
       else
-        method_name = field.keys.first
+        link_to value.to_s, admin_edit_uri(value) unless value.nil?
       end
+    elsif data_item.has_uploader?
+      RademadeAdmin::Upload::PreviewService.new(value).uploaded_file_html
     else
-      method_name = field
+      value.to_s
     end
-    item.send(method_name)
   end
 
   def pagination_option(number, name = 'paginate')
@@ -31,24 +29,15 @@ module RademadeAdmin::FieldHelper
     hash_params.delete(:page)
     hash_params[name.to_sym] = number
 
-    options = '?' + hash_params.map do |k, v|
-      "#{k.to_s}=#{v}"
-    end.join('&')
-
+    options = '?' + hash_params.map { |k, v| "#{k.to_s}=#{v}" }.join('&')
     selected = number == request.query_parameters[name.to_sym].to_i
 
-    content_tag(:option, number.to_s, selected: selected, value: request.path+options)
+    content_tag(:option, number.to_s, :selected => selected, :value => request.path + options)
   end
 
   def input_attr(attrs = {})
-    attrs.merge :wrapper_html => {:class => 'form-group'},
-                :input_html => {:class => 'form-control'}
-  end
-
-  private
-
-  def configured_field?(field)
-    field.is_a? Hash
+    attrs.deep_merge :wrapper_html => { :class => 'form-group' },
+                :input_html => { :class => 'form-input' }
   end
 
 end

data/app/helpers/rademade_admin/form_helper.rb

@@ -2,8 +2,9 @@
 module RademadeAdmin::FormHelper
 
   def admin_form(record, model, &block)
-    semantic_form_for(
+    simple_form_for(
       record,
+      :wrapper => :rademade,
       :url => record.new_record? ? admin_create_uri(model) : admin_update_uri(record),
       :as => :data,
       :html => {
@@ -16,42 +17,71 @@ module RademadeAdmin::FormHelper
     )
   end
 
-  def admin_field(form, name, params, model_info, record)
-    attrs = admin_default_params(name).merge(admin_field_params(params))
+  def admin_field(form, form_field, model_info)
+    name = form_field.name
+    attrs = admin_default_params(name, model_info)
+      .merge(field_params(form_field))
+      .merge(input_params(name))
+    concat form.input(name, input_attr(attrs))
+  end
 
-    field = form.input(name, input_attr(attrs))
+  def admin_localized_field(form, form_field, model_info, locale)
+    name = "#{form_field.getter}][#{locale}"
+    attrs = admin_default_params(form_field.name, model_info)
+      .merge(field_params(form_field))
+      .merge(localized_field_params(form_field, locale))
+    concat form.input(name, input_attr(attrs))
+  end
 
-    if model_info.model_reflection.many_relation? name
-      link = admin_field_link_to_list(name, model_info, record).to_s
-    else
-      link = ''
-    end
+  private
 
-    concat field + link
+  def admin_default_params(name, model_info)
+    { :label => model_info.label_for(name) }
   end
 
-  def admin_default_params(name)
-    {:label => field_to_label(name)}
+  def field_params(form_field)
+    field_params = form_field.form_params
+    field_params[:as] = default_field_type(form_field) unless field_params[:as].present?
+    field_params
   end
 
-  def admin_field_link_to_list(name, model_info, record)
-    if record.id
-      related_model = model_info.reflect_on_association(name).class_name
-      uri = admin_model_url_for(related_model, {
-        :action => :related_index,
-        :parent => model_info.model,
-        :parent_id => record.id.to_s
-      })
-      link_to(RademadeAdmin::Model::Graph.instance.model_info(related_model).item_name + ' list', uri) if uri
-    end
+  def input_params(name)
+    {
+      :input_html => {
+        :id => "#{name}_#{@item.id}"
+      }
+    }
   end
 
-  def admin_field_params(field_params)
-    if field_params.is_a? Hash
-      field_params
+  def localized_field_params(form_field, locale)
+    {
+      :input_html => {
+        :id => "#{form_field.getter}_#{locale}_#{@item.id}",
+        :value => localized_value(form_field.getter, locale)
+      }
+    }
+  end
+
+  def default_field_type(form_field)
+    if form_field.has_relation?
+       :'rademade_admin/related_select'
+    elsif form_field.has_uploader?
+       :'rademade_admin/file'
+    elsif form_field.date_time?
+       :'rademade_admin/date_time'
     else
-      {:as => field_params}
+       nil
     end
   end
 
-end
+  private
+
+  def localized_value(getter, locale)
+    current_locale = I18n.locale
+    I18n.locale = locale
+    item_value = (@item.try(:translation) || @item).send(getter)
+    I18n.locale = current_locale
+    item_value
+  end
+
+end

data/app/helpers/rademade_admin/menu_helper.rb

@@ -4,8 +4,7 @@ module RademadeAdmin::MenuHelper
   def main_menu
     @model_infos = RademadeAdmin::Model::Graph.instance.root_models
     menu = collect_children
-    menu.unshift({ :uri => url_for(:root), :name => 'Home', :ico => 'fa fa-home', :sub => [] })
-    menu
+    unshift_root_url(menu)
   end
 
   def active?(menu_item)
@@ -13,9 +12,7 @@ module RademadeAdmin::MenuHelper
       true
     else
       menu_item[:sub].each do |sub_item|
-        if active?(sub_item)
-          return true
-        end
+        return true if active?(sub_item)
       end
       false
     end
@@ -23,6 +20,16 @@ module RademadeAdmin::MenuHelper
 
   private
 
+  def unshift_root_url(menu)
+    menu.unshift({
+      :uri => root_url,
+      :name => t('rademade_admin.home'),
+      :ico => 'glyphicon glyphicon-home',
+      :is_current => current_page?(root_url),
+      :sub => []
+    })
+  end
+
   def collect_children(parent = nil)
     menu = []
     @model_infos.each do |model_info|

data/app/helpers/rademade_admin/uri_helper.rb

@@ -1,24 +1,6 @@
 # -*- encoding : utf-8 -*-
 module RademadeAdmin::UriHelper
 
-  def admin_link_uri(model, parent, parent_id)
-    admin_model_url_for(model.class, {
-      :action => :link_relation,
-      :id => model.id,
-      :parent => parent,
-      :parent_id => parent_id
-    })
-  end
-
-  def admin_unlink_uri(model, parent, parent_id)
-    admin_model_url_for(model.class, {
-      :action => :unlink_relation,
-      :id => model.id,
-      :parent => parent,
-      :parent_id => parent_id
-    })
-  end
-
   def admin_list_uri(model)
     admin_model_url_for(model, {
       :action => :index
@@ -26,15 +8,9 @@ module RademadeAdmin::UriHelper
   end
 
   def admin_autocomplete_uri(model, opts = {})
-    admin_model_url_for(model, {
+    admin_model_url_for(model, opts.merge({
       :action => :autocomplete
-    }.merge(opts))
-  end
-
-  def admin_link_autocomplete_uri(model, opts = {})
-    admin_model_url_for(model, {
-      :action => :link_autocomplete
-    }.merge(opts))
+    }))
   end
 
   def admin_new_uri(model)
@@ -49,50 +25,66 @@ module RademadeAdmin::UriHelper
     })
   end
 
+  def admin_create_uri(model)
+    admin_model_url_for(model, {
+      :action => :create
+    })
+  end
+
   def admin_edit_uri(model)
-    entity_url(model, :edit)
+    _entity_url(model, :edit)
   end
 
   def admin_edit_form_uri(model)
-    entity_url(model, :form)
+    _entity_url(model, :form)
   end
 
   def admin_delete_uri(model)
-    entity_url(model, :destroy)
+    _entity_url(model, :destroy)
   end
 
-  def admin_create_uri(model)
-    admin_model_url_for(model, {
-      :action => :create
-    })
+  def admin_update_uri(model)
+    _entity_url(model, :update)
   end
 
-  def admin_update_uri(model)
-    entity_url(model, :update)
+  def admin_related_item(model, relation_getter, opts = {})
+    admin_related_uri(model, :related, relation_getter, opts)
   end
 
-  def admin_model_url_for(model_info, options = {})
-    unless model_info.is_a? RademadeAdmin::Model::Info
-      model_info = RademadeAdmin::Model::Graph.instance.model_info(model_info)
-    end
-    options.merge!(get_id(model_info)) if nested?(model_info)
-    url_options = options.merge({
-      :controller => model_info.controller
-    })
-    admin_url_for(url_options)
+  def admin_link_autocomplete_uri(model, relation_getter, opts = {})
+    admin_related_uri(model, :link_autocomplete, relation_getter, opts)
+  end
+
+  def admin_link_uri(model, relation_getter, opts = {})
+    admin_related_uri(model, :related_add, relation_getter, opts)
+  end
+
+  def admin_unlink_uri(model, relation_getter, opts = {})
+    admin_related_uri(model, :related_destroy, relation_getter, opts)
+  end
+
+  def admin_related_uri(model, action, relation_getter, opts = {})
+    _entity_url(model, action, opts.merge({
+      :relation => relation_getter
+    }))
   end
 
-  def admin_url_for(url_options)
-    url_options = url_options.merge({
+  def admin_model_url_for(model, opts = {})
+    admin_url_for(opts.merge({
+      :controller => _real_model_info(model).controller
+    }))
+  end
+
+  def admin_url_for(opts)
+    opts = opts.merge({
+      :controller => "rademade_admin/#{opts[:controller]}",
       :only_path => true
     })
-    #todo folder of admin controllers
-    url_options[:controller] = 'rademade_admin/' + url_options[:controller]
     begin
-      Rails.application.routes.url_helpers.url_for(url_options)
+      Rails.application.routes.url_helpers.url_for(opts)
     rescue
       begin
-        RademadeAdmin::Engine.routes.url_helpers.url_for(url_options)
+        RademadeAdmin::Engine.routes.url_helpers.url_for(opts)
       rescue
         nil
       end
@@ -101,20 +93,16 @@ module RademadeAdmin::UriHelper
 
   private
 
-  def nested?(model_info)
-    @object and model_info
-  end
-
-  def get_id(model_info)
-    key = model_info.model.to_s.foreign_key
-    { key.to_sym => @object.id }
-  end
-
-  def entity_url(model, action)
-    admin_model_url_for(model.class, {
+  def _entity_url(model, action, opts = {})
+    admin_model_url_for(model.class, opts.merge({
       :action => action,
       :id => model.id
-    })
+    })) if model.persisted? # rm_todo: check for AR
+  end
+
+  def _real_model_info(model)
+    return model if model.is_a? RademadeAdmin::Model::Info
+    RademadeAdmin::Model::Graph.instance.model_info(model)
   end
 
 end