lato_core 1.1

data/config/routes.rb

@@ -0,0 +1,20 @@
+LatoCore::Engine.routes.draw do
+  root 'back/back#home'
+
+  # Authentication
+  get 'login', to: 'back/authentication#login', as: 'login'
+  post 'exec_login', to: 'back/authentication#exec_login', as: 'exec_login'
+  delete 'exec_logout', to: 'back/authentication#exec_logout', as: 'exec_logout'
+
+  # view richiesta email
+  get 'password_forget', to: 'back/authentication#password_forget', as: 'password_forget'
+  # invio email recupero psw
+  post 'password_recover', to: 'back/authentication#password_recover', as: 'password_recover'
+  # view inserimento nuova psw
+  get 'password_edit/:token', to: 'back/authentication#password_edit', as: 'password_edit'
+  # aggiornamento password
+  post 'password_update', to: 'back/authentication#password_update', as: 'password_update'
+  # Users
+  resources :superusers, module: 'back'
+
+end

data/db/migrate/20160224181217_create_lato_core_superusers.rb

@@ -0,0 +1,15 @@
+class CreateLatoCoreSuperusers < ActiveRecord::Migration
+  def change
+
+    create_table :lato_core_superusers do |t|
+      t.string :name
+      t.string :username
+      t.string :email
+      t.integer :permission
+      t.string :session_code
+      t.string :password_digest
+
+      t.timestamps null: false
+    end
+  end
+end

data/lib/lato_core.rb

@@ -0,0 +1,11 @@
+# Lato Core e' una gemma che si occupa di generare un pannello di amministrazione
+# con gestione delle utenze da utilizzare nello sviluppo di cms e gestionali.
+# Lato Core e' stato sviluppato per supportare l'integrazione con altri moduli
+# e necessita della gemma 'lato_view' per funzionare in modo corretto.
+module LatoCore
+
+  # Includo interface e engine
+  require "lato_core/engine"
+  require "lato_core/interface"
+  
+end

data/lib/lato_core/engine.rb

@@ -0,0 +1,26 @@
+module LatoCore
+  # Classe che gestisce l'inizializzazione del modulo.
+  # Principalmente si occupa di rendere obbligatorie le migrazioni nell'app
+  # principale e di inserire nel Rails.application.routes le routes del modulo.
+  class Engine < ::Rails::Engine
+    isolate_namespace LatoCore
+
+    # Aggiunta del supporto alle migrazioni
+    initializer 'Add migration support' do |app|
+      unless app.root.to_s.match root.to_s
+        config.paths['db/migrate'].expanded.each do |expanded_path|
+          app.config.paths['db/migrate'] << expanded_path
+        end
+      end
+    end
+
+    # Aggiunta del supporto ai routes
+    initializer 'Add gem routes to application',
+                before: :load_config_initializers do
+      Rails.application.routes.append do
+        # modificare '/lato/starter' con l'url di base dei routes del modulo
+        mount LatoCore::Engine, at: '/lato/core'
+      end
+    end
+  end
+end

data/lib/lato_core/interface.rb

@@ -0,0 +1,29 @@
+module LatoCore
+  # L'interfaccia contiene un insieme di funzioni utilizzabili in maniera
+  # universale dall'applicazione principale o da alti moduli
+  module Interface
+
+    # Azioni principali per la gestione della cache
+    require 'lato_core/interface/cache'
+    include LatoCore::Interface::Cache
+    # Azioni principali per la gestione delle comunicazioni
+    require 'lato_core/interface/communication'
+    include LatoCore::Interface::Communication
+    # Azioni principali per la gestione delle sessioni
+    require 'lato_core/interface/session'
+    include LatoCore::Interface::Session
+    # Azioni principali per la gestione della navigazione
+    require 'lato_core/interface/navigation'
+    include LatoCore::Interface::Navigation
+    # Azioni principali per il controllo dell'autenticazione
+    require 'lato_core/interface/authentication'
+    include LatoCore::Interface::Authentication
+    # Azioni principali per la gestione delle lingue
+    require 'lato_core/interface/languages'
+    include LatoCore::Interface::Languages
+    # Azioni principali per la gestione delle impostazioni superusers
+    require 'lato_core/interface/superusers'
+    include LatoCore::Interface::Superusers
+
+  end
+end

