dscf-payment 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 510fd8007681aac5a20434463cc546f4b9c108a7e5e53b8fa09c81f939267c6c
+  data.tar.gz: b0f00ba8049489d151673e54f2c5a73f4d3307750a2e65a84f969d5c537fcb43
+SHA512:
+  metadata.gz: d87c868934387b69afceb4ed91f78ce1d5a3a7b808ca0d61fdc1201054f33409bcb50166c551d2b88e3acc946c510a9524bf72206a7a540cb4cd028e68ca7362
+  data.tar.gz: fb6b47a296c410f4d8ffdef7d2ed39c189458629f76c8c10010dd3755f2bcc6d489b8891bb2286c3e650705d10b9842ca9ce18a3f0c9f9d71f42ff462a476343

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Asrat
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# Dscf::Payment
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "dscf-payment"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install dscf-payment
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/controllers/dscf/payment/application_controller.rb

@@ -0,0 +1,25 @@
+module Dscf
+  module Payment
+    class ApplicationController < ActionController::API
+      include Dscf::Core::Authenticatable
+      include Dscf::Core::TokenAuthenticatable
+      include Dscf::Core::JsonResponse
+
+      # Handle CORS for authentication
+      before_action :set_cors_headers
+
+      private
+
+      def set_cors_headers
+        headers["Access-Control-Allow-Origin"] = request.headers["Origin"] || "*"
+        headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, PATCH, DELETE, OPTIONS"
+        headers["Access-Control-Allow-Headers"] = "Origin, Content-Type, Accept, Authorization, X-Requested-With"
+        headers["Access-Control-Allow-Credentials"] = "false"
+      end
+
+      def authentication_required?
+        false # Override in specific controllers
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Dscf::Payment
+  class PaymentRequestsController < ApplicationController
+    include Dscf::Core::Common
+
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+
+    def create
+      super do
+        Dscf::Payment::PaymentRequest.new(model_params)
+      end
+    end
+
+    def process_payment
+      payment_request = Dscf::Payment::PaymentRequest.find(params[:id])
+
+      unless payment_request.pending?
+        return render_error(
+          error: "Payment request cannot be processed",
+          errors: [ "Payment request status is #{payment_request.status}" ]
+        )
+      end
+
+      service = Dscf::Payment::PaymentService.new(payment_request, current_user)
+      payment = service.process
+
+      render_success(
+        data: payment,
+        message: "Payment processed successfully"
+      )
+    rescue ActiveRecord::RecordNotFound
+      render_error(error: "Payment request not found", status: :not_found)
+    rescue => e
+      render_error(error: "Payment processing failed", errors: [ e.message ])
+    end
+
+    private
+
+    def authentication_required?
+      true
+    end
+
+    def model_params
+      params.require(:payment_request).permit(
+        :payment_type,
+        :amount,
+        :currency,
+        :description,
+        :from_account_id,
+        :to_account_id,
+        :payable_type,
+        :payable_id,
+        metadata: {}
+      )
+    end
+
+    def eager_loaded_associations
+      [ :from_account, :to_account, :payable, :payments ]
+    end
+
+    def allowed_order_columns
+      %w[id payment_type amount currency status reference_number created_at updated_at]
+    end
+
+    private
+
+    def record_not_found
+      render_error(error: "Payment request not found", status: :not_found)
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Dscf::Payment
+  class PaymentsController < ApplicationController
+    include Dscf::Core::Common
+
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+
+    private
+
+    def authentication_required?
+      true
+    end
+
+    def model_params
+      # Read-only controller - no creation via API
+      {}
+    end
+
+    def eager_loaded_associations
+      [ :payment_request, :banking_transaction ]
+    end
+
+    def allowed_order_columns
+      %w[id transaction_reference amount currency status processed_at created_at updated_at]
+    end
+
+    private
+
+    def record_not_found
+      render_error(error: "Payment not found", status: :not_found)
+    end
+  end
+end

data/app/jobs/dscf/payment/application_job.rb

@@ -0,0 +1,6 @@
+module Dscf
+  module Payment
+    class ApplicationJob < ActiveJob::Base
+    end
+  end
+end

data/app/mailers/dscf/payment/application_mailer.rb

