kono_utils 0.15.5

data/app/input/bs_readonly_input.rb

@@ -0,0 +1,52 @@
+class BsReadonlyInput < Formtastic::Inputs::StringInput
+  include FormtasticBootstrap::Inputs::Base
+  include FormtasticBootstrap::Inputs::Base::Collections
+  include ActionView::Helpers::TagHelper
+  include ActionView::Context
+  include FontAwesome::Rails::IconHelper
+  include ActionView::Helpers::JavaScriptHelper
+
+
+  ##
+  # Nel caso di collection si può definire con
+  # :show_hidden => [true] per stampare il campo hidden o meno con il vero valore
+  # :display_field come options quale campo usare per stampare
+  # :value_renderer => Proc da aggiungere, a cui passiamo
+  #              campo, valore , se passato nulla viene
+  #             renderizzato standard un p contenente il valore
+  #
+  def to_html
+
+    field_name = method
+    show_value = object.send(method)
+    if show_value.is_a?(ActiveRecord::Base) and !options[:display_field].blank?
+      #vuol dire che siamo in una collection
+      show_value = show_value.send(options[:display_field])
+      field_name = input_name
+    end
+
+    if !options[:value_renderer].is_a?(Proc)
+      options[:value_renderer]=Proc.new { |field, value|
+        buff = ActiveSupport::SafeBuffer.new
+        buff<<content_tag(:p, value, class: 'form-control-static', id: "#{field.form_control_input_html_options[:id]}_container")
+        buff
+      }
+    end
+
+
+    bootstrap_wrapping do
+      content_tag(:div, class: 'input-group date') do
+
+        buff = ActiveSupport::SafeBuffer.new
+
+        buff<< options[:value_renderer].call(self, show_value)
+
+        buff<< builder.hidden_field(field_name, form_control_input_html_options)
+
+        buff
+
+      end
+    end
+  end
+
+end

data/app/input/bs_timepicker_input.rb

@@ -0,0 +1,14 @@
+class BsTimepickerInput < BsDatetimepickerInput
+
+  def icon
+    fa_icon("clock-o".to_sym)
+  end
+
+  def default_javascript_options
+    {
+        server_format: 'YYYY-MM-DD HH:mm:ss UTC',
+        server_match: '/^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2} UTC$/',
+        format: 'HH:mm'
+    }
+  end
+end

data/app/policies/kono_utils/base_editing_policy_concern.rb

@@ -0,0 +1,27 @@
+require 'active_support/concern'
+module KonoUtils
+
+  module BaseEditingPolicyConcern
+    extend ActiveSupport::Concern
+
+    included do
+      def permitted_attributes
+        # [:descrizione]
+        record.class.column_names.collect { |s| s.to_sym } - [:id, :created_at, :updated_at]
+      end
+    end
+
+    if defined? ::Application::Scope
+      class Scope < ::Application::Scope
+        def resolve
+          scope
+        end
+      end
+    end
+
+#  module ClassMethods
+
+#  end
+  end
+end
+

data/app/views/kono_utils/base_editing/_edit.html.erb

@@ -0,0 +1,3 @@
+<%= render 'edit_page_title_header' %>
+<%= render 'edit_page_side_title_header' %>
+<%= render 'form' %>

data/app/views/kono_utils/base_editing/_edit_page_side_title_header.html.erb

@@ -0,0 +1,3 @@
+<% content_for :side_title do %>
+    <%= list_button index_custom_polymorphic_path(base_class) if policy(base_class).index? %>
+<% end %>

data/app/views/kono_utils/base_editing/_edit_page_title_header.html.erb

@@ -0,0 +1,3 @@
+<% content_for :page_title do %>
+    <%= title_mod_g(base_class) %>
+<% end %>

data/app/views/kono_utils/base_editing/_form.html.erb

@@ -0,0 +1,15 @@
+<%= semantic_form_for(*semantic_form_attributes(@object)) do |f| %>
+
+    <div class="row">
+      <% form_attributes(@object).each do |field| %>
+
+          <div class="<%= cell_column_class(field) %>">
+            <%= editing_form_print_field(f, field) %>
+          </div>
+
+      <% end %>
+    </div>
+
+    <%= form_submit f %>
+
+<% end %>

