dscf-credit 0.1.4 → 0.1.5

data/app/controllers/concerns/dscf/core/reviewable_controller.rb

@@ -0,0 +1,347 @@
+module Dscf
+  module Core
+    module ReviewableController
+      extend ActiveSupport::Concern
+      include Dscf::Core::JsonResponse
+
+      included do
+        class_attribute :review_context_configs, default: {}
+        class_attribute :reviewable_model_class, default: nil
+
+        # Initialize with default context config for zero-config support
+        self.review_context_configs = default_context_config.dup
+
+        # Auto-define default actions for zero-config
+        define_default_review_actions
+
+        before_action :set_reviewable_resource, if: :review_action?
+        before_action :authorize_review_action!, if: :review_action?
+      end
+
+      class_methods do
+        def reviewable_model(model_class)
+          self.reviewable_model_class = model_class
+        end
+
+        def reviewable_context(context_name, options = {})
+          statuses = options[:statuses]&.map(&:to_s) || %w[pending approved rejected modify]
+          initial_status = options[:initial_status]&.to_s || "pending"
+
+          # Convert linear transitions array to hash if provided
+          transitions = if options[:transitions].is_a?(Array)
+                          validate_linear_transitions(options[:transitions], statuses, context_name)
+                          build_linear_transitions(options[:transitions])
+          else
+                          options[:transitions] || {}
+          end
+
+          defaults = {
+            statuses: statuses,
+            initial_status: initial_status,
+            transitions: transitions,
+            actions: options[:actions] || default_actions
+          }
+
+          validate_action_config(defaults[:actions], defaults[:statuses], context_name)
+          unless defaults[:statuses].include?(defaults[:initial_status])
+            raise ArgumentError,
+                  "Initial status '#{defaults[:initial_status]}' in context '#{context_name}' must be one of: #{defaults[:statuses].join(', ')}"
+          end
+
+          # Add to existing configs instead of replacing them
+          self.review_context_configs = review_context_configs.merge(context_name.to_sym => defaults)
+
+          # Define methods for all actions in this context
+          defaults[:actions].each_key do |action_name|
+            # Only define if not already defined
+            define_review_action_method(action_name) unless method_defined?(action_name)
+          end
+        end
+
+        def define_default_review_actions
+          default_context_config.each do |context_name, config|
+            validate_action_config(config[:actions], config[:statuses], context_name)
+            config[:actions].each_key do |action_name|
+              define_review_action_method(action_name)
+            end
+          end
+        end
+
+        def define_review_action_method(action_name)
+          define_method(action_name) do
+            context = current_review_context
+            action_config = context_config[:actions][action_name.to_sym]
+            unless action_config
+              return render_error(
+                errors: [ "Action '#{action_name}' not defined for context '#{context}'" ],
+                status: :bad_request
+              )
+            end
+            perform_review_action(**action_config.slice(:status, :require_feedback, :after, :update_model))
+          end
+        end
+
+        def default_actions
+          {
+            approve: { status: "approved" },
+            reject: { status: "rejected", require_feedback: true },
+            request_modification: { status: "modify", require_feedback: true },
+            resubmit: { status: "pending", update_model: true }
+          }
+        end
+
+        def default_context_config
+          {
+            default: {
+              statuses: %w[pending approved rejected modify],
+              initial_status: "pending",
+              transitions: { "pending" => %w[approved rejected modify], "modify" => [ "pending" ] },
+              actions: default_actions
+            }
+          }
+        end
+
+        def validate_action_config(actions, statuses, context_name)
+          actions.each do |action_name, opts|
+            unless statuses.include?(opts[:status])
+              raise ArgumentError,
+                    "Action '#{action_name}' in context '#{context_name}' maps to invalid status '#{opts[:status]}'. Must be one of: #{statuses.join(', ')}"
+            end
+          end
+        end
+
+        def validate_linear_transitions(transitions, statuses, context_name)
+          transitions.each do |status|
+            unless statuses.include?(status.to_s)
+              raise ArgumentError, "Transition status '#{status}' in context '#{context_name}' must be one of: #{statuses.join(', ')}"
+            end
+          end
+        end
+
+        def build_linear_transitions(transitions)
+          transitions.each_with_object({}).with_index do |(status, hash), index|
+            next_status = transitions[index + 1]
+            hash[status.to_s] = next_status ? [ next_status.to_s ] : []
+          end
+        end
+
+        def review_action_names
+          # Get actions from initialized contexts + default fallback
+          all_actions = review_context_configs.values.flat_map { |config| config[:actions].keys }
+          all_actions += default_context_config[:default][:actions].keys
+          all_actions.uniq
+        end
+      end
+
+      private
+
+      def review_action?
+        self.class.review_action_names.include?(action_name.to_sym)
+      end
+
+      def perform_review_action(status:, require_feedback: false, after: nil, update_model: false)
+        # Validate context exists before proceeding
+        begin
+          context_config
+        rescue ArgumentError => e
+          return render_error(errors: [ e.message ], status: :bad_request)
+        end
+
+        current_review = reviewable_resource.current_review_for(current_review_context)
+
+        feedback = if require_feedback
+                     feedback_data = params[:review_feedback].presence || params.dig(:review_feedback)&.to_unsafe_h
+                     return render_error(errors: [ "Feedback is required for #{status}" ]) if feedback_data.blank?
+
+                     feedback_data
+        else
+                     nil
+        end
+
+        unless valid_transition?(current_review&.status, status)
+          return render_error(errors: [ "Cannot transition from '#{current_review&.status || context_config[:initial_status]}' to '#{status}'" ])
+        end
+
+        begin
+          ActiveRecord::Base.transaction do
+            # Update the model if required (e.g., for resubmit with changes)
+            if update_model
+              begin
+                model_updates = model_params
+                if model_updates.present? && !reviewable_resource.update(model_updates)
+                  return render_error(errors: reviewable_resource.errors.full_messages)
+                end
+              rescue ActionController::ParameterMissing => e
+                return render_error(errors: [ e.message ])
+              end
+            end
+
+            # Update existing review or create new one if none exists
+            review = current_review || reviewable_resource.build_review_for(current_review_context)
+            review.assign_attributes(
+              status: status,
+              feedback: feedback,
+              reviewed_by: current_user,
+              reviewed_at: Time.current
+            )
+
+            before_review_action(review)
+            review.save!
+            execute_after_callbacks(review, after)
+            after_review_action(review)
+          end
+          render_success(data: reviewable_resource.reload)
+        rescue StandardError => e
+          render_error(errors: [ e.message ], status: :unprocessable_entity)
+        end
+      end
+
+      def execute_after_callbacks(review, after_callbacks = nil)
+        # Get action callbacks from the current action config or passed callbacks
+        action_config = context_config[:actions][action_name.to_sym]
+        action_callbacks = after_callbacks || action_config&.[](:after)
+        return unless action_callbacks
+
+        Array(action_callbacks).each do |callback|
+          if callback.is_a?(Symbol)
+            send(callback, review)
+          elsif callback.respond_to?(:call)
+            callback.call(review)
+          else
+            raise "Invalid callback: #{callback.inspect}"
+          end
+        rescue StandardError => e
+          Rails.logger.error "Callback failed: #{callback.inspect}, error: #{e.message}"
+          raise
+        end
+      end
+
+      def current_review_context
+        params[:context]&.to_sym || :default
+      end
+
+      def available_contexts
+        # Get all configured contexts plus default if not explicitly configured
+        contexts = self.class.review_context_configs.keys
+        contexts << :default unless contexts.include?(:default)
+        contexts
+      end
+
+      def context_config
+        context = current_review_context
+        config = self.class.review_context_configs[context]
+
+        # If requesting default context and it's not configured, use the built-in default
+        config = self.class.default_context_config[:default] if context == :default && config.nil?
+
+        # If context is not found and it's not the default, it's invalid
+        raise ArgumentError, "Invalid context '#{context}'. Available contexts: #{available_contexts.join(', ')}" if config.nil?
+
+        Rails.logger.debug "Context config for '#{context}': #{config.inspect}"
+        config
+      end
+
+      def allowed_statuses
+        context_config[:statuses]
+      end
+
+      def valid_transition?(from, to)
+        return true if context_config[:transitions].blank?
+
+        allowed_to = context_config[:transitions][from || context_config[:initial_status]] || []
+        allowed_to.include?(to)
+      end
+
+      def authorize_review_action!
+        # Override for custom auth
+      end
+
+      def before_review_action(review)
+        # Default implementation - can be overridden
+        # Check if there's a custom hook method defined
+        return unless respond_to?(:before_reviewable_action, true)
+
+        before_reviewable_action(review, reviewable_resource, current_review_context)
+
+        # Custom pre-save logic override point
+      end
+
+      def after_review_action(review)
+        # New hook for post-action logic
+        return unless respond_to?(:after_reviewable_action, true)
+
+        after_reviewable_action(review, reviewable_resource, current_review_context)
+      end
+
+      def current_user
+        # Default implementation that can be overridden
+        # Check if there's a custom user method defined
+        if respond_to?(:current_reviewer, true)
+          current_reviewer
+        else
+          # Default fallback - can be overridden in controllers
+          # Try common patterns or return nil if none exist
+          return super if defined?(super)
+          return @current_user if defined?(@current_user)
+          return session[:user_id] if session && session[:user_id]
+
+          nil
+        end
+      end
+
+      def model_params
+        # Default implementation that can be overridden
+        # Try different common parameter patterns
+        resource_name = controller_name.singularize
+
+        # First try the standard Rails pattern: resource_name_params
+        params_method = "#{resource_name}_params"
+        return send(params_method) if respond_to?(params_method, true)
+
+        # Fallback to generic reviewable_params
+        return reviewable_params if respond_to?(:reviewable_params, true)
+
+        # If neither exists, return empty hash (no model updates)
+        {}
+      rescue ActionController::ParameterMissing => e
+        raise e # Re-raise parameter missing errors
+      rescue StandardError => e
+        Rails.logger.warn "Failed to get model params: #{e.message}"
+        {}
+      end
+
+      def model_class
+        return reviewable_model_class if reviewable_model_class
+
+        model_name = controller_name.classify
+
+        controller_namespace = self.class.name.deconstantize
+        if controller_namespace.present?
+          namespaced_model = "#{controller_namespace}::#{model_name}"
+          return namespaced_model.constantize if Object.const_defined?(namespaced_model)
+        end
+
+        return model_name.constantize if Object.const_defined?(model_name)
+
+        raise NameError, "Could not determine model class for #{self.class.name}. " \
+                        "Please configure it explicitly using 'reviewable_model ModelClass' " \
+                        "in your controller class."
+      rescue NameError => e
+        Rails.logger.error "Model resolution failed for #{self.class.name}: #{e.message}"
+        raise
+      end
+
+      def set_reviewable_resource
+        @reviewable_resource = model_class.find(params[:id])
+      rescue ActiveRecord::RecordNotFound => e
+        render_error(status: :not_found, errors: [ e.message ])
+      rescue NameError => e
+        render_error(status: :internal_server_error, errors: [ "Configuration error: #{e.message}" ])
+      end
+
+      def reviewable_resource
+        @reviewable_resource
+      end
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ module Dscf::Credit
     end
 
     def eager_loaded_associations
