dscf-core 0.1.1 → 0.1.3

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

@@ -0,0 +1,58 @@
+module Dscf
+  module Core
+    module UserAuthenticatable
+      extend ActiveSupport::Concern
+
+      included do
+        has_secure_password
+
+        validates :email, uniqueness: true, allow_blank: true
+        validates :phone, uniqueness: true, allow_blank: true
+        validate :email_or_phone_present
+
+        has_many :refresh_tokens, dependent: :destroy, class_name: "Dscf::Core::RefreshToken"
+      end
+
+      def authenticate_with_password(password)
+        authenticate(password)
+      end
+
+      def generate_auth_tokens(request)
+        AuthService.generate_auth_tokens(self, request)
+      end
+
+      def valid_for_authentication?
+        active? && !locked?
+      end
+
+      def active?
+        true # Override in specific models if needed
+      end
+
+      def locked?
+        false # Override in specific models if needed
+      end
+
+      def track_device(request)
+        # Track device information for security
+        {
+          user_agent: request.user_agent,
+          ip_address: request.remote_ip,
+          device_id: request.params[:device_id]
+        }
+      end
+
+      def revoke_all_tokens
+        AuthService.revoke_all_user_tokens(self)
+      end
+
+      private
+
+      def email_or_phone_present
+        return unless email.blank? && phone.blank?
+
+        errors.add(:base, "Either email or phone must be provided")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Dscf
+  module Core
+    class Address < ApplicationRecord
+      belongs_to :user, class_name: "Dscf::Core::User"
+
+      enum :address_type, {shipping: 0, residence: 1, current: 2, branch: 3}
+
+      validates :country, presence: true
+    end
+  end
+end

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

@@ -6,6 +6,8 @@ module Dscf
 
       has_one_attached :logo
 
+      has_many :documents, as: :documentable, dependent: :destroy, class_name: "Dscf::Core::Document"
+
       validates :name, presence: true
 
       def logo_url

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

