kono_utils 0.15.5

data/lib/kono_utils/concerns/base_modals.rb

@@ -0,0 +1,97 @@
+require 'active_support/concern'
+module KonoUtils::Concerns
+  module BaseModals
+    extend ActiveSupport::Concern
+
+    def create
+      authorize @obj if defined? Pundit
+      save_response
+    end
+
+    def destroy
+      authorize @obj if defined? Pundit
+      @obj.destroy
+      respond_to do |f|
+        f.json { render json: {success: true} }
+      end
+    end
+
+
+    def update
+      authorize @obj if defined? Pundit
+      @obj.assign_attributes(update_params)
+      save_response
+    end
+
+    included do
+      before_action :load_parent_assoc
+      before_action :load_obj, :only => [:destroy, :update]
+
+      private
+      ##
+      # Metodo promemoria per caricare il modello padre
+      def load_parent_assoc
+        @parent_model = nil
+        raise 'Sovrascrivi funzione "load_parent_assoc" nei figli la definizione di questa variabile: @parent_model'
+      end
+
+      ##
+      # Metodo promemoria per caricare l'oggetto dell'aggiornamento
+      # ES:
+      #    @obj = @person.person_contacts.find(params[:id])
+      def load_obj
+        @obj=nil
+        raise 'Sovrascrivi funzione "load_obj" in figli la definizione di questa variabile: @obj'
+      end
+
+      ##
+      # Metodo promemoria per pulire i parametri
+      # ES:
+      #   params.require(:person_contact).permit(:contacttype_id, :contact)
+      def update_params
+        raise 'Sovrascrivi in figli'
+      end
+
+
+      def render_part_to_json(partial, locals, status=200)
+        render json: {
+            partial: (
+            render_to_string(
+                :partial => partial,
+                :layout => false, :locals => locals)
+            )
+        }, status: status
+      end
+
+      def save_response
+        raise "Sovrascrivere:
+              def save_response
+                    respond_to do |f|
+                      if @obj.valid?
+                        @obj.save
+                        f.json do
+                          render_part_to_json('tikal_core/people/person_contacts/panel.html', {:contact => @obj})
+                        end
+                      else
+                        f.json do
+                          render_part_to_json('tikal_core/people/person_contacts/modal_form.html', {:contact => @obj, :id => ''}, 400)
+                        end
+                      end
+                    end
+                  end
+
+              ed aggiungere se non già fatto:
+              def create
+                @obj = @person.person_contacts.build(update_params)
+                super
+              end
+              def update_params
+                params.require(:person_contact).permit(:contacttype_id, :contact)
+              end
+              "
+      end
+    end
+
+
+  end
+end

data/lib/kono_utils/concerns/success_message.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+module KonoUtils::Concerns
+  module SuccessMessage
+
+    extend ActiveSupport::Concern
+
+    included do
+      private
+      def success_create_message(model)
+        t('activerecord.successful.messages.created', :model => model.mn)
+      end
+
+      def success_update_message(model)
+        t('activerecord.successful.messages.updated', :model => model.mn)
+      end
+
+      def success_destroy_message(model)
+        t('activerecord.successful.messages.destroyed', :model => model.mn)
+      end
+
+    end
+
+
+  end
+end

data/lib/kono_utils/encoder.rb

@@ -0,0 +1,55 @@
+module KonoUtils
+  ##
+  # Classe che si occupa di decodificare una qualsiasi stringa in formato utf8,
+  # cercando di trovare l'encoding iniziale a tentativi.
+  class Encoder
+
+
+    attr_accessor :string
+
+
+    ##
+    # * *Attributes*  :
+    #   - string -> Stringa da elaborare
+    def initialize(string)
+      self.string = string
+    end
+
+
+    ##
+    # Funcione di rimozione del carattere BOM http://en.wikipedia.org/wiki/Byte_order_mark
+    # e encoding normale
+    def remove_bom
+      string_encoder.gsub("\xEF\xBB\xBF".force_encoding("UTF-8"), '')
+    end
+
+    ##
+    # Funzione di encoding semplice
+    def string_encoder
+      return self.string if self.string.valid_encoding?
+      str = self.string
+      Encoding.list.each do |e|
+        begin
+          str.force_encoding(e.name)
+          tmp_string = str.encode("UTF-8")
+          return tmp_string if tmp_string.valid_encoding?
+        rescue
+          logger.debug { "Rescue -> #{e.name}" }
+        end
+      end
+
+      impossible_encoding
+
+      self.string
+    end
+
+    ##
+    # Metodo placeholder, volendo si può estendere la funzione e sovrascrivere questa funzione
+    # per essere notificati in caso di mancata decodifica
+    def impossible_encoding
+
+    end
+
+
+  end
+end

