feat: implement service layer for business logic

- Application service base class with error handling
- Dashboard stats service for real-time metrics calculation
- User management service for CRUD operations
- User search service with filtering and pagination
- Separation of concerns between controllers and business logic

Author: lucasleandro1

app/services/application_service.rb

@@ -0,0 +1,60 @@
+# Base service class following Command pattern
+class ApplicationService
+  class << self
+    # Call the service with given arguments
+    def call(*args, **kwargs)
+      new(*args, **kwargs).call
+    end
+  end
+
+  # Override in subclasses
+  def call
+    raise NotImplementedError, "Subclasses must implement the call method"
+  end
+
+  private
+
+  # Success result
+  def success(data = nil)
+    ServiceResult.new(success: true, data: data)
+  end
+
+  # Error result
+  def failure(errors)
+    ServiceResult.new(success: false, errors: errors)
+  end
+end
+
+# Service result object
+class ServiceResult
+  attr_reader :data, :errors
+
+  def initialize(success:, data: nil, errors: nil)
+    @success = success
+    @data = data
+    @errors = errors || []
+  end
+
+  def success?
+    @success
+  end
+
+  def failure?
+    !@success
+  end
+
+  def error_messages
+    return [] if errors.blank?
+
+    case errors
+    when String
+      [ errors ]
+    when Array
+      errors
+    when ActiveModel::Errors
+      errors.full_messages
+    else
+      [ errors.to_s ]
+    end
+  end
+end

app/services/dashboard_stats_service.rb

@@ -0,0 +1,80 @@
+class DashboardStatsService < ApplicationService
+  def initialize(current_user)
+    @current_user = current_user
+  end
+
+  def call
+    return failure("Unauthorized access") unless can_access_dashboard?
+
+    stats = calculate_dashboard_stats
+    success(stats)
+  end
+
+  private
+
+  attr_reader :current_user
+
+  def can_access_dashboard?
+    current_user&.admin?
+  end
+
+  def calculate_dashboard_stats
+    {
+      users: user_statistics,
+      imports: import_statistics,
+      activity: activity_statistics,
+      growth: growth_statistics
+    }
+  end
+
+  def user_statistics
+    {
+      total: User.count,
+      admins: User.where(role: "admin").count,
+      regular_users: User.where(role: "user").count,
+      recent: User.with_attached_avatar_image.order(created_at: :desc).limit(5),
+      created_today: User.where(created_at: Date.current.beginning_of_day..Date.current.end_of_day).count,
+      created_this_week: User.where(created_at: 1.week.ago..Time.current).count,
+      created_this_month: User.where(created_at: 1.month.ago..Time.current).count
+    }
+  end
+
+  def import_statistics
+    {
+      total: Import.count,
+      pending: Import.where(status: "pending").count,
+      processing: Import.where(status: "processing").count,
+      completed: Import.where(status: "completed").count,
+      failed: Import.where(status: "failed").count,
+      recent: Import.order(created_at: :desc).limit(5)
+    }
+  end
+
+  def activity_statistics
+    {
+      users_created_today: User.where(created_at: Date.current.beginning_of_day..Date.current.end_of_day).count,
+      imports_started_today: Import.where(created_at: Date.current.beginning_of_day..Date.current.end_of_day).count,
+      last_activity: [
+        User.maximum(:updated_at),
+        Import.maximum(:updated_at)
+      ].compact.max
+    }
+  end
+
+  def growth_statistics
+    # Calculate user growth over the last 30 days
+    growth_data = (0..29).map do |days_ago|
+      date = days_ago.days.ago.to_date
+      {
+        date: date,
+        users_created: User.where(created_at: date.beginning_of_day..date.end_of_day).count
+      }
+    end.reverse
+
+    {
+      daily_growth: growth_data,
+      total_growth_30_days: User.where(created_at: 30.days.ago..Time.current).count,
+      average_daily_growth: growth_data.sum { |d| d[:users_created] } / 30.0
+    }
+  end
+end

app/services/user_management_service.rb

