kono_utils 0.15.5

data/lib/kono_utils/base_editing_helper.rb

@@ -0,0 +1,194 @@
+module KonoUtils
+  module BaseEditingHelper
+
+    def BaseEditingHelper.included(mod)
+      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
+
+    ##
+    # Serie di metodi che identificano i titoli generati automaticamente
+    # Viene utilizzato i18n per identificare se un determinato modello è di tipo F o M
+    # é presente quindi una chiave in YML che identifica ogni modello(default M)
+    def title_mod_g(model)
+      "#{t("edit_title_#{model_gender(model)}", default: 'Modifica')} #{model.mn}"
+    end
+
+    def title_new_g(model)
+      "#{t("new_title_#{model_gender(model)}", default: 'Nuovo')} #{model.mn}"
+    end
+
+    def title_del_g(model)
+      "#{t("del_title_#{model_gender(model)}", default: 'Cancella')} #{model.mn}"
+    end
+
+    def model_gender(model)
+      t("activerecord.modelgender.#{model.name.underscore.to_sym}", :default => :m).to_sym
+    end
+
+    def new_button(path, base_class=nil)
+      options = {class: 'btn btn-success btn-xs'}
+      options[:title] = title_new(base_class) unless base_class.nil?
+
+      link_to fa_icon("plus fw"), path, options
+    end
+
+    def edit_button(path)
+      link_to fa_icon("pencil fw"), path, class: 'btn btn-primary btn-xs'
+    end
+
+    def delete_button(path)
+      link_to fa_icon("trash fw"), path, method: :delete, data: {confirm: t(:are_you_sure)}, class: 'btn btn-danger btn-xs'
+    end
+
+    def form_submit(f)
+      f.actions do
+        f.action :submit, :button_html => {:class => "btn btn-primary", :disable_with => t('wait', default: 'Wait...')}
+      end
+    end
+
+    ##
+    # Questa funzione serve per essere sovrascritta nell'helper specializzato del controller
+    def index_print_column(record, field)
+      record.send(field)
+    end
+
+    ##
+    # Questa funzione serve per stampare il contenuto dell'header
+    def index_print_column_head(field)
+      block_given? ? yield(field) : base_class.han(field)
+    end
+
+    ##
+    # Questa funzione serve per generare la colonna della tabella
+    #
+    # * *Attributes*  :
+    #   - colonna
+    #   - tipo di colonna td|th
+    #   - opzionali     : hash{record} per fare altro
+    def index_column_builder(field, column, record: nil)
+      column_class = "column_#{field}"
+      column_id=''
+      if record
+        column_id = "#{column_class}-#{dom_id(record)}"
+      end
+      content_tag column, class: column_class, id: column_id do
+        yield column_class, column_id
+      end
+    end
+
+    def list_button(path)
+      link_to fa_icon("list fw"), path, class: 'btn btn-default btn-xs'
+    end
+
+    ##
+    # Questa funzione serve per essere sovrascritta nell'helper specializzato del controller
+    # e quindi stampare un determinato campo in modo differente
+    # si occupa anche di gestire i campi provenienti dalla policy nel caso siano a più livelli con i nested
+    # prendiamo in considerazione la situazione con has_many :campo=>[] o con :campo=>[:ciao,:pippo,:pluto]
+    def editing_form_print_field(form, field)
+      if field.is_a?(Hash)
+        #devo nestarlo
+        bf = ActiveSupport::SafeBuffer.new
+
+        field.each do |k, v|
+          if v.length==0
+            #caso in cui è un elemento normale, ma che ha una selezione multipla
+            bf<< editing_form_print_field(form, k)
+          else
+            #caso in cui potremmo essere in un campo di multipli elementi con vari valori ognuno
+            bf<< nest_editing_form_print_field(form, k, v)
+          end
+        end
+        bf
+      else
+        form.input field
+      end
+    end
+
+    ##
+    # Questa funzione può essere sovrascritta per gestire in modo personale la renderizzazine dei nested attributes
+    # * *Attributes*  :
+    #   - form              -> form di formtastic
+    #   - contenitore       -> campo principale
+    #   - campi             -> i campi interni
+    def nest_editing_form_print_field(form, contenitore, campi)
+      form.semantic_fields_for contenitore do |item|
+        item.inputs :name => t(".#{form.object.mn}.#{contenitore}", :default => contenitore.to_s.camelcase) do
+          bf = ActiveSupport::SafeBuffer.new
+          campi.each do |c|
+            bf<<editing_form_print_field(item, c)
+          end
+          bf
+        end
+      end
+    end
+
+    ##
+    # Per divisione in celle della form
+    #
+    def cell_column_class(field)
+      "col-md-12"
+    end
+
+
+    ##
+    # Funzione che visualizza il caricamento e l'immagine caricata precedente se presente
+    #
+    # * *Args*    :
+    #   - form
+    #   - attribute
+    # * *Returns* :
+    #   - ActiveSupport:SafeBuffer
+    #
+    def image_show_upload(form, attribute)
+
+      buff = ActiveSupport::SafeBuffer.new
+
+      buff<<form.label(attribute)
+
+      buff<<content_tag(:div, class: 'row') do
+        tmp = ActiveSupport::SafeBuffer.new
+
+
+        tmp << content_tag(:div, class: "col-md-5") do
+          form.input attribute, :label => false
+        end
+
+        if form.object.send(attribute).exists?
+          tmp << content_tag(:div, class: "col-md-2 col-lg-5") do
+            link_to image_tag(form.object.send(attribute).url(:original), class: 'img-thumbnail logo-original'), form.object.send(attribute).url
+          end
+        end
+
+        tmp
+      end
+
+
+    end
+
+
+    def semantic_form_attributes(obj)
+      obj
+    end
+
+
+    ##
+    # Helper per visualizzare l'alert del destroy
+    def destroy_link_to(path, options)
+      link_to t('.destroy'), path,
+              :method => :delete,
+              :class => "btn",
+              :confirm => t('.destroy_confirm.body', :item => options[:item]),
+              "data-confirm-fade" => true,
+              "data-confirm-title" => t('.destroy_confirm.title', :item => options[:item]),
+              "data-confirm-cancel" => t('.destroy_confirm.cancel', :item => options[:item]),
+              "data-confirm-cancel-class" => "btn-cancel",
+              "data-confirm-proceed" => t('.destroy_confirm.proceed', :item => options[:item]),
+              "data-confirm-proceed-class" => "btn-danger"
+    end
+
+  end
+end

