dscf-credit 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b98c5581c2ba2394b35bee75cce5a9f8de59cf7c94c12f1b8d162988a2e8a285
-  data.tar.gz: 6a377eaa47bd1b079f77fb24b408ebdbaf37e498703d85e3f39fbe5b0d233779
+  metadata.gz: 3a206be7d1f68e8a83476b508b3238c990eb67226243a5f242d3149828454891
+  data.tar.gz: 2fb1cc62bf33eaf81c4dd52e8413ab9bb2bfa186287b4714b603cb95360fe522
 SHA512:
-  metadata.gz: 8ddcceea25d14c51c2af4e3ec279751f8a69193afa3a0e8713de2fc6acb9470f0691067e3c3cbbf34b4727acb905714402c22abbc4e0e0b8bdc20bfdf16ef6a5
-  data.tar.gz: 620cd65a6e50a64c084aeba071ba854bc10ee9a01fd8acccb3b740c51245fc0b0138fcb249e80261fbf305c1ebe6572841d89bc882d442f9e2e09c6add0bf16e
+  metadata.gz: cc931ad8d941a12b6d4680a761ea5210982ed5714e54bd2aec47a74444fea96e92a526250301d4391194da9bf389e92c4253818e6540fafdbf2d9d3d7728b0d7
+  data.tar.gz: c24155a0a4ef04ebfa0366d523feeba334842be98dcff13708447af5b286a81b0a5118786f785748b0f65c1e76c263b98b6e44196cc55e2501381eceadaf2bf4

data/app/controllers/dscf/credit/loan_accruals_controller.rb

@@ -0,0 +1,113 @@
+module Dscf::Credit
+  class LoanAccrualsController < ApplicationController
+    include Dscf::Core::Common
+
+    def generate
+      service = LoanAccrualGeneratorService.new(
+        loan_ids: params[:loan_ids],
+        accrual_date: parse_accrual_date,
+        force_regenerate: ActiveModel::Type::Boolean.new.cast(params[:force_regenerate])
+      )
+
+      result = service.generate_daily_accruals
+
+      if result[:success]
+        render_success(
+          result[:message],
+          data: result,
+          status: :created
+        )
+      else
+        render_error(
+          result[:message],
+          errors: result[:errors],
+          status: :unprocessable_entity
+        )
+      end
+    end
+
+    def statistics
+      loan = Loan.find(params[:loan_id])
+
+      stats = {
+        loan_id: loan.id,
+        principal_amount: loan.principal_amount,
+        remaining_amount: loan.remaining_amount,
+        total_facilitation_fee: loan.total_facilitation_fee,
+        total_interest: loan.total_interest,
+        total_penalty: loan.total_penalty,
+        total_vat: loan.total_vat,
+        total_outstanding: loan.total_outstanding,
+        accrual_breakdown: {
+          facilitation_fee: {
+            pending: loan.loan_accruals.where(accrual_type: "facilitation_fee", status: "pending").sum(:amount),
+            paid: loan.loan_accruals.where(accrual_type: "facilitation_fee", status: "paid").sum(:amount)
+          },
+          tax: {
+            pending: loan.loan_accruals.where(accrual_type: "tax", status: "pending").sum(:amount),
+            paid: loan.loan_accruals.where(accrual_type: "tax", status: "paid").sum(:amount)
+          },
+          interest: {
+            pending: loan.loan_accruals.where(accrual_type: "interest", status: "pending").sum(:amount),
+            paid: loan.loan_accruals.where(accrual_type: "interest", status: "paid").sum(:amount)
+          },
+          penalty: {
+            pending: loan.loan_accruals.where(accrual_type: "penalty", status: "pending").sum(:amount),
+            paid: loan.loan_accruals.where(accrual_type: "penalty", status: "paid").sum(:amount)
+          }
+        },
+        accrual_count: {
+          total: loan.loan_accruals.count,
+          pending: loan.loan_accruals.where(status: "pending").count,
+          paid: loan.loan_accruals.where(status: "paid").count,
+          cancelled: loan.loan_accruals.where(status: "cancelled").count
+        }
+      }
+
+      render_success(
+        "Loan accrual statistics retrieved successfully",
+        data: stats
+      )
+    end
+
+    private
+
+    # Parse accrual_date parameter
+    #
+    # @return [Date] Parsed date or Date.current
+    def parse_accrual_date
+      return Date.current unless params[:accrual_date].present?
+
+      Date.parse(params[:accrual_date].to_s)
+    rescue ArgumentError
+      Date.current
+    end
+
+    def model_params
+      params.require(:loan_accrual).permit(
+        :loan_id,
+        :accrual_type,
+        :amount,
+        :applied_on,
+        :status
+      )
+    end
+
+    def eager_loaded_associations
+      [ :loan ]
+    end
+
+    def allowed_order_columns
+      %w[id accrual_type amount applied_on status created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [ :loan ],
+        show: [ :loan ],
+        create: [ :loan ],
+        update: [ :loan ]
+      }
+    end
+  end
+end

