lesli 5.1.12 → 5.1.13

data/app/controllers/lesli/items/tasks_controller.rb

@@ -33,93 +33,163 @@ Building a better future, one line of code at a time.
 module Lesli
     module Items
         class TasksController < ApplicationLesliController
-            before_action :set_task, only: %i[show update]
-            before_action :set_taskable, only: %i[index create]
+            before_action :set_taskable, only: :create
+            before_action :set_task, only: :update
 
-            def index
-                @tasks = task_class
-                    .where(account: current_user.account)
-                    .order(created_at: :desc)
-                respond_with_lesli(json: @tasks)
+            def create
+                task = @taskable.add_task!(
+                    creator: current_user,
+                    title: task_params[:title]
+                )
+                refresh_tasks
+
+                message = I18n.t("lesli.items.tasks.created")
+                respond_with_lesli(
+                    turbo: [
+                        stream_notification_success(message),
+                        tasks_stream
+                    ],
+                    json: {
+                        message: message,
+                        task: task_payload(task)
+                    },
+                    status: :created
+                )
+            rescue ActiveRecord::RecordInvalid => error
+                respond_with_task_errors(error.record)
             end
 
-            def show
+            def update
+                @task.update!(done: !@task.done?)
+
+                message = task_status_message
+                respond_with_lesli(
+                    turbo: [
+                        stream_notification_success(message),
+                        turbo_stream.replace(
+                            helpers.dom_id(@task, scope_key)
+                        ) do
+                            render_task(@task)
+                        end
+                    ],
+                    json: {
+                        message: message,
+                        task: task_payload(@task)
+                    }
+                )
+            rescue ActiveRecord::RecordInvalid => error
+                respond_with_task_errors(error.record)
             end
 
-            def create
-                task = task_class.new(task_params)
+            private
 
-                task.user = current_user
-                task.account = current_user.account
-                task.taskable = @taskable if @taskable
+            def scope_key
+                ActiveSupport::Inflector
+                    .underscore(task_class.name)
+                    .tr("/", "_")
+            end
 
-                if task.save
-                    respond_with_lesli(:turbo => [
-                        stream_notification_success("Task created"),
-                        turbo_stream.prepend("#{scope_key}-lesli-items-tasks-list") do
-                            LesliView::Items::Task.new(task, scope_key).render_in(view_context)
-                        end
-                    ])
-                else
-                    respond_with_lesli(
-                        :turbo => stream_notification_danger(task.errors.full_messages)
-                    )
-                end
+            def task_class
+                self.class.module_parent.const_get("Task")
             end
 
-            def update
-                @task.done = true
-                @task.save
-                respond_with_lesli(:turbo => [
-                    stream_notification_success("Task updated #{@taskable}"),
-                    turbo_stream.replace(helpers.dom_id(@task, scope_key)) do 
-                        LesliView::Items::Task.new(@task, scope_key).render_in(view_context)
-                    end
-                ])
+            def taskable_class
+                allowed_taskable_classes.find do |klass|
+                    klass.name == params.require(:taskable_type)
+                end || raise(
+                    ActiveRecord::RecordNotFound,
+                    "Unauthorized taskable type"
+                )
             end
 
-            private
+            def allowed_taskable_classes
+                []
+            end
 
-            # return a key to identify the engine where the tasks are running
-            def scope_key = ActiveSupport::Inflector.underscore(task_class.name).tr("/", "_")
+            def set_task
+                @task = task_class.find(params[:id])
+                ensure_taskable_access!(@task.taskable)
+            end
 
-            # return the task class including the engine where the tasks are running
-            def task_class = self.class.module_parent.const_get("Task")
+            def set_taskable
+                @taskable = taskable_class.find(
+                    params.require(:taskable_id)
+                )
+                ensure_taskable_access!(@taskable)
+            end
 
-            # validate we invoke only models that implements Lesli::Item::Tasks concern
-            def validate_taskable taskable
+            def ensure_taskable_access!(taskable)
+                allowed = taskable.respond_to?(:lesli_item_accessible_by?) &&
+                    taskable.lesli_item_accessible_by?(current_user)
 