data/lib/kono_utils/base_search.rb

@@ -0,0 +1,173 @@
+require 'kono_utils/search_attribute'
+module KonoUtils
+  ##
+  # Classe base per i form di ricerca nel sistema
+  class BaseSearch < VirtualModel
+
+    class UndefinedSearchModel < StandardError
+      def initialize(msg = 'Definire nella classe, attraverso set_search_model, il modello da utilizzare come base per la ricerca')
+        super(msg)
+      end
+    end
+
+    class_attribute :_search_model, :_search_attributes, instance_writer: false
+    attr_accessor :scope
+
+    define_model_callbacks :set_scope, :make_query
+
+    ##
+    # Definisce per la classe quale modello utilizzare per la ricerca
+    #
+    def self.set_search_model(model)
+      self._search_model = model
+    end
+
+    ##
+    # Definisce gli attributi da utilizzare per la ricerca
+    # passandogli un hash finale si possono passare parametri di default
+    # per ognuno dei campi settati a formtastic per renderizzare il campo
+    # ES:
+    #   set_search_attributes :nome,:cognome,:as=>:string
+    #   renderizzerà nome e cognome come stringhe
+    #
+    #   set_search_attributes :datadinascita, :as=>:datetimepicker
+    #   renderizzerà un campo predisposto per attivare il datetimepicker
+    #
+    #   Possiamo anche passare una Proc come ultimo elemento per la generazione degli attributi per la form,
+    #   come argomento è presente il current_user
+    #   set_search_attributes :datadinascita, Proc.new { |current_user,form| funzione da lanciare per eseguire la generazione
+    #                                             degli attibuti da passare alla form per generare il campo }
+    #
+    #   come hash di opzioni possiamo anche passargli una chiave :field_options
+    #   con dentro configurazioni vedi TikalCore::SearchAttribute
+    #
+    # CALLBACKS
+    # Quando vengono creati gli attributi, vengono anche creati gli eventi per ogni attributi, sia per la
+    # chiamata del getter (nome_metodo) sia per setter (nome_metodo=), ogni callback ha un prefisso
+    # per avere quindi un namespace specifico per questa funzionalità:
+    # ES:
+    #   set_search_attributes :datadinascita....
+    #
+    #  genererà:
+    #         - before_search_attr_datadinascita
+    #         - before_search_attr_datadinascita_set  => relativo al setter
+    #         - around_search_attr_datadinascita
+    #         - around_search_attr_datadinascita_set  => relativo al setter
+    #         - after_search_attr_datadinascita
+    #         - after_search_attr_datadinascita_set   => relativo al setter
+    #
+    def self.set_search_attributes(*attributes)
+      options = attributes.extract_options!
+      options = {:as => :string}.merge(options)
+
+      if attributes.last.is_a?(Proc)
+        options = attributes.pop
+      end
+
+      self._search_attributes = self._search_attributes || []
+      attributes.each do |a|
+
+        attr_accessor(a.to_sym)
+
+        # instance_variable_set "@#{a}".to_sym, nil
+        #
+        # unless method_defined? a.to_sym
+        define_method(a.to_sym) do
+          run_callbacks "search_attr_#{a}" do
+            # logger.debug { "Chiamata a metodo virtuale #{a} " }
+            instance_variable_get "@#{a}".to_sym
+          end
+        end
+        # end
+        #
+        # unless method_defined? "#{a}=".to_sym
+        define_method("#{a}=".to_sym) do |*args|
+          run_callbacks "search_attr_#{a}_set" do
+            # logger.debug { "Chiamata a metodo virtuale #{a}= -> #{args.inspect}" }
+            instance_variable_set "@#{a}".to_sym, *args
+          end
+        end
+        # end
+
+
+        #Definisco delle callbacks per ogni attributo
+        define_model_callbacks "search_attr_#{a}".to_sym, "search_attr_#{a}_set".to_sym
+        self._search_attributes += [KonoUtils::SearchAttribute.new(a, options)]
+      end
+      self._search_attributes.uniq!
+    end
+
+    ##
+    # Restituisce il modello di ricerca
+    def search_model
+      self.class._search_model
+    end
+
+    ##
+    # Attributi di ricerca
+    def search_attributes
+      self.class._search_attributes
+    end
+
+    def initialize
+      raise UndefinedSearchModel if search_model.nil?
+      super
+      self.scope = self.class._search_model
+    end
+
+
+    ##
+    #  deve indicarmi se i dati della ricerca sono stati inseriti
+    def data_loaded?
+      get_query_params.length>0
+    end
+
+    ##
+    # Setta lo scope iniziale del modello
+    def set_scope(scope)
+      run_callbacks :set_scope do
+        self.scope = scope
+      end
+    end
+
+
+    ##
+    # Genera la query di ricerca, passando i parametri da
+    # ricercare nello scoper di ricerca del modelo
+    def make_query
+      run_callbacks :make_query do
+        self.scope.search(get_query_params)
+      end
+    end
+
+
+    ##
+    # Restituisce un hash con tutti i parametri da implementare sulla ricerca
+    #
+    def get_query_params
+      out = {}
+      search_attributes.each do |val|
+        out[val.field]=self.send(val.field) unless self.send(val.field).blank?
+      end
+
+      out
+    end
+
+    ##
+    # Si occupa di aggiornare i valori interni di ricerca
+    def update_attributes(datas)
+      search_attributes.each do |val|
+        self.send("#{val.field}=", val.cast_value(datas[val.field]))
+      end
+    end
+
+    def method_missing(m, *args, &block)
+      if self.search_attributes.collect(&:field).include?(m.to_s.gsub(/=$/, ''))
+        self.send(m, *args)
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/kono_utils/concerns.rb

