lesli 5.0.4 → 5.0.5

data/app/controllers/lesli/shared/dashboards_controller.rb

@@ -0,0 +1,308 @@
+=begin
+
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Ruby on Rails SaaS Development Framework.
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+=end
+module Lesli
+    module Shared
+        class DashboardsController < ApplicationLesliController
+            before_action :set_dashboard, only: [:show, :update, :destroy, :options]
+
+            def index
+                respond_to do |format|
+                    format.html {}
+                    format.json do
+                        dynamic_info = self.class.dynamic_info
+                        model = dynamic_info[:model]
+
+                        dashboards = model.list(current_user, @query)
+                        respond_with_successful(dashboards)
+                    end
+                end
+            end
+
+            def show
+                respond_to do |format|
+                    format.html {}
+                    format.json do
+                        return respond_with_not_found unless @dashboard
+                        respond_with_successful(@dashboard.show)
+                    end
+                end
+            end
+
+            def new
+            end
+
+            def edit
+            end
+
+            # @controller_action_param :name [String] The name of the new dashboard
+            # @controller_action_param :default [Boolean] A flag that marks this dashboard as default or not. The default dashboard is the dashboard all users will have access to on the root page
+            # @controller_action_param :main    [Boolean] A flag that marks this dashboard as main. Since a user can have multiple dashboards, this is the one they will see on the root page when loging in
+            # @controller_action_param :roles_id [Integer] The id of the role that will have access to this dashboard
+            # @controller_action_param :user_main_id [Integer] The id of the user 
+            # @controller_action_param :component_attributes [Array] Array of hashes that represent the attributes of the dashboard components
+            # @controller_action_param :component_attributes.name [String] The name of this component given to the user
+            # @controller_action_param :component_attributes.component_id [String] An enum value, that indicates which component is being loaded
+            # @controller_action_param :component_attributes.layout [Integer] Number from 1 to 12, bigger numbers default to 12, smallest numbers default to 1. The column size that the UI component will use
+            # @controller_action_param :component_attributes.index [Integer] The position of the component in the layout
+            # @controller_action_param :component_attributes.configuration [Hash] Specific filtering and configuration of the components
+            # @return [Json] Json that contains wheter the creation of the dashboard was successful or not. 
+            #     If it is not successful, it returns an error message
+            # @description Creates a new dashboard associated to the *current_user*'s *account*
+            # @example
+            # # Executing this controller's action from javascript's frontend
+            #     let data = {
+            #         dashboard: {
+            #             name: "Sales Dashboard",
+            #             default: false,
+            #             roles_id: 3,
+            #             components_attributes: [
+            #                 {
+            #                     name: 'Projects Count',
+            #                     component_id: projects_component,
+            #                     layout: 4,
+            #                     index: 3,
+            #                     configuration: {}
+            #                 }, {
+            #                     name: 'New Customers Count',
+            #                     component_id: new_customers_component,
+            #                     layout: 4,
+            #                     index: 3,
+            #                     configuration: {}
+            #                 }
+            #             ]
+            #         }
+            #     };
+            #     this.http.post('127.0.0.1/help/dashboards', data);
+            def create
+                dynamic_info = self.class.dynamic_info
+                module_name = dynamic_info[:module_name]
+                model = dynamic_info[:model]
+                full_module_name = dynamic_info[:full_module_name].underscore
+
+                dashboard = model.new(dashboard_params)
+                dashboard["#{full_module_name}_account_id".to_sym] = current_user.account.id
+                dashboard.user_creator = current_user
+
+                if dashboard.save
+                    respond_with_successful(dashboard)
+                else
+                    respond_with_error(dashboard.errors.full_messages.to_sentence)
+                end
+            end
+
+            # @controller_action_param :name [String] The name of the new dashboard
+            # @controller_action_param :default [Boolean] A flag that marks this dashboard as default or not. The default dashboard is the dashboard all users will have access to on the root page
+            # @controller_action_param :main    [Boolean] A flag that marks this dashboard as main. Since a user can have multiple dashboards, this is the one they will see on the root page when loging in
+            # @controller_action_param :roles_id [Integer] The id of the role that will have access to this dashboard
+            # @controller_action_param :user_main_id [Integer] The id of the user 
+            # @controller_action_param :component_attributes [Array] Array of hashes that represent the attributes of the dashboard components
+            # @controller_action_param :component_attributes.name [String] The name of this component given to the user
+            # @controller_action_param :component_attributes.component_id [String] An enum value, that indicates which component is being loaded
+            # @controller_action_param :component_attributes.layout [Integer] Number from 1 to 12, bigger numbers default to 12, smallest numbers default to 1. The column size that the UI component will use
+            # @controller_action_param :component_attributes.index [Integer] The position of the component in the layout
+            # @controller_action_param :component_attributes.configuration [Hash] Specific filtering and configuration of the components
+            # @return [Json] Json that contains wheter the dashboard was successfully updated or not. 
+            #     If it it not successful, it returns an error message
+            # @description Updates an existing dashboard associated to the *current_user*'s *account*.
+            # @example
+            # # Executing this controller's action from javascript's frontend
+            # let dashboard_id = 4;
+            # let data = {
+            #     dashboard: {
+            #         name: "Sales Dashboard",
+            #         default: false,
+            #         roles_id: 3,
+            #         components_attributes: [
+            #             {
+            #                 name: 'Projects Count',
+            #                 component_id: projects_component,
+            #                 layout: 4,
+            #                 index: 3,
+            #                 configuration: {}
+            #             }, {
+            #                 name: 'New Customers Count',
+            #                 component_id: new_customers_component,
+            #                 layout: 4,
+            #                 index: 3,
+            #                 configuration: {}
+            #             }
+            #         ]
+            #     }
+            # };
+            # this.http.put(`127.0.0.1/help/dashboards/${dashboard_id}`, data);
+            def update
+                return respond_with_not_found unless @dashboard
+
+                if @dashboard.update(dashboard_params)
+                    respond_with_successful(@dashboard.show)
+                else
+                    respond_with_error(@dashboard.errors.full_messages.to_sentence)
+                end
+            end
+
+            # @return [Json] Json that contains wheter the dashboard was successfully deleted or not. 
+            #     If it it not successful, it returns an error message
+            # @description Deletes an existing *dashboard* associated to the *current_user*'s *account*.
+            #     Since the dashboard has details, these are also deleted. However, if there
+            #     is an existing *cloud_object* associated to the *dashboard*, it cannot be deleted
+            # @example
+            #     # Executing this controller's action from javascript's frontend
+            #     let dashboard_id = 4;
+            #     this.http.delete(`127.0.0.1/help/dashboards/${dashboard_id}`);
+            def destroy
+                return respond_with_not_found unless @dashboard
+
+                if @dashboard.destroy
+                    respond_with_successful
+                else
+                    respond_with_error(@dashboard.errors.full_messages.to_sentence)
+                end
+            end
+
+            def options
+                dynamic_info = self.class.dynamic_info
+                model = dynamic_info[:module_model]
+
+                respond_with_successful(model.options(current_user, @query))
+            end
+
+            def resource_component
+                dynamic_info = self.class.dynamic_info
+                component_model = dynamic_info[:component_model]
+
+                component_id = sanitize(params[:component_id].to_sym)
+
+                # We verify if the method exists, and if it is in the available component list
+                if component_model.respond_to?(component_id) && component_model.component_ids[component_id]
+                    respond_with_successful(component_model.public_send(component_id, current_user, @query))
+                else
+                    respond_with_not_found()
+                end
+            end
+
+            private
+
+            # @return [void]
+            # @description Sets the variable @dashboard. The variable contains the *cloud_object* *dashboard* 
+            #     to be handled by the controller action that called this method
+            # @example
+            #     #suppose params[:id] = 1
+            #     puts @dashboard # will display nil
+            #     set_dashboard
+            #     puts @dashboard # will display an instance of CloudHelp:TicketDashboard
+            def set_dashboard
+                dynamic_info = self.class.dynamic_info
+
+                model = dynamic_info[:module_model]
+                module_name = dynamic_info[:module_name]
+                module_name_full = dynamic_info[:module_name_full].underscore
+
+                # When params[:id] is 'default' order of priority is:
+                # Main dashboard for user goes first
+                # Main dashboard for role goes second
+                # Default dashboard goes third
+                if params[:id] == "default"
+                    # Main dashboard for user
+                    @dashboard = model.find_by(
+                        #"#{full_module_name}_account_id".to_sym => current_user.account.id,
+                        account_id: current_user.account.id,
+                        main: true,
+                        #user_main_id: current_user.id
+                    )
+
+                    return if @dashboard
+                    
+                    # Main dashboard for role
+                    # @dashboard = model.find_by(
+                    #     :account_id => current_user.account.id,
+                    #     role_id: current_user.roles.first.id
+                    # )
+                    # return if @dashboard
+
+                    # Default dashboard
+                    @dashboard = model.find_by(
+                        account_id: current_user.account.id,
+                        default: true
+                    )
+                else
+                    @dashboard = model.find_by(
+                        id: params[:id],
+                        :account_id => current_user.account.id,
+                    )
+                end
+            end
+
+            def dashboard_params
+                params.require(:dashboard).permit(
+                    :name,
+                    :default,
+                    :roles_id,
+                    components_attributes: [
+                        :id,
+                        :name,
+                        :component_id,
+                        :layout,
+                        :index,
+                        {query_configuration: {}},
+                        {custom_configuration: {}},
+                        :_destroy
+                    ]
+                )
+            end
+
+            private
+
+            # Build the Rails models and engine information for 
+            # the current engine implementing the shared dashboards
+            # Example: For the LesliAudit engine
+            # {
+            #     :module_name => "audit", 
+            #     :module_name_full => "LesliAudit", 
+            #     :module_model => "LesliAudit::Dashboard", 
+            #     :module_model_component => "LesliAudit::Dashboard::Component"
+            # }
+            def self.dynamic_info
+
+                module_info = self.name.split("::")
+
+                module_name = module_info[0].sub("Lesli", "").downcase
+                
+                {
+                    module_name: module_name,
+                    module_name_full: module_info[0],
+                    module_model: "#{ module_info[0] }::Dashboard".constantize,
+                    module_model_component: "#{ module_info[0] }::Dashboard::Component".constantize
+                }
+            end
+        end
+    end
+end