data/lib/lato_core/interface/authentication.rb

@@ -0,0 +1,34 @@
+module LatoCore
+  module Interface
+    # Insieme di funzioni che permettono di gestire l'autenticazione degli
+    # utenti che vogliono accedere al backoffice
+    module Authentication
+
+      # Funzione che controlla se l'utente ha i permessi di accedere al
+      # backoffice. Se l'utente non ha i permessi viene rimandato alla pagina di login.
+      def core_controlUser
+        redirect_to lato_core.login_path unless core_controlSession
+      end
+
+      # Funzione che ritorna l'oggetto utente loggato.
+      # * *Returns* :
+      # - user_id se la sessione dell'utente risulta valida
+      # - false se la sessione non esiste o non e' valida
+      def core_getCurrentUser
+        user = LatoCore::Superuser.find(session[:user])
+        return user if session[:user] && session[:session_code] && user
+      end
+
+      # Funzione che controlla se i permessi dell'utente sono superiori al
+      # livello ricevuto come parametro
+      # * *Returns* :
+      # - true se la sessione dell'utente ha permessi maggiori o uguali del parametro ricevuto
+      # - false se la sessione non esiste o non ha i permessi necessari
+      def core_controlPermission(permission)
+        user = core_getCurrentUser
+        user && user.permission >= permission
+      end
+
+    end
+  end
+end

data/lib/lato_core/interface/cache.rb

@@ -0,0 +1,29 @@
+module LatoCore
+  module Interface
+    # Insieme di funzioni che gestiscono la cache dei moduli sulla
+    # applicazione principale.
+    module Cache
+
+      # Funzione che ritorna il percorso alla directory di cache usata dai
+      # moduli lato per memorizzare informazioni sull'applicazione principale.
+      # La directory dell'app principale usata come cache si trova nel percorso
+      # #{Rails.root}/config/lato
+      def core_getCacheDirectory
+        # creo le directory per gli assets se non esistono
+        dirname = "#{Rails.root}/app/assets/images/lato"
+        FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
+        dirname = "#{Rails.root}/app/assets/stylesheets/lato"
+        FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
+        dirname = "#{Rails.root}/app/assets/javascripts/lato"
+        FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
+        # creo la directory di cache se non esiste
+        dirname = "#{Rails.root}/config/lato"
+        FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
+        # ritorno la directory di cache
+        return dirname
+      end
+
+    end
+
+  end
+end

data/lib/lato_core/interface/communication.rb

