dscf-credit 0.1.1 → 0.1.3

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

@@ -40,6 +40,7 @@ module Dscf::Credit
         :penalty_rate,
         :facilitation_fee_rate,
         :tax_rate,
+        :credit_line_multiplier,
         :max_penalty_days,
         :loan_duration,
         :interest_frequency,
@@ -57,7 +58,7 @@ module Dscf::Credit
     end
 
     def allowed_order_columns
-      %w[id min_amount max_amount interest_rate penalty_rate facilitation_fee_rate tax_rate max_penalty_days loan_duration interest_frequency interest_income_tax vat max_interest_calculation_days penalty_frequency penalty_income_tax active created_at updated_at]
+      %w[id min_amount max_amount interest_rate penalty_rate facilitation_fee_rate tax_rate credit_line_multiplier max_penalty_days loan_duration interest_frequency interest_income_tax vat max_interest_calculation_days penalty_frequency penalty_income_tax active created_at updated_at]
     end
 
     def default_serializer_includes

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

@@ -1,6 +1,7 @@
 module Dscf::Credit
   class CreditLinesController < ApplicationController
     include Dscf::Core::Common
+    include Dscf::Credit::Reviewable
 
     def create
       super do
@@ -10,36 +11,6 @@ module Dscf::Credit
       end
     end
 
-    def approve
-      @obj = @clazz.find(params[:id])
-      if @obj.update(
-        status: "approved",
-        approved_by: current_user,
-        approval_date: Time.current
-      )
-        render_success(data: @obj)
-      else
-        render_error(errors: @obj.errors.full_messages, status: :unprocessable_entity)
-      end
-    rescue StandardError => e
-      render_error(error: e.message)
-    end
-
-    def reject
-      @obj = @clazz.find(params[:id])
-      if @obj.update(
-        status: "pending",
-        approved_by: current_user,
-        approval_date: Time.current
-      )
-        render_success(data: @obj)
-      else
-        render_error(errors: @obj.errors.full_messages, status: :unprocessable_entity)
-      end
-    rescue StandardError => e
-      render_error(error: e.message)
-    end
-
     private
 
     def model_params
@@ -50,26 +21,28 @@ module Dscf::Credit
         :code,
         :description,
         :status,
-        :approved_by_type,
-        :approved_by_id,
-        :approval_date
+        :reviewed_by_type,
+        :reviewed_by_id,
+        :review_date,
+        :document_reference,
+        :review_feedback
       )
     end
 
     def eager_loaded_associations
-      [ :bank, :category, :created_by, :approved_by, :credit_line_specs ]
+      [ :bank, :category, :created_by, :reviewed_by, :credit_line_specs, :loans, :eligible_credit_lines ]
     end
 
     def allowed_order_columns
-      %w[id name code status approval_date created_at updated_at category_id]
+      %w[id name code status review_date created_at updated_at category_id]
     end
 
     def default_serializer_includes
       {
         index: [ :bank, :category ],
-        show: [ :bank, :category, :created_by, :approved_by, :credit_line_specs ],
-        create: [ :bank, :category, :created_by, :approved_by ],
-        update: [ :bank, :category, :created_by, :approved_by, :credit_line_specs ]
+        show: [ :bank, :category, :created_by, :reviewed_by, :credit_line_specs, :loans, :eligible_credit_lines ],
+        create: [ :bank, :category, :created_by, :reviewed_by ],
+        update: [ :bank, :category, :created_by, :reviewed_by, :credit_line_specs, :loans, :eligible_credit_lines ]
       }
     end
   end

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