data/app/controllers/users/confirmations_controller.rb

@@ -25,7 +25,7 @@ class Users::ConfirmationsController < Devise::ConfirmationsController
         # register a log with a validation atempt for the user
         log = user.logs.create({ description: "confirmation_atempt_successful" })
 
-        registration_operator = Lesli::User::RegistrationOperator.new(user)
+        registration_operator = Lesli::UserRegistrationOperator.new(user)
 
         # confirm the user
         registration_operator.confirm

data/app/controllers/users/passwords_controller.rb

@@ -34,16 +34,13 @@ class Users::PasswordsController < Devise::PasswordsController
 
         #user.logs.create({ title: "password_creation_successful" })
 
-        # begin
-        #     #UserMailer.with(user: user, token: token).reset_password_instructions.deliver_now
-             #super()
-        Lesli::DeviseMailer.reset_password_instructions(user, token)
-        respond_with_successful
-        # rescue => exception
-        #     #Honeybadger.notify(exception)
-        #     respond_with_error(exception.message)
-        # end
-
+        begin
+            Lesli::DeviseMailer.reset_password_instructions(user, token).deliver_now
+            respond_with_successful
+        rescue => exception
+            #Honeybadger.notify(exception)
+            respond_with_error(exception.message)
+        end
     end
 
     def update

