Enhancements/events (#1073)

This pull request introduces several enhancements and refactors to the
BetterTogether event management features, focusing on improving event
time handling, optimizing database queries, enhancing privacy display
consistency, and refining RSVP logic. It also adds new helper methods
for UI consistency and performance, and updates documentation and
linting rules.

**Event Management & RSVP Improvements**
* Refactored RSVP actions in `events_controller.rb` to ensure only
scheduled events allow RSVP, require login for RSVP/cancel actions, and
provide user feedback via redirects and alerts.
[[1]](diffhunk://#diff-ffc530a02a78834a7cc82d089dee80fa08f52d911015abfa0c563543b9fce194L38-R60)
[[2]](diffhunk://#diff-ffc530a02a78834a7cc82d089dee80fa08f52d911015abfa0c563543b9fce194L77-R119)
* Added preloading of event associations (categories, hosts,
attendances, translations, images, location) in `set_resource_instance`
to avoid N+1 queries and improve event page performance.
* Added AJAX card rendering for event show requests, improving
responsiveness for event hover cards.

**Event Time Handling**
* Added a new Stimulus controller (`event_datetime_controller.js`) for
dynamic synchronization of event start time, end time, and duration
fields, enforcing minimum duration and providing user feedback.
* Introduced the `display_event_time` helper to intelligently format
event times based on duration and date span for clearer UI display.

**Privacy Display Consistency**
* Added `privacy_display_value` helper for consistent, translated
privacy level display across the application, and updated
`privacy_badge` to use this helper.
[[1]](diffhunk://#diff-42549e834458635fd46c3c7f70c4278eae0c631ec6db068ea95c0f9916de5325R15-R22)
[[2]](diffhunk://#diff-42549e834458635fd46c3c7f70c4278eae0c631ec6db068ea95c0f9916de5325L32-R40)
[[3]](diffhunk://#diff-42a55df7b5b86f1d10011c781d511e1158047cc673b277f34091e0567e37141cR83-R96)

**Performance Optimizations**
* Preloaded calendar associations for people in `people_controller.rb`
to avoid N+1 queries.

**UI Consistency & Documentation**
* Added `event_relationship_icon` helper to display appropriate icons
and colors for a person's relationship to an event.
* Updated view helper documentation to include privacy display best
practices.
* Disabled Rubocop's `RSpec/MultipleExpectations` cop to allow multiple
expectations per test.

Author: rsmithlal

.github/instructions/view-helpers.instructions.md

@@ -80,6 +80,20 @@ end
 - `truncate`, `pluralize`, `excerpt`, `word_wrap`, `simple_format`.
 - For rich text (Action Text), use `record.body` and `to_plain_text` for indexing/search.
 
+### Privacy Display
+- Use `privacy_display_value(entity)` for consistent, translated privacy level display across the application.
+- This helper automatically looks up the proper translation from `attributes.privacy_list` and falls back to humanized values.
+- Supports all privacy levels: `public`, `private`, `community`, `unlisted`.
+
+```ruby
+# Instead of: entity.privacy.humanize or entity.privacy.capitalize
+<%= privacy_display_value(@event) %>      # "Public" / "Público" / "Public"
+<%= privacy_display_value(@community) %>  # "Private" / "Privado" / "Privé"
+
+# Works in badges too (automatically used)
+<%= privacy_badge(@entity) %>  # Uses privacy_display_value internally
+```
+
 ---
 
 ## 4. Navigation & Link Helpers

.rubocop.yml

@@ -13,6 +13,8 @@ plugins:
   - rubocop-rspec_rails
   - rubocop-capybara
   - rubocop-factory_bot
+RSpec/MultipleExpectations:
+  Enabled: false
 Style/StringLiterals:
   Exclude:
     - 'db/migrate/*'

app/assets/javascripts/better_together/controllers/event_datetime_controller.js

@@ -0,0 +1,127 @@
+// Event DateTime Controller
+// Handles dynamic synchronization between start time, end time, and duration fields
+// 
+// Behavior:
+// - When start time changes: Updates end time based on current duration
+// - When end time changes: Updates duration based on start/end time difference  
+// - When duration changes: Updates end time based on start time + duration
+// - Validates minimum duration (5 minutes)
+// - Defaults duration to 30 minutes when not set
+
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["startTime", "endTime", "duration"]
+
+  connect() {
+    // Set default duration if not already set
+    if (!this.durationTarget.value || this.durationTarget.value === "0") {
+      this.durationTarget.value = "30"
+    }
+    
+    // Initialize end time if start time is set but end time is not
+    if (this.startTimeTarget.value && !this.endTimeTarget.value) {
+      this.updateEndTimeFromDuration()
+    }
+  }
+
+  // Called when start time changes
+  updateEndTime() {
+    if (!this.startTimeTarget.value) {
+      this.endTimeTarget.value = ""
+      return
+    }
+
+    // Use current duration or default to 30 minutes
+    const duration = this.getDurationInMinutes()
+    this.calculateEndTime(duration)
+  }
+
+  // Called when end time changes  
+  updateDuration() {
+    if (!this.startTimeTarget.value || !this.endTimeTarget.value) {
+      return
+    }
+
+    const startTime = new Date(this.startTimeTarget.value)
+    const endTime = new Date(this.endTimeTarget.value)
+    
+    // Validate end time is after start time
+    if (endTime <= startTime) {
+      this.showTemporaryError("End time must be after start time")
+      return
+    }
+
+    // Calculate duration in minutes
+    const diffInMs = endTime.getTime() - startTime.getTime()
+    const diffInMinutes = Math.round(diffInMs / (1000 * 60))
+    
+    // Enforce minimum duration
+    if (diffInMinutes < 5) {
+      this.durationTarget.value = "5"
+      this.calculateEndTime(5)
+    } else {
+      this.durationTarget.value = diffInMinutes.toString()
+    }
+  }
+
+  // Called when duration changes
+  updateEndTimeFromDuration() {
+    if (!this.startTimeTarget.value) {
+      return
+    }
+
+    const duration = this.getDurationInMinutes()
+    
+    // Enforce minimum duration
+    if (duration < 5) {
+      this.durationTarget.value = "5"
+      this.calculateEndTime(5)
+    } else {
+      this.calculateEndTime(duration)
+    }
+  }
+
+  // Helper methods
+  getDurationInMinutes() {
+    const duration = parseInt(this.durationTarget.value) || 30
+    return Math.max(duration, 5) // Minimum 5 minutes
+  }
+
+  calculateEndTime(durationMinutes) {
+    if (!this.startTimeTarget.value) return
+
+    const startTime = new Date(this.startTimeTarget.value)
+    const endTime = new Date(startTime.getTime() + (durationMinutes * 60 * 1000))
+    
+    // Format for datetime-local input (YYYY-MM-DDTHH:MM)
+    const year = endTime.getFullYear()
+    const month = String(endTime.getMonth() + 1).padStart(2, '0')
+    const day = String(endTime.getDate()).padStart(2, '0')
+    const hours = String(endTime.getHours()).padStart(2, '0')
+    const minutes = String(endTime.getMinutes()).padStart(2, '0')
+    
+    this.endTimeTarget.value = `${year}-${month}-${day}T${hours}:${minutes}`
+  }
+
+  showTemporaryError(message) {
+    // Create or update error message
+    let errorElement = this.element.querySelector('.datetime-sync-error')
+    
+    if (!errorElement) {
+      errorElement = document.createElement('div')
+      errorElement.className = 'alert alert-warning datetime-sync-error mt-2'
+      errorElement.setAttribute('role', 'alert')
+      this.element.appendChild(errorElement)
+    }
+    
+    errorElement.textContent = message
+    
+    // Remove error after 3 seconds
+    setTimeout(() => {
+      if (errorElement && errorElement.parentNode) {
+        errorElement.parentNode.removeChild(errorElement)
+      }
+    }, 3000)
+  }
+}

app/controllers/better_together/agreements_controller.rb

@@ -9,18 +9,22 @@ class AgreementsController < FriendlyResourceController
     # return only the fragment wrapped in the expected <turbo-frame id="agreement_modal_frame">...</turbo-frame>
     # so Turbo can swap it into the frame. For normal requests, fall back to the
     # default rendering (with layout).
-    def show
+    def show # rubocop:todo Metrics/MethodLength
       if @agreement.page
         @page = @agreement.page
         @content_blocks = @page.content_blocks
         @layout = 'layouts/better_together/page'
         @layout = @page.layout if @page.layout.present?
       end
 
-      return unless turbo_frame_request?
-
-      content = render_to_string(action: :show, layout: false)
-      render html: view_context.turbo_frame_tag('agreement_modal_frame', content)
+      # Check if this is a Turbo Frame request
+      if request.headers['Turbo-Frame'].present?
+        Rails.logger.debug 'Rendering turbo frame response'
+        render partial: 'modal_content', layout: false
+      else
+        Rails.logger.debug 'Rendering normal response'
+        # Normal full-page rendering continues with the view
+      end
     end
 
     protected

app/controllers/better_together/events_controller.rb

@@ -2,7 +2,7 @@
 
 module BetterTogether
   # CRUD for BetterTogether::Event
-  class EventsController < FriendlyResourceController
+  class EventsController < FriendlyResourceController # rubocop:todo Metrics/ClassLength
     before_action if: -> { Rails.env.development? } do
       # Make sure that all subclasses are loaded in dev to generate type selector
       Rails.application.eager_load!
@@ -17,6 +17,14 @@ def index
     end
 
     def show
+      # Handle AJAX requests for card format - only our specific hover card requests
+      card_request = request.headers['X-Card-Request'] == 'true' || request.headers['HTTP_X_CARD_REQUEST'] == 'true'
+
+      if request.xhr? && card_request
+        render partial: 'better_together/events/event', locals: { event: @event }, layout: false
+        return
+      end
+
       super
     end
 
@@ -35,10 +43,21 @@ def rsvp_going
       rsvp_update('going')
     end
 
-    def rsvp_cancel
-      @event = set_resource_instance
+    def rsvp_cancel # rubocop:disable Metrics/MethodLength
+      set_resource_instance
+      return if performed? # Exit early if 404 was already rendered
+
+      @event = @resource
       authorize @event, :show?
-      attendance = BetterTogether::EventAttendance.find_by(event: @event, person: helpers.current_person)
+
+      # Ensure current_person exists
+      current_person = helpers.current_person
+      unless current_person
+        redirect_to @event, alert: t('better_together.events.login_required', default: 'Please log in to manage RSVPs.')
+        return
+      end
+
+      attendance = BetterTogether::EventAttendance.find_by(event: @event, person: current_person)
       attendance&.destroy
       redirect_to @event, notice: t('better_together.events.rsvp_cancelled', default: 'RSVP cancelled')
     end
@@ -74,10 +93,30 @@ def resource_class
 
     private
 
-    def rsvp_update(status)
-      @event = set_resource_instance
+    # rubocop:todo Metrics/MethodLength
+    def rsvp_update(status) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
+      set_resource_instance
+      return if performed? # Exit early if 404 was already rendered
+
+      @event = @resource
       authorize @event, :show?
-      attendance = BetterTogether::EventAttendance.find_or_initialize_by(event: @event, person: helpers.current_person)
+
+      # Check if event allows RSVP
+      unless @event.scheduled?
+        redirect_to @event,
+                    alert: t('better_together.events.rsvp_not_available',
+                             default: 'RSVP is not available for this event.')
+        return
+      end
+
+      # Ensure current_person exists before creating attendance
+      current_person = helpers.current_person
+      unless current_person
+        redirect_to @event, alert: t('better_together.events.login_required', default: 'Please log in to RSVP.')
+        return
+      end
+
+      attendance = BetterTogether::EventAttendance.find_or_initialize_by(event: @event, person: current_person)
       attendance.status = status
       authorize attendance
       if attendance.save
@@ -86,5 +125,54 @@ def rsvp_update(status)
         redirect_to @event, alert: attendance.errors.full_messages.to_sentence
       end
     end
+    # rubocop:enable Metrics/MethodLength
+
+    # Override base controller method to add performance optimizations
+    def set_resource_instance
+      super
+
+      # Preload associations needed for event show page to avoid N+1 queries
+      preload_event_associations! unless json_request?
+    end
+
+    def json_request?
+      request.format.json?
+    end
+
+    # rubocop:todo Metrics/AbcSize
+    # rubocop:todo Metrics/MethodLength
+    def preload_event_associations! # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize
+      return unless @event
+
+      # Preload categories and their translations to avoid N+1 queries
+      @event.categories.includes(:string_translations).load
+
+      # Preload event hosts and their associated models
+      @event.event_hosts.includes(:host).load
+
+      # Preload event attendances to avoid count queries in view
+      @event.event_attendances.includes(:person).load
+
+      # Preload current person's attendance for RSVP buttons
+      if current_person
+        @current_attendance = @event.event_attendances.find do |a|
+          a.person_id == current_person.id
+        end
+      end
+
+      # Preload translations for the event itself
+      @event.string_translations.load
+      @event.text_translations.load
+
+      # Preload cover image attachment to avoid attachment queries
+      @event.cover_image_attachment&.blob&.load if @event.cover_image.attached?
+
+      # Preload location if present
+      @event.location&.reload
+
+      self
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
   end
 end

app/controllers/better_together/people_controller.rb

@@ -17,6 +17,9 @@ def show
                           :string_translations,
                           blocks: { background_image_file_attachment: :blob }
                         )
+
+      # Preload calendar associations to avoid N+1 queries
+      @person.preload_calendar_associations!
     end
 
     # GET /people/new

app/helpers/better_together/application_helper.rb

@@ -204,5 +204,25 @@ def main_app_url_helper?(method)
     def better_together_url_helper?(method)
       method.to_s.end_with?('_path', '_url') && BetterTogether::Engine.routes.url_helpers.respond_to?(method)
     end
+
+    # Returns the appropriate icon and color for an event based on the person's relationship to it
+    def event_relationship_icon(person, event) # rubocop:todo Metrics/MethodLength
+      relationship = person.event_relationship_for(event)
+
+      case relationship
+      when :created
+        { icon: 'fas fa-user-edit', color: '#28a745',
+          tooltip: t('better_together.events.relationship.created', default: 'Created by you') }
+      when :going
+        { icon: 'fas fa-check-circle', color: '#007bff',
+          tooltip: t('better_together.events.relationship.going', default: 'You\'re going') }
+      when :interested
+        { icon: 'fas fa-heart', color: '#e91e63',
+          tooltip: t('better_together.events.relationship.interested', default: 'You\'re interested') }
+      else
+        { icon: 'fas fa-circle', color: '#6c757d',
+          tooltip: t('better_together.events.relationship.calendar', default: 'Calendar event') }
+      end
+    end
   end
 end

app/helpers/better_together/badges_helper.rb

@@ -12,6 +12,14 @@ def categories_badge(entity, rounded: true, style: 'info')
       )
     end
 
+    # Get the translated display value for a privacy setting
+    def privacy_display_value(entity)
+      return '' unless entity.respond_to?(:privacy) && entity.privacy.present?
+
+      privacy_key = entity.privacy.to_s.downcase
+      t("attributes.privacy_list.#{privacy_key}", default: entity.privacy.humanize.capitalize)
+    end
+
     # Render a privacy badge for an entity.
     # By default, map known privacy values to sensible Bootstrap context classes.
     # Pass an explicit `style:` to force a fixed Bootstrap style instead of using the mapping.
@@ -29,7 +37,7 @@ def privacy_badge(entity, rounded: true, style: nil)
 
       chosen_style = style || privacy_style_map[privacy_key] || 'primary'
 
-      create_badge(entity.privacy.humanize.capitalize, rounded: rounded, style: chosen_style)
+      create_badge(privacy_display_value(entity), rounded: rounded, style: chosen_style)
     end
 
     # Return the mapped bootstrap-style for an entity's privacy. Useful for wiring