@@ -0,0 +1,8 @@
+module Dscf
+  module Payment
+    class ApplicationMailer < ActionMailer::Base
+      default from: "from@example.com"
+      layout "mailer"
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Dscf
+  module Payment
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Dscf::Payment
+  class Payment < ApplicationRecord
+    self.table_name = "dscf_payment_payments"
+
+    belongs_to :payment_request, class_name: "Dscf::Payment::PaymentRequest"
+    belongs_to :banking_transaction, class_name: "Dscf::Banking::Transaction", optional: true
+
+    validates :transaction_reference, :amount, presence: true
+    validates :amount, numericality: { greater_than: 0 }
+    validates :status, inclusion: { in: %w[pending processing completed failed cancelled] }
+    validates :transaction_reference, uniqueness: true
+    validates :currency, presence: true
+
+    before_validation :generate_transaction_reference, on: :create
+
+    scope :by_status, ->(status) { where(status: status) }
+    scope :completed, -> { where(status: "completed") }
+    scope :failed, -> { where(status: "failed") }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id transaction_reference amount currency status processed_at failure_reason created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[payment_request banking_transaction]
+    end
+
+    private
+
+    def generate_transaction_reference
+      return if transaction_reference.present?
+
+      timestamp = Time.current.strftime("%Y%m%d%H%M%S")
+      random_suffix = SecureRandom.hex(4).upcase
+      self.transaction_reference = "PAY#{timestamp}#{random_suffix}"
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Dscf::Payment
+  class PaymentRequest < ApplicationRecord
+    self.table_name = "dscf_payment_payment_requests"
+
+    belongs_to :from_account, class_name: "Dscf::Banking::Account", optional: true
+    belongs_to :to_account, class_name: "Dscf::Banking::Account", optional: true
+    belongs_to :payable, polymorphic: true, optional: true
+    has_many :payments, class_name: "Dscf::Payment::Payment", foreign_key: "payment_request_id", dependent: :destroy
+
+    validates :payment_type, :amount, :reference_number, presence: true
+    validates :amount, numericality: { greater_than: 0 }
+    validates :payment_type, inclusion: { in: %w[disbursement transfer repayment] }
+    validates :status, inclusion: { in: %w[pending approved processing completed failed cancelled] }
+    validates :reference_number, uniqueness: true
+    validates :currency, presence: true
+
+    before_validation :generate_reference_number, on: :create
+
+    scope :pending, -> { where(status: "pending") }
+    scope :approved, -> { where(status: "approved") }
+    scope :processing, -> { where(status: "processing") }
+    scope :completed, -> { where(status: "completed") }
+    scope :failed, -> { where(status: "failed") }
+    scope :by_type, ->(type) { where(payment_type: type) }
+
+    def pending?
+      status == "pending"
+    end
+
+    def approved?
+      status == "approved"
+    end
+
+    def processing?
+      status == "processing"
+    end
+
+    def completed?
+      status == "completed"
+    end
+
+    def failed?
+      status == "failed"
+    end
+
+    def self.ransackable_attributes(auth_object = nil)
+      %w[id payment_type amount currency status reference_number description created_at updated_at]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[from_account to_account payable payments]
+    end
+
+    private
+
+    def generate_reference_number
+      return if reference_number.present?
+
+      timestamp = Time.current.strftime("%Y%m%d%H%M%S")
+      random_suffix = SecureRandom.hex(4).upcase
+      self.reference_number = "PAYREQ#{timestamp}#{random_suffix}"
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Dscf::Payment
+  class PaymentRequestSerializer < ActiveModel::Serializer
+    attributes :id,
+      :payment_type,
+      :amount,
+      :currency,
+      :status,
+      :reference_number,
+      :description,
+      :created_at,
+      :updated_at
+
+    belongs_to :from_account, serializer: Dscf::Banking::AccountSerializer
+    belongs_to :to_account, serializer: Dscf::Banking::AccountSerializer
+    belongs_to :payable
+    has_many :payments, serializer: Dscf::Payment::PaymentSerializer
+  end
+end

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

@@ -0,0 +1,16 @@
+module Dscf::Payment
+  class PaymentSerializer < ActiveModel::Serializer
+    attributes :id,
+      :transaction_reference,
+      :amount,
+      :currency,
+      :status,
+      :processed_at,
+      :failure_reason,
+      :created_at,
+      :updated_at
+
+    belongs_to :payment_request, serializer: Dscf::Payment::PaymentRequestSerializer
+    belongs_to :banking_transaction, serializer: Dscf::Banking::TransactionSerializer
+  end
+end

data/app/services/dscf/payment/banking_integration_service.rb

