dscf-credit 0.1.1 → 0.1.3

data/app/serializers/dscf/credit/daily_routine_transaction_serializer.rb

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class DailyRoutineTransactionSerializer < ActiveModel::Serializer
+    attributes :id, :routine_type, :amount, :status, :processed_at,
+               :failure_reason, :created_at, :updated_at
+
+    belongs_to :loan, serializer: LoanSerializer
+  end
+end

data/app/serializers/dscf/credit/eligible_credit_line_serializer.rb

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class EligibleCreditLineSerializer < ActiveModel::Serializer
+    attributes :id, :credit_limit, :available_limit, :risk, :created_at, :updated_at
+
+    belongs_to :loan_profile, serializer: Dscf::Credit::LoanProfileSerializer
+    belongs_to :credit_line, serializer: Dscf::Credit::CreditLineSerializer
+  end
+end

data/app/serializers/dscf/credit/facilitator_performance_serializer.rb

@@ -2,7 +2,7 @@ module Dscf::Credit
   class FacilitatorPerformanceSerializer < ActiveModel::Serializer
     attributes :id, :score, :total_outstanding_loans, :total_outstanding_amount,
                :approval_required, :previous_performance_id, :input_data,
-               :expires_at, :created_at, :updated_at
+               :created_at, :updated_at
 
     belongs_to :facilitator, serializer: Dscf::Credit::FacilitatorSerializer
     belongs_to :created_by, polymorphic: true

data/app/serializers/dscf/credit/facilitator_serializer.rb

@@ -1,11 +1,11 @@
 module Dscf::Credit
   class FacilitatorSerializer < ActiveModel::Serializer
-    attributes :id, :name, :type, :total_limit, :kyc_status,
+    attributes :id, :name, :type, :total_limit, :kyc_status, :kyc_review_date, :review_feedback,
                :created_at, :updated_at
 
     belongs_to :user, serializer: Dscf::Core::UserSerializer
     belongs_to :bank, serializer: Dscf::Credit::BankSerializer
-    belongs_to :kyc_approved_by, polymorphic: true
+    belongs_to :kyc_reviewed_by, polymorphic: true
     has_many :facilitator_performances, serializer: Dscf::Credit::FacilitatorPerformanceSerializer
   end
 end

data/app/serializers/dscf/credit/loan_profile_scoring_spec_serializer.rb

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class LoanProfileScoringSpecSerializer < ActiveModel::Serializer
+    attributes :id, :scoring_input_data, :score, :total_limit, :active, :created_at, :updated_at
+
+    belongs_to :loan_profile, serializer: Dscf::Credit::LoanProfileSerializer
+    belongs_to :created_by
+  end
+end

data/app/serializers/dscf/credit/loan_profile_serializer.rb

@@ -0,0 +1,15 @@
+module Dscf::Credit
+  class LoanProfileSerializer < ActiveModel::Serializer
+    attributes :id, :status, :total_amount, :available_amount, :review_date, :review_feedback, :created_at, :updated_at
+
+    belongs_to :bank, serializer: Dscf::Credit::BankSerializer
+    belongs_to :review_branch, serializer: Dscf::Credit::BankBranchSerializer
+    belongs_to :reviewed_by
+    belongs_to :backer
+    belongs_to :user, serializer: Dscf::Core::UserSerializer
+
+    has_many :loan_profile_scoring_specs, serializer: Dscf::Credit::LoanProfileScoringSpecSerializer
+    has_many :loans, serializer: Dscf::Credit::LoanSerializer
+    has_many :eligible_credit_lines, serializer: Dscf::Credit::EligibleCreditLineSerializer
+  end
+end

data/app/serializers/dscf/credit/loan_serializer.rb

@@ -0,0 +1,12 @@
+module Dscf::Credit
+  class LoanSerializer < ActiveModel::Serializer
+    attributes :id, :status, :principal_amount, :accrued_interest, :accrued_penalty, :facilitation_fee,
+               :total_loan_amount, :remaining_amount, :due_date, :disbursed_at, :created_at, :updated_at
+
+    belongs_to :loan_profile, serializer: LoanProfileSerializer
+    belongs_to :credit_line, serializer: CreditLineSerializer
+    belongs_to :payment_request, serializer: PaymentRequestSerializer
+    has_many :loan_transactions, serializer: LoanTransactionSerializer
+    has_many :daily_routine_transactions, serializer: DailyRoutineTransactionSerializer
+  end
+end

