dscf-credit 0.1.4 → 0.1.6

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

@@ -1,112 +0,0 @@
-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/payment_requests_controller.rb

@@ -1,87 +0,0 @@
-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,
-        :amount,
-        :receiver_account_reference,
-        :status,
-        :failure_reason
-        )
-    end
-
-    def eager_loaded_associations
-      [ :user, :loans, :payments ]
-    end
-
-    def allowed_order_columns
-      %w[id order_id request_type amount status initiated_at approved_at created_at updated_at]
-    end
-
-    def default_serializer_includes
-      {
-        index: [ :user ],
-        show: [ :user, :loans, :payments ],
-        create: [ :user ],
-        update: [ :user, :loans, :payments ]
-      }
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module Dscf::Credit
-  class PaymentsController < ApplicationController
-    include Dscf::Core::Common
-
-    private
-
-    def model_params
-      params.require(:payment).permit(
-        :payment_request_id,
-        :amount,
-        :receiver_account_reference,
-        :transaction_reference,
-        :status,
-        :failure_reason,
-        :processed_at
-      )
-    end
-
-    def eager_loaded_associations
-      [ :payment_request ]
-    end
-
-    def allowed_order_columns
-      %w[id amount status processed_at created_at updated_at]
-    end
-
-    def default_serializer_includes
-      {
-        index: [ :payment_request ],
-        show: [ :payment_request ],
-        create: [ :payment_request ],
-        update: [ :payment_request ]
-      }
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-module Dscf::Credit
-  class ScoringTablesController < ApplicationController
-    include Dscf::Core::Common
-
-    def create
-      super do
-        scoring_table = @clazz.new(model_params)
-        scoring_table.created_by = current_user
-        scoring_table
-      end
-    end
-
-    def activate
-      @obj = @clazz.find(params[:id])
-      if @obj.update(active: true)
-        render_success(data: @obj, serializer_options: { include: [ :category, :scoring_parameter, :created_by ] })
-      else
-        render_error(errors: @obj.errors.full_messages[0], status: :unprocessable_entity)
-      end
-    rescue StandardError => e
-      render_error(error: e.message)
-    end
-
-    def deactivate
-      @obj = @clazz.find(params[:id])
-      if @obj.update(active: false)
-        render_success(data: @obj, serializer_options: { include: [ :category, :scoring_parameter, :created_by ] })
-      else
-        render_error(errors: @obj.errors.full_messages[0], status: :unprocessable_entity)
-      end
-    rescue StandardError => e
-      render_error(error: e.message)
-    end
-
-    private
-
-    def model_params
-      params.require(:scoring_table).permit(
-        :category_id,
-        :scoring_parameter_id,
-        :weight,
-        :active
-      )
-    end
-
-    def eager_loaded_associations
-      [ :category, :scoring_parameter, :created_by ]
-    end
-
-    def allowed_order_columns
-      %w[id weight active created_at updated_at]
-    end
-
-    def default_serializer_includes
-      {
-        index: [ :category, :scoring_parameter, :created_by ],
-        show: [ :category, :scoring_parameter, :created_by ],
-        create: [ :category, :scoring_parameter, :created_by ],
-        update: [ :category, :scoring_parameter, :created_by ]
-      }
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-module Dscf::Credit
-  class Payment < ApplicationRecord
-    self.table_name = "dscf_credit_payments"
-
-    belongs_to :payment_request, class_name: "Dscf::Credit::PaymentRequest", foreign_key: "payment_request_id"
-
-    validates :amount, :receiver_account_reference, :transaction_reference, :status, presence: true
-    validates :amount, numericality: { greater_than: 0 }
-    validates :status, inclusion: { in: %w[pending processing completed failed cancelled] }
-    validates :transaction_reference, uniqueness: true
-
-    scope :by_status, ->(status) { where(status: status) }
-
-    def self.ransackable_attributes(auth_object = nil)
-      %w[id amount receiver_account_reference transaction_reference status failure_reason processed_at created_at updated_at]
-    end
-
-    def self.ransackable_associations(auth_object = nil)
-      %w[payment_request]
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-module Dscf::Credit
-  class PaymentRequest < ApplicationRecord
-    self.table_name = "dscf_credit_payment_requests"
-
-    if defined?(Dscf::Core::User)
-      belongs_to :user, class_name: "Dscf::Core::User", foreign_key: "user_id"
-    end
-    has_many :loans, class_name: "Dscf::Credit::Loan", foreign_key: "payment_request_id", dependent: :destroy
-    has_many :payments, class_name: "Dscf::Credit::Payment", foreign_key: "payment_request_id", dependent: :destroy
-
-    validates :order_id, presence: true, uniqueness: true
-    validates :request_type, :amount, :receiver_account_reference, presence: true
-    validates :amount, numericality: { greater_than: 0 }
-    validates :status, inclusion: { in: %w[pending approved rejected processed failed] }
-
-    scope :pending, -> { where(status: "pending") }
-    scope :approved, -> { where(status: "approved") }
-    scope :processed, -> { where(status: "processed") }
-    scope :failed, -> { where(status: "failed") }
-
-    def self.ransackable_attributes(auth_object = nil)
-      %w[id order_id request_type amount receiver_account_reference status failure_reason initiated_at approved_at created_at updated_at]
-    end
-
-    def self.ransackable_associations(auth_object = nil)
-      %w[user loans payments]
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Dscf::Credit
-  class ScoringTable < ApplicationRecord
-    self.table_name = "dscf_credit_scoring_tables"
-
-    belongs_to :category, class_name: "Dscf::Credit::Category", foreign_key: "category_id"
-    belongs_to :scoring_parameter, class_name: "Dscf::Credit::ScoringParameter", foreign_key: "scoring_parameter_id"
-    belongs_to :created_by, polymorphic: true
-
-    validates :weight, presence: true, numericality: { greater_than: 0, less_than_or_equal_to: 1 }
-    validates :category_id, uniqueness: { scope: :scoring_parameter_id }
-
-    scope :active, -> { where(active: true) }
-    scope :by_category, ->(category_id) { where(category_id: category_id) }
-    scope :by_scoring_parameter, ->(scoring_parameter_id) { where(scoring_parameter_id: scoring_parameter_id) }
-
-    def self.ransackable_attributes(auth_object = nil)
-      %w[id weight active created_at updated_at]
-    end
-
-    def self.ransackable_associations(auth_object = nil)
-      %w[category scoring_parameter created_by]
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-module Dscf::Credit
-  class PaymentRequestSerializer < ActiveModel::Serializer
-    attributes :id, :order_id, :request_type, :amount, :receiver_account_reference,
-               :status, :failure_reason, :initiated_at, :approved_at, :created_at, :updated_at
-
-    belongs_to :user, serializer: Dscf::Core::UserSerializer
-    has_many :loans, serializer: Dscf::Credit::LoanSerializer
-    has_many :payments, serializer: Dscf::Credit::PaymentSerializer
-  end
-end

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