@@ -0,0 +1,37 @@
+module Dscf::Payment
+  class BankingIntegrationService
+    def transfer(from_account, to_account, amount, description, transaction_type_code: "TRANSFER")
+      validate_transfer_params(from_account, to_account, amount)
+
+      transfer_service = Dscf::Banking::TransferService.new(
+        debit_account: from_account,
+        credit_account: to_account,
+        amount: amount,
+        description: description,
+        transaction_type_code: transaction_type_code
+      )
+
+      result = transfer_service.execute
+
+      unless result.success?
+        raise BankingTransactionError.new("Banking transfer failed: #{result.errors.join(", ")}")
+      end
+
+      result.transaction
+    rescue AccountNotActiveError, InvalidAmountError, InsufficientFundsError, BankingTransactionError
+      raise
+    rescue => e
+      raise BankingTransactionError.new("Banking transfer error: #{e.message}")
+    end
+
+    private
+
+    def validate_transfer_params(from_account, to_account, amount)
+      raise InvalidAmountError.new("Amount must be positive") unless amount&.positive?
+      raise AccountNotActiveError.new("From account not active") unless from_account&.active? && from_account.status == "active"
+      raise AccountNotActiveError.new("To account not active") unless to_account&.active? && to_account.status == "active"
+      raise InsufficientFundsError.new("Insufficient funds") unless from_account.sufficient_funds_for_withdrawal?(amount)
+      raise BankingTransactionError.new("Currency mismatch") unless from_account.currency == to_account.currency
+    end
+  end
+end

data/app/services/dscf/payment/credit_integration_service.rb

@@ -0,0 +1,56 @@
+module Dscf::Payment
+  class CreditIntegrationService
+    def process_disbursement(amount, loan_profile, eligible_credit_line)
+      validate_disbursement_params(amount, loan_profile, eligible_credit_line)
+
+      disbursement_service = Dscf::Credit::DisbursementService.new(
+        amount: amount,
+        loan_profile: loan_profile,
+        eligible_credit_line: eligible_credit_line
+      )
+
+      result = disbursement_service.process_disbursement
+
+      unless result[:success]
+        raise CreditOperationError.new("Disbursement failed: #{result[:error]}")
+      end
+
+      result
+    rescue CreditOperationError, InvalidAmountError
+      raise
+    rescue => e
+      raise CreditOperationError.new("Credit disbursement error: #{e.message}")
+    end
+
+    def process_repayment(loan, amount, current_user)
+      validate_repayment_params(loan, amount, current_user)
+
+      repayment_service = Dscf::Credit::RepaymentService.new(loan, amount, current_user)
+      result = repayment_service.process_repayment
+
+      unless result[:success]
+        raise CreditOperationError.new("Repayment failed: #{result[:error]}")
+      end
+
+      result
+    rescue CreditOperationError, InvalidAmountError
+      raise
+    rescue => e
+      raise CreditOperationError.new("Credit repayment error: #{e.message}")
+    end
+
+    private
+
+    def validate_disbursement_params(amount, loan_profile, eligible_credit_line)
+      raise InvalidAmountError.new("Amount must be positive") unless amount&.positive?
+      raise CreditOperationError.new("Loan profile required") unless loan_profile
+      raise CreditOperationError.new("Eligible credit line required") unless eligible_credit_line
+    end
+
+    def validate_repayment_params(loan, amount, current_user)
+      raise InvalidAmountError.new("Amount must be positive") unless amount&.positive?
+      raise CreditOperationError.new("Loan required") unless loan
+      raise CreditOperationError.new("Current user required") unless current_user
+    end
+  end
+end

data/app/services/dscf/payment/payment_service.rb

