lcp 0.1.0

data/app/controllers/lcp_ruby/actions_controller.rb

@@ -0,0 +1,481 @@
+module LcpRuby
+  class ActionsController < ApplicationController
+    def execute_single
+      record = load_action_record!(params[:id])
+      action_name = params[:action_name]
+
+      # Check if this single action defines a pipeline
+      single_config = find_single_action_config(action_name)
+
+      if single_config && single_config["pipeline"]
+        execute_single_pipeline(record, single_config)
+      else
+        ensure_action_execution_allowed!
+        action_key = "#{current_presenter.model}/#{action_name}"
+
+        result = Actions::ActionExecutor.new(action_key, {
+          record: record,
+          current_user: current_user,
+          params: action_params,
+          model_class: @model_class
+        }).execute
+
+        handle_result(result)
+      end
+    end
+
+    def execute_collection
+      ensure_action_execution_allowed!
+      authorize @model_class, :index?
+      action_key = "#{current_presenter.model}/#{params[:action_name]}"
+
+      result = Actions::ActionExecutor.new(action_key, {
+        current_user: current_user,
+        params: action_params,
+        model_class: @model_class
+      }).execute
+
+      handle_result(result)
+    end
+
+    def execute_batch
+      action_name = params[:action_name]
+
+      # Authorize
+      if built_in_batch_action?(action_name)
+        authorize_built_in_batch(action_name)
+      else
+        unless current_evaluator.can_execute_action?(action_name)
+          raise Pundit::NotAuthorizedError, "not allowed to execute action #{action_name}"
+        end
+      end
+
+      batch_action_config = find_batch_action_config(action_name)
+
+      # Reject filter mode when select_all_filter is false
+      if params[:selection_mode] == "filter"
+        select_all = batch_action_config&.dig("select_all_filter")
+        if select_all == false
+          return handle_result(Actions::Result.new(
+            success: false,
+            message: I18n.t("lcp_ruby.batch.result.filter_not_allowed",
+                            default: "This action does not support 'select all matching filter' mode."),
+            redirect_to: nil, data: nil, errors: []
+          ))
+        end
+      end
+
+      # Reject ID selection exceeding max_explicit_ids
+      if params[:selection_mode] != "filter"
+        ids = params[:ids] || []
+        max_ids = LcpRuby.configuration.max_explicit_ids
+        if max_ids && ids.length > max_ids
+          return handle_result(Actions::Result.new(
+            success: false,
+            message: I18n.t("lcp_ruby.batch.result.too_many_ids",
+                            count: ids.length, max: max_ids,
+                            default: "Too many records selected (%{count}). Maximum is %{max}."),
+            redirect_to: nil, data: nil, errors: []
+          ))
+        end
+      end
+
+      # Check min_selection / max_selection (ID mode only)
+      if params[:selection_mode] != "filter"
+        selection_count = (params[:ids] || []).length
+        min_sel = batch_action_config&.dig("min_selection")
+        max_sel = batch_action_config&.dig("max_selection")
+        if min_sel && selection_count < min_sel
+          return handle_result(Actions::Result.new(
+            success: false,
+            message: I18n.t("lcp_ruby.batch.result.too_few",
+                            count: selection_count, min: min_sel,
+                            default: "Too few records selected (%{count}). Minimum is %{min}."),
+            redirect_to: nil, data: nil, errors: []
+          ))
+        end
+        if max_sel && selection_count > max_sel
+          return handle_result(Actions::Result.new(
+            success: false,
+            message: I18n.t("lcp_ruby.batch.result.selection_too_many",
+                            count: selection_count, max: max_sel,
+                            default: "Too many records selected (%{count}). Maximum is %{max}."),
+            redirect_to: nil, data: nil, errors: []
+          ))
+        end
+      end
+
+      # Check max_batch_records limit (uses count, no record loading)
+      max = batch_action_config&.dig("max_batch_records")
+      record_count = batch_record_count
+      if max && record_count > max
+        return handle_result(Actions::Result.new(
+          success: false,
+          message: I18n.t("lcp_ruby.batch.result.too_many",
+                          count: record_count, max: max,
+                          default: "Too many records (%{count}). Maximum is %{max}."),
+          redirect_to: nil, data: nil, errors: []
+        ))
+      end
+
+      # Create batch_operation record if result_log is enabled
+      batch_op = nil
+      if batch_action_config&.dig("result_log") && batch_operation_model_available?
+        batch_op = create_batch_operation(action_name, params[:selection_mode])
+      end
+
+      # Determine execution mode (reuses record_count, no extra query)
+      execution_mode = resolve_execution_mode(batch_action_config, record_count)
+
+      if execution_mode == "background"
+        return enqueue_background_batch(action_name, batch_action_config, batch_op)
+      end
+
+      # Load records for inline execution
+      records = resolve_batch_records
+
+      # Execute inline
+      if built_in_batch_action?(action_name)
+        result = execute_built_in_batch(action_name, records, batch_operation: batch_op)
+        broadcast_model_change(current_model_definition.name)
+      else
+        action_key = find_batch_action_key
+        result = BatchActions::CustomActionDispatcher.new(
+          action_key: action_key, records: records,
+          current_user: current_user, params: action_params,
+          model_class: @model_class, model_definition: current_model_definition,
+          batch_operation: batch_op
+        ).call
+      end
+
+      handle_result(result)
+    end
+
+    private
+
+    def find_single_action_config(action_name)
+      current_presenter.single_actions.find { |a| a["name"] == action_name.to_s }
+    end
+
+    def execute_single_pipeline(record, action_config)
+      # Authorize action steps in the pipeline
+      action_config["pipeline"].each do |step|
+        if step.is_a?(Hash) && step["action"]
+          unless current_evaluator.can_execute_action?(step["action"])
+            raise Pundit::NotAuthorizedError, "not allowed to execute action #{step["action"]}"
+          end
+        end
+      end
+
+      pipeline_result = Actions::FormActionPipeline.execute(
+        record, action_config["pipeline"],
+        user: current_user,
+        evaluator: current_evaluator,
+        model_name: current_presenter.model,
+        model_class: @model_class,
+        params: action_params
+      )
+
+      if pipeline_result.success?
+        pipeline_result.deferred_events.each do |event|
+          Events::Dispatcher.dispatch(**event)
+        end
+
+        handle_result(Actions::Result.new(
+          success: true,
+          message: pipeline_result.message,
+          redirect_to: pipeline_result.redirect_to,
+          data: nil,
+          errors: []
+        ))
+      else
+        handle_result(Actions::Result.new(
+          success: false,
+          message: pipeline_result.errors.first || I18n.t("lcp_ruby.actions.pipeline_failed",
+                                                          default: "Pipeline execution failed"),
+          redirect_to: nil,
+          data: nil,
+          errors: pipeline_result.errors
+        ))
+      end
+    end
+
+    def ensure_action_execution_allowed!
+      return if current_evaluator.can_execute_action?(params[:action_name])
+
+      raise Pundit::NotAuthorizedError, "not allowed to execute action #{params[:action_name]}"
+    end
+
+    def load_action_record!(id)
+      scope = policy_scope(@model_class)
+      scope = apply_soft_delete_scope(scope)
+      record = scope.find(id)
+      authorize record, :show?
+      record
+    end
+
+    def load_action_records!(ids)
+      requested_ids = Array(ids).filter_map { |id| id.presence&.to_s }.uniq
+      scope = policy_scope(@model_class)
+      scope = apply_soft_delete_scope(scope)
+      records = scope.where(@model_class.primary_key => requested_ids)
+      found_ids = records.pluck(@model_class.primary_key).map(&:to_s)
+      missing_ids = requested_ids - found_ids
+
+      raise ActiveRecord::RecordNotFound, "Couldn't find all requested records" if missing_ids.any?
+
+      records.load.each { |record| authorize record, :show? }
+      records
+    end
+
+    def action_params
+      # Return a plain Hash (not ActionController::Parameters) to prevent
+      # accidental mass assignment if handlers pass params to record.update().
+      # Action params are free-form by design — each custom action defines its own schema.
+      params.fetch(:action_params, {}).to_unsafe_h.deep_symbolize_keys
+    end
+
+    def built_in_batch_action?(name)
+      BatchActions::BUILT_IN_ACTIONS.include?(name.to_s)
+    end
+
+    def authorize_built_in_batch(action_name)
+      crud_action = case action_name.to_s
+      when "destroy", "permanently_destroy" then :destroy
+      when "restore" then :update
+      end
+      unless current_evaluator.can?(crud_action)
+        raise Pundit::NotAuthorizedError, "not allowed to execute batch action #{action_name}"
+      end
+    end
+
+    def resolve_batch_records
+      if params[:selection_mode] == "filter"
+        scope = policy_scope(@model_class)
+        scope = apply_soft_delete_scope(scope)
+        scope = apply_batch_filter_search(scope)
+        scope
+      else
+        ids = params[:ids] || []
+        load_batch_records_by_ids(ids)
+      end
+    end
+
+    def load_batch_records_by_ids(ids)
+      scope = policy_scope(@model_class)
+      if current_model_definition.soft_delete?
+        scope = case current_presenter.scope
+        when "discarded" then scope.discarded
+        when "with_discarded" then scope.with_discarded
+        else scope.kept
+        end
+      end
+      scope.where(id: ids)
+    end
+
+    def apply_batch_filter_search(scope)
+      fp = params[:filter_params]&.to_unsafe_h || {}
+
+      # Temporarily inject filter params so apply_advanced_search reads them
+      original_f = params[:f]
+      original_qs = params[:qs]
+      original_filter = params[:filter]
+      original_cf = params[:cf]
+      original_scope_param = params[:scope]
+      original_saved_filter = params[:saved_filter]
+
+      begin
+        params[:f] = fp["f"] if fp.key?("f")
+        params[:qs] = fp["qs"] if fp.key?("qs")
+        params[:filter] = fp["filter"] if fp.key?("filter")
+        params[:cf] = fp["cf"] if fp.key?("cf")
+        params[:scope] = fp["scope"] if fp.key?("scope")
+        params[:saved_filter] = fp["saved_filter"] if fp.key?("saved_filter")
+
+        apply_advanced_search(scope)
+      ensure
+        params[:f] = original_f
+        params[:qs] = original_qs
+        params[:filter] = original_filter
+        params[:cf] = original_cf
+        params[:scope] = original_scope_param
+        params[:saved_filter] = original_saved_filter
+      end
+    end
+
+    def execute_built_in_batch(action_name, records, batch_operation: nil)
+      service_class = case action_name.to_s
+      when "destroy" then BatchActions::DestroyService
+      when "restore" then BatchActions::RestoreService
+      when "permanently_destroy" then BatchActions::PermanentlyDestroyService
+      end
+
+      service_class.new(
+        records: records,
+        evaluator: current_evaluator,
+        model_definition: current_model_definition,
+        current_user: current_user,
+        batch_operation: batch_operation
+      ).call
+    end
+
+    def find_batch_action_config(action_name)
+      current_presenter.batch_actions.find do |a|
+        (a.is_a?(Hash) ? a["name"] : nil) == action_name.to_s
+      end
+    end
+
+    def find_batch_action_key
+      batch_action = current_presenter.batch_actions.find do |a|
+        a["name"] == params[:action_name]
+      end
+
+      if batch_action
+        action_class_key = batch_action.is_a?(Hash) ? batch_action["action_class"] : nil
+        action_class_key || "#{current_presenter.model}/#{params[:action_name]}"
+      else
+        "#{current_presenter.model}/#{params[:action_name]}"
+      end
+    end
+
+    def handle_result(result)
+      fallback = result.redirect_to || resources_path
+      message = result.message
+      message = append_batch_details_link(message, result.data) if result.success? && result.data
+
+      respond_to do |format|
+        if result.success?
+          if result.file_download?
+            format.html {
+              send_data result.data[:file_data],
+                filename: result.data[:filename] || "download",
+                type: result.data[:content_type] || "application/octet-stream",
+                disposition: "attachment"
+            }
+          else
+            format.html { redirect_back(fallback_location: fallback, notice: message) }
+          end
+          format.json { render json: { success: true, message: result.message, data: result.data } }
+        else
+          format.html { redirect_back(fallback_location: fallback, alert: message) }
+          format.json { render json: { success: false, message: result.message, errors: result.errors }, status: :unprocessable_content }
+        end
+      end
+    end
+
+    def batch_record_count
+      if params[:selection_mode] == "filter"
+        scope = policy_scope(@model_class)
+        scope = apply_soft_delete_scope(scope)
+        scope = apply_batch_filter_search(scope)
+        scope.count
+      else
+        (params[:ids] || []).length
+      end
+    end
+
+    def resolve_execution_mode(config, record_count)
+      mode = config&.dig("execution") || "inline"
+      return "inline" if mode == "inline"
+
+      unless BackgroundJobs::Registry.available?
+        Rails.logger.warn("[LcpRuby] Batch action execution '#{mode}' requested but BackgroundJobs not available, falling back to inline")
+        return "inline"
+      end
+
+      return "background" if mode == "background"
+
+      if mode == "auto"
+        threshold = config&.dig("background_threshold") || 100
+        return record_count > threshold ? "background" : "inline"
+      end
+
+      "inline"
+    end
+
+    def enqueue_background_batch(action_name, _config, batch_op)
+      BatchActions.register_background_job!
+
+      job_params = {
+        "action_name" => action_name.to_s,
+        "model_name" => current_model_definition.name,
+        "selection_mode" => params[:selection_mode],
+        "presenter_scope" => current_presenter.scope,
+        "triggered_by_id" => current_user&.id
+      }
+
+      if params[:selection_mode] == "filter"
+        job_params["filter_params"] = (params[:filter_params]&.to_unsafe_h || {})
+      else
+        job_params["ids"] = (params[:ids] || []).map(&:to_s)
+      end
+
+      job_params["batch_operation_id"] = batch_op.id if batch_op
+
+      execution = BackgroundJobs.enqueue(
+        job_type: "batch_action",
+        params: job_params,
+        target_model: current_model_definition.name,
+        triggered_by: current_user
+      )
+
+      count_label = params[:selection_mode] == "filter" ? "matching" : (params[:ids] || []).length.to_s
+      message = I18n.t("lcp_ruby.batch.result.processing_background",
+                        count: count_label,
+                        default: "Processing %{count} records in background...")
+
+      handle_result(Actions::Result.new(
+        success: true,
+        message: message,
+        redirect_to: nil,
+        data: { job_execution_id: execution.id },
+        errors: []
+      ))
+    end
+
+    def apply_soft_delete_scope(scope)
+      return scope unless current_model_definition.soft_delete?
+
+      case current_presenter.scope
+      when "discarded"
+        scope.discarded
+      when "with_discarded"
+        scope.with_discarded
+      else
+        scope.kept
+      end
+    end
+
+    def policy_scope(scope)
+      policy_class = Authorization::PolicyFactory.policy_for(current_presenter.model)
+      policy_class::Scope.new(current_user, scope).resolve
+    end
+
+    def batch_operation_model_available?
+      LcpRuby.registry.model_for("batch_operation")
+    rescue LcpRuby::Registry::ModelNotFoundError
+      false
+    end
+
+    def create_batch_operation(action_name, selection_mode)
+      batch_op_model = LcpRuby.registry.model_for("batch_operation")
+      batch_op_model.create!(
+        operation_type: "batch_action",
+        action_name: action_name.to_s,
+        target_model: current_model_definition.name,
+        presenter_name: current_presenter.name,
+        selection_mode: selection_mode || "ids",
+        status: "processing",
+        created_by_id: current_user&.id
+      )
+    end
+
+    def append_batch_details_link(message, data)
+      return message unless data&.dig(:batch_operation_id)
+
+      op_id = data[:batch_operation_id]
+      flash[:batch_operation_id] = op_id
+      message
+    end
+  end
+end