@@ -0,0 +1,55 @@
+module Dscf::Credit
+  class DisbursementsController < ApplicationController
+    def create
+      credit_line = Dscf::Credit::CreditLine.find(params[:credit_line_id])
+      payment_request = Dscf::Credit::PaymentRequest.find(params[:payment_request_id])
+
+      service = Dscf::Credit::DisbursementService.new(credit_line, payment_request, current_user)
+      result = service.process_disbursement
+
+      if result[:success]
+        render_success(
+          "disbursement.success.create",
+          data: {
+            loan: result[:loan],
+            disbursement_details: result[:disbursement_details],
+            credit_line: credit_line,
+            payment_request: payment_request
+          },
+          serializer_options: {
+            include: [
+              :loan_profile,
+              :credit_line,
+              :payment_request,
+              :loan_transactions
+            ]
+          }
+        )
+      else
+        render_error(
+          "disbursement.errors.create",
+          errors: [ result[:error] ],
+          status: :unprocessable_entity
+        )
+      end
+    rescue ActiveRecord::RecordNotFound => e
+      render_error(
+        "disbursement.errors.not_found",
+        errors: [ e.message ],
+        status: :not_found
+      )
+    rescue StandardError => e
+      render_error(
+        "disbursement.errors.create",
+        errors: [ e.message ],
+        status: :internal_server_error
+      )
+    end
+
+    private
+
+    def model_params
+      params.permit(:credit_line_id, :payment_request_id)
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Dscf::Credit
+  class EligibleCreditLinesController < ApplicationController
+    include Dscf::Core::Common
+
+    before_action :set_object, only: [ :show, :apply_risk ]
+
+    def apply_risk
+      unless params[:risk].present?
+        return render_error("eligible_credit_line.errors.apply_risk", errors: [ "Risk parameter is required" ])
+      end
+
+      service = RiskApplicationService.new(@obj, params[:risk])
+      result = service.apply_risk
+
+      if result[:success]
+        render_success(data: result[:data].reload)
+      else
+        render_error(errors: result[:errors])
+      end
+    end
+
+    private
+
+    def model_params
+      params.require(:eligible_credit_line).permit(
+        :loan_profile_id,
+        :credit_line_id,
+        :credit_limit,
+        :available_limit
+      )
+    end
+
+    def eager_loaded_associations
+      [ :loan_profile, :credit_line ]
+    end
+
+    def allowed_order_columns
+      %w[id credit_limit available_limit risk created_at updated_at loan_profile_id credit_line_id]
+    end
+
+    def default_serializer_includes
+      {
+        index: [ :loan_profile, :credit_line ],
+        show: [ :loan_profile, :credit_line ],
+        create: [ :loan_profile, :credit_line ],
+        update: [ :loan_profile, :credit_line ]
+      }
+    end
+  end
+end

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

@@ -2,36 +2,14 @@ module Dscf::Credit
   class FacilitatorsController < ApplicationController
     include Dscf::Core::Common
 
-    skip_before_action :authenticate_user, only: [ :submit_additional_info ]
     before_action :set_facilitator_for_approval, only: [ :approve, :reject, :set_limit ]
 
     def create
       super do
-        user = Dscf::Core::User.find(model_params[:user_id])
-        business = user.businesses.first
-
-        unless business
-          return render_error("facilitator.errors.no_business",
-                            errors: "User must have a business associated to become a facilitator")
-        end
-
-        facilitator_data = model_params.to_h.merge(
-          name: business.name,
-          type: business.business_type.name.downcase
-        )
-
-        facilitator = @clazz.new(facilitator_data)
-        facilitator.kyc_approved_by = current_user
-        if facilitator.save
-          facilitator.facilitator_performances.create!(
-            total_outstanding_loans: 0,
-            total_outstanding_amount: 0.0,
-            approval_required: false,
-            created_by: current_user
-          )
-          facilitator
-        else
-          facilitator
+        begin
+          FacilitatorCreationService.new(current_user, @clazz).create_single(model_params)
+        rescue StandardError => e
+          return render_error(errors: e.message)
         end
       end
     end
@@ -39,27 +17,27 @@ module Dscf::Credit
     def approve
       begin
         FacilitatorApprovalService.new(@facilitator, current_user).approve(params[:total_limit])
-        render_success("facilitator.success.approved", data: @facilitator)
+        render_success(data: @facilitator)
       rescue StandardError => e
-        render_error("facilitator.errors.approval_failed", errors: e.message)
+        render_error(errors: e.message)
       end
     end
 
     def reject
       begin
-        FacilitatorApprovalService.new(@facilitator, current_user).reject(params[:rejection_reason])
-        render_success("facilitator.success.rejected", data: @facilitator)
+        FacilitatorApprovalService.new(@facilitator, current_user).reject(params[:review_feedback])
+        render_success(data: @facilitator)
       rescue StandardError => e
-        render_error("facilitator.errors.rejection_failed", errors: e.message)
+        render_error(errors: e.message)
       end
     end
 
     def set_limit
       begin
         FacilitatorApprovalService.new(@facilitator, current_user).set_limit(params[:total_limit])