data/app/serializers/dscf/credit/loan_transaction_serializer.rb

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class LoanTransactionSerializer < ActiveModel::Serializer
+    attributes :id, :transaction_type, :amount, :transaction_reference, :status,
+               :created_at, :updated_at
+
+    belongs_to :loan, serializer: LoanSerializer
+  end
+end

data/app/serializers/dscf/credit/payment_request_serializer.rb

@@ -0,0 +1,10 @@
+module Dscf::Credit
+  class PaymentRequestSerializer < ActiveModel::Serializer
+    attributes :id, :order_id, :request_type, :amount, :receiver_account_reference,
+               :status, :failure_reason, :initiated_at, :approved_at, :created_at, :updated_at
+
+    belongs_to :user, serializer: Dscf::Core::UserSerializer
+    has_many :loans, serializer: Dscf::Credit::LoanSerializer
+    has_many :payments, serializer: Dscf::Credit::PaymentSerializer
+  end
+end

data/app/serializers/dscf/credit/payment_serializer.rb

@@ -0,0 +1,8 @@
+module Dscf::Credit
+  class PaymentSerializer < ActiveModel::Serializer
+    attributes :id, :amount, :receiver_account_reference, :transaction_reference,
+               :status, :failure_reason, :processed_at, :created_at, :updated_at
+
+    belongs_to :payment_request, serializer: PaymentRequestSerializer
+  end
+end

data/app/serializers/dscf/credit/scoring_param_type_serializer.rb

@@ -0,0 +1,7 @@
+module Dscf::Credit
+  class ScoringParamTypeSerializer < ActiveModel::Serializer
+    attributes :id, :name, :description, :created_at, :updated_at
+
+    has_many :scoring_parameters, serializer: Dscf::Credit::ScoringParameterSerializer
+  end
+end

data/app/serializers/dscf/credit/scoring_parameter_serializer.rb

@@ -1,12 +1,15 @@
 module Dscf::Credit
   class ScoringParameterSerializer < ActiveModel::Serializer
-    attributes :id, :name, :description, :data_type, :type, :weight, :min_value,
-               :max_value, :active, :expires_at, :created_at, :updated_at
+    attributes :id, :name, :description, :data_type, :weight, :min_value,
+               :max_value, :active, :status, :review_date, :review_feedback, :source, :document_reference, :created_at, :updated_at
 
     belongs_to :bank, serializer: Dscf::Credit::BankSerializer
     belongs_to :created_by, polymorphic: true
-    belongs_to :approved_by, polymorphic: true
+    belongs_to :reviewed_by, polymorphic: true
+    belongs_to :scoring_param_type, serializer: Dscf::Credit::ScoringParamTypeSerializer
     belongs_to :previous_version, serializer: Dscf::Credit::ScoringParameterSerializer
     has_many :parameter_normalizers, serializer: Dscf::Credit::ParameterNormalizerSerializer
+    has_many :scoring_tables, serializer: Dscf::Credit::ScoringTableSerializer
+    has_many :categories, serializer: Dscf::Credit::CategorySerializer
   end
 end

data/app/serializers/dscf/credit/scoring_table_serializer.rb

@@ -2,7 +2,7 @@ module Dscf::Credit
   class ScoringTableSerializer < ActiveModel::Serializer
     attributes :id, :weight, :active, :created_at, :updated_at
 
-    belongs_to :credit_line, serializer: Dscf::Credit::CreditLineSerializer
+    belongs_to :category, serializer: Dscf::Credit::CategorySerializer
     belongs_to :scoring_parameter, serializer: Dscf::Credit::ScoringParameterSerializer
     belongs_to :created_by, serializer: Dscf::Core::UserSerializer
   end

data/app/serializers/dscf/credit/system_config_serializer.rb

@@ -1,6 +1,6 @@
 module Dscf::Credit
   class SystemConfigSerializer < ActiveModel::Serializer