data/lib/kono_utils/engine.rb

@@ -0,0 +1,13 @@
+module KonoUtils
+  class Engine < ::Rails::Engine
+
+    require 'bootstrap3-datetimepicker-rails'
+    require 'momentjs-rails'
+    require 'font-awesome-rails'
+    require 'rails-assets-bootstrap-treeview'
+    require 'will_paginate'
+    require 'will_paginate-bootstrap'
+    require 'rdiscount'
+
+  end
+end

data/lib/kono_utils/fiscal_code.rb

@@ -0,0 +1,47 @@
+module KonoUtils
+  module FiscalCode
+    class ControllaCF
+      LT = [[1, '0'], [0, '1'], [5, '2'], [7, '3'], [9, '4'], [13, '5'], [15, '6'], [17, '7'], [19, '8'], [21, '9'], [1, 'A'], [0, 'B'], [5, 'C'], [7, 'D'], [9, 'E'], [13, 'F'], [15, 'G'], [17, 'H'], [19, 'I'], [21, 'J'], [2, 'K'], [4, 'L'], [18, 'M'], [20, 'N'], [11, 'O'], [3, 'P'], [6, 'Q'], [8, 'R'], [12, 'S'], [14, 'T'], [16, 'U'], [10, 'V'], [22, 'W'], [25, 'X'], [24, 'Y'], [23, 'Z']]
+      Z9 = ('0'..'9').to_a
+      AZ = ('A'..'Z').to_a
+      class EmptyString < Exception;
+      end
+      class InvalidLength < Exception;
+      end
+      class CaseError < Exception;
+      end
+
+      def self.valid?(cf, strict = false)
+        cf = cf.to_s
+        raise EmptyString.new("codice fiscale non può essere lasciato in bianco") if cf.empty?
+        raise InvalidLength.new("codice fiscale dev'essere composto da 16 caratteri alfanumerici") if cf.size != 16
+        if strict==true && cf != cf.upcase;
+          raise CaseError.new("i caratteri del codice fiscale devono essere maiuscoli");
+        else
+          cf.upcase!
+        end;
+        s = (0..14).collect { |i| (i&1)!=0 ? ([Z9.include?(cf[i, 1]) ? cf[i, 1].to_i : AZ.index(cf[i, 1]), cf[i, 1]]) : LT.rassoc(cf[i, 1]) }
+        s.include?(nil) ? false : AZ.at((s.transpose[0].inject(0) { |t, n| t+n })%26) == cf[-1, 1]
+      end
+
+
+    end
+
+    class ControllaPI
+      NU = ('0'..'9').to_a
+      class EmptyString < Exception;
+      end
+      class InvalidLength < Exception;
+      end
+
+      def self.valid?(pi)
+        pi = pi.to_s
+        raise EmptyString.new("partita iva non può essere lasciata in bianco") if pi.empty?
+        raise InvalidLength.new("partita iva dev'essere composta da 11 cifre") if pi.size != 11
+        s = (0..9).collect { |i| NU.include?(pi[i, 1]) ? ((i&1)!=0 ? (pi[i, 1].to_i > 4 ? ((pi[i, 1].to_i*2) - 9) : pi[i, 1].to_i * 2) : pi[i, 1].to_i) : nil }
+        r = s.include?(nil) ? false : ((s.inject(0) { |t, n| t+n }) % 10)
+        r != false && (r==0 ? r : 10-r) == pi[-1, 1].to_i
+      end
+    end
+  end
+end