data/app/controllers/lcp_ruby/application_controller.rb

@@ -0,0 +1,59 @@
+module LcpRuby
+  class ApplicationController < LcpRuby.configuration.parent_controller.constantize
+    helper LcpRuby::I18nPayloadHelper
+    helper LcpRuby::LinkThroughHelper
+    helper LcpRuby::DialogHelper
+    include LcpRuby::Controller::ErrorHandling
+    include LcpRuby::Controller::Authentication
+    include LcpRuby::Controller::BearerAuthentication
+    include LcpRuby::Controller::LocaleBinding
+    include LcpRuby::Controller::PresenterSetup
+    include LcpRuby::Controller::Impersonation
+    include LcpRuby::Controller::Authorization
+    include LcpRuby::Controller::PathHelpers
+    include LcpRuby::Controller::ViewHelpers
+    include LcpRuby::Controller::Search
+    include LcpRuby::Controller::CrudHelpers
+
+    layout "lcp_ruby/application"
+
+    around_action :instrument_request
+
+    private
+
+    def instrument_request
+      # Store request context for error_log_capture_request_context
+      Thread.current[:lcp_ruby_current_request] = request
+      Thread.current[:lcp_ruby_current_user_id] = current_user&.id
+
+      payload = {
+        presenter: @presenter_definition&.name || "",
+        view_group: current_view_group&.name || "",
+        model: @model_definition&.name,
+        action: action_name,
+        method: request.request_method,
+        status: nil
+      }
+
+      ActiveSupport::Notifications.instrument("request.lcp_ruby", payload) do
+        yield
+        payload[:status] = response.status.to_s.first + "xx"
+      end
+    rescue StandardError
+      payload[:status] = "5xx"
+      raise
+    ensure
+      Thread.current[:lcp_ruby_current_request] = nil
+      Thread.current[:lcp_ruby_current_user_id] = nil
+    end
+
+    def broadcast_model_change(model_name)
+      return unless defined?(Turbo::StreamsChannel) && defined?(ActionCable)
+
+      Turbo::StreamsChannel.broadcast_refresh_to("lcp_model_#{model_name}")
+    rescue StandardError => e
+      raise unless Rails.env.production?
+      LcpRuby.record_error(e, subsystem: "broadcast", model: model_name.to_s)
+    end
+  end
+end

