Update platform invitations views for better performance

- Created a new partial `_filter_hidden_fields.html.erb` to preserve filter parameters across form submissions in the platform invitations.
- Updated `_platform_invitation.html.erb` to use caching for table rows.
- Refactored `index.html.erb` to include the new filter hidden fields partial and improved the form structure for filtering and pagination.
- Enhanced localization files (`en.yml`, `es.yml`, `fr.yml`) to include new translations for platform invitation attributes.
- Updated controller specs to reflect changes in the platform invitation model and added tests for filtering, searching, and sorting functionality.
- Adjusted factories for platform invitations and roles to ensure proper associations and unique invitee emails.

Author: rsmithlal

app/controllers/better_together/platform_invitations_controller.rb

@@ -16,12 +16,10 @@ class PlatformInvitationsController < ApplicationController # rubocop:todo Style
     def index
       authorize BetterTogether::PlatformInvitation
 
-      # Use optimized query with all necessary includes to prevent N+1
-      @platform_invitations = policy_scope(@platform.invitations)
-                              .includes(
-                                { inviter: [:string_translations] },
-                                { invitee: [:string_translations] }
-                              )
+      # Build filtered and sorted collection with pagination
+      @platform_invitations = build_filtered_collection
+      @platform_invitations = apply_sorting(@platform_invitations)
+      @platform_invitations = @platform_invitations.page(params[:page]).per(25)
 
       # Preload roles for the form to prevent N+1 queries during rendering
       @community_roles = BetterTogether::Role.where(resource_type: 'BetterTogether::Community')
@@ -64,8 +62,8 @@ def create # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
         else
           flash.now[:alert] = t('flash.generic.error_create', resource: t('resources.invitation'))
           format.html do