data/app/helpers/lesli/general_helper.rb

@@ -35,7 +35,7 @@ module Lesli
     module GeneralHelper
         # build a url path to change locales
         def language_url(locale)
-            "/language?locale=#{locale}"
+            "/lesli/language?locale=#{locale}"
         end
 
         # return flag code according to locale code

data/app/helpers/lesli/navigation_helper.rb

@@ -32,6 +32,14 @@ Building a better future, one line of code at a time.
 
 module Lesli
     module NavigationHelper
+
+        # Prints a separator line
+        def navigation_separator
+            content_tag(:li) do
+                content_tag(:hr)
+            end
+        end
+
         # Prints a html link inside a list item
         def navigation_item(path, label, icon = nil, reload: false)
             # default vue router links for single page applications
@@ -58,15 +66,9 @@ module Lesli
             end
         end
 
-        # Prints a separator line
-        def navigation_separator
-            content_tag(:li) do
-                content_tag(:hr)
-            end
-        end
-
         # 00.00 System administration
         def navigation_engine_admin(title: "Administration", subtitle: "Users, privileges, access roles.")
+            return unless defined? LesliAdmin
             navigation_engine_item(title, subtitle, "admin", lesli_admin.root_path, controller_path.include?("lesli_admin"))
         end
 
@@ -243,10 +245,10 @@ module Lesli
 
         # 07.02 Help engine
         def navigation_engine_help(title: "Help", subtitle: "Support Ticket System")