data/app/controllers/dscf/credit/loan_applications_controller.rb

@@ -62,17 +62,17 @@ module Dscf::Credit
 
     def calculate_credit_score
       loan_application = @clazz.find(params[:id])
-      category_id = score_params[:category_id]
+      scoring_param_type_id = score_params[:scoring_param_type_id]
 
-      unless category_id
+      unless scoring_param_type_id
         return render_error(
           "loan_application.errors.calculate_credit_score",
-          errors: [ "Category ID is required for credit scoring" ],
+          errors: [ "Scoring parameter type ID is required for credit scoring" ],
           status: :unprocessable_entity
         )
       end
 
-      scoring_engine = CreditScoringEngine.new(loan_application.id, category_id)
+      scoring_engine = CreditScoringEngine.new(loan_application.id, scoring_param_type_id)
       result = scoring_engine.calculate_score
 
       if result[:success]
@@ -215,7 +215,7 @@ module Dscf::Credit
     end
 
     def score_params
-      params.permit(:category_id)
+      params.permit(:scoring_param_type_id)
     end
 
     def eager_loaded_associations

data/app/controllers/dscf/credit/loan_profiles_controller.rb

@@ -105,7 +105,8 @@ module Dscf::Credit
 
     def eager_loaded_associations
       [
-        :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines,
+        :loan_application, :loan_profile_scoring_specs, :loans,
+        { eligible_credit_lines: :credit_line },
         reviews: { reviewed_by: :user_profile }
       ]
     end
@@ -116,13 +117,17 @@ module Dscf::Credit
 
     def default_serializer_includes
       {
-        index: [ :loan_application, reviews: { reviewed_by: :user_profile } ],
+        index: [ :loan_application, { eligible_credit_lines: :credit_line },
+                 reviews: { reviewed_by: :user_profile } ],
         show: [
-          :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines, reviews: { reviewed_by: :user_profile }
+          :loan_application, :loan_profile_scoring_specs, :loans,
+          { eligible_credit_lines: :credit_line },
+          reviews: { reviewed_by: :user_profile }
         ],
         create: [ :loan_application, :loan_profile_scoring_specs, :reviews ],
         update: [
-          :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines,
+          :loan_application, :loan_profile_scoring_specs, :loans,
+          { eligible_credit_lines: :credit_line },
           reviews: { reviewed_by: :user_profile }
         ]
       }

data/app/controllers/dscf/credit/loans_controller.rb

@@ -10,10 +10,6 @@ module Dscf::Credit
         :credit_line_id,
         :status,
         :principal_amount,
-        :accrued_interest,
-        :accrued_penalty,
-        :facilitation_fee,
-        :total_loan_amount,
         :remaining_amount,
         :due_date,
         :disbursed_at,
