dscf-credit 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2284e9439102461eb4cb1d93804c47510c1d7b01e476e3ef8986a6b552e4aaea
-  data.tar.gz: d14c68b09509e8da8e2eb679f2c0a8905238ec761ff701802f2d30fa31e45db4
+  metadata.gz: 226454dfdada01577236a828d48ac886241ba1ca0681cf2ba6ea5f56958d0288
+  data.tar.gz: 4d5855466e0a7e5e9d7e7a9f861500b0ca46dd6a77ab0181de340fc226f646c1
 SHA512:
-  metadata.gz: fb0041c463dd58d218524a7ef033bc7c3995cb89aedc70faf2df38d0ad3e2e0d210c80fcb650f8271c8dcc09303d58029cae5e0461400e2293fcdb5c50e849da
-  data.tar.gz: cb8101b2a8618250a5d961c59746c45e8d364ad921875ad6967ddf458445cb2ea3d8265865a293a04a22a817b7b4653d9301cfed27b55ddd9394f88a73c38560
+  metadata.gz: f9ee24827894995bf986b3b580cb1b08a8e0bdcd9656eb28d0b3107f288eafaad16537ed6b1066869243508c92648f31a3a8ad7429da674186935aed44fa670c
+  data.tar.gz: 42550e6f1341e2acf9ff5a6643aca6e8c02b1ec25574b8fc7e20194cd935d987525c062a5cfb6732c5bb3df398518837f110bf90a9b85670d785a40e3bea4a8d

data/app/controllers/concerns/dscf/credit/reviewable.rb

@@ -0,0 +1,112 @@
+module Dscf
+  module Credit
+    module Reviewable
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :set_reviewable_resource, only: %i[approve reject request_modification resubmit]
+      end
+
+      # PATCH /resource/:id/approve
+      def approve
+        if reviewable_resource.update(
+            status: :approved,
+            reviewed_by: current_reviewer,
+            review_date: Time.current
+          )
+          render_success(data: reviewable_resource)
+        else
+          render_error(errors: reviewable_resource.errors.full_messages)
+        end
+      end
+
+      # PATCH /resource/:id/request_modification
+      def request_modification
+        feedback = safe_feedback_param! or return
+
+        if reviewable_resource.update(
+            status: :modify,
+            review_feedback: feedback,
+            reviewed_by: current_reviewer,
+            review_date: Time.current
+          )
+          render_success(data: reviewable_resource)
+        else
+          render_error(errors: reviewable_resource.errors.full_messages)
+        end
+      end
+
+      # PATCH /resource/:id/reject
+      def reject
+        feedback = safe_feedback_param! or return
+
+        unless feedback.key?("message")
+          return render_error(errors: "Provide review_feedback with a 'message' key")
+        end
+
+        if reviewable_resource.update(
+            status: :rejected,
+            review_feedback: feedback,
+            reviewed_by: current_reviewer,
+            review_date: Time.current
+          )
+          render_success(data: reviewable_resource)
+        else
+          render_error(errors: reviewable_resource.errors.full_messages)
+        end
+      end
+
+      # PATCH /resource/:id/resubmit
+      def resubmit
+        unless reviewable_resource.status.to_s == "modify"
+          return render_error(errors: "Only items with status 'modify' can be resubmitted", status: :unprocessable_entity)
+        end
+
+        updates = model_params.merge(
+          status: :pending,
+          review_feedback: {},
+        )
+
+        if reviewable_resource.update(updates)
+          render_success(data: reviewable_resource)
+        else
+          render_error(errors: reviewable_resource.errors.full_messages)
+        end
+      end
+
+      private
+
+      def safe_feedback_param!
+        feedback = params[:review_feedback]
+        unless feedback.respond_to?(:to_unsafe_h)
+          render_error(errors: "review_feedback must be a JSON object") and return
+        end
+        feedback.to_unsafe_h
+      end
+
+      def model_class
+        model_name = controller_name.classify
+
+        controller_namespace = self.class.name.deconstantize
+        "#{controller_namespace}::#{model_name}".constantize
+      rescue NameError
+        model_name.constantize
+      end
+
+      def reviewable_resource
+        @reviewable_resource ||= model_class.find(params[:id])
+      end
+
+      # Override if current_user is not the reviewer
+      def current_reviewer
+        current_user
+      end
+
+      def set_reviewable_resource
+        reviewable_resource
+      rescue ActiveRecord::RecordNotFound => e
+        render_error("errors.record_not_found", status: :not_found, errors: [ e.message ])
+      end
+    end
+  end
+end

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