-                # 1. Attempt to resolve the class safely
-                klass = taskable.safe_constantize
+                raise ActiveRecord::RecordNotFound unless allowed
+            end
 
-                # 2. VALIDATION: Check if the class is allowed to be taskable
-                # We check if the class exists AND if it includes your specific taskable trait
-                unless klass && klass.respond_to?(:is_lesli_taskable?) && klass.is_lesli_taskable?
-                    render json: { error: "Unauthorized taskable type" }, status: :forbidden and return
-                end
+            def task_params
+                params.require(scope_key.to_sym).permit(:title)
+            end
 
-                klass
+            def render_task(task)
+                LesliView::Items::Task
+                    .new(task, scope_key)
+                    .render_in(view_context)
             end
 
-            def set_task
-                @task = task_class.where(account: current_user.account).find(params[:id])
+            def task_payload(task)
+                {
+                    id: task.id,
+                    title: task.title,
+                    done: task.done?,
+                    taskable_type: task.taskable_type,
+                    taskable_id: task.taskable_id,
+                    creator: {
+                        id: task.user_id,
+                        name: task.user.name
+                    },
+                    created_at: task.created_at,
+                    updated_at: task.updated_at
+                }
             end
 
-            # Permite filtrar/crear para un actionable específico:
-            # params: actionable_type=LesliSupport::Ticket&actionable_id=123
-            def set_taskable
-                type = params[:taskable_type].presence
-                id   = params[:taskable_id].presence
-                return if type.blank? || id.blank?
+            def refresh_tasks
+                association_name =
+                    @taskable.class.lesli_tasks_association_name
 
-                taskable = validate_taskable(type)
+                @taskable.public_send(association_name).reset
+            end
 
-                # 3. Execution: Now it is safe to query
-                @taskable = taskable.where(account: current_user.account).find_by(id: id)
+            def task_status_message
+                status = @task.done? ? :completed : :reopened
+                I18n.t("lesli.items.tasks.#{status}")
             end
 
-            def task_params
-                params.require(scope_key.to_sym).permit(:title)
+            def tasks_stream(task: nil)
+                turbo_stream.replace(
+                    helpers.dom_id(@taskable, :tasks)
+                ) do
+                    LesliView::Items::Tasks
+                        .new(@taskable, task: task)
+                        .render_in(view_context)
+                end
+            end
+
+            def respond_with_task_errors(task)
+                turbo = [
+                    stream_notification_danger(
+                        task.errors.full_messages.to_sentence
+                    )
+                ]
+
+                if task.new_record?
+                    refresh_tasks
+                    turbo << tasks_stream(task: task)
+                end
+
+                respond_with_lesli(
+                    turbo: turbo,
+                    json: { errors: task.errors },
+                    status: :unprocessable_content
+                )
             end
         end
     end

data/app/helpers/lesli/turbo_helper.rb

@@ -37,24 +37,6 @@ module Lesli
             link_to(body, url, class: "link", data: { turbo_frame: '_top' })
         end
 
-        # Meta-programming to define flash setter methods dynamically
-        # success("Everything worked!")
-        # danger("Oops, there was an error.")
-        # info("Just an informational message.")
-        # warning("This is a warning.")
-        [:info, :success, :warning, :danger].each do |flash_type|
-            define_method(flash_type) do |message|
-                flash[flash_type] = message
-            end
-        end
-
-        def stream_notification_success(message)
-            success(message)
-            turbo_stream.replace("application-lesli-notifications") do
-                render("lesli/partials/application-lesli-notifications")
-            end
-        end
-
         def render_form_stream(partial_path, locals = {})
 
             # Detect the current engine's namespace

data/app/interfaces/lesli/responder_interface.rb

@@ -33,6 +33,10 @@ Building a better future, one line of code at a time.
 module Lesli
     module ResponderInterface
 
+        # Lesli-specific response status used to tell JSON clients that they
+        # must execute the action included in the response body.
+        ACTION_REQUIRED_STATUS = 490
+
         # Standard json structure for paginated data,
         # this is compatible for json, html and turbo responses
         # NOTE: LesliView::Element::Table require this structure
