lesli 5.0.11 → 5.0.12

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

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

@@ -0,0 +1,158 @@
+=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::CustomField < ApplicationLesliRecord
+    self.abstract_class = true
+    belongs_to :user_creator, class_name: "::User", foreign_key: "users_id"
+
+    # @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
+
+=begin
+    # @param cloud_object [ApplicationRecord] Cloud object to which an user can subscribe to
+    # @param user [User] The user that is subscribing to the *cloud_ubject*
+    # @param event [Symbol] A valid event from this class's *event* enum to wich the *user* will be subscribed
+    # @param notification_type [Symbol] A valid notification_type from this class's *notification_type* enum
+    # @return [void]
+    # @description Subscribes a *user* to one or all *events* of the *cloud_object*. If no *event* is provided, the *user*
+    #     is subscribed to all the *events*
+    # @example
+    #     first_ticket = CloudHelp::Ticket.find( 1 )
+    #     second_ticket = CloudHelp::Ticket.find( 2 )
+    #     user = current_user
+    #     CloudHelp::Ticket::Subscriber.add_subscriber( first_ticket, current_user )
+    #     CloudHelp::Ticket::Subscriber.add_subscriber( second_ticket, current_user, :http_post, :email )
+    def self.add_subscriber(cloud_object, user, event=nil, notification_type= :web)
+        model = dynamic_info[:model]
+
+        if event
+            return cloud_object.subscribers.create(
+                user: user,
+                event: event,
+                notification_type: model.notification_types[notification_type]
+            )
+        end
+        
+        model.events.values.each do |event|
+            cloud_object.subscribers.create(
+                user: user,
+                event: event,
+                notification_type: model.notification_types[notification_type]
+            )
+        end
+    end
+
+    # @param cloud_object [ApplicationRecord] Cloud object to which an user can subscribe to
+    # @param subject [String] The subject that will be shown in the notification
+    # @param event [Symbol] A valid event from this class's *event* enum
+    # @return [void]
+    # @description Notifies all the users subscribed to the *cloud_object*'s *event* using the *Courier* engine
+    # @example
+    #     ticket = CloudHelp::Ticket.find( 1 )
+    #     ClodHelp::Ticket::Subscriber.notify_subscribers(
+    #         ticket,
+    #         "A new comment has been added to ticket #{ticket.id}",
+    #         :comment_created
+    #     )
+    def self.notify_subscribers(cloud_object, subject, event)
+        module_name = dynamic_info[:module_name]
+        object_name = dynamic_info[:object_name]
+
+        cloud_object.subscribers.where(event: event).each do |subscriber|
+            Courier::Bell::Notifications.send(
+                user: subscriber.user,
+                subject: subject,
+                href: "#{module_name}/#{object_name}/#{cloud_object.id}",
+                type: subscriber.notification_type,
+                cloud_object_type: "#{module_name}/#{object_name}"
+            )
+        end
+    end
+
+    # @param cloud_object [ApplicationRecord] Cloud object to which an user can subscribe to
+    # @param user [User] The user that is subscribing to the *cloud_object*
+    # @return [Array] Array of subscriptions. There is one subscription per *event*.
+    # @description Generates an array of subscription, Each element contains a subscription *event*, 
+    #     information about wheter the *user* is subscribed or not and, if the user is subscribed, 
+    #     the notification type of the subscription
+    # @example
+    #     ticket = CloudHelp::Ticket.find( 1 )
+    #     subscription_events = CloudHelp::Ticket::Subscriber.subscription_events(
+    #         ticket,
+    #         current_user
+    #     )
+    def self.subscription_events(cloud_object, user)
+        model = dynamic_info[:model]
+
+        data = { }
+        events = model.events.keys
+        events.each do |event|
+            data[event] = {
+                event: event,
+                subscribed: false,
+                notification_type: :web
+            }
+        end
+        cloud_object.subscribers.where(users_id: user.id).each do |subscriber|
+            data[subscriber.event][:id] = subscriber.id
+            data[subscriber.event][:subscribed] = true
+            data[subscriber.event][:notification_type] = subscriber.notification_type
+        end
+        data.values
+    end
+
+    private
+
+    # @return [Hash] Hash that contains information about the class
+    # @description Returns dynamic information based on the current implementation of this abstract class
+    # @example
+    #     dynamic_info = CloudHelp::Ticket::Subscriber.dynamic_info
+    #     puts dynamic_info[:module_name] # will print 'help'
+    #     puts dynamic_info[:object_name] # will print 'ticket'
+    #     dynamic_info.model.new # will return an instance of CloudHelp::Ticket::Subscriber
+    def self.dynamic_info
+        module_info = self.name.split("::")
+        {
+            module_name: module_info[0].sub("Cloud", "").downcase,
+            object_name: module_info[1].downcase,
+            model: "#{module_info[0]}::#{module_info[1]}::Subscriber".constantize
+        }
+    end
+=end
+
+end
+end