-        render_success("facilitator.success.limit_updated", data: @facilitator)
+        render_success(data: @facilitator)
       rescue StandardError => e
-        render_error("facilitator.errors.limit_update_failed", errors: e.message)
+        render_error(errors: e.message)
       end
     end
 
@@ -69,123 +47,32 @@ module Dscf::Credit
 
       begin
         result = FacilitatorAdditionalInfoService.new.submit_info(facilitator_id, additional_info)
-        render_success("facilitator.success.additional_info_submitted", data: result)
+        render_success(data: result)
       rescue StandardError => e
-        render_error("facilitator.errors.additional_info_failed", errors: e.message)
+        render_error(errors: e.message)
       end
     end
 
     def batch_create
       facilitators_params = params[:facilitators]
 
-      unless facilitators_params.is_a?(Array)
-        return render_error("facilitator.errors.invalid_batch_format",
-                          errors: "Expected an array of facilitator objects")
-      end
-
-      if facilitators_params.empty?
-        return render_error("facilitator.errors.empty_batch",
-                          errors: "At least one facilitator is required")
-      end
-
-      if facilitators_params.length > 100
-        return render_error("facilitator.errors.batch_too_large",
-                          errors: "Maximum 100 facilitators allowed per batch")
-      end
-
-      results = {
-        successful: [],
-        failed: [],
-        total_count: facilitators_params.length,
-        success_count: 0,
-        failure_count: 0
-      }
+      begin
+        service = FacilitatorCreationService.new(current_user, @clazz)
+        results = service.create_batch(facilitators_params)
 
-      facilitators_params.each_with_index do |facilitator_attrs, index|
-        begin
-          if facilitator_attrs.is_a?(ActionController::Parameters)
-            permitted_attrs = facilitator_attrs.permit(:user_id, :bank_id, :kyc_status)
-          else
-            permitted_attrs = ActionController::Parameters.new(facilitator_attrs)
-                                                          .permit(:user_id, :bank_id, :kyc_status)
-          end
-
-          user = Dscf::Core::User.find(permitted_attrs[:user_id])
-          business = user.businesses.first
-
-          unless business
-            results[:failed] << {
-              index: index,
-              user_id: permitted_attrs[:user_id],
-              errors: [ "User must have a business associated to become a facilitator" ]
-            }
-            results[:failure_count] += 1
-            next
-          end
-
-          facilitator_data = permitted_attrs.to_h.merge(
-            name: business.name,
-            type: business.business_type.name.downcase
-          )
-
-          facilitator = @clazz.new(facilitator_data)
-          facilitator.kyc_approved_by = current_user
-
-          if facilitator.save
-            facilitator.facilitator_performances.create!(
-              total_outstanding_loans: 0,
-              total_outstanding_amount: 0.0,
-              approval_required: false,
-              created_by: current_user
-            )
-
-            results[:successful] << {
-              index: index,
-              id: facilitator.id,
-              name: facilitator.name,
-              message: "Successfully created"
-            }
-            results[:success_count] += 1
-          else
-            results[:failed] << {
-              index: index,
-              name: business&.name || "Unknown Business",
-              errors: facilitator.errors.full_messages
-            }
-            results[:failure_count] += 1
-          end
-        rescue StandardError => e
-          user_id = permitted_attrs&.[](:user_id) || facilitator_attrs.try(:[], :user_id)
-          business_name = "Unknown Business"
-
-          if user_id
-            begin
-              user = Dscf::Core::User.find(user_id)
-              business_name = user.businesses.first&.name || "No Business Associated"
-            rescue
-              business_name = "Invalid User ID"
-            end
-          end
-
-          results[:failed] << {
-            index: index,
-            name: business_name,
-            errors: [ e.message ]
-          }
-          results[:failure_count] += 1
+        if results[:failure_count] == 0
+          render_success("facilitator.success.batch_created_all", data: results)
+        elsif results[:success_count] == 0
+          render_error("facilitator.errors.batch_failed_all", errors: results)
+        else
+          render json: {
+            success: true,
+            message: I18n.t("facilitator.success.batch_created_partial"),
+            data: results
+          }, status: :multi_status
         end