@@ -0,0 +1,10 @@
+module KonoUtils::Concerns
+
+  extend ActiveSupport::Autoload
+
+  autoload :BaseModals
+  autoload :SuccessMessage
+  autoload :BaseEditing
+
+end
+

data/lib/kono_utils/concerns/active_record_translation.rb

@@ -0,0 +1,47 @@
+require 'active_support/concern'
+module KonoUtils::Concerns
+  module ActiveRecordTranslation
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      def han(attr)
+        self.class.han(attr)
+      end
+
+      def mnp
+        self.class.mnp
+      end
+
+      def mn
+        self.class.mn
+      end
+
+    end
+
+    class_methods do
+
+      ##
+      # E' un'alias per il TikalCore::Registration.human_attribute_name(:isee)
+      def han(attr)
+        self.human_attribute_name(attr)
+      end
+
+      ##
+      # E' un alias di model_name.human(count:2)
+      def mnp
+        self.model_name.human(count: 2)
+      end
+
+      ##
+      # E' un alias di model_name.human
+      def mn
+        self.model_name.human
+      end
+
+
+    end
+
+  end
+end

data/lib/kono_utils/concerns/base_editing.rb

@@ -0,0 +1,195 @@
+require 'active_support/concern'
+
+module KonoUtils
+  module Concerns
+    module BaseEditing
+      extend ActiveSupport::Concern
+
+      included do
+
+        before_action :append_view_paths
+
+        before_action :load_object, except: [:index, :new, :create]
+        helper_method :base_class
+        helper_method :form_attributes
+        helper_method :table_columns
+        helper_method :new_custom_polymorphic_path
+        helper_method :edit_custom_polymorphic_path
+        helper_method :index_custom_polymorphic_path
+        after_action :check_errors, only: [:create, :update]
+
+        ##
+        # E' possibile passare una callback per poter
+        # renderizzare ulteriori formati oppure cambiare la normale
+        # renderizzazione. La callback riceve il format della respond_to
+        # GET /utenti
+        # GET /utenti.xml
+        def index(respond_to_call: nil)
+          @objects = policy_scope(base_scope).all
+          @objects = yield(@objects) if block_given?
+          @objects = @objects.paginate(:page => params[:page])
+
+          respond_to do |format|
+            format.html # index.html.erb
+            format.xml { render :xml => @objects }
+            unless respond_to_call.nil?
+              respond_to_call.call(format)
+            end
+          end
+        end
+
+        # GET /utenti/new
+        # GET /utenti/new.xml
+        def new
+          @object = base_class.new
+          authorize @object
+          @object = yield(@object) if block_given?
+          logger.debug { "Nuovo oggetto #{@object.inspect}" }
+
+          respond_to do |format|
+            format.html
+            format.xml { render :xml => @object }
+          end
+        end
+
+        # GET /utenti/1/edit
+        def edit
+          @object = yield(@object) if block_given?
+        end
+
+        # PUT /utenti/1
+        # PUT /utenti/1.xml
+        def update
+          @object = yield(@object) if block_given?
+          respond_to do |format|
+            if @object.update_attributes(clean_params)
+              format.html { redirect_to edit_custom_polymorphic_path(@object), :notice => success_update_message(@object) }
+              format.xml { head :ok }
+            else
+              format.html { render :action => :edit }
+              format.xml { render :xml => @object.errors, :status => :unprocessable_entity }
+            end
+          end
+        end
+
+        # POST /utenti
+        # POST /utenti.xml
+        def create
+          @object = base_class.new(clean_params)
+          authorize @object
+          @object = yield(@object) if block_given?
+          logger.debug { "Nuovo oggetto #{@object.inspect}" }
+
+          respond_to do |format|
+            if @object.save
+              format.html { redirect_to edit_custom_polymorphic_path(@object), :notice => success_create_message(@object) }
+              format.xml { render :xml => @object, :status => :created, :location => @object }
+            else
+              format.html { render :action => :new }
+              format.xml { render :xml => @object.errors, :status => :unprocessable_entity }
+            end
+          end
+        end
+
+        # DELETE /utenti/1
+        # DELETE /utenti/1.xml
+        def destroy
+          @object = yield(@object) if block_given?
+
+
+          respond_to do |format|
+            if @object.destroy
+              format.html { redirect_to index_custom_polymorphic_path(base_class),
+                                        :notice => success_destroy_message(@object) }
+              format.xml { head :ok }
+            else
+              format.html { redirect_to index_custom_polymorphic_path(base_class),
+                                        :flash => {:error => @object.errors.full_messages.join(',')} }
+              format.xml { head :ko }
+            end
+          end
+        end
+
+        ##
+        # Elenco degli attributi da visualizzare nella form
+        def form_attributes(model = base_class.new)
+          policy(model).permitted_attributes
+        end
+
+        ##
+        # Elenco ordinato dei campi da utilizzare nella visualizzazione della tabella index
+        def table_columns
+          policy(base_class.new).permitted_attributes
+        end
+
+        private
+        def load_object
+          @object = base_class.find(params[:id])
+          authorize @object
+          logger.debug { "Oggetto #{@object.inspect}" }
+
+        end
+
+        def base_class
+          controller = controller_name
+          modello = controller.singularize.camelize.safe_constantize
+          logger.debug { "Editazione del controller:#{controller} per modello: #{modello.to_s}" }
+
+          raise "Non riesco a restituire la classe base per il controller #{controller}" if modello.nil?
+
+          modello
+        end
+
+        ##
+        # Scope iniziale per index, sovrascrivibile per poter inizializzare ricerca,
+        # viene passato al policy_scope in index
+        def base_scope
+          base_class
+        end
+
+        def clean_params
+          permitted = policy(base_class.new).permitted_attributes
+          dati = params.required(base_class.name.underscore.gsub('/', '_').to_sym).permit(permitted)
+          ::Rails.logger.info { "Permitted Attributes: #{permitted.inspect}" }
+          ::Rails.logger.info { "Parametri puliti: #{dati.inspect}" }
+          dati
+        end
+
+        def check_errors
+          unless @object.valid?
+            logger.debug { "Invalid Obj:" }
+            logger.debug { @object.errors.inspect }
+          end
+        end
+
+        ##
+        # Aggiungo una path alla vista del base editing controller,
+        # nel caso non siamo derivati dal controller ma ho solamente incluso il concern
+        def append_view_paths
+          append_view_path KonoUtils::Engine.root.join("app", "views", "kono_utils")
+          append_view_path KonoUtils::Engine.root.join("app", "views", "kono_utils", "base_editing")
+        end
+
+
+        def new_custom_polymorphic_path(*base_class)
+          new_polymorphic_path(*base_class)
+        end
+
+        def edit_custom_polymorphic_path(*rec)
+          edit_polymorphic_path(*rec)
+        end
+
+        def index_custom_polymorphic_path(*rec)
+          polymorphic_path(*rec)
+        end
+
+
+      end
+
+      # module ClassMethods
+      #
+      #
+      # end
+    end
+  end
+end