lato_core 1.1.5 → 2.1

data/app/cells/lato_core/inputs/textarea/views/show.html.erb

@@ -0,0 +1,16 @@
+<div class="inputs-textarea inputs__container <%= @args[:class] %>">
+
+  <%= render '../../shared/label.html' %>
+
+  <textarea
+    class="inputs__textarea"
+    name="<%= @args[:name] %>"
+    placeholder="<%= @args[:placeholder] %>"
+    data-required="<%= @args[:required] %>"
+    data-max-length="<%= @args[:max_length] %>"
+    data-min-length="<%= @args[:min_length] %>"
+  /><%= @args[:value] %></textarea>
+
+  <%= render '../../shared/help.html' %>
+  
+</div>

data/app/cells/lato_core/widgets/index/cell.rb

@@ -0,0 +1,215 @@
+# TODO: Write the component in a better way.
+
+module LatoCore
+
+  class Widgets::Index::Cell < Cell
+
+    @@requested_args = [:records]
+
+    @@default_args = {
+      head: [],
+      columns: [],
+      index_url: nil,
+      pagination: false,
+      search: false,
+      actions: {
+        show: false,
+        edit: false,
+        delete: false,
+        new: false
+      }
+    }
+
+    def initialize(args = {})
+      @args = validate_args(
+        args: args,
+        requested_args: @@requested_args,
+        default_args: @@default_args
+      )
+
+      set_conditions
+    end
+
+    def show
+      render 'show.html'
+    end
+
+    private
+
+      def set_conditions
+        @records = @args[:records].is_a?(Hash) ? @args[:records][:records] : @args[:records]
+        # conditions for show
+        @show_row_actions = @args[:index_url] && @args[:actions] && (@args[:actions][:show] || @args[:actions][:edit] || @args[:actions][:delete])
+        @show_row_actions_class = @show_row_actions ? 'widgets-index--actions' : ''
+        @show_search = @args[:index_url] && @args[:search]
+        @show_pagiantion = @args[:index_url] && @args[:pagination]
+        @show_new_action = @args[:index_url] && @args[:actions] && @args[:actions][:new]
+        # generate table components
+        @table = generate_table
+        @table_head = generate_table_head
+        @table_body = generate_table_body
+        @table_rows = generate_table_rows
+        # generate search components
+        @search_form = generate_search_form if @show_search
+        @search_input = generate_search_input if @show_search
+        @search_submit = generate_search_submit if @show_search
+        @search_params = generate_search_params if @show_search
+        # generate action components
+        @action_new_button = generate_new_button if @show_new_action
+        # generate pagination components
+        @pagination = generate_pagination if @show_pagiantion
+      end
+
+      # Table generation:
+
+      # This function generate the table.
+      def generate_table
+        return LatoCore::Elements::Table::Container::Cell.new
+      end
+
+      # This function generate the head for the table.
+      def generate_table_head
+        labels = []
+
+        if @args[:head] && @args[:head].length > 0
+          # manage case with custom head
+          labels = @args[:head]
+          labels.push(LANGUAGES[:lato_core][:mixed][:actions]) if @show_row_actions
+        elsif @records && @records.length > 0
+          # manage case without custom head
+          labels = @records.first.attributes.keys.map {|s| s.gsub('_', ' ')}
+          labels = labels.map(&:capitalize)
+          labels.push(LANGUAGES[:lato_core][:mixed][:actions]) if @show_row_actions
+        end
+
+        return LatoCore::Elements::Table::Head::Cell.new(labels: labels)
+      end
+
+      # This function generate the table body.
+      def generate_table_body
+        return LatoCore::Elements::Table::Body::Cell.new
+      end
+
+      # This function generate the rows fr the table.
+      def generate_table_rows
+        table_rows = []
+
+        if @args[:columns] && @args[:columns].length > 0
+          # manage case with custom columns
+          table_rows = generate_table_rows_from_columns_functions(@args[:columns])
+        elsif @records && @records.length > 0
+          # manage case without custom columns
+          table_rows = generate_table_rows_from_columns_functions(@records.first.attributes.keys)
+        end
+
+        return table_rows
+      end
+
+      # This function generate the rows for a list of columns.
+      def generate_table_rows_from_columns_functions columns_functions
+        table_rows = []
+
+        @records.each do |record|
+          labels = []
+          # add function result to row columns
+          columns_functions.each do |column_function|
+            labels.push(record.send(column_function))
+          end
+          # add actions to row columns
+          if @show_row_actions
+            labels.push(generate_actions_bottongroup_for_record(record))
+          end
+          # puts rows on table rows
+          table_rows.push(LatoCore::Elements::Table::Row::Cell.new(labels: labels))
+        end
+
+        return table_rows
+      end
+
+      # This function generate row actions for a table row.
+      def generate_actions_bottongroup_for_record record
+        action_buttons = []
+        action_buttons.push(generate_show_button(record.id)) if @args[:actions][:show]
+        action_buttons.push(generate_edit_button(record.id)) if @args[:actions][:edit]
+        action_buttons.push(generate_delete_button(record.id)) if @args[:actions][:delete]
+        return LatoCore::Elements::Buttongroup::Cell.new(buttons: action_buttons)
+      end
+
+      # Actions generation:
+
+      # This function generate the show button for a record.
+      def generate_show_button record_id
+        return unless @args[:index_url]
+        url = @args[:index_url].end_with?('/') ? "#{@args[:index_url].gsub(/\?.*/, '')}#{record_id}" : "#{@args[:index_url].gsub(/\?.*/, '')}/#{record_id}"
+        return LatoCore::Elements::Button::Cell.new(label: LANGUAGES[:lato_core][:mixed][:show], url: url, style: 'info', icon: 'eye')
+      end
+
+      # This function generate the edit button for a record.
+      def generate_edit_button record_id
+        return unless @args[:index_url]
+        url = @args[:index_url].end_with?('/') ? "#{@args[:index_url].gsub(/\?.*/, '')}#{record_id}/edit" : "#{@args[:index_url].gsub(/\?.*/, '')}/#{record_id}/edit"
+        return LatoCore::Elements::Button::Cell.new(label: LANGUAGES[:lato_core][:mixed][:edit], url: url, style: 'warning', icon: 'pencil')
+      end
+
+      # This function generate the delete button for a record.
+      def generate_delete_button record_id
+        return unless @args[:index_url]
+        url = @args[:index_url].end_with?('/') ? "#{@args[:index_url].gsub(/\?.*/, '')}#{record_id}" : "#{@args[:index_url].gsub(/\?.*/, '')}/#{record_id}"
+        return LatoCore::Elements::Button::Cell.new(label: LANGUAGES[:lato_core][:mixed][:delete], url: url, method: 'delete',
+        icon: 'trash', style: 'danger', confirmation: {
+          message: LANGUAGES[:lato_core][:mixed][:default_delete_message],
+          positive_response: LANGUAGES[:lato_core][:mixed][:default_delete_positive_response],
+          negative_response: LANGUAGES[:lato_core][:mixed][:default_delete_negative_response]
+        })
+      end
+
+      # This function generate new button.
+      def generate_new_button
+        return unless @args[:index_url]
+        url = "#{@args[:index_url].gsub(/\?.*/, '')}/new"
+        return LatoCore::Elements::Button::Cell.new(label: LANGUAGES[:lato_core][:mixed][:new],
+        url: url, icon: 'plus')
+      end
+
+      # Search generation:
+
+      # This function generate a form for the index.
+      def generate_search_form
+        return unless @args[:index_url]
+        return LatoCore::Inputs::Form::Cell.new(url: @args[:index_url], method: 'get')
+      end 
+
+      # This function generate and return the search input.
+      def generate_search_input
+        search_placeholder = @args[:records].is_a?(Hash) ? @args[:records][:search_key].humanize : ''
+        search_value = @args[:records].is_a?(Hash) ? @args[:records][:search] : ''
+        return LatoCore::Inputs::Text::Cell.new(name: 'widget_index[search]', value: search_value, placeholder: search_placeholder)
+      end
+
+      # This function generate the search submit button.
+      def generate_search_submit
+        return LatoCore::Elements::Button::Cell.new(label: ' ', icon: 'search', type: 'submit', icon_align: 'right')
+      end
+
+      # This function generate a list of params the need to be set on the search form.
+      def generate_search_params
+        return Rack::Utils.parse_query URI(@args[:index_url]).query
+      end
+
+      # Pagination generation:
+
+      def generate_pagination
+        total_records = @args[:records].is_a?(Hash) ? @args[:records][:total] : @args[:records].length
+        total_records_per_page = @args[:records].is_a?(Hash) ? @args[:records][:per_page] : @args[:records].length
+        total_pages = (total_records.to_f / total_records_per_page.to_f).ceil
+        current_page = @args[:records].is_a?(Hash) ? @args[:records][:pagination] : 1
+        search_value = @args[:records].is_a?(Hash) ? @args[:records][:search] : ''
+
+        url = core__add_param_to_url(@args[:index_url], 'widget_index[search]', search_value)
+        return LatoCore::Elements::Pagination::Cell.new(total: total_pages, current: current_page, url: url,
+        param: 'widget_index[pagination]')
+      end
+
+  end
+
+end

