dscf-credit 0.1.4 → 0.1.6

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

@@ -1,116 +1,28 @@
 module Dscf::Credit
   class FacilitatorsController < ApplicationController
     include Dscf::Core::Common
-
-    before_action :set_facilitator_for_approval, only: [ :approve, :reject, :set_limit ]
-
-    def create
-      super do
-        begin
-          FacilitatorCreationService.new(current_user, @clazz).create_single(model_params)
-        rescue StandardError => e
-          return render_error(errors: e.message)
-        end
-      end
-    end
-
-    def approve
-      begin
-        FacilitatorApprovalService.new(@facilitator, current_user).approve
-        render_success(data: @facilitator)
-      rescue StandardError => e
-        render_error(errors: e.message)
-      end
-    end
-
-    def reject
-      begin
-        FacilitatorApprovalService.new(@facilitator, current_user).reject(params[:review_feedback])
-        render_success(data: @facilitator)
-      rescue StandardError => e
-        render_error(errors: e.message)
-      end
-    end
-
-    def set_limit
-      begin
-        FacilitatorApprovalService.new(@facilitator, current_user).set_limit(params[:total_limit])
-        render_success(data: @facilitator)
-      rescue StandardError => e
-        render_error(errors: e.message)
-      end
-    end
-
-    def submit_additional_info
-      facilitator_id = params[:id] || params[:facilitator_id]
-      additional_info = params[:additional_info]&.permit!.to_h
-
-      begin
-        result = FacilitatorAdditionalInfoService.new.submit_info(facilitator_id, additional_info)
-        render_success(data: result)
-      rescue StandardError => e
-        render_error(errors: e.message)
-      end
-    end
-
-    def batch_create
-      facilitators_params = params[:facilitators]
-
-      begin
-        service = FacilitatorCreationService.new(current_user, @clazz)
-        results = service.create_batch(facilitators_params)
-
-        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
-      rescue StandardError => e
-        render_error("facilitator.errors.batch_creation_failed", errors: e.message)
-      end
-    end
+    include Dscf::Core::ReviewableController
 
     private
 
     def model_params
-      params.require(:facilitator).permit(
-        :user_id,
-        :bank_id,
-        :kyc_status,
-        :total_limit,
-        :kyc_review_date,
-        :additional_info,
-        :review_feedback
-      )
-    end
-
-    def set_facilitator_for_approval
-      @facilitator = @clazz.find(params[:id])
+      params.require(:facilitator).permit(:facilitator_application_id, :total_limit)
     end
 
     def eager_loaded_associations
-      [ :user, :bank, :kyc_reviewed_by, :facilitator_performances ]
+      [ :facilitator_application, reviews: { reviewed_by: :user_profile } ]
     end
 
     def allowed_order_columns
-      %w[id name type kyc_status total_limit kyc_review_date created_at updated_at]
+      %w[id total_limit created_at updated_at]
     end
 
     def default_serializer_includes
       {
-        index: [ :user, :bank ],
-        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 ]
+        index: [ :facilitator_application, reviews: { reviewed_by: :user_profile } ],
+        show: [ :facilitator_application, reviews: { reviewed_by: :user_profile } ],
+        create: [ :reviews ],
+        update: [ :facilitator_application, reviews: { reviewed_by: :user_profile } ]
       }
     end
   end

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