-            return unless defined? CloudHelp
+            return unless defined? LesliHelp
 
-            navigation_engine_item(title, subtitle, "help", cloud_help.root_path,
-                                   controller_path.include?("cloud_help"))
+            navigation_engine_item(title, subtitle, "help", lesli_help.root_path,
+                                   controller_path.include?("lesli_help"))
         end
 
         # 07.03 Portal engine
@@ -267,12 +269,11 @@ module Lesli
 
         # SECURITY & PRIVACY
 
-        # 08.01 Vault engine
-        def navigation_engine_vault(title: "Vault", subtitle: "")
-            return unless defined? LesliVault
-
-            navigation_engine_item(title, subtitle, "vault", lesli_vault.root_path,
-                                    controller_path.include?("lesli_vault"))
+        # 08.01 Guard engine
+        def navigation_engine_guard(title: "Guard", subtitle: "Users, privileges and access roles.")
+            return unless defined? LesliGuard
+            navigation_engine_item(title, subtitle, "guard", lesli_guard.root_path,
+                                    controller_path.include?("lesli_guard"))
         end
 
         # 08.03 Audit engine

data/app/lib/lesli/system.rb

@@ -88,7 +88,8 @@ module Lesli
             "LesliAudit", 
             "LesliBell", 
             "LesliDriver",
-            "LesliVault"
+            "LesliGuard",
+            "LesliHelp"
         ]
     end
 end

data/app/mailers/lesli/devise_mailer.rb

@@ -17,7 +17,7 @@ module Lesli
             }
 
             # send email