@@ -0,0 +1,68 @@
+class UserManagementService < ApplicationService
+  def initialize(user_params, current_user)
+    @user_params = user_params
+    @current_user = current_user
+  end
+
+  def call
+    if can_perform_action?
+      create_or_update_user
+    else
+      failure("You do not have permission to perform this action")
+    end
+  end
+
+  private
+
+  attr_reader :user_params, :current_user
+
+  def can_perform_action?
+    current_user&.admin?
+  end
+
+  def create_or_update_user
+    if user_params[:id].present?
+      update_existing_user
+    else
+      create_new_user
+    end
+  end
+
+  def update_existing_user
+    user = User.find(user_params[:id])
+
+    if user.update(filtered_params)
+      success(user)
+    else
+      failure(user.errors)
+    end
+  rescue ActiveRecord::RecordNotFound
+    failure("User not found")
+  end
+
+  def create_new_user
+    # Generate random password for new users
+    params_with_password = filtered_params.merge(
+      password: generate_secure_password,
+      password_confirmation: nil
+    )
+
+    user = User.new(params_with_password)
+
+    if user.save
+      # Send welcome email with password
+      UserMailer.welcome_email(user, params_with_password[:password]).deliver_later
+      success(user)
+    else
+      failure(user.errors)
+    end
+  end
+
+  def filtered_params
+    user_params.permit(:full_name, :email, :role, :avatar_url, :avatar_image)
+  end
+
+  def generate_secure_password
+    SecureRandom.alphanumeric(12)
+  end
+end

app/services/user_search_service.rb

@@ -0,0 +1,91 @@
+class UserSearchService < ApplicationService
+  def initialize(search_params, current_user)
+    @search_params = search_params
+    @current_user = current_user
+  end
+
+  def call
+    return failure("Unauthorized access") unless can_search?
+
+    users = build_search_query
+    success({
+      users: users,
+      total_count: users.count,
+      filters_applied: filters_applied?
+    })
+  end
+
+  private
+
+  attr_reader :search_params, :current_user
+
+  def can_search?
+    current_user&.admin?
+  end
+
+  def build_search_query
+    query = User.all
+    query = apply_search_filter(query)
+    query = apply_role_filter(query)
+    query = apply_date_filter(query)
+    query = apply_sorting(query)
+    query
+  end
+
+  def apply_search_filter(query)
+    return query if search_params[:search].blank?
+
+    search_term = "%#{search_params[:search].strip}%"
+    query.where(
+      "full_name ILIKE ? OR email ILIKE ?",
+      search_term, search_term
+    )
+  end
+
+  def apply_role_filter(query)
+    return query if search_params[:role].blank?
+
+    query.where(role: search_params[:role])
+  end
+
+  def apply_date_filter(query)
+    return query unless search_params[:date_from].present? || search_params[:date_to].present?
+
+    if search_params[:date_from].present?
+      query = query.where("created_at >= ?", Date.parse(search_params[:date_from]))
+    end
+
+    if search_params[:date_to].present?
+      query = query.where("created_at <= ?", Date.parse(search_params[:date_to]).end_of_day)
+    end
+
+    query
+  rescue Date::Error
+    query
+  end
+
+  def apply_sorting(query)
+    sort_by = search_params[:sort_by]&.to_s
+    sort_direction = search_params[:sort_direction]&.to_s
+
+    case sort_by
+    when "name"
+      query.order("full_name #{sort_direction == 'desc' ? 'DESC' : 'ASC'}")
+    when "email"
+      query.order("email #{sort_direction == 'desc' ? 'DESC' : 'ASC'}")
+    when "role"
+      query.order("role #{sort_direction == 'desc' ? 'DESC' : 'ASC'}")
+    when "created_at"
+      query.order("created_at #{sort_direction == 'desc' ? 'DESC' : 'ASC'}")
+    else
+      query.order(created_at: :desc)
+    end
+  end
+
+  def filters_applied?
+    search_params[:search].present? ||
+      search_params[:role].present? ||
+      search_params[:date_from].present? ||
+      search_params[:date_to].present?
+  end
+end