-            redirect_to platform_platform_invitations_path(@platform),
-                        alert: @platform_invitation.errors.full_messages.to_sentence
+            index
+            render :index, status: :unprocessable_entity
           end
           format.turbo_stream do
             render turbo_stream: [
@@ -147,6 +145,119 @@ def set_platform_invitation
       @platform_invitation = @platform.invitations.find(params[:id])
     end
 
+    def build_filtered_collection
+      collection = base_collection
+      collection = apply_status_filter(collection) if filter_params[:status].present? || params[:status].present?
+      collection = apply_email_filter(collection) if filter_params[:search].present? || params[:search].present?
+      collection = apply_valid_from_filter(collection) if filter_params[:valid_from].present?
+      collection = apply_valid_until_filter(collection) if filter_params[:valid_until].present?
+      collection = apply_accepted_at_filter(collection) if filter_params[:accepted_at].present?
+      collection = apply_last_sent_filter(collection) if filter_params[:last_sent].present?
+      collection
+    end
+
+    def apply_sorting(collection)
+      sort_by = params[:sort_by]
+      sort_direction = params[:sort_direction] == 'asc' ? :asc : :desc
+
+      default_sort = { created_at: sort_direction }
+
+      case sort_by
+      when 'invitee_email'
+        collection.order({ invitee_email: sort_direction }.merge(default_sort))
+      when 'status'
+        collection.order({ status: sort_direction }.merge(default_sort))
+      when 'created_at'
+        collection.order({ created_at: sort_direction }.merge(default_sort))
+      when 'valid_from'
+        collection.order({ valid_from: sort_direction }.merge(default_sort))
+      when 'valid_until'
+        collection.order({ valid_until: sort_direction }.merge(default_sort))
+      when 'accepted_at'
+        collection.order({ accepted_at: sort_direction }.merge(default_sort))
+      when 'last_sent'
+        collection.order({ last_sent: sort_direction }.merge(default_sort))
+      else
+        # Default sort by created_at (newest first)
+        collection.order(created_at: :desc)
+      end
+    end
+
+    def base_collection
+      policy_scope(@platform.invitations).includes(
+        { inviter: [:string_translations] },
+        { invitee: [:string_translations] }
+      )
+    end
+
+    def apply_status_filter(collection)
+      status = filter_params[:status] || params[:status]
+      collection.where(status: status) if status.present?
+    end
+
+    def apply_email_filter(collection)
+      search_term = filter_params[:search] || params[:search]
+      return collection unless search_term.present?
+
+      collection.where('invitee_email ILIKE ?', "%#{search_term.strip}%")
+    end
+
+    def apply_valid_from_filter(collection)
+      date_filter = filter_params[:valid_from]
+      return collection unless date_filter.present?
+
+      apply_datetime_filter(collection, :valid_from, date_filter)
+    end
+
+    def apply_valid_until_filter(collection)
+      date_filter = filter_params[:valid_until]
+      return collection unless date_filter.present?
+
+      apply_datetime_filter(collection, :valid_until, date_filter)
+    end
+
+    def apply_accepted_at_filter(collection)
+      date_filter = filter_params[:accepted_at]
+      return collection unless date_filter.present?
+
+      apply_datetime_filter(collection, :accepted_at, date_filter)
+    end
+
+    def apply_last_sent_filter(collection)
+      date_filter = filter_params[:last_sent]
+      return collection unless date_filter.present?
+
+      apply_datetime_filter(collection, :last_sent, date_filter)
+    end
+
+    def apply_datetime_filter(collection, column, date_filter)
+      return collection unless date_filter.is_a?(Hash)
+
+      if date_filter[:from].present?
+        from_date = parse_date(date_filter[:from])
+        collection = collection.where("#{column} >= ?", from_date.beginning_of_day) if from_date
+      end
+
+      if date_filter[:to].present?
+        to_date = parse_date(date_filter[:to])
+        collection = collection.where("#{column} <= ?", to_date.end_of_day) if to_date
+      end
+
+      collection
+    end
+
+    def parse_date(date_string)
+      return nil unless date_string.present?
+
+      Date.parse(date_string.to_s)
+    rescue ArgumentError
+      nil
+    end
+
+    def filter_params
+      params[:filters] || {}
+    end
+
     def platform_invitation_params
       params.require(:platform_invitation).permit(
         :invitee_email, :platform_role_id, :community_role_id, :locale,
@@ -156,11 +267,13 @@ def platform_invitation_params
     end
 
     def param_invitation_class
-      param_type = params[:platform_invitation][:type]
+      param_type = params[:platform_invitation]&.[](:type)
 
       Rails.application.eager_load! unless Rails.env.production? # Ensure all models are loaded
       valid_types = [BetterTogether::PlatformInvitation, *BetterTogether::PlatformInvitation.descendants]
-      valid_types.find { |klass| klass.to_s == param_type }
+      found_class = valid_types.find { |klass| klass.to_s == param_type }
+
+      found_class || BetterTogether::PlatformInvitation
     end
   end
   # rubocop:enable Metrics/ClassLength

app/helpers/better_together/platform_invitations_helper.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module BetterTogether
+  # Helper methods for platform invitations views
+  module PlatformInvitationsHelper
+    def sortable_column_header_for_invitations(column, label, platform)
+      sort_info = calculate_sort_info_for_invitations(column)
+
+      link_to build_sort_path_for_invitations(column, sort_info[:direction], platform),
+              sort_link_options_for_invitations do
+        build_sort_content_for_invitations(label, sort_info[:icon_class])
+      end
+    end
+
+    def calculate_sort_info_for_invitations(column)
+      if currently_sorted_by_invitations?(column)
+        active_column_sort_info_for_invitations
+      else
+        default_column_sort_info_for_invitations
+      end
+    end
+
+    def currently_sorted_by_invitations?(column)
+      params[:sort_by] == column.to_s
+    end
+
+    def active_column_sort_info_for_invitations
+      current_direction = params[:sort_direction]
+      {
+        direction: current_direction == 'asc' ? 'desc' : 'asc',
+        icon_class: current_direction == 'asc' ? 'fas fa-sort-up' : 'fas fa-sort-down'
+      }
+    end
+
+    def default_column_sort_info_for_invitations
+      {
+        direction: 'asc',
+        icon_class: 'fas fa-sort text-muted'
+      }
+    end
+
+    def build_sort_path_for_invitations(column, direction, platform)
+      platform_platform_invitations_path(platform,
+                                         filters: {
+                                           search: current_search_filter_for_invitations,
+                                           status: current_status_filter_for_invitations,
+                                           valid_from: current_valid_from_filter_for_invitations.presence,
+                                           valid_until: current_valid_until_filter_for_invitations.presence,
+                                           accepted_at: current_accepted_at_filter_for_invitations.presence,
+                                           last_sent: current_last_sent_filter_for_invitations.presence
+                                         }.compact_blank,
+                                         sort_by: column,
+                                         sort_direction: direction,
+                                         page: params[:page])
+    end
+
+    def sort_link_options_for_invitations
+      {
+        class: 'text-decoration-none d-flex align-items-center justify-content-between',
+        data: {
+          turbo_frame: 'platform_invitations_content',
+          turbo_prefetch: false # disable Turbo prefetch for these links
+        }
+      }
+    end
+
+    def build_sort_content_for_invitations(label, icon_class)
+      safe_join([
+                  content_tag(:span, label),
+                  content_tag(:i, '', class: icon_class, 'aria-hidden': true)
+                ])
+    end
+
+    def current_search_filter_for_invitations
+      filter_params[:search] || params[:search]
+    end
+
+    def current_status_filter_for_invitations
+      filter_params[:status] || params[:status]
+    end
+
+    def current_valid_from_filter_for_invitations
+      filter = filter_params[:valid_from] || {}
+      {
+        from: filter[:from].presence,
+        to: filter[:to].presence
+      }.compact
+    end
+
+    def current_valid_until_filter_for_invitations
+      filter = filter_params[:valid_until] || {}
+      {
+        from: filter[:from].presence,
+        to: filter[:to].presence
+      }.compact
+    end
+
+    def current_accepted_at_filter_for_invitations
+      filter = filter_params[:accepted_at] || {}
+      {
+        from: filter[:from].presence,
+        to: filter[:to].presence
+      }.compact
+    end
+
+    def current_last_sent_filter_for_invitations
+      filter = filter_params[:last_sent] || {}
+      {
+        from: filter[:from].presence,
+        to: filter[:to].presence
+      }.compact
+    end
+
+    private
+
+    def filter_params
+      params[:filters] || {}
+    end
+  end
+end

app/models/better_together/platform.rb

@@ -20,7 +20,6 @@ class Platform < ApplicationRecord
              member_type: 'person'
 
     has_many :invitations,
-             -> { order(created_at: :desc) },
              class_name: '::BetterTogether::PlatformInvitation',
              foreign_key: :invitable_id
 

app/models/better_together/platform_invitation.rb

@@ -32,7 +32,7 @@ class PlatformInvitation < ApplicationRecord
 
     has_rich_text :greeting, encrypted: true
 
-    validates :invitee_email, uniqueness: { scope: :invitable_id, allow_nil: true }
+    validates :invitee_email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
     validates :invitee_email, uniqueness: { scope: :invitable_id, allow_nil: true, allow_blank: true }
     validates :locale, presence: true, inclusion: { in: I18n.available_locales.map(&:to_s) }
     validates :status, presence: true, inclusion: { in: STATUS_VALUES.values }
@@ -84,6 +84,14 @@ def to_s
       "[#{self.class.model_name.human}] - #{id}"
     end
 
+    # Attributes permitted for strong parameters
+    def self.permitted_attributes(id: false, destroy: false)
+      super + %i[
+        invitee_email platform_role_id community_role_id locale
+        valid_from valid_until greeting session_duration_mins
+      ]
+    end
+
     private
 
     def set_accepted_timestamp

app/views/better_together/platform_invitations/_filter_hidden_fields.html.erb

@@ -0,0 +1,57 @@
+<%
+# Partial to preserve filter parameters across form submissions
+# Params:
+# - form: the form builder
+# - exclude: array of filter types to exclude (symbols)
+
+exclude_fields = local_assigns[:exclude] || []
+%>
+
+<% unless exclude_fields.include?(:search) %>
+  <% if current_search_filter_for_invitations.present? %>
+    <%= form.hidden_field 'filters[search]', value: current_search_filter_for_invitations %>
+  <% end %>
+<% end %>
+
+<% unless exclude_fields.include?(:status) %>
+  <% if current_status_filter_for_invitations.present? %>
+    <%= form.hidden_field 'filters[status]', value: current_status_filter_for_invitations %>
+  <% end %>
+<% end %>
+
+<% unless exclude_fields.include?(:valid_from) %>
+  <% if current_valid_from_filter_for_invitations.any? %>
+    <% current_valid_from_filter_for_invitations.each do |key, value| %>
+      <%= form.hidden_field "filters[valid_from][#{key}]", value: value %>
+    <% end %>
+  <% end %>
+<% end %>
+
+<% unless exclude_fields.include?(:valid_until) %>
+  <% if current_valid_until_filter_for_invitations.any? %>
+    <% current_valid_until_filter_for_invitations.each do |key, value| %>
+      <%= form.hidden_field "filters[valid_until][#{key}]", value: value %>
+    <% end %>
+  <% end %>
+<% end %>
+
+<% unless exclude_fields.include?(:accepted_at) %>
+  <% if current_accepted_at_filter_for_invitations.any? %>
+    <% current_accepted_at_filter_for_invitations.each do |key, value| %>
+      <%= form.hidden_field "filters[accepted_at][#{key}]", value: value %>
+    <% end %>
+  <% end %>
+<% end %>
+
+<% unless exclude_fields.include?(:last_sent) %>
+  <% if current_last_sent_filter_for_invitations.any? %>
+    <% current_last_sent_filter_for_invitations.each do |key, value| %>
+      <%= form.hidden_field "filters[last_sent][#{key}]", value: value %>
+    <% end %>
+  <% end %>
+<% end %>
+
+<!-- Preserve sort and pagination parameters -->
+<%= form.hidden_field :sort_by, value: params[:sort_by] if params[:sort_by].present? %>
+<%= form.hidden_field :sort_direction, value: params[:sort_direction] if params[:sort_direction].present? %>
+<%= form.hidden_field :page, value: params[:page] if params[:page].present? %>