data/app/cells/lato_core/widgets/index/views/partials/new.html.erb

@@ -0,0 +1,3 @@
+<div class="widgets-index__new-action">
+  <%= @action_new_button %>
+</div>

data/app/cells/lato_core/widgets/index/views/partials/pagination.html.erb

@@ -0,0 +1,3 @@
+<div class="widgets-index__pagination">
+  <%= @pagination.show %>
+</div>

data/app/cells/lato_core/widgets/index/views/partials/search.html.erb

@@ -0,0 +1,17 @@
+<div class="widgets-index__search">
+
+  <%= @search_form.open %>
+
+    <!-- MANTAIN OLD PARAMS -->
+    <% @search_params.each do |key, value| %>
+      <input type="hidden" name="<%= key %>" value="<%= value %>">
+    <% end %>
+    <!-- / MANTAIN OLD PARAMS -->
+  
+    <%= @search_input.show %>
+
+    <%= @search_submit.show %>
+
+  <%= @search_form.close %>
+  
+</div>

data/app/cells/lato_core/widgets/index/views/show.html.erb

@@ -0,0 +1,45 @@
+<div class="widgets-index <%= @show_row_actions_class %>">
+
+  <% if @show_search || @show_new_action %>
+
+    <div class="widgets-index__head">
+
+      <% if @show_search %>
+
+        <%= render './partials/search.html' %>
+
+      <% end %>
+
+      <% if @show_new_action %>
+
+        <%= render './partials/new.html' %>
+
+      <% end %>
+
+    </div>
+
+  <% end %>
+
+  <%=raw @table.open %>
+
+    <%=raw @table_head.show %>
+
+    <%=raw @table_body.open %>
+
+    <% @table_rows.each do |table_row| %>
+
+      <%=raw table_row.show %>
+
+    <% end %>
+
+    <%=raw @table_body.close %>
+
+  <%=raw @table.close %>
+  
+  <% if @show_pagiantion %>
+
+    <%= render './partials/pagination.html' %>
+
+  <% end %>
+
+</div>

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

