lato_core 1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6cb92d3b3c9b544994b4a3d1b0c29867ae4c9b52
+  data.tar.gz: 8bd48730a7264e0574ae614f83bccacfde7f4b96
+SHA512:
+  metadata.gz: 36e9ec71600ea4de301286f49a40729525c8851e90f493125177b4b584a89a6a094a94d1b27e941771bebcae74ef7418ae52e0feb3e5949c4356a0c6a1a78eed
+  data.tar.gz: 1080153b8ad42ac9ffcdcfbf975835c4c75a3bace55b0a299f2aade157cbc39cd1007aa9a237fa5174023929463aa3291495509ef1c2e5ba47df44294ac5e654

data/Rakefile

@@ -0,0 +1,38 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'LatoCore'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/lato_core.rb')
+  rdoc.rdoc_files.include('lib/lato_core/**/*.rb')
+  rdoc.rdoc_files.include('app/models/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/controllers/lato_core/api/v1/api_controller.rb

@@ -0,0 +1,9 @@
+module LatoCore
+  module Api::V1
+    
+    # Classe che gestisce le API del modulo
+    class ApiController < ApplicationController
+    end
+
+  end
+end

data/app/controllers/lato_core/application_controller.rb

@@ -0,0 +1,6 @@
+module LatoCore
+  # Classe base dei controller del modulo
+  class ApplicationController < ActionController::Base
+
+  end
+end

data/app/controllers/lato_core/back/authentication_controller.rb

@@ -0,0 +1,114 @@
+module LatoCore
+  module Back
+    # Controller che gestisce il login e il logout degli utenti
+    class AuthenticationController < Back::BackController
+
+      # Disattivo il controllo dell'autenticazione utente
+      skip_before_action :core_controlUser, except: [:exec_logout]
+
+      # Richiama la view della pagina di login
+      def login
+        redirect_to lato_core.root_path if core_controlSession
+      end
+
+      # Esegue il login e, se l'utente e' autenticato lo rimanda
+      # alla homepage del backoffice
+      def exec_login
+        if core_createSession(params[:username], params[:password])
+          redirect_to lato_core.root_path
+        else
+          flash[:warning] = CORE_LANG['superusers']['login_error']
+          redirect_to lato_core.login_path
+        end
+      end
+
+      # Esegue il logout e rimanda alla pagina di login del backoffice
+      def exec_logout
+        core_destroySession
+        redirect_to lato_core.login_path
+      end
+
+      # Richiama la view per la richiesta di una nuova password nel caso di
+      # password dimenticata
+      def password_forget
+        redirect_to lato_core.root_path unless core_getRecoveryPasswordPermission
+        redirect_to lato_core.root_path if core_controlSession
+      end
+
+      # Esegue il necessario per il recupero password e invia l'email al richiedente
+      def password_recover
+        redirect_to lato_core.root_path unless core_getRecoveryPasswordPermission
+        if user = LatoCore::Superuser.find_by(email: params[:email].downcase)
+          # genero il codice da salvare come session code
+          code = "RECPSW-#{SecureRandom.urlsafe_base64}"
+          # genero il codice per formare l'url di recupero password
+          code_url = URI.encode("#{user.id}::#{Time.now}::#{code}")
+          # memorizzo il session_code sul db
+          user.update_attribute(:session_code, code)
+          # invio una mail di recupero
+          LatoCore::SuperusersMailer.recover_password(user.email, code_url).deliver_now
+          flash[:success] = CORE_LANG['recover_password']['confirm_send']
+        else
+          flash[:warning] = CORE_LANG['superusers']['not_found']
+        end
+        redirect_to lato_core.login_path
+      end
+
+      # Richiama la view con il form per l'inserimento di una nuova password
+      def password_edit
+        redirect_to lato_core.root_path unless core_getRecoveryPasswordPermission
+        redirect_to lato_core.root_path if core_controlSession
+        # splitto il token ricevuto (formato: id utente, timestamp, session_code)
+        data = URI.decode(params[:token]).split('::')
+        # controllo che il formato sia corretto
+        if data.length != 3
+          flash[:warning] = CORE_LANG['recover_password']['recover_error_token']
+          redirect_to lato_core.login_path and return false
+        end
+        # identifico i singoli dati
+        user_id = data.first
+        timestamp = data.second
+        session_code = data.last
+        # cerco l'utente e, se non esiste, stampo un errore
+        @user = LatoCore::Superuser.find(user_id)
+        if !@user
+          flash[:warning] = CORE_LANG['recover_password']['recover_error_user']
+          redirect_to lato_core.login_path and return false
+        end
+        # verifico che il token sia ancora valido e non abbia superato le 24 ore
+        if !time = timestamp.to_time || time < Time.now - 24.hours
+          flash[:warning] = CORE_LANG['recover_password']['recover_error_token_time']
+          redirect_to lato_core.login_path and return false
+        end
+        # verifico che il session_code del token sia corretto
+        if @user.session_code != session_code
+          flash[:warning] = CORE_LANG['recover_password']['recover_error_token']
+          redirect_to lato_core.login_path and return false
+        end
+        # genero un nuovo token per togliere la validita' al link di recupero password
+        # e lo memorizzo all'utente
+        new_code = SecureRandom.urlsafe_base64
+        @user.update_attribute(:session_code, new_code)
+      end
+
+      # Aggiorna la password dell'utente che ha richiesto il recupero password
+      def password_update
+        redirect_to lato_core.root_path unless core_getRecoveryPasswordPermission
+        user = LatoCore::Superuser.find(params[:id])
+        if !user || user.session_code != params[:token]
+          flash[:warning] = CORE_LANG['recover_password']['recover_error']
+          redirect_to lato_core.login_path and return false
+        end
+        user.update(password: params[:password], password_confirmation: params[:password])
+        if !user.save
+          flash[:warning] = CORE_LANG['recover_password']['recover_error']
+          redirect_to lato_core.login_path and return false
+        end
+
+        flash[:success] = CORE_LANG['recover_password']['recover_success']
+        redirect_to lato_core.login_path
+      end
+
+    end
+  end
+end

data/app/controllers/lato_core/back/back_controller.rb

@@ -0,0 +1,28 @@
+# Includo l'interfaccia di lato_core
+include LatoCore::Interface
+# Includo l'interfaccia di lato_view
+include LatoView::Interface
+
+module LatoCore
+  module Back
+    # Classe che gestisce il pannello di backoffice del modulo
+    class BackController < ApplicationController
+
+      # Imposto layout di base dal lato_view
+      layout 'lato_layout'
+
+      # Attivo il controllo delle credenziali
+      before_action :core_controlUser
+
+      # Richiama la view della home del pannello di backoffice
+      def home
+        # rimando ad una pagina custom se è stato impostato da file di configurazione
+        if login_root = core_getApplicationLoginRoot and login_root
+          redirect_to login_root
+        end
+      end
+
+    end
+
+  end
+end

data/app/controllers/lato_core/back/superusers_controller.rb

@@ -0,0 +1,172 @@
+module LatoCore
+  module Back
+    # Controller che gestisce il CRUD degli utenti amministratori
+    class SuperusersController < Back::BackController
+
+      # Imposto la voce di menu da attivare
+      before_action :set_unique_name
+      # Controllo permessi utente
+      before_action :control_permission
+
+      # Richiama la view di creazione di un nuovo utente con permessi di
+      # accesso al pannello di backoffice
+      def new
+        @superuser = LatoCore::Superuser.new
+      end
+
+      # Crea un nuovo utente con permessi di accesso al pannello di backoffice
+      # e rimanda alla pagina di visualizzazione del profilo utente appena
+      # creato
+      def create
+        superuser = LatoCore::Superuser.new(superuser_params)
+        # controllo che l'utente creato non abbia permessi superiori dell'utente
+        # creatore
+        if superuser.permission > core_getCurrentUser.permission
+          flash[:warning] = CORE_LANG['superusers']['permission_create']
+          redirect_to lato_core.superusers_path and return false
+        end
+        # controllo che la creazione dell'utente non abbia avuto errori
+        unless superuser.save
+          flash[:danger] = CORE_LANG['superusers']['failed_create']
+          redirect_to lato_core.superusers_path and return false
+        end
+
+        flash[:success] = CORE_LANG['superusers']['success_create']
+        redirect_to lato_core.superuser_path(superuser)
+      end
+
+      # Richiama la view di modifica dell'utente con id uguale a quello ricevuto
+      # come parametro
+      def edit
+        @superuser = LatoCore::Superuser.find(params[:id])
+        # controllo che l'utente da modificare esista
+        unless @superuser
+          flash[:warning] = CORE_LANG['superusers']['not_found']
+          redirect_to lato_core.superusers_path and return false
+        end
+        # controllo che l'utente da modificare non abbia permessi uguali o
+        # maggiori dell'utente modificatore
+        if @superuser.permission >= core_getCurrentUser.permission &&
+           @superuser.permission != core_getCurrentUser.permission
+          flash[:warning] = CORE_LANG['superusers']['permission_update']
+          redirect_to lato_core.superusers_path and return false
+        end
+      end
+
+      # Aggiorna l'utente con i dati ricevuti come parametro
+      def update
+        superuser = LatoCore::Superuser.find(params[:id])
+        # controllo che l'utente da modificare esista
+        unless superuser
+          flash[:warning] = CORE_LANG['superusers']['not_found']
+          redirect_to lato_core.superusers_path and return false
+        end
+        # controllo che l'utente da modificare non abbia permessi uguali o
+        # maggiori dell'utente modificatore
+        if superuser.permission >= core_getCurrentUser.permission &&
+           superuser != core_getCurrentUser
+          flash[:warning] = CORE_LANG['superusers']['permission_update']
+          redirect_to lato_core.superusers_path and return false
+        end
+        # controllo che l'utente non si stia auto aumentando i permessi
+        if superuser.id === core_getCurrentUser.id &&
+           superuser.permission < params[:superuser][:permission].to_i
+          flash[:warning] = CORE_LANG['superusers']['level_update']
+          redirect_to lato_core.superusers_path and return false
+        end
+        # faccio in modo che l'aggiornamento avvenga senza problemi anche se
+        # la password non e' stata inserita
+        if params[:superuser][:password].blank? &&
+           params[:superuser][:password_confirmation].blank?
+          params[:superuser].delete(:password)
+          params[:superuser].delete(:password_confirmation)
+        end
+        # controllo che non ci siano stati errori di aggiornamento
+        unless superuser.update(superuser_params)
+          flash[:danger] = CORE_LANG['superusers']['failed_update']
+          redirect_to lato_core.superuser_path(superuser) and return false
+        end
+
+        flash[:success] = CORE_LANG['superusers']['success_update']
+        redirect_to lato_core.superuser_path(superuser)
+      end
+
+      # Elimina l'utente con id ricevuto come parametro
+      def destroy
+        superuser = LatoCore::Superuser.find(params[:id])
+        # controllo che l'utente da eliminare esista
+        unless superuser
+          flash[:warning] = CORE_LANG['superusers']['not_found']
+          redirect_to lato_core.superusers_path and return false
+        end
+        # controllo che l'utente non stia provando a eliminare se stesso
+        if superuser === core_getCurrentUser
+          flash[:warning] = CORE_LANG['superusers']['itself_destroy']
+          redirect_to lato_core.superusers_path and return false
+        end
+        # controllo che l'utente da eliminare non abbia permessi maggiori o
+        # uguali all'utente eliminatore
+        if superuser.permission >= core_getCurrentUser.permission
+          flash[:warning] = CORE_LANG['superusers']['permission_destroy']
+          redirect_to lato_core.superusers_path and return false
+        end
+        # controllo che non ci siano stati errori durante l'eliminazione
+        unless superuser.destroy
+          flash[:danger] = CORE_LANG['superusers']['failed_destroy']
+          redirect_to lato_core.superuser_path(superuser) and return false
+        end
+
+        flash[:success] = CORE_LANG['superusers']['success_destroy']
+        redirect_to lato_core.superusers_path
+      end
+
+      # Richiama la view per la visualizzazione di un singolo utente
+      # con lo stesso id ricevuto come parametro
+      def show
+        @superuser = LatoCore::Superuser.find(params[:id])
+        # controllo che l'utente da mostrare sia esistente
+        redirect_to lato_core.superusers_path unless @superuser
+      end
+
+      # Richiama la view per la visualizzazione di tutti gli utenti
+      # del sistema
+      def index
+        @search_superusers = LatoCore::Superuser.ransack(params[:q])
+        # controllo che non vengano mostrati gli utenti impostati nascosti
+        hide_settings = core_getHideUsersSettings
+        if hide_settings && !hide_settings.blank?
+          permissions_not_accepted = []
+          current_user_permission = core_getCurrentUser.permission
+          hide_settings.each do |setting|
+            permissions_not_accepted.push(setting.first) if setting.last.to_i === current_user_permission
+          end
+          @superusers = @search_superusers.result.where.not(permission: permissions_not_accepted)
+        else
+          @superusers = @search_superusers.result
+        end
+        @superusers = @superusers.order(
+          'username ASC'
+        ).paginate(page: params[:page], per_page: 10)
+      end
+
+      # Definisce i parametri accettati per le azioni di aggiornamento della
+      # tabella superusers nel database
+      private def superuser_params
+        params.require(:superuser).permit(:name, :username, :email, :permission,
+                                          :password, :password_digest)
+      end
+
+      # Imposta la voce della navbar degli utenti come attiva
+      private def set_unique_name
+        view_setCurrentVoice('core_superusers')
+      end
+
+      # Controlla che l'utente abbia i permessi per accedere alla sezione
+      private def control_permission
+        redirect_to lato_core.root_path unless core_controlPermission(6)
+      end
+
+    end
+
+  end
+end

data/app/mailers/lato_core/application_mailer.rb

@@ -0,0 +1,10 @@
+# Includo l'interfaccia di lato_core
+include LatoCore::Interface
+
+module LatoCore
+  # Classe base di gestione dei mailers
+  class ApplicationMailer < ActionMailer::Base
+    default from: core_getApplicationServiceEmail
+    layout 'lato_core/mailers/layouts/mailer'
+  end
+end

data/app/mailers/lato_core/superusers_mailer.rb

@@ -0,0 +1,29 @@
+module LatoCore
+  # Mailer utilizzato per la comunicazione con l'utente amministratore tramite email
+  class SuperusersMailer < ApplicationMailer
+
+    # Prende in input un utente, un titolo e un testo per notificare l'utente
+    # con il messaggio richiesto
+    def notify(user, title, message)
+      # imposto i dati come variabili di classe
+      @title = title
+      @message = message
+      # definisco oggetto email
+      subject = "#{CORE_LANG['mailers']['notify_subject']} #{core_getApplicationName}"
+      # invio l'email di notifica all'utente
+      mail(to: user.email, subject: subject,
+           template_path: 'lato_core/mailers/superusers')
+    end
+
+    # Prende in input un utente e un codice speciale.
+    # Invia all'utente l'email per il recupero password contenente il codice speciale
+    def recover_password(email, code_url)
+      # identifico codice completo per l'utente
+      @recover_url = core_getApplicationURL + lato_core.password_edit_path(code_url)
+      # invio l'email all'utente
+  	  mail(to: email, subject: CORE_LANG['recover_password']['email_subject'],
+           template_path: 'lato_core/mailers/superusers')
+    end
+
+  end
+end

data/app/models/lato_core/superuser.rb

@@ -0,0 +1,43 @@
+module LatoCore
+  # Modello che si riferisce agli utenti con accesso al pannello di amministrazione
+  class Superuser < ActiveRecord::Base
+
+    # Lista validazioni
+    validates :name, presence: true, length: { maximum: 50 }
+
+    validates :username, presence: true,
+                         length: { maximum: 50 },
+                         uniqueness: { case_sensitive: false }
+
+    validates :email, presence: true,
+                      length: { maximum: 255 },
+                      format: { with: /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i },
+                      uniqueness: { case_sensitive: false }
+
+    validates :permission, presence: true,
+                           length: { minimum: 1, maximum: 10 }
+
+    validates :password, presence: true,
+                         length: { minimum: 6, maximum: 50 },
+                         on: :create
+
+    has_secure_password
+
+    # Azioni prima del salvataggio
+    before_save do
+      username.downcase!
+      email.downcase!
+
+      set_admin_permission
+    end
+
+    # Funzione che imposta i permessi dell'utente amministratore al
+    # massimo livello
+    private def set_admin_permission
+      first_user = LatoCore::Superuser.first
+      self.permission = 10 if first_user && id === first_user.id
+    end
+
+  end
+
+end