-    attributes :id, :config_value, :status, :created_at, :updated_at
+    attributes :id, :config_value, :status, :review_date, :review_feedback, :created_at, :updated_at
 
     attribute :config_definition do
       {
@@ -13,6 +13,6 @@ module Dscf::Credit
     end
 
     belongs_to :last_updated_by, serializer: Dscf::Core::UserSerializer
-    belongs_to :approved_by, serializer: Dscf::Core::UserSerializer
+    belongs_to :reviewed_by, serializer: Dscf::Core::UserSerializer
   end
 end

data/app/services/dscf/credit/credit_limit_calculation_service.rb

@@ -0,0 +1,153 @@
+module Dscf::Credit
+  class CreditLimitCalculationService
+    attr_reader :loan_profile, :category
+
+    def initialize(loan_profile, category)
+      @loan_profile = loan_profile
+      @category = category
+    end
+
+    # Calculate credit limits for all credit lines in a category for a specific loan profile
+    # @return [Hash] Result containing eligible credit lines with calculated limits
+    def calculate_credit_limits
+      return error_result("Loan profile not found") unless loan_profile
+      return error_result("Category not found") unless category
+
+      scoring_spec = loan_profile.loan_profile_scoring_specs.active.first
+      return error_result("No active scoring found for loan profile") unless scoring_spec
+
+      credit_lines = category.credit_lines.approved.includes(:bank, :category, :credit_line_specs)
+      return error_result("No approved credit lines found for category") if credit_lines.empty?
+
+      eligible_credit_lines = calculate_limits_for_credit_lines(credit_lines, scoring_spec)
+
+      success_result(eligible_credit_lines)
+    rescue StandardError => e
+      error_result("Credit limit calculation failed: #{e.message}")
+    end
+
+    private
+
+    def calculate_limits_for_credit_lines(credit_lines, scoring_spec)
+      results = []
+
+      credit_lines.each do |credit_line|
+        limit_data = calculate_individual_credit_limit(credit_line, scoring_spec)
+        next if limit_data[:credit_limit] <= 0
+
+        eligible_credit_line = find_or_create_eligible_credit_line(credit_line)
+        eligible_credit_line.assign_attributes(limit_data)
+
+        if eligible_credit_line.save
+          results << {
+            credit_line: credit_line,
+            eligible_credit_line: eligible_credit_line,
+            calculated_limit: limit_data[:credit_limit],
+            available_limit: limit_data[:available_limit],
+            risk_factor: limit_data[:risk]
+          }
+        end
+      end
+
+      results
+    end
+
+    def calculate_individual_credit_limit(credit_line, scoring_spec)
+      base_limit = scoring_spec.total_limit
+
+      credit_line_specs = credit_line.credit_line_specs.active
+      adjusted_limit = apply_credit_line_specifications(base_limit, credit_line_specs)
+
+      risk_factor = calculate_risk_factor(credit_line, loan_profile)
+      final_limit = adjusted_limit * (1 - risk_factor)
+
+      used_limit = calculate_used_limit(credit_line)
+      available_limit = [ final_limit - used_limit, 0 ].max
+
+      {
+        credit_limit: final_limit.round(2),
+        available_limit: available_limit.round(2),
+        risk: risk_factor.round(4)
+      }
+    end
+
+    def apply_credit_line_specifications(base_limit, credit_line_specs)
+      return base_limit if credit_line_specs.empty?
+
+      spec = credit_line_specs.first
+      return base_limit unless spec
+
+      if spec.credit_line_multiplier && spec.credit_line_multiplier > 0
+        adjustment_factor = spec.credit_line_multiplier / 30.0 # Normalize against default 30 days
+        adjusted_limit = base_limit * adjustment_factor
+      else
+        adjusted_limit = base_limit
+      end
+
+      if spec.max_amount && adjusted_limit > spec.max_amount
+        adjusted_limit = spec.max_amount
+      end
+
+      if spec.min_amount && adjusted_limit < spec.min_amount
+        adjusted_limit = spec.min_amount
+      end
+
+      adjusted_limit
+    end
+
+    def calculate_risk_factor(credit_line, loan_profile)
+      base_risk = 0.1 # 10% base risk
+
+      # Increase risk based on loan profile characteristics
+      risk_adjustments = 0.0
+
+      # Risk based on previous loan performance
+      if loan_profile.loans.overdue.any?
+        risk_adjustments += 0.2 # 20% additional risk for overdue loans
+      end
+
+      # Risk based on available amount vs total amount ratio
+      if loan_profile.total_amount > 0
+        utilization_ratio = (loan_profile.total_amount - loan_profile.available_amount) / loan_profile.total_amount
+        risk_adjustments += utilization_ratio * 0.1 # Up to 10% additional risk
+      end
+
+      # Risk based on credit line category
+      case credit_line.category.name.downcase
+      when "high_risk"
+        risk_adjustments += 0.15
+      when "medium_risk"
+        risk_adjustments += 0.05
+      end
+
+      # Cap total risk at 90%
+      [ base_risk + risk_adjustments, 0.9 ].min
+    end
+
+    def calculate_used_limit(credit_line)
+      credit_line.loans.where(status: [ "active", "overdue" ]).sum(:remaining_amount)
+    end
+
+    def find_or_create_eligible_credit_line(credit_line)
+      loan_profile.eligible_credit_lines.find_or_initialize_by(credit_line: credit_line)
+    end
+
+    def success_result(eligible_credit_lines)
+      {
+        success: true,
+        data: eligible_credit_lines,
+        message: "Credit limits calculated successfully",
+        count: eligible_credit_lines.size
+      }
+    end
+
+    def error_result(message)
+      {
+        success: false,
+        data: [],
+        error: message,
+        count: 0
+      }
+    end
+  end
+end

data/app/services/dscf/credit/disbursement_service.rb

@@ -0,0 +1,180 @@
+module Dscf::Credit
+  class DisbursementService
+    attr_reader :credit_line, :payment_request, :current_user
+
+    def initialize(credit_line, payment_request, current_user)
+      @credit_line = credit_line
+      @payment_request = payment_request
+      @current_user = current_user
+    end
+
+    # Process disbursement by creating a loan record from selected credit line
+    # @return [Hash] Result containing created loan and disbursement details
+    def process_disbursement
+      return error_result("Credit line not found") unless credit_line
+      return error_result("Payment request not found") unless payment_request
+      return error_result("Credit line is not approved") unless credit_line.status == "approved"
+
+      eligible_credit_line = find_eligible_credit_line
+      return error_result("No eligible credit line found") unless eligible_credit_line
+
+      loan_profile = eligible_credit_line.loan_profile
+      return error_result("Loan profile not approved") unless loan_profile.status == "approved"
+
+      validation_result = validate_disbursement_amount(eligible_credit_line)
+      return validation_result unless validation_result[:success]
+
+      ActiveRecord::Base.transaction do
+        loan = create_loan_record(loan_profile, eligible_credit_line)
+        process_payment_and_charges(loan)
+        update_credit_line_limits(eligible_credit_line, loan)
+        lock_other_credit_lines(loan_profile, credit_line)
+
+        success_result(loan)
+      end
+    rescue StandardError => e
+      error_result("Disbursement processing failed: #{e.message}")
+    end
+
+    private
+
+    def find_eligible_credit_line
+      credit_line.eligible_credit_lines
+                 .joins(:loan_profile)
+                 .where(dscf_credit_loan_profiles: { status: "approved" })
+                 .first
+    end
+
+    def validate_disbursement_amount(eligible_credit_line)
+      requested_amount = payment_request.amount
+      available_limit = eligible_credit_line.available_limit
+
+      if requested_amount <= 0
+        return error_result("Invalid disbursement amount")
+      end
+
+      if requested_amount > available_limit
+        return error_result("Requested amount exceeds available credit limit")
+      end
+
+      { success: true }
+    end
+
+    def create_loan_record(loan_profile, eligible_credit_line)
+      loan_terms = calculate_loan_terms(eligible_credit_line)
+
+      loan = Dscf::Credit::Loan.new(
+        loan_profile: loan_profile,
+        credit_line: credit_line,
+        payment_request: payment_request,
+        principal_amount: payment_request.amount,
+        facilitation_fee: loan_terms[:facilitation_fee],
+        total_loan_amount: loan_terms[:total_amount],
+        remaining_amount: loan_terms[:total_amount],
+        accrued_interest: 0,
+        accrued_penalty: 0,
+        status: "disbursed",
+        due_date: loan_terms[:due_date],
+        disbursed_at: Time.current
+      )
+
+      raise "Failed to create loan: #{loan.errors.full_messages.join(', ')}" unless loan.save
+
+      loan
+    end
+
+    def calculate_loan_terms(eligible_credit_line)
+      principal = payment_request.amount
+
+      credit_line_spec = credit_line.credit_line_specs.active.first
+
+      if credit_line_spec
+        facilitation_rate = credit_line_spec.facilitation_fee_rate
+        vat_rate = credit_line_spec.vat
+        loan_duration = credit_line_spec.loan_duration
+      else
+        facilitation_rate = 0.02  # 2%
+        vat_rate = 0.15          # 15%
+        loan_duration = 30       # 30 days
+      end
+
+      facilitation_fee = principal * facilitation_rate
+      vat_amount = facilitation_fee * vat_rate
+      total_amount = principal + facilitation_fee + vat_amount
+
+      due_date = Date.current + loan_duration.days
+
+      {
+        facilitation_fee: facilitation_fee.round(2),
+        vat_amount: vat_amount.round(2),
+        total_amount: total_amount.round(2),
+        due_date: due_date
+      }
+    end
+
+    def process_payment_and_charges(loan)
+      payment_request.update!(
+        status: "processed",
+        approved_at: Time.current
+      )
+
+      Dscf::Credit::LoanTransaction.create!(
+        loan: loan,
+        transaction_type: "disbursement",
+        amount: loan.principal_amount,
+        transaction_reference: "DISB-#{payment_request.order_id}-#{Time.current.to_i}",
+        status: "completed"
+      )
+
+      if loan.facilitation_fee > 0
+        Dscf::Credit::LoanTransaction.create!(
+          loan: loan,
+          transaction_type: "fee_charge",
+          amount: loan.facilitation_fee,
+          transaction_reference: "FEE-#{loan.id}-#{Time.current.to_i}",
+          status: "completed"
+        )
+      end
+    end
+
+    def update_credit_line_limits(eligible_credit_line, loan)
+      new_available_limit = eligible_credit_line.available_limit - loan.total_loan_amount
+      eligible_credit_line.update!(available_limit: [ new_available_limit, 0 ].max)
+
+      # Update loan profile available amount
+      loan_profile = eligible_credit_line.loan_profile
+      new_profile_available = loan_profile.available_amount - loan.total_loan_amount
+      loan_profile.update!(available_amount: [ new_profile_available, 0 ].max)
+    end
+
+    def lock_other_credit_lines(loan_profile, current_credit_line)
+      other_eligible_lines = loan_profile.eligible_credit_lines
+                                        .where.not(credit_line: current_credit_line)
+
+      other_eligible_lines.update_all(available_limit: 0)
+    end
+
+    def success_result(loan)
+      {
+        success: true,
+        loan: loan,
+        disbursement_details: {
+          principal_amount: loan.principal_amount,
+          facilitation_fee: loan.facilitation_fee,
+          total_loan_amount: loan.total_loan_amount,
+          due_date: loan.due_date,
+          disbursed_at: loan.disbursed_at
+        },
+        message: "Disbursement processed successfully"
+      }
+    end
+
+    def error_result(message)
+      {
+        success: false,
+        loan: nil,
+        error: message
+      }
+    end
+  end
+end

data/app/services/dscf/credit/facilitator_approval_service.rb

@@ -29,15 +29,16 @@ module Dscf::Credit
       end
     end
 
-    def reject(rejection_reason = nil)
+    def reject(review_feedback = nil)
       ActiveRecord::Base.transaction do
         facilitator.update!(
           kyc_status: "rejected",
-          kyc_approved_by: approver
+          kyc_approved_by: approver,
+          review_feedback: review_feedback
         )
 
         begin
-          FacilitatorMailer.rejection_notification(facilitator, rejection_reason).deliver_now
+          FacilitatorMailer.rejection_notification(facilitator, review_feedback).deliver_now
         rescue => e
           Rails.logger.error "Failed to send rejection email: #{e.message}"
         end

data/app/services/dscf/credit/facilitator_creation_service.rb

@@ -0,0 +1,157 @@
+module Dscf::Credit
+  class FacilitatorCreationService
+    attr_reader :current_user, :facilitator_class
+
+    def initialize(current_user, facilitator_class = Dscf::Credit::Facilitator)
+      @current_user = current_user
+      @facilitator_class = facilitator_class
+    end
+
+    # Creates a single facilitator
+    # @param facilitator_params [Hash] The facilitator parameters
+    # @return [Dscf::Credit::Facilitator] The created facilitator
+    # @raise [StandardError] If creation fails
+    def create_single(facilitator_params)
+      ActiveRecord::Base.transaction do
+        facilitator_data = build_facilitator_data(facilitator_params)
+        facilitator = facilitator_class.new(facilitator_data)
+        facilitator.kyc_reviewed_by = current_user
+        facilitator.kyc_review_date = Time.current
+
+        if facilitator.save
+          create_initial_performance(facilitator)
+          facilitator
+        else
+          raise StandardError, facilitator.errors.full_messages.join(", ")
+        end
+      end
+    end
+
+    # Creates multiple facilitators in batch
+    # @param facilitators_params [Array<Hash>] Array of facilitator parameters
+    # @return [Hash] Results containing successful and failed creations
+    def create_batch(facilitators_params)
+      validate_batch_params(facilitators_params)
+
+      results = initialize_batch_results(facilitators_params.length)
+
+      facilitators_params.each_with_index do |facilitator_attrs, index|
+        process_single_facilitator_in_batch(facilitator_attrs, index, results)
+      end
+
+      results
+    end
+
+    private
+
+    def build_facilitator_data(facilitator_params)
+      user = find_user(facilitator_params[:user_id])
+      business = find_user_business(user)
+
+      facilitator_params.to_h.merge(
+        name: business.name,
+        type: business.business_type.name.downcase
+      )
+    end
+
+    def find_user(user_id)
+      user = Dscf::Core::User.find(user_id)
+      raise StandardError, "User not found with ID: #{user_id}" unless user
+      user
+    rescue ActiveRecord::RecordNotFound
+      raise StandardError, "User not found with ID: #{user_id}"
+    end
+
+    def find_user_business(user)
+      business = user.businesses.first
+      raise StandardError, "User must have a business associated to become a facilitator" unless business
+      business
+    end
+
+    def create_initial_performance(facilitator)
+      facilitator.facilitator_performances.create!(
+        total_outstanding_loans: 0,
+        total_outstanding_amount: 0.0,
+        approval_required: false,
+        created_by: current_user
+      )
+    end
+
+    def validate_batch_params(facilitators_params)
+      unless facilitators_params.is_a?(Array)
+        raise StandardError, "Expected an array of facilitator objects"
+      end
+
+      if facilitators_params.empty?
+        raise StandardError, "At least one facilitator is required"
+      end
+
+      if facilitators_params.length > 100
+        raise StandardError, "Maximum 100 facilitators allowed per batch"
+      end
+    end
+
+    def initialize_batch_results(total_count)
+      {
+        successful: [],
+        failed: [],
+        total_count: total_count,
+        success_count: 0,
+        failure_count: 0
+      }
+    end
+
+    def process_single_facilitator_in_batch(facilitator_attrs, index, results)
+      begin
+        permitted_attrs = permit_facilitator_attrs(facilitator_attrs)
+        facilitator = create_single(permitted_attrs)
+
+        add_successful_result(results, index, facilitator)
+      rescue StandardError => e
+        add_failed_result(results, index, facilitator_attrs, e)
+      end
+    end
+
+    def permit_facilitator_attrs(facilitator_attrs)
+      if facilitator_attrs.is_a?(ActionController::Parameters)
+        facilitator_attrs.permit(:user_id, :bank_id, :kyc_status)
+      else
+        ActionController::Parameters.new(facilitator_attrs)
+                                    .permit(:user_id, :bank_id, :kyc_status)
+      end
+    end
+
+    def add_successful_result(results, index, facilitator)
+      results[:successful] << {
+        index: index,
+        id: facilitator.id,
+        name: facilitator.name,
+        message: "Successfully created"
+      }
+      results[:success_count] += 1
+    end
+
+    def add_failed_result(results, index, facilitator_attrs, error)
+      business_name = extract_business_name_for_error(facilitator_attrs)
+
+      results[:failed] << {
+        index: index,
+        name: business_name,
+        errors: [ error.message ]
+      }
+      results[:failure_count] += 1
+    end
+
+    def extract_business_name_for_error(facilitator_attrs)
+      user_id = facilitator_attrs.try(:[], :user_id) || facilitator_attrs[:user_id]
+      return "Unknown Business" unless user_id
+
+      begin
+        user = Dscf::Core::User.find(user_id)
+        user.businesses.first&.name || "No Business Associated"
+      rescue
+        "Invalid User ID"
+      end
+    end
+  end
+end