-            email(
+            pp email(
                 params,
                 to: user.email, 
                 subject: email_subject,

data/app/models/concerns/account_initializer.rb

@@ -79,6 +79,15 @@ module AccountInitializer
             end
         end
 
+        # 07.02 LesliHelp - Support Ticket System
+        if defined? LesliHelp
+            if self.help.blank?
+                self.help = LesliHelp::Account.new
+                self.help.account = self
+                self.help.save!
+            end
+        end
+
         # 08.03 LesliAudit - System analytics
         if defined? LesliAudit
             if self.audit.blank?

data/app/models/lesli/account.rb

@@ -54,6 +54,7 @@ module Lesli
         has_many :currencies
         has_many :logs
 
+        has_one :help, class_name: "LesliHelp::Account"
         has_one :audit, class_name: "LesliAudit::Account"
         has_one :admin, class_name: "LesliAdmin::Account"
         has_one :driver, class_name: "LesliDriver::Account"

data/app/models/lesli/application_lesli_record.rb

@@ -31,7 +31,7 @@ Building a better future, one line of code at a time.
 =end
 
 module Lesli 
-    class ApplicationLesliRecord < ApplicationRecord
+    class ApplicationLesliRecord < ActiveRecord::Base
         self.abstract_class = true
         acts_as_paranoid
     end

data/app/models/lesli/shared/dashboard.rb

@@ -0,0 +1,162 @@
+=begin
+
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Your Smart Business Assistant. 
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·
+
+=end
+
+module Lesli
+    module Shared
+        class Dashboard < ::Lesli::ApplicationLesliRecord
+            self.abstract_class = true
+
+            belongs_to :user_creator, class_name: "User", foreign_key: "users_id", optional: true
+
+            after_update :verify_default_dashboard
+            after_create :verify_default_dashboard
+
+            enum component_ids: {}
+
+            # @return [void]
+            # @param account [LesliEngine::Account]
+            # @description Initializes a default dummy dashboard for the account. This guarantees that the users
+            #     will be able to access the dashboard page. Even if it's empty.
+            # @example
+            #     # Imagine you are adding a new engine to your instance (CloudProposal)
+            #     # To execute this function, you must only do
+            #     my_account = Account.first
+            #     my_account.proposal = CloudProposal::Account.new
+            def self.initialize_data(account)
+                self.create!(
+                    account: account,
+                    name: "Default Dashboard",
+                    default: true,
+                    main: false
+                )
+            end
+
+            # @return [Hash] Hash of containing the information of the dashboard and its components.
+            # @description Returns a hash with information about the dashboard and all its *components*.
+            #     Each component is returned in the configuration view, not the render view. This means that
+            #     this method is ment to be used when updating the dashboard
+            # @example
+            #     respond_with_successful(CloudHelp::Dashboard.first.show)
+            def show
+                attributes.merge({
+                    components: components.order(index: :asc)
+                    # components: [{
+                    #     name: "ticket",
+                    #     component_id: "ticket"
+                    # },{
+                    #     name: "ticket",
+                    #     component_id: "ticket"
+                    # }]
+                })
+            end
+
+            # @return [Hash] Hash containing the options to create and manage dashboards
+            # @param current_user [User] The user that made this request
+            # @param query [Hash] Query containing filters. Currently unused, but required
+            # @descriptions Returns a list of options needed to create and manage dashboard components. For now,
+            #     the returned options are: A list of roles, the enoun containing the component_ids, generic configuration options
+            #     for all dashboad components and a descriptions hash, that contains brief descriptions for each component to help
+            #     the user understand what each component does. Any class that inherits from this one can send a block to add extra
+            #     functionality. For example, the descriptions must be implemented directly from the engine.
+            # @example
+            #         CloudHouse::Dashboard.options(User.find(2), nil)
+            def self.options(current_user, query)
+                dynamic_info = self.dynamic_info
+                component_model = dynamic_info[:module_model_component]
+
+                component_ids = component_model.component_ids.map do |comp|
+                    {
+                        value: comp,
+                        text: comp
+                    }
+                end
+
+                options = {
+                    component_ids: component_ids,
+                    #components_configuration_options: component_model.configuration_options,
+                    descriptions: {}
+                }
+
+                if block_given?
+                    yield(options)
+                else
+                    return options
+                end
+            end
+
+            private
+
+            # @return [void]
+            # @descriptions This is an after_updated and after_create method that validates that at any moment in time, there is only
+            #     one default dashboard in the engine. If there is another default dashboard, it's *default* field is set to false
+            #     before committing the changes
+            # @example
+            #     CloudFocus::Dasbhoard.where(default: false).first.update!(default: true)
+            #     # This will automatically trigger this function and remove the *default* field from the old default dashboard
+            def verify_default_dashboard
+                if default
+                    dashboards = self.class.where.not(id: id).where(account: account)
+                    self.class.where.not(id: id).where(account: account).update_all(default: false)
+                end
+    
+                unless self.class.where(account: account).find_by(default: true)
+                    errors.add(:base, I18n.t("core.dashboards.messages_danger_default_dashboard_must_exist"))
+                    raise ActiveRecord::Rollback
+                end
+            end
+
+            # Build the Rails models and engine information for 
+            # the current engine implementing the shared dashboards
+            # Example: For the LesliAudit engine
+            # {
+            #     :module_name => "audit", 
+            #     :module_name_full => "LesliAudit", 
+            #     :module_model => "LesliAudit::Dashboard", 
+            #     :module_model_component => "LesliAudit::Dashboard::Component"
+            # }
+            def self.dynamic_info
+
+                module_info = self.name.split("::")
+
+                module_name = module_info[0].sub("Lesli", "").downcase
+                
+                {
+                    module_name: module_name,
+                    module_name_full: module_info[0],
+                    module_model: "#{ module_info[0] }::Dashboard".constantize,
+                    module_model_component: "#{ module_info[0] }::Dashboard::Component".constantize
+                }
+            end
+        end
+    end
+end

data/app/models/lesli/system_controller.rb

@@ -85,6 +85,7 @@ module Lesli
                     cc[engine][controller] = { 
                         id: c[:controller_id], 
                         name: c[:controller_name], 
+                        route: c[:route], 
                         actions: []
                     } 
                 end