@@ -0,0 +1,252 @@
+module Dscf::Credit
+  class LoanApplicationsController < ApplicationController
+    include Dscf::Core::Common
+    include Dscf::Core::ReviewableController
+
+    def create
+      super do
+        loan_application = @clazz.new(model_params)
+        loan_application.user = current_user
+        loan_application.reviews.build(context: "default", status: "pending")
+
+        loan_application
+      end
+    end
+
+    def update_bank_info
+      loan_application = @clazz.find(params[:id])
+      if loan_application.update(bank_info: bank_info_params)
+        render_success("loan_application.success.update_bank_info", data: loan_application, serializer_options: { include: [ :bank, :user ] })
+      else
+        render_error("loan_application.errors.update_bank_info", errors: loan_application.errors.full_messages[0], status: :unprocessable_entity)
+      end
+    rescue => e
+      if Rails.env.development? || Rails.env.test?
+        render_error(errors: e.message, status: :unprocessable_entity)
+      else
+        render_error(status: :unprocessable_entity)
+      end
+      Rails.logger.error("Unexpected error: #{e.class} - #{e.message}")
+    end
+
+    def update_facilitator_info
+      loan_application = @clazz.find(params[:id])
+      if loan_application.update(facilitator_info: facilitator_info_params)
+        render_success("loan_application.success.update_facilitator_info", data: loan_application, serializer_options: { include: [ :bank, :user ] })
+      else
+        render_error("loan_application.errors.update_facilitator_info", errors: loan_application.errors.full_messages[0], status: :unprocessable_entity)
+      end
+    rescue => e
+      if Rails.env.development? || Rails.env.test?
+        render_error(errors: e.message, status: :unprocessable_entity)
+      else
+        render_error(status: :unprocessable_entity)
+      end
+      Rails.logger.error("Unexpected error: #{e.class} - #{e.message}")
+    end
+
+    def update_field_assessment
+      loan_application = @clazz.find(params[:id])
+      if loan_application.update(field_assessment: field_assessment_params)
+        render_success("loan_application.success.update_field_assessment", data: loan_application, serializer_options: { include: [ :bank, :user ] })
+      else
+        render_error("loan_application.errors.update_field_assessment", errors: loan_application.errors.full_messages[0], status: :unprocessable_entity)
+      end
+    rescue => e
+      if Rails.env.development? || Rails.env.test?
+        render_error(errors: e.message, status: :unprocessable_entity)
+      else
+        render_error(status: :unprocessable_entity)
+      end
+    end
+
+    def calculate_credit_score
+      loan_application = @clazz.find(params[:id])
+      category_id = score_params[:category_id]
+
+      unless category_id
+        return render_error(
+          "loan_application.errors.calculate_credit_score",
+          errors: [ "Category ID is required for credit scoring" ],
+          status: :unprocessable_entity
+        )
+      end
+
+      scoring_engine = CreditScoringEngine.new(loan_application.id, category_id)
+      result = scoring_engine.calculate_score
+
+      if result[:success]
+        ActiveRecord::Base.transaction do
+          loan_application.update!(score: result[:score])
+
+          update_review_status(loan_application, result[:status])
+
+          if result[:status] == "approved"
+            create_loan_profile_for_approved_application(loan_application, result[:score])
+          end
+
+          loan_application.reload
+        end
+
+        render_success(
+          "loan_application.success.calculate_credit_score",
+          data: result.merge(loan_application: loan_application),
+          status: :ok
+        )
+      else
+        render_error(
+          "loan_application.errors.calculate_credit_score",
+          errors: result[:errors] || [ result[:error] ],
+          status: :unprocessable_entity
+        )
+      end
+    rescue ActiveRecord::RecordNotFound
+      render_error(
+        "loan_application.errors.not_found",
+        errors: [ "Loan application not found" ],
+        status: :not_found
+      )
+    rescue => e
+      Rails.logger.error("Credit scoring error: #{e.class} - #{e.message}")
+      Rails.logger.error(e.backtrace.join("\n"))
+
+      if Rails.env.development? || Rails.env.test?
+        render_error(
+          "loan_application.errors.calculate_credit_score",
+          errors: [ e.message ],
+          status: :unprocessable_entity
+        )
+      else
+        render_error(
+          "loan_application.errors.calculate_credit_score",
+          errors: [ "An error occurred while calculating credit score" ],
+          status: :unprocessable_entity
+        )
+      end
+    end
+
+    private
+
+    def update_review_status(loan_application, status)
+      current_review = loan_application.current_review_for(:default)
+
+      if current_review
+        current_review.update!(
+          status: status,
+          reviewed_by: current_user,
+          reviewed_at: Time.current,
+          feedback: build_review_feedback(status, loan_application.score)
+        )
+      else
+        loan_application.reviews.create!(
+          context: "default",
+          status: status,
+          reviewed_by: current_user,
+          reviewed_at: Time.current,
+          feedback: build_review_feedback(status, loan_application.score)
+        )
+      end
+    end
+
+    # Build feedback message based on status and score
+    def build_review_feedback(status, score)
+      case status
+      when "approved"
+        {
+          message: "Automatically approved based on credit score: #{score}% (>60%)"
+        }
+      when "rejected"
+        {
+          message: "Automatically rejected based on credit score: #{score}% (<50%)"
+        }
+      when "pending_review"
+        {
+          message: "Manual review required based on credit score: #{score}% (50%-60%)"
+        }
+      else
+        {
+          message: "Status determined by credit scoring system"
+        }
+      end
+    end
+
+    # Create loan profile for approved applications
+    def create_loan_profile_for_approved_application(loan_application, score)
+      profile_service = LoanProfileCreationService.new(loan_application, score)
+      profile_result = profile_service.create_loan_profile
+
+      unless profile_result[:success]
+        error_message = "Failed to create loan profile for approved application #{loan_application.id}: #{profile_result[:error]}"
+        Rails.logger.error error_message
+        # Raise error to rollback the entire transaction including score and review status
+        raise StandardError, error_message
+      else
+        Rails.logger.info "Loan profile created successfully for approved application #{loan_application.id}"
+      end
+
+      profile_result
+    end
+
+    def model_params
+      params.require(:loan_application).permit(
+        :bank_id,
+        :backer_type,
+        :backer_id,
+        :review_branch_id,
+        :bank_statement_source,
+        user_info: {},
+        facilitator_info: {},
+        bank_info: {},
+        field_assessment: {},
+        bank_statement_attachments: []
+      )
+    end
+
+    def bank_info_params
+      params.require(:loan_application).require(:bank_info)
+    end
+
+    def facilitator_info_params
+      params.require(:loan_application).require(:facilitator_info)
+    end
+
+    def field_assessment_params
+      params.require(:loan_application).require(:field_assessment)
+    end
+
+    def score_params
+      params.permit(:category_id)
+    end
+
+    def eager_loaded_associations
+      [
+        :bank, :user, :backer, :review_branch, :loan_profile,
+        reviews: { reviewed_by: :user_profile }
+      ]
+    end
+
+    def allowed_order_columns
+      %w[id bank_statement_source created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [
+          :bank, :user, :backer, :review_branch, :loan_profile,
+          reviews: { reviewed_by: :user_profile }
+        ],
+        show: [
+          :bank, :user, :backer, :review_branch, :loan_profile,
+          reviews: { reviewed_by: :user_profile }
+        ],
+        create: [
+          :bank, :user, :backer, :review_branch, :loan_profile, :reviews
+        ],
+        update: [
+          :bank, :user, :backer, :review_branch, :loan_profile,
+          reviews: { reviewed_by: :user_profile }
+        ]
+      }
+    end
+  end
+end

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