-      end
-
-      if results[:failure_count] == 0
-        render_success("facilitator.success.batch_created_all", data: results)
-      elsif results[:success_count] == 0
-        render_error("facilitator.errors.batch_failed_all", errors: results)
-      else
-        render json: {
-          success: true,
-          message: I18n.t("facilitator.success.batch_created_partial"),
-          data: results
-        }, status: :multi_status
+      rescue StandardError => e
+        render_error("facilitator.errors.batch_creation_failed", errors: e.message)
       end
     end
 
@@ -196,7 +83,9 @@ module Dscf::Credit
         :user_id,
         :bank_id,
         :kyc_status,
-        :additional_info
+        :kyc_review_date,
+        :additional_info,
+        :review_feedback
       )
     end
 
@@ -205,22 +94,22 @@ module Dscf::Credit
     end
 
     def eager_loaded_associations
-      [ :user, :bank, :kyc_approved_by, :facilitator_performances ]
+      [ :user, :bank, :kyc_reviewed_by, :facilitator_performances ]
     end
 
     def allowed_order_columns
-      %w[id name type kyc_status total_limit created_at updated_at]
+      %w[id name type kyc_status total_limit kyc_review_date created_at updated_at]
     end
 
     def default_serializer_includes
       {
         index: [ :user, :bank ],
-        show: [ :user, :bank, :kyc_approved_by, :facilitator_performances ],
-        create: [ :user, :bank, :kyc_approved_by ],
-        update: [ :user, :bank, :kyc_approved_by, :facilitator_performances ],
-        approve: [ :user, :bank, :kyc_approved_by, :facilitator_performances ],
-        reject: [ :user, :bank, :kyc_approved_by ],
-        set_limit: [ :user, :bank, :kyc_approved_by ]
+        show: [ :user, :bank, :kyc_reviewed_by, :facilitator_performances ],
+        create: [ :user, :bank, :kyc_reviewed_by ],
+        update: [ :user, :bank, :kyc_reviewed_by, :facilitator_performances ],
+        approve: [ :user, :bank, :kyc_reviewed_by, :facilitator_performances ],
+        reject: [ :user, :bank, :kyc_reviewed_by ],
+        set_limit: [ :user, :bank, :kyc_reviewed_by ]
       }
     end
   end

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

@@ -0,0 +1,138 @@
+module Dscf::Credit
+  class LoanProfilesController < ApplicationController
+    include Dscf::Core::Common
+    include Dscf::Credit::Reviewable
+
+    def create
+      super do
+        loan_profile = @clazz.new(model_params)
+
+        ActiveRecord::Base.transaction do
+          loan_profile.save!
+
+          if loan_profile.user.present?
+            loan_profile.loan_profile_scoring_specs.create!(
+              created_by: loan_profile.user
+            )
+          end
+        end
+
+        loan_profile
+      end
+    end
+
+    def calculate_score
+      loan_profile = @clazz.find(params[:id])
+      scoring_service = Dscf::Credit::ScoringService.new(loan_profile)
+
+      external_scoring_data = params[:scoring_input_data]
+
+      result = scoring_service.calculate_credit_score(external_scoring_data)
+
+      if result[:success]
+        ActiveRecord::Base.transaction do
+          scoring_spec = if external_scoring_data.present?
+                           loan_profile.loan_profile_scoring_specs.find_or_initialize_by(
+                             scoring_input_data: external_scoring_data
+                           )
+          else
+                           # If no external data, find existing spec with input data or latest one
+                           loan_profile.loan_profile_scoring_specs
+                                      .where.not(scoring_input_data: [ nil, {} ])
+                                      .order(created_at: :desc)
+                                      .first ||
+                           loan_profile.loan_profile_scoring_specs.order(created_at: :desc).first ||
+                           loan_profile.loan_profile_scoring_specs.build
+          end
+
+          loan_profile.loan_profile_scoring_specs.where.not(id: scoring_spec.id).update_all(active: false)
+
+          scoring_spec.assign_attributes(
+            score: result[:score],
+            total_limit: result[:facility_limit],
+            scoring_input_data: result[:scoring_input_data] || scoring_spec.scoring_input_data || {},
+            active: true,
+            created_by: scoring_spec.new_record? ? current_user : scoring_spec.created_by
+          )
+
+          scoring_spec.save!
+
+          update_loan_profile_status(loan_profile, result[:score])
+        end
+
+        loan_profile.reload
+
+        render_success(
+          "loan_profile.success.calculate_score",
+          data: {
+            loan_profile: loan_profile,
+            scoring_result: result
+          },
+          serializer_options: { include: [ :loan_profile_scoring_specs ] }
+        )
+      else
+        render_error(
+          "loan_profile.errors.calculate_score",
+          errors: [ result[:error] ],
+          status: :unprocessable_entity
+        )
+      end
+    rescue ActiveRecord::RecordNotFound
+      render_error(
+        "loan_profile.errors.not_found",
+        status: :not_found
+      )
+    end
+
+    private
+
+    def update_loan_profile_status(loan_profile, score)
+      new_status = case score
+      when 0...50
+                     "rejected"
+      when 50...60
+                     "manual_review"
+      else
+                     "approved"
+      end
+
+      loan_profile.update!(
+        status: new_status,
+        reviewed_by: current_user,
+        review_date: Time.current
+      )
+    end
+
+    private
+
+    def model_params
+      params.require(:loan_profile).permit(
+        :bank_id,
+        :review_branch_id,
+        :user_id,
+        :backer_id,
+        :backer_type,
+        :status,
+        :total_amount,
+        :available_amount
+      )
+    end
+
+    def eager_loaded_associations
+      [ :bank, :review_branch, :reviewed_by, :user, :backer, :loan_profile_scoring_specs, :loans, :eligible_credit_lines ]
+    end
+
+    def allowed_order_columns
+      %w[id status total_amount available_amount review_date created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [ :bank, :review_branch, :reviewed_by, :user, :backer ],
+        show: [ :bank, :review_branch, :reviewed_by, :user, :backer, :loan_profile_scoring_specs, :loans, :eligible_credit_lines ],
+        create: [ :bank, :review_branch, :reviewed_by, :user, :backer, :loan_profile_scoring_specs ],
+        update: [ :bank, :review_branch, :reviewed_by, :user, :backer, :loan_profile_scoring_specs, :loans, :eligible_credit_lines ]
+      }
+    end
+  end
+end

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