@@ -0,0 +1,128 @@
+module Dscf::Payment
+  class PaymentService
+    attr_reader :payment_request, :current_user
+
+    def initialize(payment_request, current_user = nil)
+      @payment_request = payment_request
+      @current_user = current_user
+    end
+
+    def process
+      validate_payment_request
+
+      ActiveRecord::Base.transaction do
+        payment = create_payment_record
+
+        case payment_request.payment_type
+        when "disbursement"
+          process_disbursement(payment)
+        when "transfer"
+          process_transfer(payment)
+        when "repayment"
+          process_repayment(payment)
+        else
+          raise InvalidPaymentTypeError.new("Unknown payment type: #{payment_request.payment_type}")
+        end
+
+        mark_payment_completed(payment)
+        payment
+      end
+    rescue => e
+      handle_payment_failure(e)
+      raise
+    end
+
+    private
+
+    def validate_payment_request
+      raise InvalidPaymentTypeError.new("Invalid payment type") unless valid_payment_type?
+      raise PaymentError.new("Payment request already processed") if payment_request.processing? || payment_request.completed?
+    end
+
+    def valid_payment_type?
+      %w[disbursement transfer repayment].include?(payment_request.payment_type)
+    end
+
+    def create_payment_record
+      payment_request.payments.create!(
+        amount: payment_request.amount,
+        currency: payment_request.currency,
+        status: "processing"
+      )
+    end
+
+    def process_disbursement(payment)
+      # For disbursements: settlement account -> customer account
+      settlement_account = SettlementAccountService.settlement_account_for(currency: payment_request.currency)
+
+      # First, process the credit disbursement
+      credit_service = CreditIntegrationService.new
+      credit_service.process_disbursement(
+        payment_request.amount,
+        payment_request.payable, # Should be loan_profile
+        payment_request.metadata["eligible_credit_line"] # Need to store this in metadata
+      )
+
+      # Then transfer from settlement to customer account
+      banking_service = BankingIntegrationService.new
+      banking_transaction = banking_service.transfer(
+        settlement_account,
+        payment_request.to_account,
+        payment_request.amount,
+        "Loan disbursement for #{payment_request.reference_number}"
+      )
+
+      payment.update!(banking_transaction: banking_transaction)
+    end
+
+    def process_transfer(payment)
+      # Direct account to account transfer
+      banking_service = BankingIntegrationService.new
+      banking_transaction = banking_service.transfer(
+        payment_request.from_account,
+        payment_request.to_account,
+        payment_request.amount,
+        "Account transfer for #{payment_request.reference_number}"
+      )
+
+      payment.update!(banking_transaction: banking_transaction)
+    end
+
+    def process_repayment(payment)
+      # For repayments: customer account -> settlement account
+      settlement_account = SettlementAccountService.settlement_account_for(currency: payment_request.currency)
+
+      # First transfer to settlement account
+      banking_service = BankingIntegrationService.new
+      banking_transaction = banking_service.transfer(
+        payment_request.from_account,
+        settlement_account,
+        payment_request.amount,
+        "Loan repayment for #{payment_request.reference_number}"
+      )
+
+      credit_service = CreditIntegrationService.new
+      credit_service.process_repayment(
+        payment_request.payable,
+        payment_request.amount,
+        current_user
+      )
+
+      payment.update!(banking_transaction: banking_transaction)
+    end
+
+    def mark_payment_completed(payment)
+      payment.update!(status: "completed", processed_at: Time.current)
+      payment_request.update!(status: "completed")
+    end
+
+    def handle_payment_failure(error)
+      payment_request.payments.where(status: "processing").update_all(
+        status: "failed",
+        failure_reason: error.message,
+        processed_at: Time.current
+      )
+      payment_request.update_column(:status, "failed")
+    end
+  end
+end

data/app/services/dscf/payment/settlement_account_service.rb

@@ -0,0 +1,37 @@
+module Dscf::Payment
+  class SettlementAccountService
+    SETTLEMENT_ACCOUNT_NAME = "DSCF Payment Settlement Account"
+
+    class << self
+      def find_or_create_settlement_account(currency: "ETB")
+        account = Dscf::Banking::Account.find_by(
+          name: SETTLEMENT_ACCOUNT_NAME,
+          currency: currency,
+          system_account: true
+        )
+
+        return account if account
+
+        # Create new settlement account
+        Dscf::Banking::Account.create!(
+          name: SETTLEMENT_ACCOUNT_NAME,
+          currency: currency,
+          system_account: true,
+          current_balance: 0,
+          available_balance: 0,
+          minimum_balance: 0,
+          status: :active,
+          active: true
+        )
+      rescue ActiveRecord::RecordInvalid => e
+        raise SettlementAccountError.new("Failed to create settlement account: #{e.message}")
+      end
+
+      def settlement_account_for(currency: "ETB")
+        account = find_or_create_settlement_account(currency: currency)
+        raise SettlementAccountError.new("Settlement account not found for currency #{currency}") unless account
+        account
+      end
+    end
+  end
+end

data/config/locales/en.yml

@@ -0,0 +1,21 @@
+en:
+  dscf:
+    payment:
+      payment_request:
+        success:
+          create: "Payment request created successfully"
+          show: "Payment request retrieved successfully"
+          index: "Payment requests retrieved successfully"
+          process: "Payment processed successfully"
+        errors:
+          create: "Failed to create payment request"
+          show: "Payment request not found"
+          index: "Failed to retrieve payment requests"
+          process: "Failed to process payment"
+      payment:
+        success:
+          show: "Payment retrieved successfully"
+          index: "Payments retrieved successfully"
+        errors:
+          show: "Payment not found"
+          index: "Failed to retrieve payments"

data/config/routes.rb

@@ -0,0 +1,8 @@
+Dscf::Payment::Engine.routes.draw do
+  resources :payment_requests do
+    member do
+      post :process_payment
+    end
+  end
+  resources :payments, only: [ :index, :show ]
+end