alchemy-custom-model 0.1.0

data/app/assets/stylesheets/alchemy-custom-model/custom_tiny_mce.scss

@@ -0,0 +1,6 @@
+.base_form_container {
+  .tinymce_container {
+    float: right;
+    width: 65%;
+  }
+}

data/app/assets/stylesheets/alchemy-custom-model/manifest.css

@@ -0,0 +1,16 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require "alchemy-custom-model/custom_elfinder"
+ *= require "alchemy-custom-model/custom_tiny_mce"
+ *= require "alchemy-custom-model/custom_style"
+ */

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

@@ -0,0 +1,189 @@
+module Alchemy::Custom::Model
+  module Admin
+    class BaseController < Alchemy::Custom::Model.admin_controller_class
+
+      before_action :authorize_resource
+      before_action :clean_slug, only: [:create, :update]
+      before_action :set_language, unless: -> {params[:language_id].nil?}
+      before_action :load_object, except: :index
+
+      helper_method :base_class
+      helper_method :table_columns
+      helper_method :url_namespace
+
+      helper Alchemy::Custom::Model::BaseHelper
+
+
+      def index
+        @query = base_class.ransack(params[:q])
+        @objects = @query.result(distinct: true)
+        @objects = @objects.accessible_by(current_ability).only_current_language
+        @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
+
+      def new
+
+      end
+
+      def edit
+
+      end
+
+      def update
+        if @obj.update_attributes(clean_params)
+          after_successful_update
+        else
+          atfer_unsuccessful_update
+        end
+      end
+
+      def destroy
+        if @obj.destroy
+          after_successful_destroy
+        else
+          after_unsuccessful_destroy
+        end
+      end
+
+      def create
+        if @obj.update_attributes(clean_params)
+          after_successful_create
+        else
+          after_unsuccessful_create
+        end
+
+      end
+
+
+      class << self
+
+        mattr_accessor :parent_model_name, :parent_klass, :parent_find_method
+
+        def belongs_to(model_name, options = {})
+          prepend_before_action :load_parent
+          const_model_klass = options[:model_klass].to_s.constantize unless options[:model_klass].nil?
+          self.parent_model_name = model_name.to_s
+          self.parent_klass = const_model_klass || self.parent_model_name.to_s.classify.constantize
+          self.parent_find_method = options[:find_by].to_s || "id"
+        end
+      end
+
+
+      private
+
+      def table_columns
+        base_class.columns.collect(&:name).collect {|c| c.to_sym}.reject do |c|
+          [
+            :created_at,
+            :updated_at,
+            :id,
+            :language_id,
+            :meta_keywords,
+            :meta_description,
+            :meta_title,
+            :robot_follow,
+            :robot_index
+          ].include? c
+        end
+      end
+
+      def base_class
+        raise '-- Override Method base_class'
+      end
+
+      def url_namespace(obj=base_class)
+        [:admin, obj]
+      end
+
+      def load_object
+        if params[:id]
+          if base_class.respond_to? :friendly
+            @obj = base_class.friendly.find(params[:id])
+          else
+            @obj = base_class.find(params[:id])
+          end
+        else
+          @obj = base_class.new
+        end
+        instance_variable_set("@#{base_class.name.demodulize.underscore.downcase.singularize}", @obj)
+      end
+
+      def resource_instance_variable
+        @obj
+      end
+
+
+      def authorize_resource
+        authorize!(action_name.to_sym, @obj || base_class)
+      end
+
+      def permitted_attributes
+        base_class.attribute_names.collect {|c| c.to_sym}
+      end
+
+      def clean_params
+        dati = params.required(base_class.name.underscore.gsub('/', '_').to_sym).permit(permitted_attributes)
+        ::Rails.logger.info {"Permitted Attributes: #{permitted_attributes.inspect}"}
+        ::Rails.logger.info {"Parametri puliti: #{dati.inspect}"}
+        dati
+      end
+
+      def clean_slug
+        slug = params[base_class.name.underscore.gsub('/', '_').to_sym][:slug]
+        if slug.blank?
+          params[base_class.name.underscore.gsub('/', '_').to_sym].delete(:slug)
+        end
+      end
+
+      def after_successful_destroy
+        redirect_to polymorphic_path(url_namespace), notice: t(:record_succesfully_destroy, model: base_class.model_name.human)
+      end
+
+      def after_unsuccessful_destroy
+        redirect_to polymorphic_path(url_namespace), error: t(:record_unsuccesfully_destroy, model: base_class.model_name.human)
+      end
+
+      def after_successful_update
+        redirect_to polymorphic_path(url_namespace), notice: t(:record_succesfully_update, model: base_class.model_name.human)
+      end
+
+      def atfer_unsuccessful_update
+        render :edit
+      end
+
+      def after_successful_create
+        redirect_to polymorphic_path(url_namespace), notice: t(:record_succesfully_create, model: base_class.model_name.human)
+      end
+
+      def after_unsuccessful_create
+        render :new
+      end
+
+
+      def set_language
+        set_alchemy_language(params[:language_id])
+      end
+
+
+      def load_parent
+        unless self.class.parent_model_name.blank?
+          @parent = self.class.parent_klass.
+            find_by("#{self.class.parent_find_method.to_s}": params["#{parent_model_name_demodulized}_id"])
+
+          instance_variable_set("@#{parent_model_name_demodulized}", @parent)
+        end
+      end
+
+      def parent_model_name_demodulized
+        self.class.parent_model_name.
+          classify.demodulize.underscore
+      end
+
+
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+module Alchemy::Custom::Model
+  module Admin
+    class FilesController < Alchemy::Custom::Model.admin_controller_class
+
+      skip_before_action :verify_authenticity_token, :only => ['elfinder']
+
+      def elfinder
+        authorize! :usage, Alchemy::Custom::Model::ElFinder
+
+        h, r, f = connector.run(params)
+
+        headers.merge!(h)
+
+        if f.blank?
+          render (r.empty? ? {:nothing => true} : {:plain => r.to_json}), :layout => false
+        else
+          send_file f[:path], disposition: :inline
+        end
+
+
+      end
+
+      def ui
+        @volumes = params[:volumes]
+        authorize! :ui_usage, Alchemy::Custom::Model::ElFinder
+        render layout: false
+      end
+
+      private
+
+      def connector
+
+
+        volumi = []
+
+        if params[:volumes].blank?
+          volumi << ElFinder::Volumes::AlchemyFile.new
+        else
+
+          volumes = params[:volumes]
+          volumes = volumes.split(',') if volumes.is_a? String
+
+          volumes_cfgs = {}
+          if params[:volumes_cfgs]
+            volumes_cfgs = ActiveSupport::HashWithIndifferentAccess.new(ActiveSupport::JSON.decode(Base64.strict_decode64(params[:volumes_cfgs])))
+            Rails.logger.info {"CONFIGURAZIONE_VOLUMI: #{volumes_cfgs.inspect}"}
+          end
+
+
+          volumes.each do |v|
+
+            if volumes_cfgs.key?(v)
+
+              cfgs = volumes_cfgs[v]
+
+              volumi << ElFinder::Volumes.const_get(cfgs.delete(:volume)).new(cfgs)
+            else
+              volumi << ElFinder::Volumes.const_get(v).new
+            end
+
+          end
+        end
+
+
+        ElFinder::Connector.new(
+          :root => '/alchemy_library', #File.join(Rails.public_path, 'public'),
+          # :url => '/system/elfinder',
+          # :perms => {
+          #   /^(Welcome|README)$/ => {:read => true, :write => false, :rm => false},
+          #   '.' => {:read => true, :write => false, :rm => false}, # '.' is the proper way to specify the home/root directory.
+          #   /^test$/ => {:read => true, :write => true, :rm => false},
+          #   'logo.png' => {:read => true},
+          #   /\.png$/ => {:read => false} # This will cause 'logo.png' to be unreadable.
+          #   # Permissions err on the safe side. Once false, always false.
+          # },
+          # :extractors => {
+          #   'application/zip' => ['unzip', '-qq', '-o'], # Each argument will be shellescaped (also true for archivers)
+          #   'application/x-gzip' => ['tar', '-xzf'],
+          # },
+          # :archivers => {
+          #   'application/zip' => ['.zip', 'zip', '-qr9'], # Note first argument is archive extension
+          #   'application/x-gzip' => ['.tgz', 'tar', '-czf'],
+          # },
+          # :tree_sub_folders => true,
+          #adds {Rails.root}/public/uploads as "root" volume, named "uploads" in the GUI
+          :volumes => volumi,
+          #[{:id => "root", :name => "uploads", :root => File.join(Rails.root, 'public', 'uploads'), :url => "files/"}],
+          :mime_handler => ::ElFinder::MimeType,
+          :image_handler => ElFinder::Image,
+          :original_filename_method => lambda {|file| file.original_filename.respond_to?(:force_encoding) ? file.original_filename.force_encoding('utf-8') : file.original_filename},
+          :disabled_commands => ['mkfile'],
+          :allow_dot_files => true,
+          :upload_max_size => '50M',
+          # :upload_file_mode => 0644,
+          :home => 'Home',
+          :default_perms => {:read => true, :write => true, :rm => true, :hidden => false},
+          :thumbs => false,
+          :thumbs_directory => '.thumbs',
+          :thumbs_size => 48,
+          :thumbs_at_once => 5,
+        )
+      end
+
+    end
+  end
+end