@@ -1,78 +1,46 @@
 module Dscf::Credit
   class LoanProfilesController < ApplicationController
     include Dscf::Core::Common
-    include Dscf::Credit::Reviewable
+    include Dscf::Core::ReviewableController
 
     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.reviews.build(
+          status: "pending",
+          context: "default",
+        )
         loan_profile
       end
     end
 
-    def calculate_score
+
+    def calculate_facility_limits
       loan_profile = @clazz.find(params[:id])
-      scoring_service = Dscf::Credit::ScoringService.new(loan_profile)
+      category_id = facility_params[:category_id]
 
-      external_scoring_data = params[:scoring_input_data]
+      return render_error(
+        "loan_profile.errors.calculate_facility_limits",
+        errors: [ "Category ID is required" ],
+        status: :unprocessable_entity
+      ) unless category_id
 
-      result = scoring_service.calculate_credit_score(external_scoring_data)
+      facility_engine = FacilityLimitCalculationEngine.new(loan_profile.id, category_id)
+      result = facility_engine.calculate_facility_limits
 
       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",
+          "loan_profile.success.calculate_facility_limits",
           data: {
             loan_profile: loan_profile,
-            scoring_result: result
+            facility_result: result
           },
-          serializer_options: { include: [ :loan_profile_scoring_specs ] }
+          serializer_options: { include: [ :eligible_credit_lines ] }
         )
       else
         render_error(
-          "loan_profile.errors.calculate_score",
+          "loan_profile.errors.calculate_facility_limits",
           errors: [ result[:error] ],
           status: :unprocessable_entity
         )