@@ -1,8 +0,0 @@
-module Dscf::Credit
-  class PaymentSerializer < ActiveModel::Serializer
-    attributes :id, :amount, :receiver_account_reference, :transaction_reference,
-               :status, :failure_reason, :processed_at, :created_at, :updated_at
-
-    belongs_to :payment_request, serializer: PaymentRequestSerializer
-  end
-end

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

@@ -1,9 +0,0 @@
-module Dscf::Credit
-  class ScoringTableSerializer < ActiveModel::Serializer
-    attributes :id, :weight, :active, :created_at, :updated_at
-
-    belongs_to :category, serializer: Dscf::Credit::CategorySerializer
-    belongs_to :scoring_parameter, serializer: Dscf::Credit::ScoringParameterSerializer
-    belongs_to :created_by, serializer: Dscf::Core::UserSerializer
-  end
-end

data/db/migrate/20250822092608_create_dscf_credit_payment_requests.rb

@@ -1,26 +0,0 @@
-class CreateDscfCreditPaymentRequests < ActiveRecord::Migration[8.0]
-  def change
-    create_table :dscf_credit_payment_requests do |t|
-      t.references :user, null: false, foreign_key: { to_table: :dscf_core_users }
-      t.string :order_id, null: false
-      t.string :request_type, null: false
-      t.decimal :amount, precision: 15, scale: 2, null: false
-      t.string :receiver_account_reference, null: false
-      t.string :status, default: 'pending'
-      t.text :failure_reason
-      t.datetime :initiated_at
-      t.datetime :approved_at
-
-      t.timestamps
-    end
-
-    add_index :dscf_credit_payment_requests, :order_id, unique: true
-    add_index :dscf_credit_payment_requests, :request_type
-    add_index :dscf_credit_payment_requests, :status
-    add_index :dscf_credit_payment_requests, :receiver_account_reference
-    add_index :dscf_credit_payment_requests, :initiated_at
-    add_index :dscf_credit_payment_requests, :approved_at
-    add_index :dscf_credit_payment_requests, [ :user_id, :status ]
-    add_index :dscf_credit_payment_requests, [ :user_id, :request_type ]
-  end
-end

