lesli 5.0.11 → 5.0.13

data/app/models/concerns/account_initializer.rb

@@ -37,24 +37,41 @@ module AccountInitializer
     # initialize minimum resources needed for the account
     def initialize_account
 
+        return unless defined?(LesliSecurity)
+
         # create initial descriptors
         descriptor_owner = self.descriptors.find_or_create_by(name: "owner")
         descriptor_admin = self.descriptors.find_or_create_by(name: "admin")
         descriptor_profile = self.descriptors.find_or_create_by(name: "profile")
 
         # create default roles for the new account
-        owner = self.roles.create({ name: "owner", active: true, object_level_permission: 2147483647 })
+        owner = self.roles.create_with({
+            active: true, 
+            object_level_permission: 2147483647
+        }).find_or_create_by(:name => "owner")
 
         # platform administrator role
-        admin = self.roles.create({ name: "admin", active: true, object_level_permission: 100000 })
+        admin = self.roles.create_with({
+            active: true, object_level_permission: 100000
+        }).find_or_create_by({ name: "admin" })
 
         # access only to user profile
-        limited = self.roles.create({ name: "limited", active: true, object_level_permission: 10, path_default: "/administration/profile" })
+        limited = self.roles.create_with({
+            active: true, object_level_permission: 10, path_default: "/administration/profile" 
+        }).find_or_create_by({ name: "limited" })
 
         # assign descriptors with appropriate privileges
-        owner.powers.create(:descriptor => descriptor_owner, :plist => true, :pindex => true, :pshow => true, :pcreate => true, :pupdate => true, :pdestroy => true)
-        admin.powers.create(:descriptor => descriptor_admin, :plist => true, :pindex => true, :pshow => true, :pcreate => true, :pupdate => true, :pdestroy => true)
-        limited.powers.create(:descriptor => descriptor_profile, :plist => true, :pindex => true, :pshow => true, :pcreate => true, :pupdate => true, :pdestroy => true)
+        owner.powers.create_with({
+            plist: true, pindex: true, pshow: true, pcreate: true, pupdate: true, pdestroy: true
+        }).find_or_create_by(:descriptor => descriptor_owner)
+
+        admin.powers.create_with({
+            plist: true, pindex: true, pshow: true, pcreate: true, pupdate: true, pdestroy: true
+        }).find_or_create_by(:descriptor => descriptor_admin)
+
+        limited.powers.create_with({
+            plist: true, pindex: true, pshow: true, pcreate: true, pupdate: true, pdestroy: true
+        }).find_or_create_by(:descriptor => descriptor_profile)
     end
 
 
@@ -63,56 +80,43 @@ module AccountInitializer
 
         # 01.01 LesliAdmin - Lesli administration area
         if defined? LesliAdmin
-            if self.admin.blank?
-                self.admin = LesliAdmin::Account.new
-                self.admin.account = self
-                self.admin.save!
-            end
+            LesliAdmin::Account.create!(:account => self) if self.admin.blank?
         end
 
-        # 03.01 LesliDriver - Unified calendar app
-        if defined? LesliDriver
-            if self.driver.blank?
-                self.driver = LesliDriver::Account.new
-                self.driver.account = self
-                self.driver.save!
-            end
+        # 03.01 LesliCalendar - Unified calendar app
+        if defined? LesliCalendar
+            LesliCalendar::Account.create!(:account => self) if self.calendar.blank?
         end
 
-        # 03.05 LesliNotes - Notes & Notebooks
+        # 03.05 LesliLetter - Notes & Notebooks
         if defined? LesliLetter
-            if self.letter.blank?
-                self.letter = LesliLetter::Account.new
-                self.letter.account = self
-                self.letter.save!
-            end
+            LesliLetter::Account.create!(:account => self) if self.letter.blank?
+        end
+
+        # 03.06 LesliDashboard - 
+        if defined? LesliDashboard
+            LesliDashboard::Account.create!(:account => self) if self.dashboard.blank?
+        end
+
+        # 03.08 LesliBell - Notification system
+        if defined? LesliBell
+            LesliBell::Account.create!(:account => self) if self.bell.blank?
         end
 
         # 05.02 LesliAudit - System analytics
         if defined? LesliAudit
