dscf-core 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 921baabb605b4c33c9d64f8e0839d0aebb9558e6980553f03fc35acf12286a84
-  data.tar.gz: 762b3316a670197ab8b24baff0140658550869a25b12424953795d0d28f972ae
+  metadata.gz: 2c8bc7f7428e10e98816b30968fa31e0609cba87e3292c8ad8d248f38067e578
+  data.tar.gz: db88e3856be17b5a02d0350d28d303d3ec59abf09cf2641bae204b990bf6704c
 SHA512:
-  metadata.gz: a6505e11aafa30ca100d6e371997f68407930c2f6759be12db6d63f8fc5cc6f9fb7050c206e93ba06d877bc56670ecbcb3077c5e02309a4f86bdaf600d7686cb
-  data.tar.gz: b2e5f301c038fed2e084d3a4aa7592a902d6c97fcbc8de51fd4a47baf8be25dbf512bd281a2584186b86fd433af89db18f3592042453d4848edc41ebff3d3c58
+  metadata.gz: 1f436f1f1d10c5c8e43c6683d8d104175d480d15dab6005e7b198ef4237e9c6fee26c15ea9a17d8fba4ad0b0f14a50aecbceb735157f4103b549e1ae4cc62a06
+  data.tar.gz: 8a4dda4a6efa99ebc8469fa9bf5ba69af0edbf3065f5c5ee288f591d2d65ee844a8bcf8d723a91bcec7840edc673c8db61584c752de63c0d1b96546b9f6af7a3

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

@@ -8,7 +8,18 @@ module Dscf
         when ActiveRecord::Base, ActiveRecord::Relation
           ActiveModelSerializers::SerializableResource.new(data, options)
         when Hash
-          data.transform_values { |value| serialize(value, options) }
+          # 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/app/controllers/concerns/dscf/core/reviewable_controller.rb

@@ -0,0 +1,345 @@
+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, <<~MSG
+              Initial status '#{defaults[:initial_status]}' in context '#{context_name}' must be one of: #{defaults[:statuses].join(', ')}
+            MSG
+          end
+
+          # Add to existing configs
+          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|
+            next if statuses.include?(opts[:status])
+
+            raise ArgumentError, <<~MSG
+              Action '#{action_name}' in context '#{context_name}' maps to invalid status '#{opts[:status]}'. Must be one of: #{statuses.join(', ')}
+            MSG
+          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)
+        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]
+                     feedback_data = feedback_data.to_unsafe_h if feedback_data.respond_to?(:to_unsafe_h)
+
+                     return render_error(errors: ["Feedback is required for #{status}"]) if feedback_data.blank?
+
+                     feedback_data
+                   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)
+      end
+
+      def after_review_action(review)
+        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
+        if respond_to?(:current_reviewer, true)
+          current_reviewer
+        else
+          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
+        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/core/auth_controller.rb

@@ -13,9 +13,14 @@ module Dscf
           render_success(
             "auth.success.login",
             data: {
-              user: user_with_profile(user),
+              user: user,
               access_token: tokens[:access_token],
               refresh_token: tokens[:refresh_token].refresh_token
+            },
+            serializer_options: {
+              user: {
+                serializer: Dscf::Core::UserAuthSerializer
+              }
             }
           )
         else