-      [ :credit_lines, :scoring_tables, :scoring_parameters ]
+      [ :credit_lines, :scoring_parameters ]
     end
 
     def allowed_order_columns
@@ -24,9 +24,9 @@ module Dscf::Credit
     def default_serializer_includes
       {
         index: [],
-        show: [ :credit_lines, :scoring_tables, :scoring_parameters ],
+        show: [ :credit_lines, :scoring_parameters ],
         create: [],
-        update: [ :credit_lines, :scoring_tables, :scoring_parameters ]
+        update: [ :credit_lines, :scoring_parameters ]
       }
     end
   end

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

@@ -1,12 +1,16 @@
 module Dscf::Credit
   class CreditLinesController < ApplicationController
     include Dscf::Core::Common
-    include Dscf::Credit::Reviewable
+    include Dscf::Core::ReviewableController
 
     def create
       super do
         credit_line = @clazz.new(model_params)
         credit_line.created_by = current_user
+        credit_line.reviews.build(
+          status: "pending",
+          context: "default",
+        )
         credit_line
       end
     end
@@ -20,29 +24,33 @@ module Dscf::Credit
         :name,
         :code,
         :description,
-        :status,
-        :reviewed_by_type,
-        :reviewed_by_id,
-        :review_date,
-        :document_reference,
-        :review_feedback
+        :document_reference
       )
     end
 
     def eager_loaded_associations