data/app/views/kono_utils/base_editing/_index_buttons.html.erb

@@ -0,0 +1,2 @@
+<%= edit_button edit_custom_polymorphic_path(record) if policy(record).edit? %>
+<%= delete_button index_custom_polymorphic_path(record) if policy(record).destroy? %>

data/app/views/kono_utils/base_editing/_index_page_side_title_header.html.erb

@@ -0,0 +1,3 @@
+<% content_for :side_title do %>
+    <%= new_button new_custom_polymorphic_path(base_class) if policy(base_class.new).create? %>
+<% end %>

data/app/views/kono_utils/base_editing/_index_page_title_header.html.erb

@@ -0,0 +1,3 @@
+<% content_for :page_title do %>
+    <%= base_class.mnp %>
+<% end %>

data/app/views/kono_utils/base_editing/_new.html.erb

@@ -0,0 +1,3 @@
+<%= render 'new_page_title_header' %>
+<%= render 'new_page_side_title_header' %>
+<%= render 'form' %>

data/app/views/kono_utils/base_editing/_new_page_side_title_header.html.erb

@@ -0,0 +1,3 @@
+<% content_for :side_title do %>
+    <%= list_button index_custom_polymorphic_path(base_class) %>
+<% end %>

data/app/views/kono_utils/base_editing/_new_page_title_header.html.erb

@@ -0,0 +1,3 @@
+<% content_for :page_title do %>
+    <%= title_new_g(base_class) %>
+<% end %>

data/app/views/kono_utils/base_editing/_search_form.html.erb

@@ -0,0 +1 @@
+<%= search_form @search, {:reset_path => polymorphic_path(base_class)} %>

data/app/views/kono_utils/base_editing/application/_edit_page_side_title_header.html.erb

@@ -0,0 +1 @@
+<%= render 'base_editing/edit_page_side_title_header' %>

data/app/views/kono_utils/base_editing/application/_edit_page_title_header.html.erb

@@ -0,0 +1 @@
+<%= render 'base_editing/edit_page_title_header' %>

data/app/views/kono_utils/base_editing/application/_index_page_side_title_header.html.erb

@@ -0,0 +1 @@
+<%= render 'base_editing/index_page_side_title_header' %>

data/app/views/kono_utils/base_editing/application/_index_page_title_header.html.erb

@@ -0,0 +1 @@
+<%= render 'base_editing/index_page_title_header' %>

data/app/views/kono_utils/base_editing/application/_new_page_side_title_header.html.erb

@@ -0,0 +1 @@
+<%= render 'base_editing/new_page_title_header' %>

data/app/views/kono_utils/base_editing/application/_new_page_title_header.html.erb

@@ -0,0 +1 @@
+<%= render 'base_editing/new_page_title_header' %>

data/app/views/kono_utils/base_editing/application/edit.html.erb

@@ -0,0 +1 @@
+<%= render 'base_editing/edit' %>

data/app/views/kono_utils/base_editing/application/new.html.erb

@@ -0,0 +1 @@
+<%= render 'base_editing/new' %>

data/app/views/kono_utils/base_editing/edit.html.erb

@@ -0,0 +1 @@
+<%= render 'base_editing/edit' %>

data/app/views/kono_utils/base_editing/index.html.erb

@@ -0,0 +1,36 @@
+<%= render 'index_page_title_header' %>
+<%= render 'index_page_side_title_header' %>
+
+<%= render 'search_form' unless @search.nil? %>
+
+<table class="table table-bordered table-hover">
+  <thead>
+  <tr>
+    <% table_columns.each do |t| %>
+        <%= index_column_builder(t, :th) do %>
+            <%= index_print_column_head(t) %>
+        <% end %>
+    <% end %>
+    <th class="index-col-btn"></th>
+  </tr>
+  </thead>
+
+  <tbody>
+  <% @objects.each do |r| %>
+      <tr>
+        <% table_columns.each do |t| %>
+            <%= index_column_builder(t, :td, record: r) do %>
+                <%= index_print_column(r, t) %>
+            <% end %>
+        <% end %>
+        <th class="index-col-btn">
+          <%= render 'index_buttons', record: r %>
+        </th>
+      </tr>
+  <% end %>
+  </tbody>
+  <%= render 'index_tfoot' %>
+</table>
+
+<%= will_paginate_bst(@objects) %>
+