@@ -8,7 +8,8 @@ module Dscf::Credit
       params.require(:category).permit(
         :type,
         :name,
-        :description
+        :description,
+        :document_reference
       )
     end
 
@@ -17,7 +18,7 @@ module Dscf::Credit
     end
 
     def allowed_order_columns
-      %w[id type name description created_at updated_at]
+      %w[id type name description document_reference 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 ]
     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 ],
+        create: [ :bank, :category, :created_by, :reviewed_by ],
+        update: [ :bank, :category, :created_by, :reviewed_by, :credit_line_specs ]
       }
     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,153 +17,62 @@ 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
 
     def submit_additional_info
-      token = params[:token]
+      facilitator_id = params[:id] || params[:facilitator_id]
       additional_info = params[:additional_info]&.permit!.to_h
 
       begin
-        result = FacilitatorAdditionalInfoService.new.submit_info(token, additional_info)
-        render_success("facilitator.success.additional_info_submitted", data: result)
+        result = FacilitatorAdditionalInfoService.new.submit_info(facilitator_id, additional_info)
+        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/scoring_param_types_controller.rb

@@ -0,0 +1,31 @@
+module Dscf::Credit
+  class ScoringParamTypesController < ApplicationController
+    include Dscf::Core::Common
+
+    private
+
+    def model_params
+      params.require(:scoring_param_type).permit(
+        :name,
+        :description
+      )
+    end
+
+    def eager_loaded_associations
+      [ :scoring_parameters ]
+    end
+
+    def allowed_order_columns
+      %w[id name created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        index: [],
+        show: [ :scoring_parameters ],
+        create: [],
+        update: [ :scoring_parameters ]
+      }
+    end
+  end
+end

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

@@ -1,12 +1,13 @@
 module Dscf::Credit
   class ScoringParametersController < ApplicationController
     include Dscf::Core::Common
+    include Dscf::Credit::Reviewable
 
     def create
       super do
         scoring_parameter = @clazz.new(model_params)
         scoring_parameter.created_by = current_user
-        scoring_parameter.approved_by = current_user
+        scoring_parameter.reviewed_by = current_user
 
         scoring_parameter
       end
@@ -20,30 +21,34 @@ module Dscf::Credit
         :name,
         :description,
         :data_type,
-        :type,
         :weight,
         :min_value,
         :max_value,
         :active,
         :previous_version_id,
-        :expires_at
+        :review_date,
+        :source,
+        :scoring_param_type_id,
+        :document_reference,
+        :status,
+        :review_feedback
       )
     end
 
     def eager_loaded_associations
-      [ :bank, :created_by, :approved_by, :previous_version, :parameter_normalizers ]
+      [ :bank, :created_by, :reviewed_by, :scoring_param_type, :previous_version, :parameter_normalizers ]
     end
 
     def allowed_order_columns
-      %w[id name data_type type weight active expires_at created_at updated_at]
+      %w[id name data_type weight active review_date created_at updated_at]
     end
 
     def default_serializer_includes
       {
         index: [ :bank ],
-        show: [ :bank, :created_by, :approved_by, :previous_version, :parameter_normalizers ],
-        create: [ :bank, :created_by, :approved_by ],
-        update: [ :bank, :created_by, :approved_by, :parameter_normalizers ]
+        show: [ :bank, :created_by, :reviewed_by, :scoring_param_type, :previous_version, :parameter_normalizers ],
+        create: [ :bank, :created_by, :reviewed_by, :scoring_param_type ],
+        update: [ :bank, :created_by, :reviewed_by, :scoring_param_type, :parameter_normalizers ]
       }
     end
   end

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