@@ -58,25 +62,37 @@ module Lesli
             }
         end
 
-        # General response builder
-        # Support for: turbo, json and html
-        # Note: Turbo respond support single stream or array of streams
-        # Usage:
-        # respond_with(
-        #     turbo: [
-        #         stream_notification_success('ticket creado de forma exitosass')
-        #         stream_notification_warning('ticket creado de forma exitosass')
-        #     ],
-        #     json: {
-        #         message: "it works"
-        #     },
-        #     html: 'lesli/abouts/up'
-        # )
-        def respond_with_lesli(turbo:nil, json:nil, html:nil)
+        # Build a response for HTML, JSON, or Turbo Stream requests.
+        #
+        # `html` is passed to `render`. When omitted, Rails renders the current
+        # action's template. Use `redirect` for HTML redirects instead of
+        # invoking `redirect_to` before calling this method. `status` applies to
+        # rendered responses; redirects use `redirect_status`.
+        def respond_with_lesli(
+            turbo: nil,
+            json: nil,
+            html: nil,
+            redirect: nil,
+            status: :ok,
+            redirect_status: :see_other
+        )
+            if html && redirect
+                raise ArgumentError, "Use either html: or redirect:, not both"
+            end
+
             respond_to do |format|
-                format.html { render(html) }
-                format.json { respond_with_json(json) }
-                format.turbo_stream { render(turbo_stream: turbo) }
+                format.html do
+                    if redirect
+                        redirect_to(redirect, status: redirect_status)
+                    elsif html
+                        render(html, status: status)
+                    else
+                        render(status: status)
+                    end
+                end
+
+                format.json { respond_with_http(status, json) }
+                format.turbo_stream { render(turbo_stream: turbo, status: status) }
             end
         end
 
@@ -95,12 +111,13 @@ module Lesli
             end
         end
 