data/app/controllers/alchemy/pages_controller_decorator.rb

@@ -0,0 +1 @@
+Alchemy::PagesController.include Alchemy::Custom::Model::PagesControllerDec

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

@@ -0,0 +1,379 @@
+module Alchemy::Custom::Model::Admin::BaseHelper
+
+
+  def base_form_container
+    content_tag :div, class: "base_form_container #{controller_name}" do
+      yield
+    end
+  end
+
+  def rich_text_editor(form, field)
+
+    editor_idenfier = "#{field}_#{form.object_id}"
+
+    bf = ActiveSupport::SafeBuffer.new
+    bf << form.input(field) do
+      content_tag(:div, class: 'tinymce_container') do
+        form.text_area field, class: 'has_tinymce', id: "tinymce_#{editor_idenfier}"
+      end
+    end
+
+    bf << content_tag(:script, :type => "text/javascript") do
+      raw "(function(){
+          CustomTinyMce.initEditor('#{editor_idenfier}')
+          })();
+           "
+    end
+
+    bf
+
+
+  end
+
+
+  def single_image_input(form, field)
+
+    form.input(field) do
+      content_tag(:div, class: "elfinder_picture_thumbnail") do
+        bf = ActiveSupport::SafeBuffer.new
+
+        component_id = SecureRandom.hex(10)
+        component_id_image = "#{component_id}_image"
+
+        ref_id = nil
+
+        unless form.object.send(field).blank?
+          ref_id = form.object.send(field).to_signed_global_id.to_s
+        end
+
+        bf << form.hidden_field(field, id: component_id, value: ref_id)
+
+        image_path = no_image_path = image_url("alchemy-custom-model/no_image.png")
+
+        image_path = form.object.send(field).image_file.thumb("100x100#").url if form.object.send(field) and form.object.send(field).image_file_stored?
+
+        bf << content_tag(:div, image_tag(image_path, id: component_id_image, class: "picture_image"))
+
+        bf << content_tag(:div, class: "edit_images_bottom") do
+
+          bf2 = ActiveSupport::SafeBuffer.new
+
+          bf2 << link_to("#", class: 'open_el_finder',
+                         title: t("elfinder.edit_image_button"),
+                         data: {
+                           "elfinder-mode": 'single_selection',
+                           "elfinder-target": "##{component_id}",
+                           "elfinder-thumb-target": "##{component_id_image}",
+                           "elfinder-volumes": 'AlchemyImages'
+                         }) do
+            fa_icon("file-image")
+          end
+
+          bf2 << link_to("#", class: 'clear_selection',
+                         title: t("elfinder.clear_image_button"),
+                         data: {
+                           "clearfield-target": "##{component_id}",
+                           "clearfield-thumb-target": "##{component_id_image}",
+                           "clearfield-thumb-target-replace": no_image_path
+                         }) do
+            fa_icon("times")
+          end
+
+          bf2
+        end
+
+        bf
+
+      end
+    end
+
+
+  end
+
+  ##
+  # rimpiazzo helper per icone
+  def fa_icon(icon, title: nil)
+    content_tag(:i, nil, class: "fas fa-#{icon} fa-lg fa-fw", title: title)
+  end
+
+
+  def mime2class(mimeType)
+    prefix = 'elfinder-cwd-icon-'
+    mime = mimeType.downcase
+    #     isText = this.textMimes[mime]
+    #
+    mime = mime.split('/')
+    # if (isText) {
+    #   mime[0] += ' ' + prefix + 'text';
+    # }
+
+    prefix + mime[0] + (mime[1] ? ' ' + prefix + mime[1].gsub(/(\.|\+)/, '-') : '')
+  end
+
+
+  def single_attachment_input(form, field)
+    form.input(field) do
+      content_tag(:div, class: "elfinder_attachment") do
+        bf = ActiveSupport::SafeBuffer.new
+
+        component_id = SecureRandom.hex(10)
+
+        ref_id = nil
+        mime_class = ''
+
+        unless form.object.send(field).blank?
+          ref_id = form.object.send(field).to_signed_global_id.to_s
+          mime_class = "elfinder-cwd-icon #{mime2class(form.object.send(field).file_mime_type)}"
+        end
+
+        bf << form.hidden_field(field, id: component_id, value: ref_id)
+
+        id_icone = "#{component_id}_mime_icon"
+
+        bf << content_tag(:div, class: 'container_icon_container') do
+          content_tag(:div, nil, id: id_icone,
+                      class: mime_class)
+        end
+
+        bf << content_tag(:div, class: "edit_file_bottom") do
+
+          bf2 = ActiveSupport::SafeBuffer.new
+
+          bf2 << link_to("#", class: 'open_el_finder',
+                         title: t("elfinder.edit_attachment_button"),
+                         data: {
+                           "elfinder-mode": 'single_selection',
+                           "elfinder-target": "##{component_id}",
+                           "elfinder-mime_icon_updater": "##{id_icone}",
+                           "elfinder-volumes": 'AlchemyFiles'
+                         }) do
+            fa_icon("file")
+          end
+
+          bf2 << link_to("#", class: 'clear_selection',
+                         title: t("elfinder.clear_attachment_button"),
+                         data: {
+                           "clearfield-target": "##{component_id}",
+                           "clearfield-icon": "##{id_icone}"
+                         }) do
+            fa_icon("times")
+          end
+
+          bf2
+        end
+
+        bf
+
+      end
+    end
+  end
+
+
+  def base_container
+    content_tag :div, class: "base_container #{controller_name}" do
+      yield
+    end
+  end
+
+  def render_obj(obj, field)
+    obj.send field
+  end
+
+
+
+  ##
+  # Costruisce il necessario per la generazione della struttura della gallery e per selezione ed upload immagini
+  #
+  # @param [FormBuilder] form
+  # @param [Symbol] field
+  # @param [String] partial_url         url da richiamare ogni volta che avviene una modifica nell'elenco dei files
+  #                                     della gallery
+  # @param [String] partial_identifier  selettore css da utilizzare per fare il replace e la ricerca del contenuto
+  #                                     trovato con url
+  # @param [Array] tags                 Array di stringhe identificanti i tags da aggiungere ad ogni immagine caricata
+  #                                     direttamente nel volume legato a questo componente
+  #
+  def gallery_input(form, field, partial_url:, partial_identifier:, tags: [])
+
+    return '' unless form.object.persisted?
+
+
+    obj_cls = form.object.class
+    hint_helper = ''
+    chiave_i18n = "#{obj_cls.i18n_scope}.attributes.#{obj_cls.model_name.i18n_key}.#{field}_hint"
+    hint_helper = hint_with_tooltip(t(chiave_i18n), icon: 'question-circle') if I18n.exists?(chiave_i18n)
+
+    form.input(field, label: obj_cls.human_attribute_name(field).html_safe + hint_helper) do
+      content_tag(:div, class: 'elfinder_picture_gallery') do
+        bf2 = ActiveSupport::SafeBuffer.new
+
+        container_images = SecureRandom.hex
+
+        bf2 << content_tag(:div, class: 'blk_container_immagini', id: container_images) do
+          bf = ActiveSupport::SafeBuffer.new
+
+          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
+
+              join_record_form.hidden_field :position, class: 'gallery_position_counter'
+
+            end
+          end
+
+          bf << content_tag(:div, class: 'gallery_item_blk') do
+            link_to("#", class: 'open_el_finder', data: {
+              "elfinder-mode": 'multiple_selection',
+              "elfinder-target_upgrader": partial_url,
+              "elfinder-target": partial_identifier,
+              "elfinder-volumes": 'AlchemyImages,GalleryVolume',
+              "elfinder-volumes_cfgs": Base64.strict_encode64({
+                                                                "GalleryVolume": {
+                                                                  volume: 'ComponentAttribute',
+                                                                  attribute: field,
+                                                                  object: form.object.to_signed_global_id.to_s,
+                                                                  file_link_ref: 'picture',
+                                                                  tags: tags
+                                                                }
+                                                              }.to_json)
+            }) do
+              fa_icon("images")
+            end
+          end
+
+
+          bf
+
+        end
+
+        bf2 << content_tag(:script, :type => "text/javascript") do
+          raw "(function(){
+            $('##{container_images}').nested_attributes_sortable({field:'.gallery_position_counter'});
+          })();
+           "
+        end
+
+        bf2
+      end
+    end
+
+
+  end
+
+
+  # @param [Symbol] label per la form
+  # @param [FormBuilder] form
+  # @param [Symbol] field identifica la relazione
+  # @param [Object] to_load TODO documentare
+  # @param [Object] url_partial url da dove caricare il partial da dove arriva un nuovo blocco html contenente questo subelemento
+  # @param [Object] active_record_modifier Proc chiamata durante l'esecuzione della query per la selezione degli elementi,
+  #                                        sovrascrivere e ritornare un ActiveRecord::Relation
+  def subobject(label, form, field, to_load:, url_partial:, active_record_modifier: ->(relation) {relation})
+
+    ui_identify = "subobjects_container_#{SecureRandom.hex}"
+
+    interface = ActiveSupport::SafeBuffer.new
+    interface = content_tag(:fieldset, class: "subobjects #{ui_identify}") do
+      sb = ActiveSupport::SafeBuffer.new
+
+      sb << content_tag(:legend, label)
+      sb << content_tag(:div, class: "sub_objects_container sub_object_#{field}") do
+        sub_obj = ActiveSupport::SafeBuffer.new
+
+        active_record_modifier.call(form.object.send(field)).each_with_index do |subo, index|
+
+          sub_obj << form.simple_fields_for(field, subo, child_index: subo.new_record? ? Time.now.getutc.strftime("%9N") : index) do |subform|
+
+            form_attrs = subform.object.attributes.reject do |attr, val|
+              attr == form.object.class.reflect_on_association(field).foreign_key
+            end
+            is_sample = form_attrs.all? {|attr, val| val.blank?}
+
+            content_tag(:div, id: "#{subform.object.class.name.demodulize.underscore}_#{subform.object.id}", class: "subobject_row row_#{field.to_s.singularize} #{"sample" if is_sample}") do
+
+              form_html = ActiveSupport::SafeBuffer.new
+
+
+              form_html << content_tag(:div, class: "buttons toolbar_button") do
+                button_bar = ActiveSupport::SafeBuffer.new
+                button_bar << content_tag(:div, class: "button_with_label maximize") do
+                  link_to "#", class: "icon_button" do
+                    fa_icon "window-maximize"
+                  end
+                end
+
+                button_bar << content_tag(:div, class: "button_with_label minimize") do
+                  link_to "#", class: "icon_button" do
+                    fa_icon "window-minimize"
+                  end
+                end
+
+                button_bar << content_tag(:div, class: "button_with_label remove") do
+                  content_tag(:span, class: "icon_button") do
+                    icon_button = ActiveSupport::SafeBuffer.new
+                    icon_button << fa_icon("trash", title: t(:remove))
+                    icon_button << subform.input(:_destroy, as: :hidden, input_html: {class: "destroy"})
+                    icon_button
+                  end
+
+                end
+
+
+                button_bar
+              end
+              form_html << content_tag(:div, class: "fields") do
+                yield subform
+              end
+
+
+              form_html
+            end
+          end
+
+
+        end
+
+        #sub_obj << content_for(:"sample_#{field}")
+        sub_obj
+      end
+      sb << content_tag(:div, class: "buttons") do
+        buttons = ActiveSupport::SafeBuffer.new
+        buttons << button_tag(type: "button", class: "minimize_all", title: acm_t(:minimize_all, scope: 'sub_objects')) do
+          fa_icon("window-minimize")
+        end
+        buttons << button_tag(type: "button", class: "maximize_all", title: acm_t(:maxzimize_all, scope: 'sub_objects')) do
+          fa_icon("window-maximize")
+        end
+        buttons << button_tag(type: "button", class: "add", title: acm_t(:title_add, scope: 'sub_objects'), data: {to_load: to_load, url: url_partial}) do
+          fa_icon("plus")
+        end
+        buttons
+      end
+      sb
+    end
+
+
+    interface << content_tag(:script, :type => "text/javascript") do
+      raw "(function(){
+            $('.#{ui_identify}').subobjects();
+          })();
+           "
+    end
+
+    interface
+
+  end
+
+
+  def check_presence_polymorphic_path(record_or_hash_or_array, options = {})
+    begin
+      polymorphic_path record_or_hash_or_array, options
+      true
+    rescue NoMethodError
+      false
+    end
+  end
+
+
+end