@@ -22,11 +18,11 @@ module Dscf::Credit
     end
 
     def eager_loaded_associations
-      [ :loan_profile, :credit_line, :loan_transactions ]
+      [ :loan_profile, :credit_line, :loan_transactions, :loan_accruals ]
     end
 
     def allowed_order_columns
-      %w[id status principal_amount total_loan_amount remaining_amount due_date disbursed_at created_at updated_at]
+      %w[id status principal_amount remaining_amount due_date disbursed_at created_at updated_at]
     end
 
     def default_serializer_includes

data/app/controllers/dscf/credit/repayments_controller.rb

@@ -4,7 +4,7 @@ module Dscf::Credit
       loan = Dscf::Credit::Loan.find(params[:loan_id])
       payment_amount = params[:amount].to_f
 
-      service = Dscf::Credit::RepaymentService.new(loan, payment_amount, current_user)
+      service = Dscf::Credit::RepaymentService.new(loan, payment_amount)
       result = service.process_repayment
 
       if result[:success]
@@ -18,8 +18,7 @@ module Dscf::Credit
             include: [
               :loan_profile,
               :credit_line,
-              :payment_request,
-              :loan_transactions
+              :loan_accruals
             ]
           }
         )

data/app/controllers/dscf/credit/scoring_parameters_controller.rb