-            if self.audit.blank?
-                self.audit = LesliAudit::Account.new
-                self.audit.account = self
-                self.audit.save!
-            end
+            LesliAudit::Account.create!(:account => self) if self.audit.blank?
         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
+        # 07.02 LesliSupport - Support Ticket System
+        if defined? LesliSupport
+            LesliSupport::Account.create!(:account => self) if self.support.blank?
         end
 
-        # 08.01 LesliGuard - Security Management Module
+        # 08.02 LesliSecurity - Users, Privileges & Access Management
         if defined? LesliGuard
-            if self.guard.blank?
-                self.guard = LesliGuard::Account.new
-                self.guard.account = self
-                self.guard.save!
-            end
+            LesliGuard::Account.create!(:account => self) if self.guard.blank?
         end
+
     end
 end

data/app/models/concerns/user_extensions.rb

@@ -57,6 +57,12 @@ module UserExtensions
     end
 
 
+    # @return [String] The first name of this user.
+    def name2
+        self.first_name
+    end
+
+
     # @return [String] The name of this user.
     # @description Retrieves and returns the name of the user depending on the available information.
     #     The name can be a full name (first and last names), just the first name, or, in case the information

data/{lib/scss/devise/registrations.scss → app/models/lesli/account/detail.rb}

@@ -1,4 +1,4 @@
-/*
+=begin
 
 Lesli
 
@@ -28,6 +28,10 @@ Building a better future, one line of code at a time.
 
 // · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
 // · 
-*/
+=end
 
-@import "lesli/pages/devise";
+module Lesli
+    class Account::Detail < ApplicationLesliRecord
+        belongs_to :account
+    end
+end

data/app/models/lesli/account.rb

@@ -19,11 +19,11 @@ 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
+Made with ♥ by LesliTech
 Building a better future, one line of code at a time.
 
 @contact  hello@lesli.tech
-@website  https://www.lesli.dev
+@website  https://www.lesli.tech
 @license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
 
 // · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
@@ -38,6 +38,10 @@ module Lesli
         # accounts always belongs to a user
         belongs_to :user, optional: true
 
+        #class_name: "Lesli::Account"
+        has_one :detail, inverse_of: :account, autosave: true, dependent: :destroy
+        accepts_nested_attributes_for :detail, update_only: true
+
 
         # account resources
         has_many :users
@@ -54,12 +58,15 @@ module Lesli
         has_many :logs
 
 
+        has_one :bell, class_name: "LesliBell::Account"
         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"
-        has_one :letter, class_name: "LesliLetter::Account"
         has_one :guard, class_name: "LesliGuard::Account"
+        has_one :letter, class_name: "LesliLetter::Account"
+        has_one :support, class_name: "LesliSupport::Account"
+        has_one :calendar, class_name: "LesliCalendar::Account"
+        has_one :dashboard, class_name: "LesliDashboard::Account"
 
 
         # account statuses
@@ -80,7 +87,7 @@ module Lesli
 
 
         # required a name for the lesli account
-        validates :company_name, :presence => true
+        validates :name, :presence => true
 
 
         # initializers for new accounts

data/app/models/lesli/cloud_object/action.rb

@@ -0,0 +1,70 @@
+=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
+class CloudObject::Action < ApplicationLesliRecord
+    self.abstract_class = true
+
+    belongs_to :user_creator, class_name: "::User", foreign_key: "users_id"
+
+    # @return [Class] The class of the association 'belongs_to'
+    # @description All actions belong to a *cloud_object*. This method returns the specific class of
+    #     that cloud_object.
+    # @example
+    #     puts DeutscheLeibrenten::Project::File.cloud_object_model.new # This will display an instance of DeutscheLeibrenten::Project
+    def self.cloud_object_model
+        self.reflect_on_association(:cloud_object).klass
+    end
+
+    def self.index(curren_user, cloud_object)
+        action_groups = {}
+        cloud_object.actions.order(group: :asc).map do |action|
+            action_attributes = action.attributes.merge({
+                "user_creator_name" => action.user_creator.full_name,
+                "created_at_text" => LC::Date.to_string(action.created_at)
+            })
+            action_groups[action.group] = [] unless action_groups[action.group]
+            
+            action_groups[action.group].push(action_attributes)
+        end
+
+        action_groups
+    end
+
+    def show(current_user)
+        attributes.merge({
+            "user_creator_name" => user_creator.full_name,
+            "created_at_text" => LC::Date.to_string(created_at)
+        })
+    end
+end
+end