@@ -34,9 +39,14 @@ module Dscf
             render_success(
               "auth.success.signup",
               data: {
-                user: user_with_profile(user)
+                user: user
               },
-              status: :created
+              status: :created,
+              serializer_options: {
+                user: {
+                  serializer: Dscf::Core::UserAuthSerializer
+                }
+              }
             )
           else
             render_error(
@@ -57,7 +67,12 @@ module Dscf
         render_success(
           "auth.success.me",
           data: {
-            user: user_with_profile(current_user)
+            user: current_user
+          },
+          serializer_options: {
+            user: {
+              serializer: Dscf::Core::UserAuthSerializer
+            }
           }
         )
       end
@@ -101,16 +116,6 @@ module Dscf
         UserRole.create!(user: user, role: role)
       end
 
-      def user_with_profile(user)
-        user.as_json(
-          only: %i[id email phone],
-          include: {
-            user_profile: {only: %i[first_name last_name verification_status]},
-            roles: {only: %i[name description]}
-          }
-        )
-      end
-
       def authentication_required?
         # Skip authentication for login, signup, and refresh endpoints
         %w[login signup refresh].exclude?(action_name)

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

@@ -0,0 +1,31 @@
+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

data/app/models/dscf/core/review.rb

@@ -0,0 +1,22 @@
+module Dscf
+  module Core
+    class Review < ApplicationRecord
+      self.table_name = "dscf_core_reviews"
+
+      belongs_to :reviewable, polymorphic: true
+      belongs_to :reviewed_by, polymorphic: true, optional: true
+
+      validates :context, presence: true
+
+      scope :with_context, ->(ctx) { where(context: ctx.to_s) }
+
+      before_validation :set_default_context
+
+      private
+
+      def set_default_context
+        self.context ||= "default"
+      end
+    end
+  end
+end

data/app/models/dscf/core/role.rb

@@ -6,6 +6,14 @@ module Dscf
 
       has_many :user_roles, class_name: "Dscf::Core::UserRole"
       has_many :users, through: :user_roles, class_name: "Dscf::Core::User"
+
+      def self.ransackable_attributes(_auth_object = nil)
+        %w[id code name created_at updated_at]
+      end
+
+      def self.ransackable_associations(_auth_object = nil)
+        %w[user_roles users reviews]
+      end
     end
   end
 end

data/app/models/dscf/core/user.rb

@@ -14,6 +14,14 @@ module Dscf
 
       before_create :set_default_temp_password
 
+      def self.ransackable_attributes(_auth_object = nil)
+        %w[id email phone verified_at created_at updated_at]
+      end
+
+      def self.ransackable_associations(_auth_object = nil)
+        %w[refresh_tokens user_roles roles businesses addresses documents user_profile]
+      end
+
       private
 
       def set_default_temp_password

data/app/serializers/dscf/core/address_serializer.rb

@@ -0,0 +1,10 @@
+module Dscf
+  module Core
+    class AddressSerializer < ActiveModel::Serializer
+      attributes :id, :address_type, :country, :city, :sub_city, :woreda, :kebele, :house_numbers, :po_box, :latitude, :longitude,
+                 :created_at, :updated_at
+
+      belongs_to :user, serializer: UserSerializer
+    end
+  end
+end

data/app/serializers/dscf/core/business_serializer.rb

@@ -0,0 +1,10 @@
+module Dscf
+  module Core
+    class BusinessSerializer < ActiveModel::Serializer
+      attributes :id, :name, :description, :contact_email, :contact_phone, :tin_number, :created_at, :updated_at
+
+      belongs_to :user, serializer: Dscf::Core::UserSerializer
+      belongs_to :business_type, serializer: Dscf::Core::BusinessTypeSerializer
+    end
+  end
+end

data/app/serializers/dscf/core/business_type_serializer.rb

@@ -0,0 +1,9 @@
+module Dscf
+  module Core
+    class BusinessTypeSerializer < ActiveModel::Serializer
+      attributes :id, :name, :created_at, :updated_at
+
+      has_many :businesses, serializer: BusinessSerializer
+    end
+  end
+end

data/app/serializers/dscf/core/review_serializer.rb

@@ -0,0 +1,16 @@
+module Dscf
+  module Core
+    class ReviewSerializer < ActiveModel::Serializer
+      attributes :id, :context, :status, :feedback, :reviewed_at, :created_at, :updated_at
+
+      attribute :reviewable do
+        {
+          id: object.reviewable_id,
+          type: object.reviewable_type
+        }
+      end
+
+      belongs_to :reviewed_by, serializer: Dscf::Core::UserAuthSerializer
+    end
+  end
+end

data/app/serializers/dscf/core/role_serializer.rb

@@ -0,0 +1,9 @@
+module Dscf
+  module Core
+    class RoleSerializer < ActiveModel::Serializer
+      attributes :id, :code, :name, :created_at, :updated_at
+
+      has_many :user_roles, serializer: Dscf::Core::UserRoleSerializer
+    end
+  end
+end

data/app/serializers/dscf/core/user_auth_serializer.rb

@@ -0,0 +1,10 @@
+module Dscf
+  module Core
+    class UserAuthSerializer < ActiveModel::Serializer
+      attributes :id, :email, :phone, :verified_at
+
+      has_one :user_profile, serializer: Dscf::Core::UserProfileSerializer
+      has_many :roles, serializer: Dscf::Core::RoleSerializer
+    end
+  end
+end

data/app/serializers/dscf/core/user_profile_serializer.rb

@@ -0,0 +1,12 @@
+module Dscf
+  module Core
+    class UserProfileSerializer < ActiveModel::Serializer
+      attributes :id, :first_name, :middle_name, :last_name, :gender, :nationality, :date_of_birth,
+                 :place_of_birth, :fayda_number, :occupation, :position_title, :employer_name,
+                 :avg_monthly_income, :avg_annual_income, :pep_status, :risk_score, :watchlist_hit,
+                 :verification_status, :created_at, :updated_at
+
+      belongs_to :user, serializer: Dscf::Core::UserSerializer
+    end
+  end
+end

data/app/serializers/dscf/core/user_role_serializer.rb

@@ -0,0 +1,10 @@
+module Dscf
+  module Core
+    class UserRoleSerializer < ActiveModel::Serializer
+      attributes :id, :created_at, :updated_at
+
+      belongs_to :user, serializer: UserSerializer
+      belongs_to :role, serializer: RoleSerializer
+    end
+  end
+end

data/app/serializers/dscf/core/user_serializer.rb

@@ -0,0 +1,14 @@
+module Dscf
+  module Core
+    class UserSerializer < ActiveModel::Serializer
+      attributes :id, :email, :phone, :verified_at, :created_at, :updated_at
+
+      has_many :user_roles, serializer: Dscf::Core::UserRoleSerializer
+      has_many :roles, serializer: Dscf::Core::RoleSerializer
+      has_many :businesses, serializer: Dscf::Core::BusinessSerializer
+      has_many :addresses, serializer: Dscf::Core::AddressSerializer
+
+      has_one :user_profile, serializer: Dscf::Core::UserProfileSerializer
+    end
+  end
+end

data/db/migrate/20250926102025_create_dscf_core_reviews.rb

@@ -0,0 +1,14 @@
+class CreateDscfCoreReviews < ActiveRecord::Migration[8.0]
+  def change
+    create_table :dscf_core_reviews do |t|
+      t.references :reviewable, polymorphic: true, null: false
+      t.string :context
+      t.string :status, default: "pending"
+      t.jsonb :feedback
+      t.references :reviewed_by, polymorphic: true
+      t.datetime :reviewed_at
+
+      t.timestamps
+    end
+  end
+end

data/lib/dscf/core/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Core
-    VERSION = "0.1.7".freeze
+    VERSION = "0.1.8".freeze
   end
 end