lato 0.1.0

data/app/controllers/lato/application_controller.rb

@@ -0,0 +1,21 @@
+module Lato
+  class ApplicationController < ActionController::Base
+    include Lato::Sessionable
+    include Lato::Layoutable
+    include Lato::Componentable
+
+    def index
+      session_root_path = Lato.config.session_root_path ? main_app.send(Lato.config.session_root_path) : lato.account_path
+      redirect_to @session.valid? ? session_root_path : lato.authentication_signin_path
+    end
+
+    protected
+
+    def respond_to_with_404
+      respond_to do |format|
+        format.html { render plain: '', status: :not_found }
+        format.json { render json: {}, status: :not_found }
+      end
+    end
+  end
+end

data/app/controllers/lato/authentication_controller.rb

@@ -0,0 +1,121 @@
+module Lato
+  class AuthenticationController < ApplicationController
+    before_action :not_authenticate_session, only: %i[signin signin_action signup signup_action]
+    before_action :authenticate_session, only: %i[signout signout_action]
+    before_action :find_user, only: %i[verify_email verify_email_action update_password update_password_action]
+    before_action :hide_sidebar
+    before_action :lock_signup_if_disabled, only: %i[signup signup_action]
+
+    def signin
+      @user = Lato::User.new
+    end
+
+    def signin_action
+      @user = Lato::User.new
+
+      respond_to do |format|
+        if @user.signin(params.require(:user).permit(:email, :password))
+          session_create(@user.id)
+
+          format.html { redirect_to lato.root_path }
+          format.json { render json: @user }
+        else
+          format.html { render :signin, status: :unprocessable_entity }
+          format.json { render json: @user.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def signup
+      @user = Lato::User.new
+    end
+
+    def signup_action
+      @user = Lato::User.new(params.require(:user).permit(:first_name, :last_name, :email, :password, :password_confirmation, :accepted_privacy_policy_version, :accepted_terms_and_conditions_version))
+
+      respond_to do |format|
+        if @user.save
+          session_create(@user.id)
+
+          format.html { redirect_to lato.root_path }
+          format.json { render json: @user }
+        else
+          format.html { render :signup, status: :unprocessable_entity }
+          format.json { render json: @user.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def signout; end
+
+    def signout_action
+      session_destroy
+
+      respond_to do |format|
+        format.html { redirect_to lato.root_path }
+        format.json { render plain: '' }
+      end
+    end
+
+    def verify_email
+      @code = params[:code]
+    end
+
+    def verify_email_action
+      respond_to do |format|
+        if @user.verify_email(params.require(:user).permit(:code))
+          format.html { redirect_to lato.root_path, notice: 'Indirizzo email verificato correttamente' }
+          format.json { render json: @user }
+        else
+          format.html { render :verify_email, status: :unprocessable_entity }
+          format.json { render json: @user.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def recover_password
+      @user = Lato::User.new
+    end
+
+    def recover_password_action
+      @user = Lato::User.new
+
+      respond_to do |format|
+        if @user.request_recover_password(params.require(:user).permit(:email))
+          format.html { redirect_to lato.authentication_update_password_path(id: @user.id) }
+          format.json { render json: @user }
+        else
+          format.html { render :recover_password, status: :unprocessable_entity }
+          format.json { render json: @user.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def update_password; end
+
+    def update_password_action
+      respond_to do |format|
+        if @user.update_password(params.require(:user).permit(:code, :password, :password_confirmation))
+          format.html { redirect_to lato.authentication_signin_path, notice: 'La tua password è stata aggiornata correttamente' }
+          format.json { render json: @user }
+        else
+          format.html { render :update_password, status: :unprocessable_entity }
+          format.json { render json: @user.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    private
+
+    def find_user
+      @user = User.find_by(id: params[:id])
+      respond_to_with_404 unless @user
+    end
+
+    def lock_signup_if_disabled
+      return unless Lato.config.auth_disable_signup
+
+      respond_to_with_404 
+    end
+  end
+end

data/app/controllers/lato/operations_controller.rb

@@ -0,0 +1,23 @@
+module Lato
+  class OperationsController < ApplicationController
+    before_action :authenticate_session
+
+    def show
+      @operation = Lato::Operation.find(params[:id])
+      return unless validate_user_access_to_operation
+    end
+
+    private
+
+    def validate_user_access_to_operation
+      return true if @operation.lato_user_id == @session.user_id
+
+      respond_to do |format|
+        format.html { redirect_to lato.root_path }
+        format.json { render plain: '', status: :unauthorized }
+      end
+
+      false
+    end
+  end
+end

data/app/helpers/lato/application_helper.rb

@@ -0,0 +1,5 @@
+module Lato
+  module ApplicationHelper
+    include Lato::ComponentsHelper
+  end
+end

data/app/helpers/lato/components_helper.rb

@@ -0,0 +1,183 @@
+module Lato
+  module ComponentsHelper
+    # Navbar
+    ##
+
+    def lato_navbar_nav_item(key, path, &block)
+      active = request.path == path
+      active = @navbar_key == key if @navbar_key
+
+      render 'lato/components/navbar_nav_item', active: active, path: path do
+        yield if block
+      end
+    end
+
+    # Sidebar
+    ##
+
+    def lato_sidebar_nav_item(key, path, &block)
+      active = request.path == path
+      active = @sidebar_key == key if @sidebar_key
+
+      render 'lato/components/sidebar_nav_item', active: active, path: path do
+        yield if block
+      end
+    end
+
+    # Page head
+    ##
+
+    def lato_page_head(title, breadcrumbs = [], &block)
+      render 'lato/components/page_head', title: title, breadcrumbs: breadcrumbs do
+        yield if block
+      end
+    end
+
+    # Index
+    ##
+
+    def lato_index(collection, options = {})
+      key = options[:key] || 'default'
+
+      @_lato_index ||= {}
+      @_lato_index[key] ||= {}
+      columns = options[:columns] || @_lato_index[key][:columns] || collection.column_names || []
+      sortable_columns = @_lato_index[key][:sortable_columns] || []
+      searchable_columns = @_lato_index[key][:searchable_columns] || []
+      model_name_underscore = collection.model.name.underscore
+
+      render(
+        'lato/components/index',
+        key: key,
+        collection: collection,
+        columns: columns,
+        sortable_columns: sortable_columns,
+        searchable_columns: searchable_columns,
+        model_name_underscore: model_name_underscore,
+        custom_actions: options[:custom_actions] || {}
+      )
+    end
+
+    # Operation
+    ##
+
+    def lato_operation(operation)
+      render(
+        'lato/components/operation',
+        operation: operation
+      )
+    end
+
+    # Forms
+    ##
+
+    def _lato_form_input_options(form, key, options, action_change_event, classes = '')
+      # setup classes
+      options[:class] ||= []
+      options[:class].push(classes)
+      options[:class].push('is-invalid') unless form.object.errors[key].blank?
+
+      # setup stimulus
+      options[:data] ||= {}
+      options[:data][:action] ||= ''
+      options[:data][:action] += " #{action_change_event}->lato-form#onInputChange"
+      options[:data][:lato_form_target] = 'input'
+    end
+
+    def lato_form_notices(options = {})
+      return unless notice
+
+      options[:class] ||= []
+      options[:class] += %w[alert alert-success]
+      options[:class] += %w[alert-dismissible fade show] unless options[:fixed]
+
+      content_tag :div, options do
+        concat notice
+        concat button_tag('', type: 'button', class: 'btn-close', data: { bs_dismiss: 'alert' }) unless options[:fixed]
+      end
+    end
+
+    def lato_form_errors(instance, options = {})
+      return unless instance.errors.any?
+
+      options[:class] ||= []
+      options[:class] += %w[alert alert-danger]
+      options[:class] += %w[alert-dismissible fade show] unless options[:fixed]
+
+      errors_list = content_tag(:ul, class: %w[mb-0 ps-3]) do
+        instance.errors.collect do |error|
+          content_tag :li, error.full_message
+        end.join.html_safe
+      end
+
+      content_tag :div, options do
+        concat content_tag(:span, 'Si sono verificati i seguenti errori:')
+        concat errors_list
+        concat button_tag('', type: 'button', class: 'btn-close', data: { bs_dismiss: 'alert' }) unless options[:fixed]
+      end
+    end
+
+    def lato_form_item_label(form, key, label = nil, options = {})
+      options[:class] ||= []
+      options[:class].push('form-label')
+
+      form.label key, label, options
+    end
+
+    def lato_form_item_input_text(form, key, options = {})
+      _lato_form_input_options(form, key, options, :keyup, 'form-control')
+
+      form.text_field key, options
+    end
+
+    def lato_form_item_input_email(form, key, options = {})
+      _lato_form_input_options(form, key, options, :keyup, 'form-control')
+
+      form.email_field key, options
+    end
+
+    def lato_form_item_input_password(form, key, options = {})
+      _lato_form_input_options(form, key, options, :keyup, 'form-control')
+
+      form.password_field key, options
+    end
+
+    def lato_form_item_input_check(form, key, label, options = {})
+      _lato_form_input_options(form, key, options, :change, 'form-check-input')
+
+      # TO-DO: Trovare il modo di calcolare l'id dato da rails a check_input_tag e metterlo nell'attributo :for di check_label_tag
+
+      content_tag :div, class: 'form-check' do
+        concat form.check_box(key, options)
+        concat label_tag(key, raw(label), class: 'form-check-label')
+      end
+    end
+
+    def lato_form_submit(form, label, options = {})
+      options[:class] ||= []
+      options[:class].push('btn')
+      options[:class].push('btn-primary')
+
+      options[:data] ||= {}
+      options[:data][:lato_form_target] = 'submit'
+
+      form.submit label, options
+    end
+
+    # Data
+    ##
+
+    def lato_data_badge(label, color = 'primary')
+      content_tag :span, label, class: "badge rounded-pill bg-#{color}"
+    end
+
+    def lato_data_user(label, image_url = nil)
+      image_url ||= image_path('lato/user-150x150')
+
+      content_tag :div, class: 'd-flex align-items-center' do
+        concat content_tag :div, '', class: 'border border-2 rounded-circle me-2', style: "background-position: center; background-size: cover; background-repeat: no-repeat; background-image: url(#{image_url}); width: 30px; height: 30px;"
+        concat content_tag :small, label, class: 'text-black'
+      end
+    end
+  end
+end

data/app/jobs/lato/application_job.rb

@@ -0,0 +1,59 @@
+module Lato
+  # ApplicationJob.
+  class ApplicationJob < ActiveJob::Base
+    around_perform :manage_operation
+
+    protected
+
+    def operation?
+      !!@operation
+    end
+
+    def update_operation_percentage(percentage)
+      return false unless operation?
+
+      @operation.update(
+        percentage: percentage
+      )
+
+      true
+    end
+
+    def save_operation_output_file(file_path)
+      return false unless operation?
+
+      file = File.open(file_path)
+      file_name = File.basename(file_path)
+      @operation.output_file.attach(
+        io: file,
+        filename: file_name
+      )
+
+      true
+    end
+
+    def save_operation_output_message(message)
+      return false unless operation?
+
+      @operation.update(
+        active_job_output: @operation.active_job_output.merge(_message: message)
+      )
+
+      true
+    end
+
+    private
+
+    def manage_operation
+      @operation = Lato::Operation.find(arguments.first[:_operation_id]) if arguments.first && arguments.first.is_a?(Hash) && !arguments.first[:_operation_id].blank?
+      @operation&.running
+
+      begin
+        yield
+        @operation&.completed
+      rescue StandardError => e
+        @operation&.failed(e.message)
+      end
+    end
+  end
+end

data/app/mailers/lato/application_mailer.rb

@@ -0,0 +1,6 @@
+module Lato
+  class ApplicationMailer < ActionMailer::Base
+    default from: Lato.config.email_from
+    layout 'lato/mailer'
+  end
+end

data/app/mailers/lato/user_mailer.rb

@@ -0,0 +1,23 @@
+module Lato
+  class UserMailer < ApplicationMailer
+    def email_verification_mail(user_id, code)
+      @user = Lato::User.find(user_id)
+      @code = code
+      mail(
+        to: @user.email,
+        subject: 'Conferma il tuo indirizzo email',
+        template_path: 'lato/mailer/user'
+      )
+    end
+
+    def password_update_mail(user_id, code)
+      @user = Lato::User.find(user_id)
+      @code = code
+      mail(
+        to: @user.email,
+        subject: 'Imposta una nuova password',
+        template_path: 'lato/mailer/user'
+      )
+    end
+  end
+end

data/app/models/lato/application_record.rb

@@ -0,0 +1,5 @@
+module Lato
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/lato/operation.rb

@@ -0,0 +1,96 @@
+module Lato
+  class Operation < ApplicationRecord
+    enum status: {
+      created: 0,
+      running: 1,
+      completed: 2,
+      failed: 3
+    }, _suffix: true
+
+    has_one_attached :input_file
+    has_one_attached :output_file
+
+    # Hooks
+    ##
+
+    before_create do
+      self.status = :created
+      self.active_job_input ||= {}
+      self.active_job_output ||= {}
+    end
+
+    # Questions
+    ##
+
+    def finished?
+      completed_status? || failed_status?
+    end
+
+    def output_message?
+      active_job_output && !active_job_output['_message'].blank?
+    end
+
+    def output_error?
+      active_job_output && !active_job_output['_error'].blank?
+    end
+
+    def output_file?
+      output_file.attached?
+    end
+
+    # Helpers
+    ##
+
+    def output_error
+      active_job_output['_error']
+    end
+
+    def output_message
+      active_job_output['_message']
+    end
+
+    # Operations
+
+    def start
+      begin
+        active_job_name.constantize.perform_later(active_job_input.merge(_operation_id: id))
+      rescue StandardError
+        errors.add(:base, 'Impossibile eseguire il job')
+        return false
+      end
+
+      true
+    end
+
+    def running
+      update(status: :running)
+    end
+
+    def failed(error = nil)
+      update(
+        status: :failed,
+        closed_at: Time.now,
+        active_job_output: error ? active_job_output.merge(_error: error) : active_job_output
+      )
+    end
+
+    def completed(message = nil)
+      update(
+        status: :completed,
+        closed_at: Time.now,
+        active_job_output: message ? active_job_output.merge(_message: message) : active_job_output
+      )
+    end
+
+    # Class
+    ##
+
+    def self.generate(active_job_name, active_job_input = {}, user_id = nil)
+      Operation.create(
+        active_job_name: active_job_name,
+        active_job_input: active_job_input,
+        lato_user_id: user_id
+      )
+    end
+  end
+end

data/app/models/lato/session.rb

@@ -0,0 +1,36 @@
+module Lato
+  class Session
+    def initialize(session)
+      @session = session
+    end
+
+    # Questions
+    ##
+
+    def valid?
+      !@session.blank?
+    end
+
+    def really_valid?
+      !!user
+    end
+
+    # Helpers
+    ##
+
+    def user
+      @user ||= Lato::User.find_by(id: @session)
+    end
+
+    def user_id
+      @session
+    end
+
+    # Class
+    ##
+
+    def self.generate_session_per_user(user_id)
+      user_id
+    end
+  end
+end