data/app/controllers/lcp_ruby/approval_tasks_controller.rb

@@ -0,0 +1,98 @@
+module LcpRuby
+  class ApprovalTasksController < ApplicationController
+    before_action :set_record
+    before_action :set_task
+
+    def approve
+      authorize @record, :show?
+
+      Workflow::Approval::TaskManager.approve_task(
+        @task, user: current_user, comment: params[:comment].presence
+      )
+
+      redirect_to resource_path(@record), status: :see_other,
+        notice: I18n.t("lcp_ruby.flash.approval_task_approved",
+          default: "Task approved successfully.")
+    end
+
+    def reject
+      authorize @record, :show?
+
+      Workflow::Approval::TaskManager.reject_task(
+        @task, user: current_user, comment: params[:comment].presence
+      )
+
+      redirect_to resource_path(@record), status: :see_other,
+        notice: I18n.t("lcp_ruby.flash.approval_task_rejected",
+          default: "Task rejected.")
+    end
+
+    def return_task
+      authorize @record, :show?
+
+      Workflow::Approval::TaskManager.return_task(
+        @task, user: current_user, comment: params[:comment].presence
+      )
+
+      redirect_to resource_path(@record), status: :see_other,
+        notice: I18n.t("lcp_ruby.flash.approval_task_returned",
+          default: "Task returned for rework.")
+    end
+
+    def claim
+      authorize @record, :show?
+
+      Workflow::Approval::TaskManager.claim_task(@task, user: current_user)
+
+      redirect_to resource_path(@record), status: :see_other,
+        notice: I18n.t("lcp_ruby.flash.approval_task_claimed",
+          default: "Task claimed successfully.")
+    end
+
+    def delegate
+      authorize @record, :show?
+
+      delegate_to = params[:delegate_to_user_id]
+      raise Workflow::TaskActionError, "delegate_to_user_id is required" if delegate_to.blank?
+
+      Workflow::Approval::TaskManager.delegate_task(
+        @task, user: current_user, delegate_to_user_id: delegate_to.to_i
+      )
+
+      redirect_to resource_path(@record), status: :see_other,
+        notice: I18n.t("lcp_ruby.flash.approval_task_delegated",
+          default: "Task delegated successfully.")
+    end
+
+    private
+
+    def set_record
+      scope = policy_scope(@model_class)
+      scope = apply_soft_delete_scope(scope)
+      @record = scope.find(params[:id])
+    end
+
+    def set_task
+      task_model = Workflow::Approval::Registry.task_model
+      raise ActiveRecord::RecordNotFound, "Approval system not available" unless task_model
+
+      @task = task_model.find(params[:task_id])
+
+      # Verify task belongs to this record's active approval request
+      request = @record.active_approval_request
+      unless request
+        raise ActiveRecord::RecordNotFound, "No active approval request for this record"
+      end
+
+      step_model = Workflow::Approval::Registry.step_model
+      step = step_model.find_by(id: @task.approval_step_id, approval_request_id: request.id)
+      unless step
+        raise ActiveRecord::RecordNotFound, "Task does not belong to this record's approval request"
+      end
+    end
+
+    rescue_from Workflow::TaskActionError, Workflow::DelegationError do |e|
+      redirect_to resource_path(@record), status: :see_other, alert: e.localized_message
+    end
+  end
+end