-      [ :bank, :category, :created_by, :reviewed_by, :credit_line_specs, :loans, :eligible_credit_lines ]
+      [
+        :bank, :category, :created_by, :credit_line_specs, :loans, :eligible_credit_lines,
+        reviews: { reviewed_by: :user_profile }
+      ]
     end
 
     def allowed_order_columns
-      %w[id name code status review_date created_at updated_at category_id]
+      %w[id name code created_at updated_at category_id]
     end
 
     def default_serializer_includes
       {
-        index: [ :bank, :category ],
-        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 ]
+        index: [ :bank, :category, reviews: { reviewed_by: :user_profile } ],
+        show: [
+          :bank, :category, :created_by, :credit_line_specs, :loans, :eligible_credit_lines,
+          reviews: { reviewed_by: :user_profile }
+        ],
+        create: [ :bank, :category, :created_by, :reviews ],
+        update: [
+          :bank, :category, :created_by, :credit_line_specs, :loans, :eligible_credit_lines,
+          reviews: { reviewed_by: :user_profile }
+        ]
       }
     end
   end

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

@@ -2,31 +2,73 @@ 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" ])
+      eligible_credit_line = @clazz.find(params[:id])
+      risk_factor = risk_params[:risk_factor]
+
+      if risk_factor.nil? || risk_factor == "" || (risk_factor.is_a?(Hash) && risk_factor.empty?)
+        return render_error(
+          "eligible_credit_line.errors.apply_risk",
+          errors: [ "Risk factor is required" ],
+          status: :unprocessable_entity
+        )
       end
 