-        # General error for unauthorized request
-        # Usage:
-        #   This method is automatically triggered by the 
-        #   LesliShield authentication interface, however
-        #   you can use it anywhere by just invoking this method
-        def respond_with_unauthorized(details = {})
+        # Respond with HTTP 403 when an authenticated user does not have the
+        # privileges required to perform the requested action.
+        #
+        # This method is used by LesliShield's authorization interface after
+        # authentication has succeeded. `respond_with_unauthorized` remains
+        # available as a backwards-compatible alias for existing engines.
+        def respond_with_forbidden(details = {})
 
             @error_object = {
                 error_role: nil,
@@ -117,11 +134,13 @@ module Lesli
 
             respond_to do |format|
                 format.json { respond_with_json_unauthorized(@error_object) }
-                format.html { render('lesli/errors/unauthorized', status: :unauthorized) }
-                format.turbo_stream { render('lesli/errors/unauthorized', status: :unauthorized) }
+                format.html { render('lesli/errors/unauthorized', status: :forbidden) }
+                format.turbo_stream { render('lesli/errors/unauthorized', status: :forbidden) }
             end
         end
 
+        alias_method :respond_with_unauthorized, :respond_with_forbidden
+
 
         # ~·~   ~·~   ~·~   ~·~   ~·~   ~·~   ~·~   ~·~   ~·~   ~·~   ~·~   ~·~
         # Auxiliar methods for responders
@@ -143,7 +162,7 @@ module Lesli
 
                 # Return the stream object so you can call: 
                 # render turbo_stream: stream_notification_success("Done!")
-                turbo_stream.update(
+                turbo_stream.replace(
                     "application-lesli-notifications",
                     partial: "lesli/partials/application-lesli-notifications"
                 )
@@ -162,7 +181,7 @@ module Lesli
 
         # Just a simple json success response for JSON
         def respond_with_json(payload = nil)
-            respond_with_http(200, payload)
+            respond_with_http(:ok, payload)
         end
 
         # Just a simple json not found response for JSON
@@ -185,19 +204,20 @@ module Lesli
         end
 
         # Just a simple http response for JSON
-        def respond_with_http(status, payload)
-            render(
-                :status => status, 
-                :content_type => 'application/json', 
-                :json => payload.nil? ? "" : payload.to_json
-            )
+        def respond_with_http(status, payload = nil)
+            return head(status) if payload.nil?
+
+            render(:status => status, :json => payload)
         end
 
-        # General method to respond with and order for an action
-        # This method exists just for compatibility poruposes,
-        # a refactor is needed for this method
+        # Tell a JSON client to execute an action before it can continue.
+        # Clients using the Lesli API must handle ACTION_REQUIRED_STATUS and
+        # dispatch the action included in the response body.
         def respond_with_action(action, message = "Action Required")
-            respond_with_http(490, { :message => message, :action => action })
+            respond_with_http(
+                ACTION_REQUIRED_STATUS,
+                { :message => message, :action => action }
+            )
         end
     end
 end

data/app/mailers/lesli/application_lesli_mailer.rb

@@ -34,7 +34,12 @@ module Lesli
     class ApplicationLesliMailer < ActionMailer::Base
 
         # Set a dynamic template according to the engine that is sending the email
-        default(template_path: Lesli.config.mailer.dig(:templates))
+        default(
+            template_path: (Lesli.config.mailer || {}).fetch(
+                :templates,
+                "lesli_assets/emails"
+            )
+        )
 
         #after_action :log_mail_requests
 
@@ -48,9 +53,16 @@ module Lesli
         end
 
         def build_url(path, params = {})
-            default_url = Rails.application.config.action_mailer.default_url_options
+            default_url = mailer_url_options
             host = default_url[:host].to_s.sub(/\Ahttps?:\/\//, "")
-            scheme = default_url[:protocol]&.delete(":") || "http"
+            scheme = default_url[:protocol].presence&.to_s&.delete(":") || "http"
+
+            if host.blank?
+                raise ArgumentError, <<~MESSAGE.squish
+                    Action Mailer requires default_url_options[:host] to build
+                    absolute links in Lesli emails
+                MESSAGE
+            end
 
             URI::Generic.build(
                 scheme: scheme,
@@ -63,19 +75,32 @@ module Lesli
 
         protected
 
-        def email(params={}, user:nil, to:, subject:, template_name:) 
+        def email(
+            params = {},
+            user: nil,
+            to:,
+            subject:,
+            template_name:,
+            **headers
+        )
 
             @params = @params.merge(params)
 
             build_app_from_params(params)
 
             mail(
-                to: to, 
+                to: to,
                 subject: subject,
+                **headers,
                 template_name: template_name
             )
         end
 
+        def mailer_url_options
+            options = Rails.application.config.action_mailer.default_url_options
+            (options || {}).to_h.symbolize_keys
+        end
+
 
         private
 
@@ -88,11 +113,12 @@ module Lesli
                 tag_line: "",
             }
 
-            return if params[:user].blank? || params[:user].class.name != "Lesli::User"
+            account = params[:user]&.account
+            return if account.blank?
 
             @app[:company] = {
-                id: params[:user].account.id,
-                name: params[:user].account.name,
+                id: account.id,
+                name: account.name,
                 #tag_line: params[:user].account.company_tag_line,
             }
         end

data/app/models/concerns/lesli/account_initializer.rb

@@ -39,17 +39,17 @@ module Lesli
 
             # platform role for owners
             owner = self.roles
-            .create_with({ permission_level: 2147483647 })
+            .create_with({ permission_level: 2147483647, active: true })
             .find_or_create_by(:name => "owner")
 
             # platform role for administrators
             admin = self.roles
-            .create_with({ permission_level: 100000})
+            .create_with({ permission_level: 100000, active: true })
             .find_or_create_by(name: "admin")
 
             # platform role for guests
             guest = self.roles
-            .create_with({ permission_level: 10, path_default: "/administration/profile" })
+            .create_with({ permission_level: 10, active: true , path_default: "/administration/profile" })
             .find_or_create_by(name: "guest")
 
 
@@ -64,6 +64,7 @@ module Lesli
 
         # initialize engines for new accounts
         def initialize_engines
+            initialized_engines = []
 
             LesliSystem.engines.each do |engine, data|
 
@@ -72,6 +73,13 @@ module Lesli
                 # Create an associated account if the attribute is blank
                 engine.constantize::Account.find_or_create_by!(account: self)
 
+                initialized_engines << engine
+            end
+
+            # Emit initialization events only after every engine account exists.
+            # In particular, this makes the result independent from the position
+            # of LesliAudit in the engine registry.
+            initialized_engines.each do |engine|
                 self.log(:account_initialization, "Engine: #{engine} initialized successfully")
             end
         end      

data/app/models/concerns/lesli/account_logs.rb

@@ -35,25 +35,14 @@ module Lesli
         extend ActiveSupport::Concern
 
         def log operation, description=nil, user:nil
-            return unless defined?(LesliAudit)
-            log_anonimous(operation, description) unless self.audit
-            log_account(operation, description) if self.audit
-        end
-
-        private 
-
-        def log_anonimous operation, description
-            LesliAudit::AccountLog.create({
-                operation: operation,
-                description: description
-            })
-        end
+            return unless defined?(LesliAudit::ActivityAudit)
 
-        def log_account operation, description
-            self.logs.create!({
+            LesliAudit::ActivityAudit.record_account!(
+                account: self,
+                actor: user,
                 operation: operation,
                 description: description
-            })
+            )
         end
     end
 end

data/app/models/concerns/lesli/items/activities.rb

@@ -34,9 +34,13 @@ module Lesli
     module Items
         module Activities
             extend ActiveSupport::Concern
+            include Lesli::Items::Ownership
             
             included do
                 class_attribute :lesli_activities_class, instance_accessor: false
+                class_attribute :lesli_activities_association_name,
+                    instance_accessor: false,
+                    default: :activities
                 lesli_activities_setup
             end
 
@@ -52,13 +56,7 @@ module Lesli
                     end
 
                     self.lesli_activities_class = klass
-
-                    # ✅ Auto-fix table name (works even when engine defines table_name_prefix)
-                    expected_table = lesli_expected_activity_table_name_for(klass)
-
-                    if klass.table_name != expected_table
-                        klass.table_name = expected_table
-                    end
+                    self.lesli_activities_association_name = association_name.to_sym
 
                     # Set associations
                     # Example:
@@ -66,41 +64,39 @@ module Lesli
                     #     has_many :activities, class_name: "LesliSupport::Items::Activity"
                     # end
                     has_many(association_name,
-                        -> { where(deleted_at: nil).order(created_at: :desc) },
+                        -> {
+                            where(deleted_at: nil)
+                                .order(created_at: :desc, id: :desc)
+                        },
                         as: as,
                         class_name: klass.name,
                         dependent: :destroy
                     )
-
-                    # rescue NameError
-                    #     raise NameError,
-                    #     "Task class not found for #{name}. Expected #{name.deconstantize}::Activity or pass `use:`"
-                end
-
-                private
-
-                # Build: "lesli_support_item_activities" from "LesliSupport::Item::Activity"
-                #
-                # We DO NOT rely on ActiveRecord's table_name_prefix, because that’s what breaks your case.
-                def lesli_expected_activity_table_name_for(klass)
-                    parts = klass.name.split("::").map(&:underscore) # ["lesli_support", "item", "activity"]
-                    "#{parts.join('_').pluralize}"                   # "lesli_support_item_activities"
                 end
             end
 
-            def after_save_activities
-                Termline.warn "You need to define your activity methods in your model"
-            end
-            
-            def activities_create **resource
-                self.activities.create(
-                    subject_type: self.class.name,
-                    subject_id: self.id,
-                    user_id:self.user_id,
-                    account_id:self.account_id,
-                    **resource
+            def record_activity!(
+                actor:,
+                code:,
+                description: nil,
+                metadata: {},
+                activity_type: :activity
+            )
+                activity_association.create!(
+                    actor: actor,
+                    account: lesli_item_account,
+                    activity_code: code,
+                    activity_type: activity_type,
+                    description: description,
+                    metadata: metadata
                 )
             end
+
+            private
+
+            def activity_association
+                public_send(self.class.lesli_activities_association_name)
+            end
         end
     end
 end