alchemy-custom-model 2.0.3 → 2.2.1

data/app/controllers/alchemy/custom/model/admin/base_with_globalize_controller.rb

@@ -0,0 +1,38 @@
+module Alchemy
+  module Custom
+    module Model
+      module Admin
+        class BaseWithGlobalizeController < ::Alchemy::Custom::Model::Admin::BaseController
+
+
+          around_action :switch_globalize_locale
+          before_action :load_object, except: :index
+
+
+          def index
+            @query = base_class.ransack(params[:q])
+            @objects = @query.result(distinct: true)
+            @objects = @objects.accessible_by(current_ability)
+            @total_objects = @objects
+            @objects = @objects.page(params[:page]).
+                per(params[:per_page] ||
+                        (base_class::DEFAULT_PER_PAGE if base_class.const_defined? :DEFAULT_PER_PAGE) ||
+                        25)
+            instance_variable_set "@#{base_class.name.demodulize.underscore.downcase.pluralize}", @objects
+          end
+
+
+
+          private
+
+          def switch_globalize_locale(&action)
+            locale = Alchemy::Language.current.language_code.to_sym
+            Globalize.with_locale(locale, &action)
+          end
+
+
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/alchemy/admin/nodes_controller_dec.rb

@@ -0,0 +1,55 @@
+module Alchemy
+  module Admin
+    module NodesControllerDec
+      extend ActiveSupport::Concern
+
+      included do
+
+        def custom_models
+          @custom_model_klasses = Alchemy::Custom::Model.allowed_custom_models_for_menu
+          if params[:q] and params[:q][:name]
+            @custom_model_klasses = @custom_model_klasses.select { |el| el.match /#{params[:q][:name]}/i }
+          end
+          @custom_model_klasses = Kaminari.paginate_array(@custom_model_klasses).page(params[:page]).per(params[:per_page] || 10)
+
+        end
+
+        def custom_models_methods
+          @custom_model_klasses = Alchemy::Custom::Model.allowed_custom_models_for_menu
+          @custom_model_methods = []
+          if params[:q] and params[:q][:custom_model_klass]
+            klass = Alchemy::Custom::Model.allowed_custom_models_for_menu.select { |el| el == params[:q][:custom_model_klass] }.first
+            if !klass.nil? and klass.safe_constantize
+              klass = klass.constantize
+              if klass.respond_to? :menu_generator_methods
+                @custom_model_methods = klass.menu_generator_methods
+              end
+            end
+          end
+          @custom_model_methods = Kaminari.paginate_array(@custom_model_methods).page(params[:page]).per(params[:per_page] || 10)
+        end
+
+
+        private
+
+        def resource_params
+          params.require(:node).permit(
+              :site_id,
+              :parent_id,
+              :language_id,
+              :page_id,
+              :name,
+              :url,
+              :title,
+              :nofollow,
+              :external,
+              :custom_model_klass,
+              :custom_model_method
+          )
+        end
+
+
+      end
+    end
+  end
+end

data/app/helpers/alchemy/custom/model/admin/base_helper.rb

@@ -221,9 +221,12 @@ module Alchemy::Custom::Model::Admin::BaseHelper
           component_id = SecureRandom.hex(10)
 
           bf << form.fields_for(field) do |join_record_form|
-            render(layout: 'gallery_item', locals: {picture: join_record_form.object.picture}) do
+            render(layout: 'gallery_item', locals: {picture: join_record_form.object.picture, jr_id: join_record_form.object.id}) do
+              sb = ActiveSupport::SafeBuffer.new
 
-              join_record_form.hidden_field :position, class: 'gallery_position_counter'
+              sb << join_record_form.hidden_field(:position, class: 'gallery_position_counter')
+              sb << join_record_form.hidden_field(:_destroy, class: 'gallery_item_destroy_input')
+              sb
 
             end
           end
@@ -434,4 +437,49 @@ module Alchemy::Custom::Model::Admin::BaseHelper
   end
 
 
+  def search_panel(options = {}, &block)
+    submit_button = options.fetch(:enable_submit, true)
+    klass = options.delete(:class) || []
+    
+    content_tag(:div, class: "search_panel #{klass.join(" ")}", ** options) do
+      sb = ActiveSupport::SafeBuffer.new
+
+      if @query
+        sb << content_tag(:div, class:"title") do
+          spt = ActiveSupport::SafeBuffer.new
+          spt << content_tag(:span, t("search_panel_title"), class:"title_label")
+          
+          #TODO: toggle pannello
+          #spt << content_tag(:span, class:"button_toggle") do
+          #  content_tag(:a,class:"icon_button") do
+          #    content_tag(:i, nil, class:"icon fa-fw fa-bars fas")
+          #  end
+          #end
+          spt
+        end
+
+        sb << simple_form_for(@query, url: polymorphic_path([:admin, @query.klass]), method: :get) do |f|
+          sff = ActiveSupport::SafeBuffer.new
+
+          sff << content_tag(:div, class: "search_fields_group") do
+            search_fields = ActiveSupport::SafeBuffer.new
+
+            search_fields << capture do
+              block.call(f)
+            end
+
+            search_fields
+          end
+          if submit_button
+            sff << content_tag(:div, class: "action_buttons") do
+              f.submit(::I18n.t('alchemy_ajax_form.submit_search'))
+            end
+          end
+          sff
+        end
+      end
+      sb
+    end
+  end    
+
 end

data/app/helpers/alchemy/custom/model/custom_model_helper.rb

@@ -2,37 +2,46 @@ module Alchemy::Custom::Model
   module CustomModelHelper
 
     def self.included(mod)
-      if ::Rails.application.config.action_controller.include_all_helpers!=false
+      if ::Rails.application.config.action_controller.include_all_helpers != false
         raise "Devi definire in config/application.rb config.action_controller.include_all_helpers=false
                 in modo da far funzionare correttamente l'override degli helper come per i controller"
       end
     end
 
-    def custom_model_page_urlname(obj)
-      layout = Alchemy::PageLayout.get_all_by_attributes(custom_model: obj.class.to_s).select {|ly| ly["custom_model_action"] == "show"}.first
+    def custom_model_page_urlname(obj, language: nil)
+      if language.blank?
+        language = Alchemy::Language.current
+      end
+      layout = Alchemy::PageLayout.get_all_by_attributes(custom_model: obj.class.to_s).select { |ly| ly["custom_model_action"] == "show" }.first
       if not layout.blank?
-        Alchemy::Language.current.pages.find_by(page_layout: layout["name"]).try(:parent).try(:urlname)
+        language.pages.find_by(page_layout: layout["name"]).try(:parent).try(:urlname)
       else
         nil
       end
     end
 
-    def custom_model_path(obj)
-      custom_model_url_builder(obj) do |url|
-        alchemy.show_page_path(Alchemy::Language.current.code, url)
+    def custom_model_path(obj, options = {})
+      language = options.delete(:language)
+      custom_model_url_builder(obj, language: language) do |url|
+        alchemy.show_page_path(language || Alchemy::Language.current.code, url, options)
       end
     end
 
-    def custom_model_url(obj)
-      custom_model_url_builder(obj) do |url|
-        alchemy.show_page_url(Alchemy::Language.current.code, url)
+    def custom_model_url(obj, options = {})
+      language = options.delete(:language)
+      if language.is_a? String
+        language = Alchemy::Language.find_by_code(language)
+      end
+      custom_model_url_builder(obj, language: language) do |url|
+        alchemy.show_page_url(language.code || Alchemy::Language.current.code, url, options)
       end
     end
 
+
     private
 
-    def custom_model_url_builder(obj)
-      to_url = custom_model_page_urlname obj
+    def custom_model_url_builder(obj, language: nil)
+      to_url = custom_model_page_urlname obj, language: language
       if not to_url.blank?
 
         # Url build with alchemy
@@ -49,11 +58,15 @@ module Alchemy::Custom::Model
         url += '/'
 
         if obj.class.respond_to?(:friendly_id_config)
-          url += "#{obj.send(obj.class.friendly_id_config.slug_column)}"
+          language = Alchemy::Language.current if language.blank?
+          Globalize.with_locale(language.language_code.to_sym) do
+            url += "#{obj.send(obj.class.friendly_id_config.slug_column)}"
+          end
         else
           url += "#{obj.id}"
         end
 
+
         if block_given?
           yield url
         else

data/app/helpers/alchemy/pages_helper_decorator.rb

@@ -91,5 +91,43 @@ Alchemy::PagesHelper.module_eval do
   end
 
 
+  def check_if_active node_or_cm_inst
+    if !node_or_cm_inst.is_a? Alchemy::Node
+      if node_or_cm_inst.respond_to? :for_menu_matching and node_or_cm_inst.for_menu_matching.include? @custom_element
+        return true
+      end
+    else
+      if node_or_cm_inst.custom_model?
+        if @custom_element.respond_to? :for_menu_matching and
+            @custom_element.for_menu_matching.include? node_or_cm_inst.klass_custom_model
+          return true
+        end
+      elsif node_or_cm_inst.page and node_or_cm_inst.page.self_and_descendants.include? @page
+        return true
+      end
+    end
+    false
+  end
+
+  def render_menu_with_language(name, options = {})
+    root_node = Alchemy::Node.where(language_id: Alchemy::Language.current.id).roots.find_by(name: name)
+    if root_node.nil?
+      warning("Menu with name #{name} not found!")
+      return
+    end
+
+    options = {
+        node_partial_name: "#{root_node.view_folder_name}/node"
+    }.merge(options)
+
+    render(root_node, menu: root_node, node: root_node, options: options)
+  rescue ActionView::MissingTemplate => e
+    warning <<-WARN
+          Menu partial not found for #{name}.
+          #{e}
+    WARN
+  end
+
+
 end
 

data/app/models/concerns/alchemy/node_dec.rb

@@ -0,0 +1,45 @@
+module Alchemy
+  module NodeDec
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      validates :custom_model_klass, presence: true, if: -> {
+        url.blank? and not parent.nil?
+      }
+
+      before_validation :ensure_page_nil_if_custom_model, on: [:create, :update]
+      before_validation :set_site, on: [:create], if: -> {site.nil?}
+
+      def custom_model?
+        !custom_model_klass.blank?
+      end
+
+      def klass_custom_model
+        self.custom_model_klass.constantize
+      end
+
+      private
+
+      def ensure_page_nil_if_custom_model
+        if not url.blank? and !custom_model_klass_changed? and !custom_model_method_changed?
+          self.custom_model_klass = nil
+          self.custom_model_method = nil
+        elsif !custom_model_klass.blank? and !url_changed?
+          self.page = nil
+          self.url = nil
+        end
+
+      end
+
+      def set_site
+        unless self.language.nil?
+          self.site = language.site
+        end
+      end
+
+
+    end
+  end
+end

data/app/views/alchemy/admin/nodes/_form.html.erb

@@ -0,0 +1,126 @@
+<%= alchemy_form_for([:admin, node]) do |f| %>
+
+  <% if node.root? %>
+
+    <% if Alchemy::Node.respond_to? :available_menu_names %>
+      <%= f.input :name,
+                  collection: Alchemy::Node.available_menu_names.map { |n| [I18n.t(n, scope: [:alchemy, :menu_names]), n] },
+                  include_blank: false,
+                  input_html: {class: 'alchemy_selectbox'} %>
+    <% else %>
+      <%= f.input :name, input_html: {
+          autofocus: true,
+          value: node.page && node.read_attribute(:name).blank? ? nil : node.name,
+          placeholder: node.page ? node.page.name : nil
+      } %>
+    <% end %>
+
+  <% else %>
+
+    <%= f.input :name, as: :string,  input_html: {
+        autofocus: true,
+        value: node.page && node.read_attribute(:name).blank? ? nil : node.name,
+        placeholder: node.page ? node.page.name : nil
+    } %>
+
+    <%
+      active_klass = (node.errors.keys.include? :custom_model_klass or
+          node.custom_model?) ? "ui-tabs-active" : ""
+    %>
+
+    <div class="container_selctor_age_custom_model">
+      <div id="tabs_nodes" class="ui-tabs ui-corner-all ui-widget ui-widget-content">
+        <ul role="tablist" class="ui-tabs-nav ui-corner-all ui-helper-reset ui-helper-clearfix ui-widget-header">
+          <li role="tab" tabindex="0" class="ui-tabs-tab ui-corner-top ui-state-default ui-tab">
+            <a href="#pages" role="presentation" tabindex="-1" class="ui-tabs-anchor" id="ui-id-1">
+            <%= Alchemy.t(:pages_select) %>
+            </a>
+          </li>
+          <li role="tab" tabindex="1" class="ui-tabs-tab ui-corner-top ui-tab <%= active_klass %>">
+            <a href="#custom_models" role="presentation" tabindex="1" class="ui-tabs-anchor" id="ui-id-2">
+              <%= Alchemy.t(:custom_models) %>
+            </a>
+          </li>
+        </ul>
+        <div id="custom_models" aria-labelledby="legacy_urls_label" role="tabpanel" class="ui-tabs-panel ui-corner-bottom ui-widget-content" aria-hidden="false">
+          <%= f.input :custom_model_klass, input_html: {class: 'alchemy_selectbox'} %>
+          <%= f.input :custom_model_method, input_html: {class: 'alchemy_selectbox'} %>
+        </div>
+        <div id="pages" aria-labelledby="ui-id-1" role="tabpanel" class="ui-tabs-panel ui-corner-bottom ui-widget-content" aria-hidden="false">
+          <%= f.input :page_id, label: Alchemy::Page.model_name.human, input_html: {class: 'alchemy_selectbox'} %>
+          <%= f.input :url, input_html: {disabled: node.page}, hint: Alchemy.t(:node_url_hint) %>
+          <%= f.input :title %>
+          <%= f.input :nofollow %>
+          <%= f.input :external %>
+          <%= f.hidden_field :parent_id %>
+        </div>
+
+      </div>
+    </div>
+
+
+
+
+
+
+  <% end %>
+  <% if node.respond_to? :site_id %>
+    <%= f.hidden_field :site_id %>
+  <% end %>
+  <% if node.respond_to? :language_id %>
+    <%= f.hidden_field :language_id %>
+  <% end %>
+  <%= f.submit button_label %>
+<% end %>
+
+<script>
+
+    $("#tabs_nodes").tabs();
+
+
+    $('#node_custom_model_klass').alchemyCustomModelSelect({
+        placeholder: "<%= Alchemy.t(:select_custom_model_method) %>",
+        url: "<%= alchemy.custom_models_admin_nodes_path %>",
+
+    }).on("change", function (event) {
+        $('#node_custom_model_method').select2('enable');
+
+    }).on("select2-removed", function (e) {
+        $('#node_custom_model_method').val(null).trigger("change");
+    })
+
+
+    $('#node_custom_model_method').alchemyCustomModelSelect({
+        placeholder: "<%= Alchemy.t(:select_custom_model) %>",
+        url: "<%= alchemy.custom_models_methods_admin_nodes_path %>",
+        query_params: function (term, page) {
+            var klass = $('#node_custom_model_klass').val()
+            return {
+                custom_model_klass: klass
+            }
+        }
+
+    })
+
+    $('#node_custom_model_method').select2('disable');
+
+    $('#node_page_id').alchemyPageSelect({
+        placeholder: "<%= Alchemy.t(:search_page) %>",
+        url: "<%= alchemy.api_pages_path %>",
+        <% if node.page %>
+        initialSelection: {
+            id: <%= node.page_id %>,
+            text: "<%= node.page.name %>",
+            url: "/<%= node.page.urlname %>"
+        }
+        <% end %>
+    }).on('change', function (e) {
+        if (e.val === '') {
+            $('#node_name').removeAttr('placeholder')
+            $('#node_url').val('').prop('disabled', false)
+        } else {
+            $('#node_name').attr('placeholder', e.added.name)
+            $('#node_url').val('/' + e.added.urlname).prop('disabled', true)
+        }
+    })
+</script>