@@ -2,20 +2,69 @@ module Dscf::Credit
   class PaymentRequestsController < ApplicationController
     include Dscf::Core::Common
 
+    def create
+      super do
+        obj = @clazz.new(model_params)
+        obj.request_type = "credit"
+        obj.initiated_at = Time.current
+        obj
+      end
+    end
+
+    def approve
+      @obj = @clazz.find(params[:id])
+
+      if @obj.update(status: "approved", approved_at: Time.current)
+        @obj = @clazz.includes(eager_loaded_associations).find(@obj.id) if eager_loaded_associations.present?
+        includes = serializer_includes_for_action(:show)
+        options = includes.present? ? { include: includes } : {}
+        render_success(data: @obj, serializer_options: options)
+      else
+        render_error(errors: @obj.errors.full_messages[0], status: :unprocessable_entity)
+      end
+    rescue StandardError => e
+      render_error(error: e.message)
+    end
+
+    def eligible_credit_lines
+      payment_request = @clazz.find(params[:id])
+
+      if payment_request.user.nil?
+        return render_error(error: "Payment request has no associated user", status: :unprocessable_entity)
+      end
+
+      # Find all eligible credit lines for the user through their approved loan profiles
+      # Only include credit lines with available credit
+      eligible_credit_lines = Dscf::Credit::EligibleCreditLine
+        .joins(loan_profile: :user)
+        .where(dscf_credit_loan_profiles: {
+          user_id: payment_request.user_id,
+          status: [ "approved", "kyc_approved" ]  # Only approved loan profiles
+        })
+        .where("dscf_credit_eligible_credit_lines.available_limit > 0")  # Only with available credit
+        .includes(:loan_profile, :credit_line)
+        .order("dscf_credit_eligible_credit_lines.available_limit DESC")  # Order by available limit
+
+      render_success(
+        data: eligible_credit_lines,
+      )
+    rescue ActiveRecord::RecordNotFound
+      render_error(error: "Payment request not found", status: :not_found)
+    rescue StandardError => e
+      render_error(error: e.message)
+    end
+
     private
 
     def model_params
       params.require(:payment_request).permit(
         :user_id,
         :order_id,
-        :request_type,
         :amount,
         :receiver_account_reference,
         :status,
-        :failure_reason,
-        :initiated_at,
-        :approved_at
-      )
+        :failure_reason
+        )
     end
 
     def eager_loaded_associations