data/lib/kono_utils/params_hash_array.rb

@@ -0,0 +1,37 @@
+module KonoUtils
+  module ParamsHashArray
+    extend ActiveSupport::Concern
+
+    included do
+      ##
+      # Si occupa di trasformare un hash con elementi che sono chiramente array in un hash con elementi array:
+      #
+      # {"DatiOrdineAcquisto"=>{"0"=>{"RiferimentoNumeroLinea"=>{"0"=>""}, "IdDocumento"=>"", "Data"=>"", "NumItem"=>"", "CodiceCommessaConvenzione"=>"", "CodiceCUP"=>"", "CodiceCIG"=>""}}}
+      # {"DatiOrdineAcquisto"=>[{"RiferimentoNumeroLinea"=>[""], "IdDocumento"=>"", "Data"=>"", "NumItem"=>"", "CodiceCommessaConvenzione"=>"", "CodiceCUP"=>"", "CodiceCIG"=>""}]}
+      #
+      def elaborate_params_to_hash_array(params)
+
+        out = params
+        ##Controllo se abbiamo solamente chiavi che rappresentano numeri
+        if params.is_a?(Hash)
+
+          if params.keys.select { |k| !(k.to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/) == nil ? false : true) }.length==0
+            out = []
+            params.each_value do |v|
+              out << elaborate_params_to_hash_array(v)
+            end
+          else
+            out={}
+            params.keys.each do |k|
+              out[k.to_sym] = elaborate_params_to_hash_array(params[k])
+            end
+          end
+        end
+
+        Rails.logger.debug "DEBUG #{out.inspect}"
+        out
+      end
+    end
+
+  end
+end

data/lib/kono_utils/percentage.rb

@@ -0,0 +1,60 @@
+require 'action_view'
+module KonoUtils
+##
+# Classe che si occupa di rappresentare un numero percentuale
+# ES:
+# p = Percentage.new(100,20)
+# p.percentage -> ritorna il valore percentuale float
+# p.to_i -> ritorna percentuale intera con relativi arrotondamenti
+# p.to_percentage -> si comporta come l'helper number_to_percentage
+  class Percentage
+
+    include ActionView::Helpers::NumberHelper
+
+    attr_accessor :total, :partial
+
+    def initialize(total=0, partial=0)
+      @total = total
+      @partial = partial
+    end
+
+    ##
+    #
+    # * *Args*    :
+    #   - options -> Hash :
+    #                 :locale - Sets the locale to be used for formatting (defaults to current locale).
+    #
+    #                 :precision - Sets the precision of the number (defaults to 3).
+    #
+    #                 :significant - If true, precision will be the # of significant_digits. If false, the # of fractional digits (defaults to false).
+    #
+    #                 :separator - Sets the separator between the fractional and integer digits (defaults to “.”).
+    #
+    #                 :delimiter - Sets the thousands delimiter (defaults to “”).
+    #
+    #                 :strip_insignificant_zeros - If true removes insignificant zeros after the decimal separator (defaults to false).
+    #
+    #                 :format - Specifies the format of the percentage string The number field is %n (defaults to “%n%”).
+    #
+    #                 :raise - If true, raises InvalidNumberError when the argument is invalid.
+    # * *Returns* :
+    #   - String
+    #
+    def to_percentage(options = {})
+      number_to_percentage(percentage, options)
+    end
+
+    def percentage
+      return 0 if @partial==0
+      return 0 if @total<@partial
+      @partial.to_f/@total.to_f*100.0
+    end
+
+    def to_i
+      return 100 if @total.to_s == @partial.to_s
+      percentage.to_i
+    end
+
+
+  end
+end

data/lib/kono_utils/search_attribute.rb