data/app/models/lesli/cloud_object/activity.rb

@@ -0,0 +1,311 @@
+=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 Development Platform.
+
+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
+class CloudObject::Activity < ApplicationRecord
+    self.abstract_class = true
+
+    belongs_to :user_creator, class_name: "::User", foreign_key: "users_id", optional: true
+
+    # This enum can be overrided by the model that inherits from CloudObject::Activity
+    enum category: {
+        action_list:                    "action_list",
+        action_create:                  "action_create",
+        action_show:                    "action_show",
+        action_update:                  "action_update",
+        action_destroy:                 "action_destroy",
+        action_status:                  "action_status",
+        action_workflow_action_failed:  "action_workflow_action_failed",
+        action_email_sent:              "action_email_sent",
+        action_create_file:             "action_create_file",
+        action_update_file:             "action_update_file",
+        action_destroy_file:            "action_destroy_file",
+        action_not_found_file:          "action_not_found_file",
+    }
+
+    # @return [User] This method will always return nil
+    # @description At the current time, this is a dummy method that returns nil, so the function is_editable_by? in
+    #   ApplicationLesliRecord will work without issues
+    def user_main
+        return nil
+    end
+
+    # @return [Class] The class of the association 'belongs_to'
+    # @description All activities belong to a *cloud_object*. This method returns the specific class of
+    #     that cloud_object.
+    # @example
+    #     puts DeutscheLeibrenten::Project::Activity.cloud_object_model.new # This will display an instance of DeutscheLeibrenten::Project
+    def self.cloud_object_model
+        self.reflect_on_association(:cloud_object).klass
+    end
+
+
+    #######################################################################################
+    ##############################  Activities Log Methods   ##############################
+    #######################################################################################
+
+
+    # @param current_user [User] The current logged user
+    # @param cloud_id [Integer] Id of the *cloud_object* to which this activities belongs to
+    # @param query [Query] that contains the search and pagination information
+    # @return [Array] Array of activities. Each activities contains a *responses* element,
+    #     which is an array that has all its responses ordered by date
+    # @description Retrieves and returns all activities from a *cloud_object*
+    # @example
+    #    @activities = activity_model.index(
+    #        current_user,
+    #        profile_id,
+    #        @query
+    #    )
+    def self.index(current_user, cloud_id, query)
+        cloud_object_model = self.cloud_object_model
+        account_model = cloud_object_model.reflect_on_association(:account).klass
+        translations_module = self.name.split("::")[0].gsub("Cloud", "").underscore
+
+        # get search string from query params
+        search_string = query[:search].downcase.gsub(" ","%") unless query[:search].blank?
+        
+        activities = self
+        .where("#{cloud_object_model.table_name}_id".to_sym => cloud_id)
+        .order(id: :desc)
+        .joins("inner join users u on #{self.table_name}.users_id = u.id")
+        .joins("inner join user_details ud on ud.users_id = u.id")
+
+
+        # Filter results by search string
+        unless search_string.blank?
+            # (LOWER(ud.last_name) SIMILAR TO '%#{search_string}%') OR 
+            activities = activities.where("
+            (LOWER(#{self.table_name}.field_name) SIMILAR TO '%#{search_string}%') OR
+            (LOWER(#{self.table_name}.value_from) SIMILAR TO '%#{search_string}%') OR
+            (LOWER(#{self.table_name}.value_to) SIMILAR TO '%#{search_string}%') OR
+            (LOWER(ud.first_name) SIMILAR TO '%#{search_string}%')
+            ")
+        end
+
+        activities = activities.map do |activity|
+            # We translate the category, first, we search in the core
+            category = I18n.t("core.shared.activities_enum_category_#{activity[:category]}", default: nil)
+            
+            # Then we search in the engine
+            category = I18n.t("#{translations_module}.shared.activities_enum_category_#{activity[:category]}", default: nil) unless category
+            
+            #Then we default to the real field
+            category = activity[:category] unless category
+
+            activity_attributes = activity.attributes
+            activity_attributes["category"] = category
+            activity_attributes["created_at_raw"] = activity[:created_at]
+            activity_attributes["created_at"] = LC::Date.to_string_datetime(activity[:created_at])
+            activity_attributes["updated_at"] = LC::Date.to_string_datetime(activity[:updated_at])
+
+            user = activity.user_creator
+            activity_attributes[:user_name] = user.full_name
+
+            activity_attributes
+        end
+
+        Kaminari.paginate_array(activities).page(query[:pagination][:page]).per(query[:pagination][:perPage])
+    end
+    
+    # @return [void]
+    # @param current_user [::User] The user that created the cloud_object
+    # @param cloud_object [CloudModule::Model] The cloud_object that was created
+    # @description Creates an activity for this cloud_object indicating who created it.
+    # Example
+    #   params = {...}
+    #   ticket = CloudHelp::Ticket.create(params)
+    #   CloudHelp::Ticket.log_create(User.first, ticket)
+    def self.log_create(current_user, cloud_object)
+        cloud_object.activities.create(
+            user_creator: current_user,
+            category: "action_create"
+        )
+
+        # If cloud_object has workflow
+        if defined?(cloud_object.status)
+            module_name = cloud_object.class.lesli_classname().split("::")[0].underscore
+            cloud_object.activities.create(
+                user_creator: current_user,
+                category: "action_status",
+                description: cloud_object.status&.name,
+                field_name: "#{module_name}_workflow_statuses_id",
+                value_to: cloud_object.status&.name
+            )
+        end
+
+        yield if block_given?
+    end
+
+    # @return [void]
+    # @param current_user [::User] The user that created the cloud_object
+    # @param cloud_object [CloudModule::Model] The cloud_object that was shown
+    # @description Creates an activity for this cloud_object indicating who view it.
+    # Example
+    #   params = {...}
+    #   ticket = CloudHelp::Ticket.create(params)
+    #   CloudHelp::Ticket.log_show(User.first, ticket)
+    def self.log_show(current_user, cloud_object)
+        cloud_object.activities.create(
+            user_creator: current_user,
+            category: "action_show"
+        )
+
+        yield if block_given?
+    end
+
+    # @return [void]
+    # @param current_user [::User] The user that edited the cloud_object
+    # @param cloud_object [CloudModule::Model] The cloud_object that was edited
+    # @param old_attributes[Hash] The data of the record before update
+    # @param new_attributes[Hash] The data of the record after update
+    # @description Creates an activity for this cloud_object if someone changed any of this values
+    # Example
+    #   ticket = CloudHelp::Ticket.find(1)
+    #   old_attributes  = ticket.attributes
+    #   ticket.update(user_main: User.find(33))
+    #   new_attributes = ticket.attributes
+    #   CloudHelp::TicketLogger.log_update(User.find(1), ticket, old_attributes, new_attributes)
+    def self.log_update(current_user, cloud_object, old_attributes, new_attributes, category: "action_update")
+
+        # We remove values that are not tracked in the activities
+        old_attributes.except!("id", "created_at", "updated_at", "deleted_at")
+        old_attributes.each do |key, value|
+            next if value == new_attributes[key]
+            if key.include?("id")
+                if key == "user_main_id" || key == "users_id" || key == "user_branch_office_id"
+                    update_user_field(cloud_object, current_user, key, old_attributes[key], new_attributes[key], category)
+                elsif key.include?("workflow_statuses_id")
+                    update_workflow_status_field(cloud_object, current_user, key, old_attributes[key], new_attributes[key])
+                else
+                    update_field(cloud_object, current_user, key, old_attributes[key], new_attributes[key], category)
+                end
+            else
+                update_field(cloud_object, current_user, key, old_attributes[key], new_attributes[key], category)
+            end
+        end
+
+        yield if block_given?
+    end
+
+    # @return [void]
+    # @param current_user [::User] The user that deleted the cloud_object
+    # @param cloud_object [CloudModule::Model] The cloud_object that was destroyed
+    # @description Creates an activity for this cloud_object indicating that someone deleted it
+    # Example
+    #   ticket = CloudHelp::Ticket.find(1)
+    #   CloudHelp::TicketLogger.log_destroy(User.first, ticket)
+    #   ticket.destroy
+    def self.log_destroy(current_user, cloud_object)
+        cloud_object.activities.create(
+            user_creator: current_user,
+            category: "action_destroy"
+        )
+
+        yield if block_given?
+    end
+
+    protected
+
+    # @return [void]
+    # @param current_user [User] The user that deleted the cloud_object
+    # @param cloud_object [CloudModule::Model] The cloud_object that updated
+    # @param key [String] The user field to be logged
+    # @param old_user_id [Integer] The id of the user prior to the update
+    # @param new_user_id [Integer] The id of the user after the update
+    # @description Logs an "action_update" activity. But instead of using the raw id of the user, it logs their name
+    # @example
+    #     project = CloudHouse::Project.first
+    #     CloudHouse::ProjectLogger.log_update(User.first, project, "users_id", 1, 2)
+    #     # This will log a change from user with id 1 to user with id 2 using their names
+    def self.update_user_field(cloud_object, current_user, key, old_user_id, new_user_id, category)
+        cloud_object.activities.create(
+            user_creator: current_user,
+            category: category,
+            field_name: key,
+            value_from: old_user_id ? User.with_deleted.find(old_user_id).full_name : nil,
+            value_to:   new_user_id ? User.with_deleted.find(new_user_id).full_name : nil
+        )
+    end
+
+    # @return [void]
+    # @param current_user [User] The user that deleted the cloud_object
+    # @param cloud_object [CloudModule::Model] The cloud_object that updated
+    # @param key [String] The user field to be logged
+    # @param old_workflow_status_id [Integer] The id of the workflow status prior to the update
+    # @param new_workflow_status_id [Integer] The id of the workflow status after the update
+    # @description Logs an "action_update" activity. But instead of using the raw id of the workflow status, it logs its name
+    # @example
+    #     project = CloudHouse::Project.first
+    #     CloudHouse::ProjectLogger.log_update(User.first, project, "cloud_house_workflow_statuses_id, 1, 2)
+    #     # This will log a change from workflow status with id 1 to workflow status with id 2 using their names
+    def self.update_workflow_status_field(cloud_object, current_user, key, old_workflow_status_id, new_workflow_status_id)
+        module_name = cloud_object.class.lesli_classname().split("::")[0]
+        old_status = eval("#{module_name}::Workflow::Status").with_deleted.find(old_workflow_status_id).name
+        new_status = eval("#{module_name}::Workflow::Status").with_deleted.find(new_workflow_status_id).name
+
+        cloud_object.activities.create(
+            user_creator: current_user,
+            description: new_status,
+            category: "action_status",
+            field_name: key,
+            value_from: old_status,
+            value_to:   new_status
+        )
+    end
+
+    # @return [void]
+    # @param current_user [User] The user that deleted the cloud_object
+    # @param cloud_object [CloudModule::Model] The cloud_object that updated
+    # @param key [String] The user field to be logged
+    # @param old_field [Integer] The value of the field prior to the update
+    # @param new_field [Integer] The value of the field after the update
+    # @description Logs an "action_update" activity. If the value that changed is a date, it uses LC::Date to turn it into a string
+    #     otherwise, it logs it as is
+    # @example
+    #     ticket = CloudHelp::Ticket.first
+    #     CloudHelp::TicketLogger.log_update(User.first, ticket, "deadline": Time.now - 1.days, Time.now)
+    #     # This will log a change from workflow on the deadline, and it will use the format specified by the lesli instance
+    def self.update_field(cloud_object, current_user, key, old_field, new_field, category)
+        old_field = LC::Date.to_string_datetime(old_field) if old_field.is_a?(Time) || old_field.is_a?(Date)
+        new_field = LC::Date.to_string_datetime(new_field) if new_field.is_a?(Time) || new_field.is_a?(Date)
+
+        cloud_object.activities.create(
+            user_creator: current_user,
+            category: category,
+            field_name: key,
+            value_from: old_field,
+            value_to: new_field
+        )
+    end
+end
+end