@@ -0,0 +1,5 @@
+module LatoCore
+  class Api::ApiController < ApplicationController
+
+  end
+end

data/app/controllers/lato_core/application_controller.rb

@@ -1,6 +1,14 @@
 module LatoCore
-  # This class is the main controller class of lato_core.
+
+  # ApplicationController
   class ApplicationController < ActionController::Base
 
+    protect_from_forgery with: :exception
+
+    def index
+      redirect_to lato_core.dashboard_path
+    end
+
   end
+
 end

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

@@ -1,115 +1,49 @@
 module LatoCore
-  module Back
-    # This class is used for authentication actions.
-    class AuthenticationController < Back::BackController
 
-      # not use login check for actions on this controller.
-      skip_before_action :core_controlUser, except: [:exec_logout]
+  # AuthenticationController
+  class Back::AuthenticationController < Back::BackController
 
-      # This function render login view if user is not logged.
-      def login
-        redirect_to lato_core.root_path if core_controlSession
-      end
+    layout 'lato_core/authentication'
 
-      # This function exec the login for user using username and password.
-      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
+    skip_before_action :core__manage_superuser_session
 
-      # This function exec the logout for user and redirect it to login page.
-      def exec_logout
-        core_destroySession
-        redirect_to lato_core.login_path
-      end
+    def index
+      redirect_to lato_core.dashboard_path if core__check_superuser_session_valid
+    end
 
-      # This function render the password forget view if user active this
-      # action on config file.
-      def password_forget
-        redirect_to lato_core.root_path unless core_getRecoveryPasswordPermission
-        redirect_to lato_core.root_path if core_controlSession
-      end
+    def exec_login
+      @superuser = LatoCore::Superuser.find_by(username: params[:username])
+      return unless check_superuser_exist
 
-      # This function exec the recover password action and send the email to
-      # user for new password.
-      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
+      # check superuser is authenticated
+      unless @superuser.authenticate(params[:password])
+        flash[:danger] = LANGUAGES[:lato_core][:flashes][:uncorrect_password]
         redirect_to lato_core.login_path
+        return
       end
 
-      # This function render the edit view for user who ask to recover
-      # its password (and check if it can do this action).
-      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
+      # save user login on database and create session
+      @superuser.save_login(request.remote_ip)
+      core__create_superuser_session(@superuser, 1.days.from_now)
+      redirect_to lato_core.dashboard_path
+    end
 
-      # This function ecec the password update after the recovery request.
-      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
+    def exec_logout
+      core__destroy_superuser_session
+      flash[:success] = LANGUAGES[:lato_core][:flashes][:logout_success]
+      redirect_to lato_core.login_path
+    end
 
-        flash[:success] = CORE_LANG['recover_password']['recover_success']
-        redirect_to lato_core.login_path
-      end
+    private
 
+    def check_superuser_exist
+      return true if @superuser
+
+      flash[:danger] = LANGUAGES[:lato_core][:flashes][:user_not_found]
+      redirect_to lato_core.login_path
+      false
     end
+
   end
+
 end