data/app/views/kono_utils/base_editing/new.html.erb

@@ -0,0 +1 @@
+<%= render 'base_editing/new' %>

data/app/views/kono_utils/change_log/index.html.erb

@@ -0,0 +1,3 @@
+<% content_for :title, t('.title', :default => 'Changelog') %>
+
+<%=raw RDiscount.new(File.open(Rails.root.join('CHANGELOG.md')).read).to_html %>

data/config/initializers/mysql.rb

@@ -0,0 +1,12 @@
+# Creates DATETIME(6) column types by default which support microseconds.
+#
+# Without it, only regular (second precise) DATETIME columns are created.
+module ActiveRecord::ConnectionAdapters
+  if ActiveRecord::Base.connection.instance_of? Mysql2Adapter
+    version = Gem::Version.new(Mysql2::Client.info.fetch(:version))
+    min_vresion = Gem::Version.new('5.6.4')
+    if version>=min_vresion
+      AbstractMysqlAdapter::NATIVE_DATABASE_TYPES[:datetime][:limit] = 6
+    end
+  end
+end

data/config/initializers/time.rb

@@ -0,0 +1,12 @@
+# NOTE: Apparently, this initializer is not necessary with Rails 4.2.5 and up.
+# It just works with the correct database type DATETIME(6).
+
+# Where 6N is the number of places after the decimal (.)
+# For less precision (eg. miliseconds), change 6N to 3N
+if ActiveRecord::Base.connection.instance_of? ActiveRecord::ConnectionAdapters::Mysql2Adapter
+  version = Gem::Version.new(Mysql2::Client.info.fetch(:version))
+  min_vresion = Gem::Version.new('5.6.4')
+  if version>=min_vresion
+    Time::DATE_FORMATS[:db] = '%Y-%m-%d %H:%M:%S.%6N'
+  end
+end

data/config/locales/it.yml

@@ -0,0 +1,18 @@
+it:
+  back: Indietro
+  new: Nuovo
+  newa: Nuova
+  edit: Modifica
+  del: Cancella
+  wait: "Wait..."
+  are_you_sure: "Confermi la cancellazione?"
+  formtastic:
+    inputs:
+      bs_file_download:
+        download: Download
+  activerecord:
+    successful:
+      messages:
+        created: "%{model} creato correttamente."
+        updated: "%{model} aggiornato correttamente."
+        destroyed: "%{model} è stato correttamente cancellato."

data/lib/generators/kono_utils/install/install_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators'
+module KonoUtils
+  class InstallGenerator < Rails::Generators::Base
+    desc "Installa l'inizializzatore"
+
+    # Commandline options can be defined here using Thor-like options:
+    # class_option :my_opt, :type => :boolean, :default => false, :desc => "My Option"
+
+    # I can later access that option using:
+    # options[:my_opt]
+
+
+    def self.source_root
+      @source_root ||= File.expand_path('../../../templates', __FILE__)
+    end
+
+    # Generator Code. Remember this is just suped-up Thor so methods are executed in order
+    def copy_files
+      copy_file 'initializer.rb', 'config/initializers/kono_utils.rb'
+    end
+
+
+  end
+end

data/lib/generators/templates/initializer.rb

@@ -0,0 +1,3 @@
+KonoUtils.configure do |config|
+  #config.google_api_key = '' #chiave API
+end

data/lib/kono_utils.rb

@@ -0,0 +1,41 @@
+require 'kono_utils/engine' if defined?(::Rails)
+
+module KonoUtils
+  extend ActiveSupport::Autoload
+
+  autoload :VirtualModel
+  autoload :Encoder
+  autoload :ParamsHashArray
+  autoload :Percentage
+  autoload :FiscalCode
+  autoload :TmpFile
+  autoload :ApplicationHelper
+  autoload :BaseEditingHelper
+  autoload :BaseSearch
+  autoload :Concerns
+
+  class Configuration
+    attr_accessor :google_api_key
+  end
+
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+
+end
+
+
+if defined?(::Rails)
+  if Rails.gem_version > Gem::Version.new('4.2.0')
+    require 'kono_utils/concerns/active_record_translation'
+  end
+end