@@ -0,0 +1,19 @@
+module Dscf
+  module Core
+    class Document < ApplicationRecord
+      belongs_to :documentable, polymorphic: true
+      belongs_to :verified_by, polymorphic: true, optional: true
+      validates :document_type, presence: true
+
+      has_one_attached :file
+
+      enum :document_type, {business_license: 0, drivers_license: 1, claim: 2}
+
+      def file_url
+        return nil unless file.attached?
+
+        Rails.application.routes.url_helpers.rails_blob_url(file, only_path: true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Dscf
+  module Core
+    class RefreshToken < ApplicationRecord
+      belongs_to :user, class_name: "Dscf::Core::User"
+
+      validates :refresh_token, presence: true, uniqueness: true
+      validates :expires_at, presence: true
+      validates :user_id, presence: true
+
+      # scopes for querying tokens
+      scope :active, -> { where("expires_at > ?", Time.current) }
+      scope :for_device, ->(device) { where(device: device) }
+
+      # generate token and set expiry on creation
+      before_validation :set_token_and_expiry, on: :create
+
+      def expired?
+        expires_at < Time.current
+      end
+
+      def set_token_and_expiry
+        self.refresh_token ||= SecureRandom.hex(32)
+        self.expires_at ||= 30.days.from_now
+      end
+
+      def self.generate(user, request)
+        create(
+          user: user,
+          device: request.params[:device_id] || "unknown",
+          ip_address: request.remote_ip,
+          user_agent: request.user_agent
+        )
+      end
+    end
+  end
+end

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

@@ -1,14 +1,24 @@
 module Dscf
   module Core
     class User < ApplicationRecord
-      has_secure_password
-
-      validates :email, presence: true, uniqueness: true
-      validates :phone, presence: true, uniqueness: true
+      include UserAuthenticatable
 
       has_many :user_roles, class_name: "Dscf::Core::UserRole"
       has_many :roles, through: :user_roles, class_name: "Dscf::Core::Role"
       has_many :businesses, dependent: :destroy, class_name: "Dscf::Core::Business"
+      has_many :addresses, dependent: :destroy, class_name: "Dscf::Core::Address"
+      has_many :documents, as: :documentable, dependent: :destroy, class_name: "Dscf::Core::Document"
+      has_one :user_profile, dependent: :destroy, class_name: "Dscf::Core::UserProfile"
+
+      accepts_nested_attributes_for :user_profile
+
+      before_create :set_default_temp_password
+
+      private
+
+      def set_default_temp_password
+        self.temp_password = false if temp_password.nil?
+      end
     end
   end
 end

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

@@ -0,0 +1,31 @@
+module Dscf
+  module Core
+    class UserProfile < ApplicationRecord
+      belongs_to :user, class_name: "Dscf::Core::User"
+
+      validates :first_name, presence: true
+      validates :last_name, presence: true
+      validates :watchlist_hit, inclusion: {in: [true, false]}
+      validates :verification_status, presence: true
+
+      enum :gender, {
+        male: 0,
+        female: 1
+      }
+
+      enum :pep_status, {
+        no_exposure: 0,
+        low: 1,
+        medium: 2,
+        high: 3
+      }
+
+      enum :verification_status, {
+        pending: 0,
+        verified: 1,
+        rejected: 2,
+        under_review: 3
+      }
+    end
+  end
+end

data/app/services/dscf/core/auth_service.rb

@@ -0,0 +1,75 @@
+require "ostruct"
+
+module Dscf
+  module Core
+    class AuthService
+      class << self
+        def authenticate_user(email_or_phone, password)
+          user = find_user_by_email_or_phone(email_or_phone)
+          return nil unless user&.authenticate(password)
+
+          user
+        end
+
+        def generate_auth_tokens(user, request)
+          access_token = TokenService.issue(TokenService.access_token_payload(user))
+          refresh_token = create_refresh_token(user, request)
+
+          {
+            access_token: access_token,
+            refresh_token: refresh_token,
+            user: user
+          }
+        end
+
+        def refresh_access_token(refresh_token_value, request)
+          refresh_token = RefreshToken.active.find_by(refresh_token: refresh_token_value)
+          return nil unless refresh_token
+
+          # Validate device and IP for security
+          if refresh_token.ip_address != request.remote_ip
+            refresh_token.destroy
+            raise AuthenticationError, "Token compromised - IP address changed"
+          end
+
+          user = refresh_token.user
+          access_token = TokenService.issue(TokenService.access_token_payload(user))
+
+          {
+            access_token: access_token,
+            user: user
+          }
+        end
+
+        def revoke_refresh_token(token_value)
+          RefreshToken.find_by(refresh_token: token_value)&.destroy
+        end
+
+        def revoke_all_user_tokens(user)
+          user.refresh_tokens.destroy_all
+        end
+
+        private
+
+        def find_user_by_email_or_phone(email_or_phone)
+          if email_or_phone.include?("@")
+            User.find_by(email: email_or_phone)
+          else
+            User.find_by(phone: email_or_phone)
+          end
+        end
+
+        def create_refresh_token(user, request)
+          # Create a simple struct-like object for the refresh token generation
+          request_data = OpenStruct.new(
+            params: {device_id: request.params[:device_id]},
+            remote_ip: request.remote_ip,
+            user_agent: request.user_agent
+          )
+
+          RefreshToken.generate(user, request_data)
+        end
+      end
+    end
+  end
+end

data/app/services/dscf/core/token_service.rb

@@ -0,0 +1,55 @@
+require "jwt"
+
+module Dscf
+  module Core
+    class TokenService
+      class << self
+        def issue(payload, expires_in: 15.minutes)
+          payload = payload.merge(exp: Time.current.to_i + expires_in.to_i)
+          ::JWT.encode(payload, key, "HS256")
+        end
+
+        def decode(token)
+          return nil if token.blank?
+
+          begin
+            decoded = ::JWT.decode(token, key, true, algorithm: "HS256")
+            decoded.first
+          rescue ::JWT::ExpiredSignature
+            raise AuthenticationError, "Token has expired"
+          rescue ::JWT::DecodeError
+            raise AuthenticationError, "Invalid token"
+          end
+        end
+
+        def refresh_token_payload(user, device: nil, ip_address: nil)
+          {
+            user_id: user.id,
+            identifier: user.email || user.phone,
+            device: device,
+            ip_address: ip_address,
+            type: "refresh"
+          }
+        end
+
+        def access_token_payload(user)
+          {
+            user_id: user.id,
+            identifier: user.email || user.phone,
+            type: "access"
+          }
+        end
+
+        def key
+          @key ||= ENV.fetch("JWT_SECRET_KEY", nil) ||
+                   if Rails.env.test?
+                     "test_jwt_secret_key_for_testing_purposes_only_12345678901234567890"
+                   else
+                     Rails.application.credentials.secret_key_base
+                   end ||
+                   "fallback_secret_key_for_development_only_12345678901234567890"
+        end
+      end
+    end
+  end
+end

data/config/initializers/jwt.rb

@@ -0,0 +1,23 @@
+# JWT Configuration
+JWT_CONFIG = {
+  algorithm: "HS256",
+  access_token_expiry: 15.minutes,
+  refresh_token_expiry: 30.days,
+  issuer: "dscf-core",
+  audience: "dscf-api"
+}.freeze
+
+# JWT Secret Key Configuration
+# Priority: ENV["JWT_SECRET_KEY"] > Rails credentials > Rails secret_key_base
+JWT_SECRET_KEY = ENV.fetch("JWT_SECRET_KEY") do
+  if Rails.env.test?
+    "test_jwt_secret_key_for_testing_purposes_only_12345678901234567890"
+  else
+    Rails.application.credentials.secret_key_base
+  end
+end
+
+# # Validate JWT configuration on startup
+# Rails.application.config.after_initialize do
+#   raise "JWT_SECRET_KEY must be set and at least 32 characters long" unless JWT_SECRET_KEY.present? && JWT_SECRET_KEY.length >= 32
+# end

data/config/initializers/ransack.rb

@@ -0,0 +1,4 @@
+Ransack.configure do |config|
+  config.ignore_unknown_conditions = false
+
+end

data/config/locales/en.yml

@@ -0,0 +1,23 @@
+en:
+  auth:
+    success:
+      login: "Login successful."
+      signup: "Account created successfully. Please log in to continue."
+      logout: "Logged out successfully."
+      me: "Profile fetched successfully."
+      refresh: "Token refreshed successfully."
+    errors:
+      invalid_credentials: "Invalid credentials."
+      missing_email_or_phone: "Either email or phone must be provided."
+      signup_failed: "Failed to create account."
+      invalid_token: "Invalid refresh token."
+
+  role:
+    success:
+      show: "Role details retrieved successfully"
+      create: "Role created successfully"
+      update: "Role updated successfully"
+    errors:
+      create: "Failed to create role"
+      update: "Failed to update role"
+      show: "Role not found"

data/config/routes.rb

@@ -1,2 +1,7 @@
 Dscf::Core::Engine.routes.draw do
+  post "auth/login", to: "auth#login"
+  post "auth/logout", to: "auth#logout"
+  post "auth/signup", to: "auth#signup"
+  post "auth/refresh", to: "auth#refresh"
+  get "auth/me", to: "auth#me"
 end

data/db/migrate/20250822072222_create_dscf_core_businesses.rb

@@ -1,4 +1,4 @@
-class CreateDscfCoreBusinesses < ActiveRecord::Migration[7.1]
+class CreateDscfCoreBusinesses < ActiveRecord::Migration[8.0]
   def change
     create_table :dscf_core_businesses do |t|
       t.string :name, null: false

data/db/migrate/20250822075206_create_dscf_core_addresses.rb

@@ -0,0 +1,19 @@
+class CreateDscfCoreAddresses < ActiveRecord::Migration[8.0]
+  def change
+    create_table :dscf_core_addresses do |t|
+      t.references :user, null: false, index: {name: "user_on_dc_add_indx"}, foreign_key: {to_table: :dscf_core_users}
+      t.integer :address_type
+      t.string :country, null: false, default: "Ethiopia"
+      t.string :city
+      t.string :sub_city
+      t.string :woreda
+      t.string :kebele
+      t.string :house_numbers
+      t.string :po_box
+      t.decimal :latitude, precision: 10, scale: 6
+      t.decimal :longitude, precision: 10, scale: 6
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20250822081522_create_dscf_core_documents.rb

@@ -0,0 +1,14 @@
+class CreateDscfCoreDocuments < ActiveRecord::Migration[8.0]
+  def change
+    create_table :dscf_core_documents do |t|
+      t.references :documentable, polymorphic: true, null: false
+      t.string :document_type, null: false
+      t.boolean :is_verified, default: false
+      t.references :verified_by, polymorphic: true, null: true
+      t.datetime :verified_at
+      t.jsonb :metadata, default: {}
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20250822083000_change_document_type_in_dscf_core_documents.rb

@@ -0,0 +1,11 @@
+class ChangeDocumentTypeInDscfCoreDocuments < ActiveRecord::Migration[8.0]
+  def up
+    remove_column :dscf_core_documents, :document_type
+    add_column :dscf_core_documents, :document_type, :integer, null: false
+  end
+
+  def down
+    remove_column :dscf_core_documents, :document_type
+    add_column :dscf_core_documents, :document_type, :string, null: false
+  end
+end

data/db/migrate/20250822092031_create_dscf_core_user_profiles.rb

@@ -0,0 +1,26 @@
+class CreateDscfCoreUserProfiles < ActiveRecord::Migration[8.0]
+  def change
+    create_table :dscf_core_user_profiles do |t|
+      t.references :user, null: false, index: {name: "user_on_dc_up_indx"}, foreign_key: {to_table: :dscf_core_users}
+      t.string :first_name, null: false
+      t.string :middle_name
+      t.string :last_name, null: false
+      t.integer :gender
+      t.string :nationality
+      t.date :date_of_birth
+      t.string :place_of_birth
+      t.string :fayda_number
+      t.string :occupation
+      t.string :position_title
+      t.string :employer_name
+      t.decimal :avg_monthly_income, precision: 18, scale: 2
+      t.decimal :avg_annual_income, precision: 18, scale: 2
+      t.integer :pep_status
+      t.decimal :risk_score, precision: 5, scale: 2
+      t.boolean :watchlist_hit, null: false
+      t.integer :verification_status, null: false, default: 0
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20250824114725_create_dscf_core_refresh_tokens.rb

@@ -0,0 +1,15 @@
+class CreateDscfCoreRefreshTokens < ActiveRecord::Migration[8.0]
+  def change
+    create_table :dscf_core_refresh_tokens do |t|
+      t.references :user, null: false, foreign_key: {to_table: :dscf_core_users}
+      t.string :refresh_token, null: false
+      t.datetime :expires_at, null: false
+      t.string :device
+      t.string :ip_address
+      t.string :user_agent
+
+      t.timestamps
+    end
+    add_index :dscf_core_refresh_tokens, :refresh_token, unique: true
+  end
+end

data/db/migrate/20250824191957_change_pep_status_to_integer_in_user_profiles.rb

@@ -0,0 +1,5 @@
+class ChangePepStatusToIntegerInUserProfiles < ActiveRecord::Migration[8.0]
+  def change
+    change_column :dscf_core_user_profiles, :pep_status, :integer
+  end
+end

data/db/migrate/20250824200927_make_email_and_phone_optional_for_users.rb

@@ -0,0 +1,6 @@
+class MakeEmailAndPhoneOptionalForUsers < ActiveRecord::Migration[8.0]
+  def change
+    change_column_null :dscf_core_users, :email, true
+    change_column_null :dscf_core_users, :phone, true
+  end
+end

data/db/migrate/20250825192113_add_defaults_to_user_profiles.rb

@@ -0,0 +1,6 @@
+class AddDefaultsToUserProfiles < ActiveRecord::Migration[8.0]
+  def change
+    change_column_default :dscf_core_user_profiles, :watchlist_hit, false
+    change_column_default :dscf_core_user_profiles, :verification_status, 0 # pending
+  end
+end

data/lib/dscf/core/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Core
-    VERSION = "0.1.1".freeze
+    VERSION = "0.1.3".freeze
   end
 end

data/lib/dscf/core.rb

@@ -1,5 +1,7 @@
 require "dscf/core/version"
 require "dscf/core/engine"
+require "ransack"
+require "active_model_serializers"
 
 module Dscf
   module Core

data/spec/factories/dscf/core/addresses.rb

@@ -0,0 +1,15 @@
+FactoryBot.define do
+  factory :address, class: "Dscf::Core::Address" do
+    user
+    address_type { Dscf::Core::Address.address_types.keys.sample }
+    country { Faker::Address.country }
+    city { Faker::Address.city }
+    sub_city { Faker::Address.community }
+    woreda { Faker::Address.community }
+    kebele { Faker::Address.community }
+    house_numbers { Faker::Address.building_number }
+    po_box { Faker::Address.postcode }
+    latitude { Faker::Address.latitude }
+    longitude { Faker::Address.longitude }
+  end
+end

data/spec/factories/dscf/core/documents.rb

@@ -0,0 +1,25 @@
+FactoryBot.define do
+  factory :document, class: "Dscf::Core::Document" do
+    association :documentable, factory: :user # Default documentable
+    document_type { Dscf::Core::Document.document_types.keys.sample }
+    is_verified { false }
+    verified_at { nil }
+    metadata { {"source" => "test"} }
+
+    trait :for_user do
+      association :documentable, factory: :user
+    end
+
+    trait :for_business do
+      association :documentable, factory: :business
+    end
+
+    after(:build) do |document|
+      document.file.attach(
+        io: File.open(Rails.root.join("app", "fixtures", "images", "logo.jpg")),
+        filename: "logo.jpg",
+        content_type: "image/jpeg"
+      )
+    end
+  end
+end

data/spec/factories/dscf/core/refresh_tokens.rb

@@ -0,0 +1,25 @@
+FactoryBot.define do
+  factory :refresh_token, class: "Dscf::Core::RefreshToken" do
+    association :user, factory: :user
+    refresh_token { SecureRandom.hex(32) }
+    expires_at { 30.days.from_now }
+    device { Faker::Device.model_name }
+    ip_address { Faker::Internet.ip_v4_address }
+    user_agent { Faker::Internet.user_agent }
+  end
+
+  # Factory for expired tokens
+  factory :expired_refresh_token, parent: :refresh_token do
+    expires_at { 1.day.ago }
+  end
+
+  # Factory for tokens without automatic generation
+  factory :manual_refresh_token, parent: :refresh_token do
+    refresh_token { nil }
+    expires_at { nil }
+
+    after(:build) do |token|
+      token.instance_variable_set(:@skip_before_validation, true)
+    end
+  end
+end

data/spec/factories/dscf/core/user_profiles.rb

@@ -0,0 +1,22 @@
+FactoryBot.define do
+  factory :user_profile, class: "Dscf::Core::UserProfile" do
+    user
+    first_name { Faker::Name.first_name }
+    middle_name { Faker::Name.middle_name }
+    last_name { Faker::Name.last_name }
+    gender { %w[male female].sample }
+    nationality { Faker::Address.country }
+    date_of_birth { Faker::Date.birthday(min_age: 18, max_age: 65) }
+    place_of_birth { Faker::Address.city }
+    fayda_number { Faker::Alphanumeric.alpha(number: 10) }
+    occupation { Faker::Job.title }
+    position_title { Faker::Job.position }
+    employer_name { Faker::Company.name }
+    avg_monthly_income { Faker::Number.decimal(l_digits: 5, r_digits: 2) }
+    avg_annual_income { Faker::Number.decimal(l_digits: 6, r_digits: 2) }
+    pep_status { [0, 1, 2, 3].sample }
+    risk_score { Faker::Number.decimal(l_digits: 1, r_digits: 2) }
+    watchlist_hit { false }
+    verification_status { 0 }
+  end
+end