@@ -0,0 +1,57 @@
+module KonoUtils
+  ##
+  # Classe che mi rappresenta un attributo di ricerca
+  # Di default utilizza il tipo string come renderizzazione
+  #
+  # * *Args* :
+  #   - form_options   -> Hash con opzioni da passare a formtastic
+  #   - field_options  -> Hash con opzioni:
+  #                       cast -> Proc per eseguire il cast del valore
+  class SearchAttribute
+
+    attr_accessor :field, :form_options, :field_options
+
+    def initialize(field, options = {})
+      self.field = field
+
+      self.field_options = {}
+      unless options.is_a? Proc
+        if options[:field_options]
+          self.field_options = options[:field_options]
+          options.delete(:field_options)
+        end
+      end
+
+      self.form_options = options
+    end
+
+    ##
+    # Esegue un casting dei valori rispetto al tipo di campo da utilizzare per formtastic
+    def cast_value(value)
+      return value if value.blank?
+      return value if form_options.is_a? Proc
+      return field_options[:cast].call(value) if field_options[:cast].is_a? Proc
+      case form_options[:as]
+        when :bs_datetimepicker
+          if value.is_a? String
+            DateTime.parse(value)
+          elsif value.is_a? Date
+            value.to_time
+          else
+            value
+          end
+        when :bs_datepicker
+          if value.is_a? String
+            DateTime.parse(value).to_date
+          elsif value.is_a? DateTime
+            value.to_date
+          else
+            value
+          end
+        else
+          value
+      end
+
+    end
+  end
+end

data/lib/kono_utils/tmp_file.rb

@@ -0,0 +1,81 @@
+require 'fileutils'
+module KonoUtils
+  ##
+  # Classe Funzionante prettamente con RAILS
+  # la classe si occupa dei files temporanei creando una cartella dentro a tmp del progetto
+  # crea una cartella random per ogni file per ovviare al problema di duplicazioni dei nomi
+  # Estende Tempfile,
+  # la root della struttura è quella di Rails.root
+  # e di default la classe scrive dentro a tmp
+  # non ha bisogno di essere cancellata, ci penserà in automatico la classe una
+  # la prossima volta che viene chiamata cancellando tutti i files con un TTL
+  # maggiore di 1.day di default
+  ## Utilizzo:
+  # tmp = Ptmpfile.new('nomefile.ext')
+  # tmp.path -> path completa
+  # tmp.write.....
+  # tmp.original_filename.......
+  # tmp.unique_filename.......
+  #
+  #
+  class TmpFile < Tempfile
+
+    PATH = 'tmp/ptmpfile'
+    TIME_LIMIT = 1.day
+    attr_accessor :root_dir
+    attr_accessor :tmp_dir
+    attr_accessor :original_filename, :unique_filename
+
+
+    ##
+    # Generate a new file with a given name
+    #
+    # * *Args*    :
+    #   - name -> String of the name file
+    # * *Returns* :
+    #   - Tempfile
+    #
+    def initialize(name)
+      self.original_filename=name
+      self.root_dir = controll_root
+      clean_tmpdir
+      #creo una nuova cartella per il file attuale
+      self.tmp_dir= "#{self.root_dir.path}/#{Time.now.to_f}"
+      Dir.mkdir(self.tmp_dir)
+      ext =File.extname(name)
+      name = [File.basename(name), ext] unless ext.blank?
+      super(name, self.tmp_dir)
+      self.unique_filename= File.basename(self.path)
+    end
+
+
+    private
+
+    ##
+    # controll presence of root dir
+    # if not exists create it
+    # * *Returns* :
+    #   - Dir
+    #
+    def controll_root
+      unless File.exist?(::Rails.root.join(PATH))
+        Dir.mkdir(::Rails.root.join(PATH))
+      end
+      Dir.open(::Rails.root.join(PATH))
+    end
+
+    ##
+    # Clean the directory
+    #
+    def clean_tmpdir
+      self.root_dir.each do |d|
+        if d != '..' and d!='.'
+          if d.to_i < Time.now.to_i-TIME_LIMIT
+            FileUtils.rm_rf(File.join(self.root_dir.path, d))
+          end
+        end
+      end
+    end
+
+  end
+end