data/app/controllers/lcp_ruby/auth/base_controller.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module LcpRuby
+  module Auth
+    # Shared base for all auth controllers.
+    # Provides the built-in mode guard and common setup.
+    module BaseController
+      extend ActiveSupport::Concern
+
+      included do
+        include LcpRuby::Controller::LocaleBinding
+
+        layout "lcp_ruby/auth"
+
+        helper LcpRuby::LayoutHelper
+        helper LcpRuby::OidcButtonHelper
+
+        skip_before_action :set_presenter_and_model, raise: false
+        skip_before_action :authorize_presenter_access, raise: false
+
+        before_action :require_session_based_auth!
+      end
+
+      private
+
+      # Auth controllers (Devise sessions / registrations / OIDC callbacks)
+      # are reachable only when LCP owns the session — i.e. :built_in or :oidc.
+      # Under :external the host owns auth and these routes must 404.
+      def require_session_based_auth!
+        return if LcpRuby::Authentication.session_based?
+
+        raise ActionController::RoutingError, "Not Found"
+      end
+
+      # Single source of truth for "where do we send the user after sign-in".
+      # Both the OIDC callback and Devise sessions controller use this so a
+      # future change to the resolution chain (e.g. landing-page lookup)
+      # only has to land in one place.
+      def signed_in_redirect_path(return_to = nil)
+        return_to || LcpRuby.configuration.auth_after_login_path || lcp_ruby.root_path
+      end
+
+      # Devise stores `request.fullpath` (a relative path) into
+      # session["user_return_to"], so this guard is defense-in-depth: if any
+      # other code path ever writes a full URL there, the redirect must not
+      # become an open redirect to an attacker-controlled host. We only accept
+      # paths that begin with a single slash (`/foo`) — protocol-relative
+      # URLs (`//evil.com`), absolute URLs, and bare schemes are rejected.
+      def safe_return_to(value)
+        return nil if value.blank?
+        s = value.to_s
+        return nil unless s.start_with?("/")
+        return nil if s.start_with?("//", "/\\")
+        s
+      end
+    end
+  end
+end