data/db/migrate/20250822092843_create_dscf_credit_payments.rb

@@ -1,23 +0,0 @@
-class CreateDscfCreditPayments < ActiveRecord::Migration[8.0]
-  def change
-    create_table :dscf_credit_payments do |t|
-      t.references :payment_request, null: false, foreign_key: { to_table: :dscf_credit_payment_requests }
-      t.decimal :amount, precision: 15, scale: 2, null: false
-      t.string :receiver_account_reference, null: false
-      t.string :transaction_reference, null: false
-      t.string :status, default: 'pending'
-      t.text :failure_reason
-      t.datetime :processed_at
-
-      t.timestamps
-    end
-
-    add_index :dscf_credit_payments, :transaction_reference, unique: true
-    add_index :dscf_credit_payments, :receiver_account_reference
-    add_index :dscf_credit_payments, :status
-    add_index :dscf_credit_payments, :amount
-    add_index :dscf_credit_payments, :processed_at
-    add_index :dscf_credit_payments, [ :payment_request_id, :status ]
-    add_index :dscf_credit_payments, :created_at
-  end
-end

data/db/migrate/20250901172842_create_dscf_credit_scoring_tables.rb

@@ -1,18 +0,0 @@
-class CreateDscfCreditScoringTables < ActiveRecord::Migration[8.0]
-  def change
-    create_table :dscf_credit_scoring_tables do |t|
-      t.references :category, null: false, foreign_key: { to_table: :dscf_credit_categories }
-      t.references :scoring_parameter, null: false, foreign_key: { to_table: :dscf_credit_scoring_parameters }
-      t.decimal :weight, precision: 5, scale: 4, null: false
-      t.boolean :active, default: true
-      t.references :created_by, polymorphic: true, null: false
-
-      t.timestamps
-    end
-
-    add_index :dscf_credit_scoring_tables, :weight
-    add_index :dscf_credit_scoring_tables, :active
-    add_index :dscf_credit_scoring_tables, [ :created_by_type, :created_by_id ]
-    add_index :dscf_credit_scoring_tables, [ :category_id, :scoring_parameter_id ], unique: true, name: 'index_scoring_tables_on_category_and_scoring_parameter'
-  end
-end

data/spec/factories/dscf/credit/payment_requests.rb