@@ -1,11 +1,12 @@
 module Dscf::Credit
   class SystemConfigsController < ApplicationController
     include Dscf::Core::Common
+    include Dscf::Credit::Reviewable
 
     def create
       super do
         obj = @clazz.new(model_params)
-        obj.approved_by = current_user
+        obj.reviewed_by = current_user
         obj.last_updated_by = current_user
         obj
       end
@@ -25,24 +26,26 @@ module Dscf::Credit
       params.require(:system_config).permit(
         :config_definition_id,
         :config_value,
-        :status
+        :status,
+        :review_date,
+        :review_feedback
       )
     end
 
     def eager_loaded_associations
-      [ :config_definition, :last_updated_by, :approved_by ]
+      [ :config_definition, :last_updated_by, :reviewed_by ]
     end
 
     def allowed_order_columns
-      %w[id config_value status created_at updated_at]
+      %w[id config_value status review_date created_at updated_at]
     end
 
     def default_serializer_includes
       {
         index: [ :config_definition ],
-        show: [ :config_definition, :last_updated_by, :approved_by ],
-        create: [ :config_definition, :last_updated_by, :approved_by ],
-        update: [ :config_definition, :last_updated_by, :approved_by ]
+        show: [ :config_definition, :last_updated_by, :reviewed_by ],
+        create: [ :config_definition, :last_updated_by, :reviewed_by ],
+        update: [ :config_definition, :last_updated_by, :reviewed_by ]
       }
     end
   end

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

@@ -11,7 +11,7 @@ module Dscf::Credit
     scope :by_type, ->(category_type) { where(type: category_type) }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id type name description created_at updated_at]
+      %w[id type name description document_reference created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)

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

@@ -5,7 +5,8 @@ module Dscf::Credit
     belongs_to :bank, class_name: "Dscf::Credit::Bank", foreign_key: "bank_id"
     belongs_to :category, class_name: "Dscf::Credit::Category", foreign_key: "category_id"
     belongs_to :created_by, polymorphic: true
-    belongs_to :approved_by, polymorphic: true, optional: true
+    belongs_to :reviewed_by, polymorphic: true, optional: true
+
     has_many :credit_line_specs, class_name: "Dscf::Credit::CreditLineSpec", foreign_key: "credit_line_id", dependent: :destroy
     has_many :loans, class_name: "Dscf::Credit::Loan", foreign_key: "credit_line_id", dependent: :destroy
     has_many :scoring_tables, class_name: "Dscf::Credit::ScoringTable", foreign_key: "credit_line_id", dependent: :destroy
@@ -13,18 +14,20 @@ module Dscf::Credit
 
     validates :name, presence: true
     validates :code, uniqueness: { scope: :bank_id }, allow_blank: true
-    validates :status, inclusion: { in: %w[pending approved active suspended] }
+    validates :status, inclusion: { in: %w[pending approved active suspended rejected modify] }
+    enum :status, { pending: "pending", approved: "approved", rejected: "rejected", modify: "modify", active: "active", suspended: "suspended" }
+
 
     scope :active, -> { where(status: "active") }
     scope :approved, -> { where(status: "approved") }
     scope :pending, -> { where(status: "pending") }
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id name code description status approval_date created_at updated_at]
+      %w[id name code description status review_date review_feedback document_reference created_at updated_at]
     end
 
     def self.ransackable_associations(auth_object = nil)
-      %w[bank category created_by approved_by credit_line_specs loans scoring_tables scoring_parameters]
+      %w[bank category created_by reviewed_by credit_line_specs loans scoring_tables scoring_parameters]
     end
   end
 end