@@ -62,7 +62,7 @@ module Dscf::Credit
 
     def default_serializer_includes
       {
-        index: [ :bank, :category, reviews: { reviewed_by: :user_profile } ],
+        index: [ :bank, :category, :parameter_normalizers, reviews: { reviewed_by: :user_profile } ],
         show: [
           :bank, :category, :created_by, :scoring_param_type, :previous_version, :parameter_normalizers,
           reviews: { reviewed_by: :user_profile }

data/app/controllers/dscf/credit/users_controller.rb

@@ -16,8 +16,14 @@ module Dscf::Credit
             )
           end
 
+          rejected_user_ids = Dscf::Credit::FacilitatorApplication.joins(:reviews)
+                                                                 .where(dscf_core_reviews: { status: "rejected" })
+                                                                 .pluck(:user_id)
+                                                                 .uniq
+
           @clazz.joins(businesses: :business_type)
                 .where(dscf_core_business_types: { name: business_type_name })
+                .where(id: rejected_user_ids)
                 .distinct
         else
           @clazz.all

data/app/jobs/dscf/credit/generate_daily_accruals_job.rb

@@ -0,0 +1,78 @@
+module Dscf::Credit
+  # Background job to generate daily loan accruals
+  #
+  # This job should be scheduled to run daily (typically at midnight or early morning)
+  # to generate interest and penalty accruals for all active loans.
+  #
+  # @example Schedule with Sidekiq (config/sidekiq.yml)
+  #   :schedule:
+  #     generate_daily_accruals:
+  #       cron: '0 1 * * *'  # Run at 1 AM daily
+  #       class: Dscf::Credit::GenerateDailyAccrualsJob
+  #
+  # @example Schedule with whenever gem (config/schedule.rb)
+  #   every 1.day, at: '1:00 am' do
+  #     runner "Dscf::Credit::GenerateDailyAccrualsJob.perform_later"
+  #   end
+  #
+  # @example Manual execution
+  #   Dscf::Credit::GenerateDailyAccrualsJob.perform_now
+  #
+  # @example With specific parameters
+  #   Dscf::Credit::GenerateDailyAccrualsJob.perform_later(
+  #     loan_ids: [1, 2, 3],
+  #     accrual_date: Date.yesterday
+  #   )
+  class GenerateDailyAccrualsJob < ApplicationJob
+    queue_as :default
+
+    # Perform the job to generate daily accruals
+    #
+    # @param loan_ids [Array<Integer>, nil] Optional specific loan IDs to process
+    # @param accrual_date [String, Date] Date for accrual generation (defaults to today)
+    # @param force_regenerate [Boolean] Whether to regenerate existing accruals
+    def perform(loan_ids: nil, accrual_date: nil, force_regenerate: false)
+      date = accrual_date ? Date.parse(accrual_date.to_s) : Date.current
+
+      service = LoanAccrualGeneratorService.new(
+        loan_ids: loan_ids,
+        accrual_date: date,
+        force_regenerate: force_regenerate
+      )
+
+      result = service.generate_daily_accruals
+
+      log_result(result)
+
+      result
+    end
+
+    private
+
+    # Log the result of accrual generation
+    #
+    # @param result [Hash] The result from the service
+    def log_result(result)
+      if result[:success]
+        Rails.logger.info(
+          "Loan Accrual Generation: #{result[:message]}"
+        )
+
+        if result[:errors].any?
+          Rails.logger.warn(
+            "Loan Accrual Generation Warnings: #{result[:errors].size} loans had errors"
+          )
+          result[:errors].each do |error|
+            Rails.logger.warn(
+              "Loan #{error[:loan_id]}: #{error[:error]}"
+            )
+          end
+        end
+      else
+        Rails.logger.error(
+          "Loan Accrual Generation Failed: #{result[:message]}"
+        )
+      end
+    end
+  end
+end

data/app/models/dscf/credit/loan.rb

@@ -6,10 +6,11 @@ module Dscf::Credit
     belongs_to :credit_line, class_name: "Dscf::Credit::CreditLine", foreign_key: "credit_line_id"
     has_many :loan_transactions, class_name: "Dscf::Credit::LoanTransaction", foreign_key: "loan_id", dependent: :destroy
     has_many :daily_routine_transactions, class_name: "Dscf::Credit::DailyRoutineTransaction", foreign_key: "loan_id", dependent: :destroy
+    has_many :loan_accruals, class_name: "Dscf::Credit::LoanAccrual", foreign_key: "loan_id", dependent: :destroy
 
-    validates :principal_amount, :total_loan_amount, :remaining_amount, :due_date, presence: true
-    validates :principal_amount, :total_loan_amount, :remaining_amount, numericality: { greater_than: 0 }
-    validates :accrued_interest, :accrued_penalty, :facilitation_fee, numericality: { greater_than_or_equal_to: 0 }
+    validates :principal_amount, :remaining_amount, :due_date, presence: true
+    validates :principal_amount, numericality: { greater_than: 0 }
+    validates :remaining_amount, numericality: { greater_than_or_equal_to: 0 }
     validates :status, inclusion: { in: %w[pending approved disbursed active overdue paid closed] }
 
     scope :active, -> { where(active: true) }
@@ -20,14 +21,34 @@ module Dscf::Credit
     scope :past_due, -> { where("due_date < ? AND status IN (?)", Date.current, [ "active", "overdue" ]) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id status principal_amount accrued_interest accrued_penalty facilitation_fee total_loan_amount remaining_amount due_date disbursed_at active created_at updated_at]
+      %w[id status principal_amount remaining_amount due_date disbursed_at active created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[loan_profile credit_line loan_transactions daily_routine_transactions]
+      %w[loan_profile credit_line loan_transactions daily_routine_transactions loan_accruals]
     end
 
     delegate :user, to: :loan_profile, allow_nil: true
     delegate :bank, to: :credit_line, allow_nil: true
+
+    def total_facilitation_fee
+      loan_accruals.where(accrual_type: "facilitation_fee", status: "pending").sum(:amount)
+    end
+
+    def total_interest
+      loan_accruals.where(accrual_type: "interest", status: "pending").sum(:amount)
+    end
+
+    def total_penalty
+      loan_accruals.where(accrual_type: "penalty", status: "pending").sum(:amount)
+    end
+
+    def total_vat
+      loan_accruals.where(accrual_type: "tax", status: "pending").sum(:amount)
+    end
+
+    def total_outstanding
+      remaining_amount + loan_accruals.where(status: "pending").sum(:amount)
+    end
   end
 end

data/app/models/dscf/credit/loan_accrual.rb

@@ -0,0 +1,25 @@
+module Dscf::Credit
+  class LoanAccrual < ApplicationRecord
+    self.table_name = "dscf_credit_loan_accruals"
+
+    belongs_to :loan, class_name: "Dscf::Credit::Loan", foreign_key: "loan_id"
+
+    validates :accrual_type, :amount, :applied_on, presence: true
+    validates :amount, numericality: { greater_than: 0 }
+    validates :accrual_type, inclusion: { in: %w[interest penalty tax facilitation_fee late_fee other] }
+    validates :status, inclusion: { in: %w[pending paid cancelled] }
+
+    scope :pending, -> { where(status: "pending") }
+    scope :paid, -> { where(status: "paid") }
+    scope :by_type, ->(type) { where(accrual_type: type) }
+    scope :for_date_range, ->(start_date, end_date) { where(applied_on: start_date..end_date) }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id accrual_type amount applied_on status created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[loan]
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Dscf::Credit
+  class LoanAccrualSerializer < ActiveModel::Serializer
+    attributes :id, :accrual_type, :amount, :applied_on, :status, :created_at, :updated_at
+
+    belongs_to :loan, serializer: LoanSerializer
+  end
+end

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

@@ -1,11 +1,44 @@
 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, :active, :created_at, :updated_at
+    attributes :id,
+               :status,
+               :principal_amount,
+               :remaining_amount,
+               :due_date,
+               :disbursed_at,
+               :total_interest,
+               :total_penalty,
+               :total_vat,
+               :total_facilitation_fee,
+               :total_outstanding,
+               :active,
+               :created_at,
+               :updated_at
 
     belongs_to :loan_profile, serializer: LoanProfileSerializer
     belongs_to :credit_line, serializer: CreditLineSerializer
     has_many :loan_transactions, serializer: LoanTransactionSerializer
     has_many :daily_routine_transactions, serializer: DailyRoutineTransactionSerializer
+    has_many :loan_accruals, serializer: LoanAccrualSerializer
+
+    def total_interest
+      object.total_interest
+    end
+
+    def total_penalty
+      object.total_penalty
+    end
+
+    def total_vat
+      object.total_vat
+    end
+
+    def total_facilitation_fee
+      object.total_facilitation_fee
+    end
+
+    def total_outstanding
+      object.total_outstanding
+    end
   end
 end

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

@@ -1,22 +1,22 @@
 module Dscf::Credit
   class CreditScoringEngine
-    attr_reader :loan_application, :category_id, :errors
+    attr_reader :loan_application, :scoring_param_type_id, :errors
 
-    def initialize(loan_application_id, category_id)
+    def initialize(loan_application_id, scoring_param_type_id)
       @loan_application = find_loan_application(loan_application_id)
-      @category_id = category_id
+      @scoring_param_type_id = scoring_param_type_id
       @errors = []
     end
 
     def calculate_score
       return error_result("Loan application not found") unless loan_application
-      return error_result("Category ID is required") unless category_id
+      return error_result("Scoring parameter type ID is required") unless scoring_param_type_id
 
       begin
         scoring_parameters = get_active_scoring_parameters
 
         if scoring_parameters.empty?
-          return error_result("No active scoring parameters found for this bank for category ID #{category_id}")
+          return error_result("No active scoring parameters found for this bank for scoring parameter type ID #{scoring_param_type_id}")
         end
 
         # Calculate weighted score using the formula
@@ -45,7 +45,7 @@ module Dscf::Credit
       loan_application.bank
                      .scoring_parameters
                      .active
-                     .where(category_id: category_id)
+                     .where(scoring_param_type_id: scoring_param_type_id)
                      .includes(:scoring_param_type, :parameter_normalizers, :category)
     end
 
@@ -217,7 +217,7 @@ module Dscf::Credit
         success: true,
         loan_application_id: loan_application.id,
         bank_id: loan_application.bank_id,
-        category_id: category_id,
+        scoring_param_type_id: scoring_param_type_id,
         calculated_at: Time.current,
         score: final_score,
         status: review_status,
@@ -235,7 +235,7 @@ module Dscf::Credit
       {
         success: false,
         loan_application_id: loan_application&.id,
-        category_id: category_id,
+        scoring_param_type_id: scoring_param_type_id,
         error: message,
         errors: @errors,
         score: 0.0,

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

@@ -60,11 +60,7 @@ module Dscf::Credit
         loan_profile: loan_profile,
         credit_line: credit_line,
         principal_amount: 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,
+        remaining_amount: amount,  # Only principal amount, not total
         status: "disbursed",
         due_date: loan_terms[:due_date],
         disbursed_at: Time.current,
@@ -73,6 +69,12 @@ module Dscf::Credit
 
       raise "Failed to create loan: #{loan.errors.full_messages.join(', ')}" unless loan.save
 
+      # Create facilitator fee accrual
+      create_facilitator_fee_accrual(loan, loan_terms[:facilitation_fee])
+
+      # Create VAT accrual if applicable
+      create_vat_accrual(loan, loan_terms[:vat_amount]) if loan_terms[:vat_amount] > 0
+
       loan
     end
 
@@ -104,19 +106,59 @@ module Dscf::Credit
       }
     end
 
+    def create_facilitator_fee_accrual(loan, facilitation_fee)
+      return if facilitation_fee <= 0
+
+      Dscf::Credit::LoanAccrual.create!(
+        loan: loan,
+        accrual_type: "facilitation_fee",
+        amount: facilitation_fee,
+        applied_on: Date.current,
+        status: "pending"
+      )
+    end
+
+    def create_vat_accrual(loan, vat_amount)
+      return if vat_amount <= 0
+
+      Dscf::Credit::LoanAccrual.create!(
+        loan: loan,
+        accrual_type: "tax",
+        amount: vat_amount,
+        applied_on: Date.current,
+        status: "pending"
+      )
+    end
+
     def update_credit_line_limits(loan)
-      new_available_limit = eligible_credit_line.available_limit - loan.total_loan_amount
+      # Calculate total amount from accruals: principal + facilitation_fee + vat
+      facilitation_fee = loan.loan_accruals.find_by(accrual_type: "facilitation_fee")&.amount || 0
+      vat = loan.loan_accruals.find_by(accrual_type: "tax")&.amount || 0
+      total_amount = loan.principal_amount + facilitation_fee + vat
+
+      new_available_limit = eligible_credit_line.available_limit - total_amount
       eligible_credit_line.update!(available_limit: [ new_available_limit, 0 ].max)
     end
 
     def success_result(loan)
+      # Reload to get associated accruals
+      loan.reload
+
+      facilitation_fee_accrual = loan.loan_accruals.find_by(accrual_type: "facilitation_fee")
+      vat_accrual = loan.loan_accruals.find_by(accrual_type: "tax")
+
+      facilitation_fee = facilitation_fee_accrual&.amount&.to_f || 0.0
+      vat_amount = vat_accrual&.amount&.to_f || 0.0
+      total_amount = loan.principal_amount.to_f + facilitation_fee + vat_amount
+
       {
         success: true,
         loan: loan,
         disbursement_details: {
           principal_amount: loan.principal_amount.to_f,
-          facilitation_fee: loan.facilitation_fee.to_f,
-          total_loan_amount: loan.total_loan_amount.to_f,
+          facilitation_fee: facilitation_fee,
+          vat_amount: vat_amount,
+          total_loan_amount: total_amount,
           due_date: loan.due_date,
           disbursed_at: loan.disbursed_at
         },