-      service = RiskApplicationService.new(@obj, params[:risk])
+      risk_factor_float = risk_factor.to_f
+      service = RiskApplicationService.new(eligible_credit_line, risk_factor_float)
       result = service.apply_risk
 
       if result[:success]
-        render_success(data: result[:data].reload)
+        render_success(
+          "eligible_credit_line.success.apply_risk",
+          data: result[:data],
+          serializer_options: { include: [ :loan_profile, :credit_line ] }
+        )
+      else
+        render_error(
+          "eligible_credit_line.errors.apply_risk",
+          errors: result[:errors],
+          status: :unprocessable_entity
+        )
+      end
+    rescue ActiveRecord::RecordNotFound
+      render_error(
+        "eligible_credit_line.errors.not_found",
+        errors: [ "Eligible credit line not found" ],
+        status: :not_found
+      )
+    rescue => e
+      Rails.logger.error("Risk application error: #{e.class} - #{e.message}")
+      Rails.logger.error(e.backtrace.join("\n"))
+
+      if Rails.env.development? || Rails.env.test?
+        render_error(
+          "eligible_credit_line.errors.apply_risk",
+          errors: [ e.message ],
+          status: :unprocessable_entity
+        )
       else
-        render_error(errors: result[:errors])
+        render_error(
+          "eligible_credit_line.errors.apply_risk",
+          errors: [ "An error occurred while applying risk factor" ],
+          status: :unprocessable_entity
+        )
       end
     end
 
     private
 
+    def risk_params
+      params.permit(:risk_factor)
+    end
+
     def model_params
       params.require(:eligible_credit_line).permit(
         :loan_profile_id,
         :credit_line_id,
         :credit_limit,
-        :available_limit
+        :available_limit,
+        :risk
       )
     end
 

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

@@ -0,0 +1,35 @@
+module Dscf::Credit
+  class FacilitatorApplicationsController < ApplicationController
+    include Dscf::Core::Common
+    include Dscf::Core::ReviewableController
+
+    def create
+      super
+      facilitator_application = @clazz.new(model_params)
+      facilitator_application.user = current_user
+      facilitator_application.reviews.build(context: "default", status: "pending")
+
+      facilitator_application
+    end
+
+    private
+
+    def model_params
+      params.require(:facilitator_application).permit(:user_id, :bank_id, facilitator_info: {})
+    end
+
+    def eager_loaded_associations
+      [ :user, :bank, reviews: { reviewed_by: :user_profile } ]
+    end
+
+    def allowed_order_columns
+      %w[id created_at updated_at]
+    end
+
+    def default_serializer_includes
+      {
+        default: [ :user, :bank, reviews: { reviewed_by: :user_profile } ]
+      }
+    end
+  end
+end

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