data/lib/kono_utils/application_helper.rb

@@ -0,0 +1,625 @@
+module KonoUtils
+  module ApplicationHelper
+
+
+    def will_paginate_bst(collection)
+      will_paginate collection, renderer: BootstrapPagination::Rails
+    end
+
+
+    def namespace_content(&block)
+      content_tag :div, class: "#{(controller.class.name.split("::") + [action_name]).join(" ")}" do
+        yield
+      end
+
+    end
+
+    def true_false_label(val)
+
+      if val
+        icon =fa_icon(:check)
+        classe='success'
+      else
+        classe='danger'
+        icon =fa_icon(:times)
+      end
+
+      content_tag(:span, icon, class: "label label-#{classe}")
+
+    end
+
+
+    ##
+    # Genera una modal da riutilizzare per far aspettare determinate operazioni al client
+    def bootstrap_please_wait
+      content_tag(:div,
+                  class: 'modal fade',
+                  id: 'processing_wait',
+                  tabindex: "-1",
+                  role: "dialog",
+                  "aria-hidden".to_sym => "true") do
+        content_tag :div, class: 'modal-dialog modal-sm' do
+          content_tag :div, class: 'modal-content' do
+
+            buff = ActiveSupport::SafeBuffer.new
+
+            buff << content_tag(:div, class: 'modal-header') do
+              content_tag(:h4, "Processing...", class: "modal-title")
+            end
+
+            buff << content_tag(:div, class: 'modal-body') do
+              content_tag :div, class: "progress" do
+                content_tag :div, ' ', class: "progress-bar progress-bar-striped active", role: "progressbar", style: "width: 100%"
+              end
+            end
+
+            buff
+          end
+        end
+      end
+    end
+
+
+    ##
+    # Genera la form di ricerca
+    # * *Args*    :
+    #   - search_model  -> KonoUtils::BaseSearch
+    #   - args          -> Hash with configurations:
+    #                       - attributes      -> array of symbols for the search, if empty used from search_model
+    #                       - reset_path      -> path per cui resettare la ricerca, nil
+    #                       - form_opts       -> opzioni da aggiungere per la form
+    #                       - buttons_editor  -> Proc chiamata, con il passaggio dell'oggetto della form e
+    #                                            del ActiveSupport::SafeBuffer con all'interno dei bottoni
+    #                                            come parametro, deve ritornare
+    #                                             un ActiveSupport::SafeBuffer a sua volta
+    # * *Returns* :
+    #   -
+    #
+    def search_form(search_model, args={})
+
+      args = {
+          :attributes => [],
+          :reset_path => nil,
+          :form_opts => {},
+          :field_option => {:wrapper_html => {:class => "col-xs-12 col-sm-6 col-md-4 col-lg-3"}},
+          :buttons_editor => Proc.new { |form_obj, sb| sb }
+      }.merge(args)
+
+      reset_path = args[:reset_path]
+
+      field_option = args[:field_option]
+
+      base_search_form_wrapper(search_model, {:attributes => args[:attributes], :form_opts => args[:form_opts]}) do |f|
+        content_tag :div, class: "panel panel-default search_panel" do
+
+          buffer = ActiveSupport::SafeBuffer.new
+
+          buffer<< content_tag(:div, class: 'panel-heading') do
+            content_tag :h3, class: "panel-title collapse_search" do
+              header = ActiveSupport::SafeBuffer.new
+
+              header<< content_tag(:span, t(:search))
+
+              header<<content_tag(:div, fa_icon("search") + content_tag(:span, nil, class: 'caret'), class: 'pull-right icon-search')
+
+              header
+            end
+          end
+
+          buffer<< content_tag(:div, class: "collapsible_panel #{(search_model.data_loaded? ? 'uncollapsed' : '')}") do
+            fb_collapse = ActiveSupport::SafeBuffer.new
+
+            fb_collapse << content_tag(:div, class: "panel-body") do
+              f.fields_builder(:field_options => field_option)
+            end
+
+
+            fb_collapse << content_tag(:div, class: 'panel-footer text-right') do
+              form_buffer = ActiveSupport::SafeBuffer.new
+
+              form_buffer<< button_tag(t(:search), type: "submit", class: "btn btn-primary")
+
+              if search_model.data_loaded? and !reset_path.nil?
+                form_buffer<< link_to(content_tag(:span, nil, class: 'glyphicon glyphicon-remove'), reset_path, class: 'btn btn-info')
+              end
+
+              args[:buttons_editor].call(f, form_buffer)
+            end
+
+            fb_collapse
+          end
+
+          buffer
+        end
+      end
+
+
+    end
+
+    class BaseSearchFormWrapper < Struct.new(:formtastic_form, :attributes, :current_user)
+
+      def fields_builder(cfgs={field_options: {}})
+        form_buffer = ActiveSupport::SafeBuffer.new
+
+        self.attributes.each do |field|
+
+          form_options = field.form_options
+          if form_options.is_a?(Proc)
+            form_options = form_options.call(current_user, self.formtastic_form)
+          end
+
+          form_buffer << self.formtastic_form.input(field.field, cfgs[:field_options].merge(form_options))
+        end
+
+        form_buffer
+      end
+    end
+
+    ##
+    # Utility interna che si occupa della logica minima per generare la il form di ricerca
+    def base_search_form_wrapper(search_model, args={:attributes => [], :form_opts => {}})
+      attributes = args[:attributes] || {}
+      form_opts = args[:form_opts] || {}
+      if attributes.length==0
+        attributes = search_model.search_attributes
+      end
+
+      form_opts = {method: :get, :html => {autocomplete: 'off'}}.merge(form_opts)
+
+      semantic_form_for search_model, form_opts do |f|
+        yield BaseSearchFormWrapper.new(f, attributes, @current_user)
+      end
+    end
+
+
+    def title_mod(model)
+      "#{t(:edit)} #{model.mn}"
+    end
+
+    def title_new(model)
+      "#{t(:new)} #{model.mn}"
+    end
+
+    def title_newa(model)
+      "#{t(:newa)} #{model.mn}"
+    end
+
+    def title_del(model)
+      "#{t(:del)} #{model.mn}"
+    end
+
+
+    ##
+    # Genera l'hash da passare come collection alle selectbox, esegue anche la traduzione con locale
+    #
+    #   <%= f.input :usage, :as => :select,
+    #                :collection => enum_collection(Logo, :usage), :input_html => {:include_blank => true} %>
+    #
+    # * *Args*    :
+    #   - model     -> ActiveRecord model contenente l'enum
+    #   - attribute -> Symbol che identifica l'attributo dell'enum
+    #   - variant   -> se c'è la variante questa viene inserite _#{variant} dopo il nome del valore
+    # * *Returns* :
+    #   - Hash
+    #
+    def enum_collection(model, attribute, variant=nil)
+
+      model.send(attribute.to_s.pluralize(2).to_sym).collect { |key, val|
+        [enum_translation(model, attribute, key, variant), key]
+      }.to_h
+    end
+
+
+    ##
+    # Si occupa di tradurre un determinato valore di un enum
+    #   - model     -> ActiveRecord model contenente l'enum
+    #   - attribute -> Symbol che identifica l'attributo dell'enum
+    #   - variant   -> se c'è la variante questa viene inserite _#{variant} dopo il nome del valore
+    #
+    # * *Returns* :
+    #   - String
+    #
+    def enum_translation(model, attribute, value, variant=nil)
+      ApplicationHelper.enum_translation(model, attribute, value, variant)
+    end
+
+
+    ##
+    # Le traduzioni dentro al locale devono essere fatte in questo modo:
+    # it:
+    #   activerecord:
+    #     attributes:
+    #       estimate_before/value:
+    #         na: NA
+    #         very_insufficient: 1
+    #         insufficient: 2
+    #         sufficient: 3
+    #         excellent: 4
+    #
+    # dove in questo caso  estimate_before è il modello e value è il nome del campo enum
+    #
+    def self.enum_translation(model, attribute, value, variant=nil)
+      return '' if value.nil?
+      variant = "_#{variant}" unless variant.nil?
+      model.human_attribute_name("#{attribute}.#{value}#{variant}")
+    end
+
+
+    ##
+    # Helper per generare una modal con all'interno un form
+    # Utilizzare passando un block il quale riceve come parametro la form di formtastic
+    # possibile passare anche una proc in buttons_proc per scrivere in modo differente i bottoni nella modal,
+    # alla proc viene passato il solito form di formtastic e il bottone standard di chiusura
+    #
+    def modal_form_generator(args = {})
+
+      args = {
+          id: 'modal',
+          class: '',
+          title: 'Titolo',
+          form_cfgs: [],
+          buttons_proc: Proc.new do |f, default_close_btn|
+            default_close_btn +
+                f.action(:submit, button_html: {class: 'btn btn-primary'}, :label => :save_and_close)
+          end
+      }.merge(args)
+
+      raise 'Passare le configurazioni per la form' if args[:form_cfgs]==[]
+
+      default_close_btn = content_tag(:button, 'Chiudi', type: 'button', class: 'btn btn-default', data: {dismiss: "modal"})
+
+      content_tag(:div,
+                  class: "modal fade kono_modal_form",
+                  id: args[:id],
+                  tabindex: "-1",
+                  role: "dialog",
+                  "aria-hidden".to_sym => "true") do
+        content_tag :div, class: 'modal-dialog' do
+          semantic_form_for(*args[:form_cfgs]) do |f|
+            content_tag :div, class: 'modal-content' do
+
+              buff = ActiveSupport::SafeBuffer.new
+
+              buff << content_tag(:div, class: 'modal-header') do
+                content_tag(:button, raw("&times;"), type: "button", class: "close", data: {dismiss: 'modal'}, "aria-hidden".to_sym => "true") +
+                    content_tag(:h4, args[:title], class: "modal-title")
+              end
+
+              buff << content_tag(:div, class: 'modal-body') do
+                yield f
+              end
+
+              buff << content_tag(:div, class: 'modal-footer') do
+                args[:buttons_proc].call(f, default_close_btn)
+              end
+
+              buff
+            end
+          end
+        end
+      end
+
+    end
+
+
+    ##
+    # Genera il bottone per editazione con una modal del contenuto,
+    # gli viene passato un block contenente la modal da lanciare per l'editazione,
+    # solitamente generata con modal_form_generator.
+    # come parametri viene passato l'id del target che si aspetta di richiamare
+    #
+    # ES:
+    #  modal_edit_button do |id|
+    #    render 'tikal_core/people/person_contacts/modal_form', :contact => contact, :id => id %>
+    #  end
+    #
+    # Attributes:
+    #   align: left|rigth
+    #   updatable_content: elemento da rimpiazzare con il partial restituito
+    #   class: classi aggiuntive per selezionare meglio il bottone
+    #   btn_class: classi aggiuntive del bottone
+    #   bnt_icon: Symbol che identifica che icona utilizzare per il bottone
+    #
+    #
+    def modal_edit_button(*args, &block)
+
+      options = {
+          align: 'left',
+          updatable_content: '',
+          class: '',
+          btn_class: '',
+          bnt_icon: :edit
+      }.merge(args.extract_options!)
+
+      id = "#{SecureRandom.hex}"
+
+
+      content_tag :div, class: "kono_edit_button align-#{options[:align]} #{options[:class]}", :data => {updatable_content: options[:updatable_content]} do
+        buffer = ActiveSupport::SafeBuffer.new
+
+        buffer << button_tag(data: {toggle: 'modal', target: "##{id}"}, class: "btn btn-default btn-xs #{options[:btn_class]}") { fa_icon(options[:bnt_icon]) }
+
+        buffer << capture do
+          block.call(id)
+        end
+
+        buffer
+      end
+    end
+
+
+    ##
+    # Genera il bottone per la cancellazione di un elemento
+    #
+    # modal_delete_button(path, [options])
+    # path -> resource to delete
+    # options:
+    #  *  confirm         : Text to display in modal
+    #  *  align           : left|right
+    #  *  callback_remove : id dell'elemento da rimuove una volta avuto successo il javascript di cancellazione
+    #  *  bnt_icon        : Symbol che identifica che icona utilizzare per il bottone
+    def modal_delete_button(*args)
+      options = {
+          confirm: 'Sicuri di voler eliminare il record? L\'azione non è annullabile.',
+          align: 'left',
+          callback_remove: nil,
+          bnt_icon: :times
+      }.merge(args.extract_options!)
+      path = args[0]
+
+      id = "#{SecureRandom.hex}"
+
+      content_tag :div, class: "tk_delete_button align-#{options[:align]}" do
+
+        buffer = ActiveSupport::SafeBuffer.new
+
+        buffer<<button_tag(data: {toggle: 'modal', target: "##{id}"}, class: 'btn btn-danger btn-xs') { fa_icon(options[:bnt_icon]) }
+
+        buffer<< content_tag(:div,
+                             class: 'modal fade',
+                             id: id,
+                             tabindex: "-1",
+                             role: "dialog",
+                             "aria-hidden".to_sym => "true") do
+          form_tag(path, method: :delete, data: {callback_remove: options[:callback_remove]}) do
+            content_tag :div, class: 'modal-dialog' do
+              content_tag :div, class: 'modal-content' do
+
+                buff = ActiveSupport::SafeBuffer.new
+
+                buff << content_tag(:div, class: 'modal-header') do
+                  tmp_buff = ActiveSupport::SafeBuffer.new
+                  tmp_buff<<button_tag(fa_icon(:times), type: "button", class: "close", data: {dismiss: "modal"}, "aria-hidden".to_sym => true)
+                  tmp_buff<<content_tag(:h4, "Attenzione", class: "modal-title")
+                  tmp_buff
+                end
+
+                buff << content_tag(:div, options[:confirm], class: 'modal-body text-danger')
+
+                buff << content_tag(:div, class: 'modal-footer') do
+                  button_tag('Annulla', type: "button", class: "btn btn-default", data: {dismiss: "modal"})+
+                      button_tag('Conferma', type: 'submit', class: "btn btn-danger")
+                end
+
+                buff
+              end
+
+            end
+          end
+        end
+
+        buffer << content_tag(:script, raw("$('##{id} form').kono_delete_button();"), :type => 'text/javascript')
+
+        buffer
+      end
+    end
+
+    ##
+    # Colleziona i mesi per la select box
+    def month_collection
+      (1..12).collect { |m| [t('date.month_names')[m].capitalize, m] }
+    end
+
+
+    ##
+    # Genera una collection degli anni per la select box
+    # parte da -8 a +1
+    #
+    def year_collection(start=-8, last=1)
+      ((Time.now.year+start)..(Time.now.year+last)).to_a.reverse
+    end
+
+    module_function :year_collection
+
+
+    ##
+    # Si occupa di generare la visualizzazione dell'exception passata, con informazioni
+    # aggiuntive se utente è super admin
+    # * *Args*    :
+    #   - exception   -> Exception
+    def bs_rescue_printer(exception)
+      bff = ActiveSupport::SafeBuffer.new
+
+      bff<< content_tag(:div, class: "alert alert-warning") do
+        button_tag(raw("&times;"), data: {dismiss: "alert", hidden: "true"}, class: 'close') +
+            content_tag(:strong, 'Errore') +
+            " Attenzione, il codice eseguito non è valido, contattare l'amministratore."
+      end
+
+      if @current_user.is_super_admin?
+
+        bff<<content_tag(:div, class: "panel panel-info") do
+          tmp = ActiveSupport::SafeBuffer.new
+          tmp<<content_tag(:div, class: "panel-heading") do
+            content_tag :h3, "Messagio di Errore: #{exception.message} "
+          end
+          tmp<<content_tag(:div, class: "panel-body") do
+            content_tag :pre, exception.backtrace.join("\n")
+          end
+
+          tmp
+        end
+      end
+
+      bff
+    end
+
+    ##
+    #
+    # * *Args*    :
+    #   - int   -> Valore intero per definire
+    #   - class -> optional classi aggiuntive
+    # * *Returns* :
+    #   - content
+    #
+    def bs_spacer(space, classe='')
+      content_tag :div, nil, class: "v-spacer space-x#{space} #{classe}"
+    end
+
+
+    ##
+    # Costruisce una tabella con i campi utili alla creazione di elementi multipli
+    #
+    # Attributes:
+    # form -> la form proveniente da formtastic
+    # field -> il campo referente dell'associazione
+    # fields -> elenco di campi su cui costruire le varie colonne
+    # options -> Hash di opzioni:
+    #             :disable_duplication => [false]    : server per disabilitare il bottone della duplicazione
+    #
+    # se gli si passa un blocco allora possiamo elaborare la costruzione dei differenti campi in modo personale
+    # al blocco viene passato la classe di formtastic della form, il campo, e un blocco contenente la proc per
+    # elaborare i campi in modo standard
+    #
+    #   multiple_elements_table(form, :campo_has_many, [:label, :string_value, :number_value]) do |field, form|
+    #     case field
+    #       when :string_value, :number_value
+    #         form.input field, label: false, input_html: {:autocomplete => 'off', class: 'toggle_value'}
+    #       else
+    #         form.input field, label: false, input_html: {:autocomplete => 'off'}
+    #     end
+    #   end
+    #
+    # Traduzioni delle colonne:
+    #
+    #   modello_iniziale/campo_has_many:
+    #     campo_del_has_many
+    #
+    #
+    def multiple_elements_table(*params)
+      options = params.extract_options!
+
+      options = {:disable_duplication => false}.merge(options)
+
+      form = params[0]
+      field = params[1]
+      fields = params[2]
+
+      semantic_form_nested=[field]
+
+      #inserimento logiche per scope su elenco elementi multipli
+      unless options[:scope].nil?
+        semantic_form_nested<<options[:scope]
+      end
+
+      content_tag :table, class: "table table-bordered" do
+
+        b = ActiveSupport::SafeBuffer.new
+
+        b<< content_tag(:thead) do
+          content_tag :tr do
+            c = ActiveSupport::SafeBuffer.new
+
+            fields.each do |f|
+              ::Rails.logger.debug { form.object.class.inspect }
+              ::Rails.logger.debug { field }
+              ::Rails.logger.debug { f.inspect }
+              c<<content_tag(:th, form.object.class.human_attribute_name("#{field}.#{f}"),class:"multi_tab_#{f}")
+            end
+            unless options[:disable_duplication]
+              c<<content_tag(:td, nil)
+            end
+
+            c
+          end
+        end
+
+        b<<content_tag(:tbody) do
+          form.semantic_fields_for(*semantic_form_nested) do |measure|
+
+            default_execution = Proc.new { |field| measure.input field, :label => false }
+
+            content_tag :tr, class: "form-inline list riga_misura" do
+
+              d = ActiveSupport::SafeBuffer.new
+
+              fields.each do |f|
+                d<<content_tag(:td,class:"multi_tab_#{f}") do
+
+                  if block_given?
+                    yield(f, measure, default_execution)
+                  else
+                    default_execution.call(f)
+                  end
+
+                end
+              end
+
+              unless options[:disable_duplication]
+                d << content_tag(:td) do
+
+                  link_to "#", class: 'btn btn-xs btn-default add_one_more' do
+
+                    h = ActiveSupport::SafeBuffer.new
+                    h<< fa_icon(:plus)
+                    h<< measure.input(:_destroy, as: :hidden)
+
+                    h
+                  end
+
+                end
+              end
+
+              d
+            end
+          end
+        end
+
+        b
+      end
+    end
+
+
+    ##
+    # Genera un'albero con bootstrap-tree
+    # deve ricevere un array di dati da trasformare in json.
+    # per come scrivere il parametro data vedi
+    # https://github.com/jonmiles/bootstrap-treeview
+    #
+    def bs_tree(data)
+
+      id_div = SecureRandom.hex(10)
+
+      tmp = ActiveSupport::SafeBuffer.new
+
+      tmp<< content_tag(:div, nil, id: id_div, class: 'bs_tree_list')
+
+      tmp<< javascript_tag do
+        raw "$('##{id_div}').treeview({data: #{data.to_json}});"
+      end
+
+    end
+
+    ##
+    # Stampa una data con il default delle date se questa non è nil
+    #
+    def print_rescue_date(date)
+      unless date.nil?
+        return l date.to_date
+      end
+      ''
+    end
+
+
+  end
+end