@@ -82,6 +50,23 @@ module Dscf::Credit
         "loan_profile.errors.not_found",
         status: :not_found
       )
+    rescue => e
+      Rails.logger.error("Facility limit calculation error: #{e.class} - #{e.message}")
+      Rails.logger.error(e.backtrace.join("\n"))
+
+      if Rails.env.development? || Rails.env.test?
+        render_error(
+          "loan_profile.errors.calculate_facility_limits",
+          errors: [ e.message ],
+          status: :unprocessable_entity
+        )
+      else
+        render_error(
+          "loan_profile.errors.calculate_facility_limits",
+          errors: [ "An error occurred while calculating facility limits" ],
+          status: :unprocessable_entity
+        )
+      end
     end
 
     private
@@ -96,10 +81,10 @@ module Dscf::Credit
                      "approved"
       end
 
-      loan_profile.update!(
+      loan_profile.reviews.create!(
         status: new_status,
-        reviewed_by: current_user,
-        review_date: Time.current
+        context: "default",
+        reviewed_by: current_user
       )
     end
 
@@ -107,31 +92,39 @@ module Dscf::Credit
 
     def model_params
       params.require(:loan_profile).permit(
-        :bank_id,
-        :review_branch_id,
-        :user_id,
-        :backer_id,
-        :backer_type,
-        :status,
-        :total_amount,
-        :available_amount
+        :loan_application_id,
+        :code,
+        :score,
+        :total_limit
       )
     end
 
+    def facility_params
+      params.permit(:category_id)
+    end
+
     def eager_loaded_associations
-      [ :bank, :review_branch, :reviewed_by, :user, :backer, :loan_profile_scoring_specs, :loans, :eligible_credit_lines ]
+      [
+        :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines,
+        reviews: { reviewed_by: :user_profile }
+      ]
     end
 
     def allowed_order_columns
-      %w[id status total_amount available_amount review_date created_at updated_at]
+      %w[id code score total_limit 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 ]
+        index: [ :loan_application, reviews: { reviewed_by: :user_profile } ],
+        show: [
+          :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines, reviews: { reviewed_by: :user_profile }
+        ],
+        create: [ :loan_application, :loan_profile_scoring_specs, :reviews ],
+        update: [
+          :loan_application, :loan_profile_scoring_specs, :loans, :eligible_credit_lines,
+          reviews: { reviewed_by: :user_profile }
+        ]
       }
     end
   end

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

@@ -8,7 +8,6 @@ module Dscf::Credit
       params.require(:loan).permit(
         :loan_profile_id,
         :credit_line_id,
-        :payment_request_id,
         :status,
         :principal_amount,
         :accrued_interest,
@@ -17,12 +16,13 @@ module Dscf::Credit
         :total_loan_amount,
         :remaining_amount,
         :due_date,
-        :disbursed_at
+        :disbursed_at,
+        :active
       )
     end
 
     def eager_loaded_associations
-      [ :loan_profile, :credit_line, :payment_request, :loan_transactions ]
+      [ :loan_profile, :credit_line, :loan_transactions ]
     end
 
     def allowed_order_columns
@@ -31,10 +31,10 @@ module Dscf::Credit
 
     def default_serializer_includes
       {
-        index: [ :loan_profile, :credit_line, :payment_request ],
-        show: [ :loan_profile, :credit_line, :payment_request, :loan_transactions ],
-        create: [ :loan_profile, :credit_line, :payment_request ],
-        update: [ :loan_profile, :credit_line, :payment_request, :loan_transactions ]
+        index: [ :loan_profile, :credit_line ],
+        show: [ :loan_profile, :credit_line, :loan_transactions ],
+        create: [ :loan_profile, :credit_line ],
+        update: [ :loan_profile, :credit_line, :loan_transactions ]
       }
     end
   end