dscf-credit 0.1.8 → 0.2.0

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

@@ -1,77 +0,0 @@
-module Dscf
-  module Core
-    module JsonResponse
-      extend ActiveSupport::Concern
-
-      def serialize(data, options = {})
-        case data
-        when ActiveRecord::Base, ActiveRecord::Relation
-          ActiveModelSerializers::SerializableResource.new(data, options)
-        when Hash
-          # Handle hash data with potential serializer options
-          serialized_hash = {}
-          data.each do |key, value|
-            if options[key] && value.is_a?(ActiveRecord::Base)
-              # Use specific serializer for this key if provided
-              serializer_opts = options[key].is_a?(Hash) ? options[key] : {}
-              serialized_hash[key] = ActiveModelSerializers::SerializableResource.new(value, serializer_opts)
-            else
-              serialized_hash[key] = serialize(value, options)
-            end
-          end
-          serialized_hash
-        when Array
-          data.map { |value| serialize(value, options) }
-        else
-          data
-        end
-      end
-
-      def render_success(message_key = nil, data: nil, status: :ok, serializer_options: {}, **options)
-        response = {success: true}
-
-        if message_key
-          response[:message] = I18n.t(message_key)
-        else
-          model_key  = @clazz&.name&.demodulize&.underscore
-          action_key = action_name
-          i18n_key   = "#{model_key}.success.#{action_key}"
-
-          response[:message] = I18n.t(i18n_key) if I18n.exists?(i18n_key)
-        end
-
-        if data
-          serialized_data = serialize(data, serializer_options)
-          response[:data] = serialized_data
-        end
-
-        # Add pagination metadata if present (handled by Common concern)
-        response[:pagination] = serializer_options[:pagination] if serializer_options[:pagination]
-
-        response.merge!(options)
-        render json: response, status: status
-      end
-
-      def render_error(message_key = nil, status: :unprocessable_entity, errors: nil, **options)
-        response = {
-          success: false
-        }
-
-        if message_key
-          response[:error] = I18n.t(message_key)
-        else
-          model_key  = @clazz&.name&.demodulize&.underscore
-          action_key = action_name
-          i18n_key   = "#{model_key}.errors.#{action_key}"
-
-          response[:error] = I18n.t(i18n_key) if I18n.exists?(i18n_key)
-        end
-
-        response[:errors] = errors if errors
-        response.merge!(options)
-
-        render json: response, status: status
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-module Dscf
-  module Core
-    module Pagination
-      extend ActiveSupport::Concern
-
-      def default_per_page
-        10
-      end
-
-      def page_no
-        params[:page]&.to_i || 1
-      end
-
-      def per_page
-        params[:per_page]&.to_i || default_per_page
-      end
-
-      def paginate_offset
-        (page_no - 1) * per_page
-      end
-
-      def order_by
-        allowed_columns = if respond_to?(:allowed_order_columns, true)
-                            allowed_order_columns
-                          else
-                            %w[id created_at updated_at]
-                          end
-        requested_column = params.fetch(:order_by, "id").to_s
-        allowed_columns.include?(requested_column) ? requested_column : "id"
-      end
-
-      def order_direction
-        if %w[asc desc].include?(params.fetch(:order_direction, "asc").to_s.downcase)
-          params.fetch(:order_direction, "asc").to_s.downcase
-        else
-          "asc"
-        end
-      end
-
-      def paginate
-        ->(it) { it.limit(per_page).offset(paginate_offset).order("#{order_by}": order_direction) }
-      end
-
-      # Generate HATEOAS pagination links
-      def pagination_links(total_pages)
-        base_path = request.path
-        current_params = request.query_parameters.except("page")
-
-        links = {}
-
-        links[:first] = build_page_url(base_path, current_params, 1)
-
-        links[:prev] = (build_page_url(base_path, current_params, page_no - 1) if page_no > 1)
-
-        links[:next] = (build_page_url(base_path, current_params, page_no + 1) if page_no < total_pages)
-
-        links[:last] = build_page_url(base_path, current_params, total_pages)
-
-        links
-      end
-
-      private
-
-      def build_page_url(base_path, params, page)
-        params_with_page = params.merge(page: page, per_page: per_page)
-        query_string = params_with_page.to_query
-        "#{base_path}?#{query_string}"
-      end
-    end
-  end
-end

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

@@ -1,347 +0,0 @@
-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/concerns/dscf/core/token_authenticatable.rb