@@ -1,40 +0,0 @@
-FactoryBot.define do
-  factory :payment_request, class: "Dscf::Credit::PaymentRequest" do
-    association :user, factory: :user if defined?(Dscf::Core::User)
-    order_id { Faker::Alphanumeric.alphanumeric(number: 16).upcase }
-    request_type { %w[loan_disbursement loan_repayment interest_payment fee_payment].sample }
-    amount { Faker::Number.decimal(l_digits: 5, r_digits: 2) }
-    receiver_account_reference { Faker::Bank.account_number }
-    status { %w[pending approved rejected processed failed].sample }
-    failure_reason { Faker::Lorem.sentence if status.in?(%w[rejected failed]) }
-    initiated_at { Faker::Time.between(from: 1.month.ago, to: Time.current) }
-    approved_at { initiated_at + rand(1..24).hours if status.in?(%w[approved processed]) }
-
-    trait :pending do
-      status { "pending" }
-      approved_at { nil }
-      failure_reason { nil }
-    end
-
-    trait :approved do
-      status { "approved" }
-      approved_at { initiated_at + rand(1..24).hours }
-      failure_reason { nil }
-    end
-
-    trait :rejected do
-      status { "rejected" }
-      failure_reason { Faker::Lorem.sentence }
-    end
-
-    trait :processed do
-      status { "processed" }
-      approved_at { initiated_at + rand(1..24).hours }
-    end
-
-    trait :failed do
-      status { "failed" }
-      failure_reason { Faker::Lorem.sentence }
-    end
-  end
-end

data/spec/factories/dscf/credit/payments.rb

@@ -1,39 +0,0 @@
-FactoryBot.define do
-  factory :payment, class: "Dscf::Credit::Payment" do
-    association :payment_request, factory: :payment_request
-    amount { Faker::Number.decimal(l_digits: 5, r_digits: 2) }
-    receiver_account_reference { Faker::Alphanumeric.alphanumeric(number: 20) }
-    transaction_reference { Faker::Alphanumeric.alphanumeric(number: 16) }
-    status { %w[pending processing completed failed cancelled].sample }
-    failure_reason { Faker::Lorem.sentence if status.in?(%w[failed cancelled]) }
-    processed_at { Faker::Time.between(from: 1.month.ago, to: Time.current) if status.in?(%w[completed failed]) }
-
-    trait :pending do
-      status { "pending" }
-      processed_at { nil }
-      failure_reason { nil }
-    end
-
-    trait :processing do
-      status { "processing" }
-      processed_at { nil }
-    end
-
-    trait :completed do
-      status { "completed" }
-      processed_at { Faker::Time.between(from: 1.month.ago, to: Time.current) }
-      failure_reason { nil }
-    end
-
-    trait :failed do
-      status { "failed" }
-      processed_at { Faker::Time.between(from: 1.month.ago, to: Time.current) }
-      failure_reason { Faker::Lorem.sentence }
-    end
-
-    trait :cancelled do
-      status { "cancelled" }
-      failure_reason { Faker::Lorem.sentence }
-    end
-  end
-end

data/spec/factories/dscf/credit/scoring_tables.rb

@@ -1,25 +0,0 @@
-FactoryBot.define do
-  factory :scoring_table, class: "Dscf::Credit::ScoringTable" do
-    association :category, factory: :category
-    association :scoring_parameter, factory: :scoring_parameter
-    association :created_by, factory: :user if defined?(Dscf::Core::User)
-    weight { Faker::Number.decimal(l_digits: 0, r_digits: 4).clamp(0.0001, 1.0) }
-    active { true }
-
-    trait :inactive do
-      active { false }
-    end
-
-    trait :high_weight do
-      weight { Faker::Number.decimal(l_digits: 0, r_digits: 4).clamp(0.7, 1.0) }
-    end
-
-    trait :medium_weight do
-      weight { Faker::Number.decimal(l_digits: 0, r_digits: 4).clamp(0.3, 0.7) }
-    end
-
-    trait :low_weight do
-      weight { Faker::Number.decimal(l_digits: 0, r_digits: 4).clamp(0.0001, 0.3) }
-    end
-  end
-end