@@ -0,0 +1,104 @@
+module LatoCore
+  module Interface
+    # Insieme di funzioni che permettono di ottenere informazioni sulla
+    # applicazione principale e sulle altre gemme che lavorano su di essa
+    module Communication
+
+      # Ritorna l'url relativo della directory a cui rimandare dopo
+      # aver effettuato il login in lato. Se tale valore non e' settato
+      # nel file di configurazione di lato allora ritorna semplicemente false.
+      def core_getApplicationLoginRoot
+        return CORE_APPLOGINROOT if defined? CORE_APPLOGINROOT
+        directory = core_getCacheDirectory
+        if File.exist? "#{directory}/config.yml"
+          config = YAML.load(
+            File.read(File.expand_path("#{directory}/config.yml", __FILE__))
+          )
+          return config['login_home'] if config && config['login_home']
+        else
+          return false
+        end
+      end
+
+      # Ritorna il nome dell'applicazione principale settato nel file
+      # config/lato/config.yml.
+      # Se l'applicazione principale non specifica nessun nome allora
+      # la funzione ritorna il valore 'Lato'
+      def core_getApplicationName
+        return CORE_APPNAME if defined? CORE_APPNAME
+        directory = core_getCacheDirectory
+        if File.exist? "#{directory}/config.yml"
+          config = YAML.load(
+            File.read(File.expand_path("#{directory}/config.yml", __FILE__))
+          )
+          if config && config['app_name']
+            return config['app_name']
+          else
+            return 'Lato'
+          end
+        end
+      end
+
+      # Legge il file di configurazione e verifica se e' stato impostato un root url
+      # per l'applicazione. Se non è stato impostato utilizza di default 'localhost'
+      def core_getApplicationURL
+        return CORE_APPURL if defined? CORE_APPURL
+        directory = core_getCacheDirectory
+        if File.exist? "#{directory}/config.yml"
+          config = YAML.load(
+            File.read(File.expand_path("#{directory}/config.yml", __FILE__))
+          )
+          if config && config['root_url']
+            return config['root_url']
+          else
+            return 'http://localhost:3000'
+          end
+        end
+      end
+
+      # Legge il file di configurazione e verifica se è stato impostato un indirizzo
+      # email di servizio. Se non e' stata impostata allora utilizza quella di
+      # default 'service@lato.com'
+      def core_getApplicationServiceEmail
+        return CORE_APPSERVICEMAIL if defined? CORE_APPSERVICEMAIL
+        directory = core_getCacheDirectory
+        if File.exist? "#{directory}/config.yml"
+          config = YAML.load(
+            File.read(File.expand_path("#{directory}/config.yml", __FILE__))
+          )
+          if config && config['service_email']
+            return config['service_email']
+          else
+            return 'service@lato.com'
+          end
+        end
+      end
+
+      # Esamina tutte le gemme della applicazione principale e ritorna
+      # solamente quelle appartenenti al progetto Lato.
+      # * *Returns* :
+      # - array di stringhe con i nomi delle gemme del progetto Lato usate dall'applicazione
+      def core_getLatoGems
+        gems = core_getGems
+        lato_gems = []
+        # controllo ogni gemma
+        gems.each do |name|
+          lato_gems.push(name) if name.start_with? 'lato'
+        end
+        # ritorno il risultato
+        lato_gems
+      end
+
+      # Ritorna la lista dei nomi delle gemme utilizzate dalla applicazione
+      # principale
+      # * *Returns* :
+      # - array di stringhe con i nomi delle gemme dell'applicazione
+      def core_getGems
+        require 'bundler'
+        Bundler.load.specs.map { |spec| spec.name }
+      end
+
+    end
+
+  end
+end

data/lib/lato_core/interface/languages.rb

@@ -0,0 +1,60 @@
+module LatoCore
+  module Interface
+    # Insieme di funzioni che determinano e gestiscono le informazioni riguardo
+    # alle lingue dell'applicazione tra le sezioni offerte dai moduli lato
+    module Languages
+
+      # Funzione che ritorna true se l'applicazione ha piu' lingue, false se
+      # l'applicazione ha una singola lingua
+      def core_applicationHasLanguages
+        return (CORE_APPLANGUAGES.length > 1) if defined? CORE_APPLANGUAGES
+        languages = core_getApplicationLanguages
+        languages.length > 1
+      end
+
+      # Funzione che ritorna un array contenente le lingue gestite
+      # dall'applicazione
+      def core_getApplicationLanguages
+        return CORE_APPLANGUAGES if defined? CORE_APPLANGUAGES
+        # definisco variabile di ritorno
+        languages = false
+        if File.exist? "#{Rails.root}/config/lato/config.yml"
+          # accedo al config.yml
+          config = YAML.load(
+            File.read(File.expand_path("#{Rails.root}/config/lato/config.yml",
+                                       __FILE__))
+          )
+          if config['languages']
+            languages = config['languages'].split(',')
+
+            languages.each do |language|
+              language.downcase.delete(' ')
+            end
+          end
+        end
+        # ritorno il risultato
+        return languages
+      end
+
+      # Funzione che ritorna la lettura del file di lingua corretto per
+      # il modulo il cui nome e' ricevuto come parametro
+      def core_loadModuleLanguages(module_name)
+        module_root = module_name.camelize.constantize::Engine.root
+        application_lang = Rails.application.config.i18n.default_locale
+        if File.exist? "#{module_root}/lang/#{application_lang}.yml"
+          return YAML.load(
+            File.read(File.expand_path("#{module_root}/lang/#{application_lang}.yml",
+                                       __FILE__))
+          )
+        else
+          return YAML.load(
+            File.read(File.expand_path("#{module_root}/lang/default.yml",
+                                       __FILE__))
+          )
+        end
+      end
+
+    end
+
+  end
+end