@@ -1,53 +0,0 @@
-module Dscf
-  module Core
-    module TokenAuthenticatable
-      extend ActiveSupport::Concern
-
-      included do
-        before_action :validate_token_expiry
-        before_action :validate_device_consistency, if: :current_user
-      end
-
-      def validate_token_expiry
-        return unless current_user
-
-        access_token = extract_access_token_from_header
-        return unless access_token
-
-        payload = TokenService.decode(access_token)
-        return unless payload
-
-        # Check if token is close to expiry (within 5 minutes)
-        if payload["exp"] && payload["exp"] - Time.current.to_i < 300
-          Rails.logger.info("Access token close to expiry for user #{current_user.id}")
-        end
-      rescue AuthenticationError
-        handle_expired_token
-      end
-
-      def validate_device_consistency
-        return unless current_user && request.params[:device_id]
-
-        refresh_token_record = current_user.refresh_tokens.active.find_by(device: request.params[:device_id])
-        return if refresh_token_record
-
-        # Device mismatch - could indicate suspicious activity
-        Rails.logger.warn("Device mismatch for user #{current_user.id}: #{request.params[:device_id]}")
-      end
-
-      def require_valid_refresh_token
-        refresh_token_value = extract_refresh_token_from_params
-        return if refresh_token_value && RefreshToken.active.exists?(refresh_token: refresh_token_value)
-
-        raise AuthenticationError, "Valid refresh token required"
-      end
-
-      private
-
-      def handle_expired_token
-        Rails.logger.warn("Expired token detected for request to #{request.path}")
-        raise AuthenticationError, "Session expired"
-      end
-    end
-  end
-end

data/app/jobs/dscf/credit/generate_daily_accruals_job.rb

@@ -1,78 +0,0 @@
-module Dscf::Credit
-  # Background job to generate daily loan accruals
-  #
-  # This job should be scheduled to run daily (typically at midnight or early morning)
-  # to generate interest and penalty accruals for all active loans.
-  #
-  # @example Schedule with Sidekiq (config/sidekiq.yml)
-  #   :schedule:
-  #     generate_daily_accruals:
-  #       cron: '0 1 * * *'  # Run at 1 AM daily
-  #       class: Dscf::Credit::GenerateDailyAccrualsJob
-  #
-  # @example Schedule with whenever gem (config/schedule.rb)
-  #   every 1.day, at: '1:00 am' do
-  #     runner "Dscf::Credit::GenerateDailyAccrualsJob.perform_later"
-  #   end
-  #
-  # @example Manual execution
-  #   Dscf::Credit::GenerateDailyAccrualsJob.perform_now
-  #
-  # @example With specific parameters
-  #   Dscf::Credit::GenerateDailyAccrualsJob.perform_later(
-  #     loan_ids: [1, 2, 3],
-  #     accrual_date: Date.yesterday
-  #   )
-  class GenerateDailyAccrualsJob < ApplicationJob
-    queue_as :default
-
-    # Perform the job to generate daily accruals
-    #
-    # @param loan_ids [Array<Integer>, nil] Optional specific loan IDs to process
-    # @param accrual_date [String, Date] Date for accrual generation (defaults to today)
-    # @param force_regenerate [Boolean] Whether to regenerate existing accruals
-    def perform(loan_ids: nil, accrual_date: nil, force_regenerate: false)
-      date = accrual_date ? Date.parse(accrual_date.to_s) : Date.current
-
-      service = LoanAccrualGeneratorService.new(
-        loan_ids: loan_ids,
-        accrual_date: date,
-        force_regenerate: force_regenerate
-      )
-
-      result = service.generate_daily_accruals
-
-      log_result(result)
-
-      result
-    end
-
-    private
-
-    # Log the result of accrual generation
-    #
-    # @param result [Hash] The result from the service
-    def log_result(result)
-      if result[:success]
-        Rails.logger.info(
-          "Loan Accrual Generation: #{result[:message]}"
-        )
-
-        if result[:errors].any?
-          Rails.logger.warn(
-            "Loan Accrual Generation Warnings: #{result[:errors].size} loans had errors"
-          )
-          result[:errors].each do |error|
-            Rails.logger.warn(
-              "Loan #{error[:loan_id]}: #{error[:error]}"
-            )
-          end
-        end
-      else
-        Rails.logger.error(
-          "Loan Accrual Generation Failed: #{result[:message]}"
-        )
-      end
-    end
-  end
-end

data/app/models/concerns/core/reviewable_model.rb

@@ -1,31 +0,0 @@
-module Dscf
-  module Core
-    module ReviewableModel
-      extend ActiveSupport::Concern
-
-      included do
-        has_many :reviews, as: :reviewable, class_name: "Dscf::Core::Review", dependent: :destroy
-      end
-
-      def review_for(context = :default)
-        reviews.with_context(context).order(created_at: :desc)
-      end
-
-      def current_review_for(context = :default)
-        review_for(context).first
-      end
-
-      def current_status_for(context = :default)
-        current_review = current_review_for(context)
-        return current_review.status if current_review
-
-        # Return default initial status for zero-config
-        "pending"
-      end
-
-      def build_review_for(context = :default)
-        reviews.build(context: context.to_s)
-      end
-    end
-  end
-end