data/lib/lato_core/interface/navigation.rb

@@ -0,0 +1,109 @@
+module LatoCore
+  module Interface
+    # Insieme di funzioni che determinano e gestiscono le informazioni
+    # riguardo alla navigazione tra le sezioni offerte dai moduli lato
+    module Navigation
+      
+      # Ritorna un array contenente le voci che andranno a formare il menu
+      # di navigazione del backoffice.
+      # * *Returns* :
+      # - array di hash contenenti i dati delle voci di menu
+      def core_getNavbarItems
+        return CORE_NAVIGATION if defined? CORE_NAVIGATION
+        getApplicationNavbarItems + getLatoNavbarItems
+      end
+
+      # Ritorna un array contenente le voci delle gemme lato che andranno
+      # a formare il menu di navigazione del backoffice.
+      # * *Returns* :
+      # - array di hash contenenti i dati delle voci di menu
+      private def getLatoNavbarItems
+        # inizializzo la lista delle voci della navbar
+        navbar_items = []
+        # identifico la lista di gemme del progetto Lato usate dalla
+        # applicazione
+        gems = core_getLatoGems
+        # per ogni gemma estraggo i dati necessari a riempire la navbar
+        gems.each do |name|
+          module_name = name.camelize
+          module_root = module_name.constantize::Engine.root
+
+          next unless File.exist? "#{module_root}/config/config.yml"
+          # accedo al config.yml
+          config = YAML.load(
+            File.read(File.expand_path("#{module_root}/config/config.yml",
+                                       __FILE__))
+          )
+          # estraggo i dati dallo yaml
+          data = getConfigNavbarData(config)
+          # aggiungo i dati nella risposta
+          data.each do |single_voice|
+            navbar_items.push(single_voice)
+          end
+        end
+        # ritorno il risultato
+        navbar_items
+      end
+
+      # Ritorna un array contenente le voci della applicazione principale
+      # che andranno a formare il menu di navigazione del backoffice.
+      # * *Returns* :
+      # - array di hash contenenti i dati delle voci di menu
+      private def getApplicationNavbarItems
+        directory = core_getCacheDirectory
+        # inizializzo la lista delle voci della navbar
+        navbar_items = []
+
+        if File.exist? "#{directory}/config.yml"
+          # accedo al config.yml
+          directory = core_getCacheDirectory
+          config = YAML.load(
+            File.read(File.expand_path("#{directory}/config.yml", __FILE__))
+          )
+          # estraggo i dati dallo yaml
+          data = getConfigNavbarData(config)
+          # aggiungo i dati nella risposta
+          data.each do |single_voice|
+            navbar_items.push(single_voice)
+          end
+        end
+        # ritorno il risultato
+        navbar_items
+      end
+
+      # Estrae i dati relativi alla navbar dal file config.yml di una
+      # applicazione controllando che la struttura del file sia corretta
+      private def getConfigNavbarData(config)
+        # inizializzo la lista di dati
+        results = []
+        # se il file e' formattato correttamente esamino ogni sua voce
+        if config and config['menu']
+          config['menu'].each do |voice|
+            # estraggo i dati
+            unique_name = voice[0]
+            name = voice[1]['name'].capitalize
+            url = voice[1]['url'].downcase
+            icon = voice[1]['icon'].downcase
+            position = voice[1]['position']
+            permission = voice[1]['permission']
+            # genero l'oggetto con le informazioni di output
+            output_voice = {
+              unique_name: unique_name,
+              name: name,
+              url:  url,
+              icon: icon,
+              position: position,
+              permission: permission
+            }
+            # aggiungo la voce al risultato
+            results.push(output_voice)
+          end
+        end
+        # ritorno il risultato
+        results
+      end
+
+    end
+
+  end
+end