Exchange Creation, Events Enhancements, i18n & Docs/CI Upgrades

app/controllers/better_together/joatu/offers_controller.rb

@@ -3,7 +3,7 @@
 module BetterTogether
   module Joatu
     # CRUD for BetterTogether::Joatu::Offer
-    class OffersController < JoatuController
+    class OffersController < JoatuController # rubocop:todo Metrics/ClassLength
       def show
         super
         mark_match_notifications_read_for(resource_instance)
@@ -66,6 +66,130 @@
       # rubocop:enable Metrics/MethodLength
       # rubocop:enable Metrics/PerceivedComplexity
 
+      def respond_with_request
+        source = set_resource_instance
+        authorize_resource
+        redirect_to new_joatu_request_path(source_type: resource_class.to_s, source_id: source.id)
+      end
+
+      # Render new with optional prefill from a source Request/Offer
+      def new # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength
+        resource_instance
+        # If source params were provided, load and authorize the source so the view can safely render it
+        if (source_type = params[:source_type].presence) && (source_id = params[:source_id].presence)
+          source_klass = source_type.to_s.safe_constantize
+          @source = source_klass&.find_by(id: source_id)
+          begin
+            authorize @source if @source
+          rescue Pundit::NotAuthorizedError
+            render_not_found and return
+          end
+
+          # Only allow responding to sources that are open or already matched
+          # :todo Metrics/BlockNesting, rubocop:todo Layout/LineLength, rubocop:todo Metrics/PerceivedComplexity,
+          redirect_to url_for(@source.becomes(@source.class)),
+                      alert: 'Cannot create a response for a source that is not open or matched.' and return
+
+        end
+
+        apply_source_prefill_offer(resource_instance)
+      end
+
+      # rubocop:todo Metrics/PerceivedComplexity
+      # rubocop:todo Metrics/MethodLength
+      # rubocop:todo Metrics/AbcSize
+      def create # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+        resource_instance(resource_params)
+        authorize_resource
+
+        respond_to do |format| # rubocop:todo Metrics/BlockLength
+          if @resource.save
+            # Controller-side fallback: if source params were provided but no nested response_link was created,
+            # create a ResponseLink linking the source Request -> this Offer.
+            source_type = params[:source_type] || params.dig(resource_name, :source_type)
+            source_id = params[:source_id] || params.dig(resource_name, :source_id)
+
+            if source_type == 'BetterTogether::Joatu::Request' && source_id.present?
+              source = BetterTogether::Joatu::Request.find_by(id: source_id)
+              if source
+                # rubocop:todo Metrics/BlockNesting
+                if source.respond_to?(:status) && !%w[open matched].include?(source.status)
+                  Rails.logger.warn(
+                    "Not creating response link: source #{source.id} status #{source.status} not respondable"
+                  )
+                elsif !BetterTogether::Joatu::ResponseLink.exists?(source: source, response: @resource)
+                  BetterTogether::Joatu::ResponseLink.create(source: source, response: @resource,
+                                                             creator_id: helpers.current_person&.id)
+                end
+                # rubocop:enable Metrics/BlockNesting
+              end
+            end
+
+            format.html do
+              redirect_to url_for(@resource.becomes(resource_class)),
+                          notice: "#{resource_class.model_name.human} was successfully created."
+            end
+            format.turbo_stream do
+              flash.now[:notice] = "#{resource_class.model_name.human} was successfully created."
+              redirect_to url_for(@resource.becomes(resource_class))
+            end
+          else
+            format.turbo_stream do
+              render status: :unprocessable_entity, turbo_stream: [
+                turbo_stream.replace(helpers.dom_id(@resource, 'form'),
+                                     partial: 'form',
+                                     locals: { resource_name.to_sym => @resource }),
+                turbo_stream.update('form_errors',
+                                    partial: 'layouts/better_together/errors',
+                                    locals: { object: @resource })
+              ]
+            end
+            format.html { render :new, status: :unprocessable_entity }
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      private
+
+      # Build an offer prefilled from a source Request when source params are present
+      # rubocop:todo Metrics/PerceivedComplexity
+      # rubocop:todo Metrics/MethodLength
+      # rubocop:todo Metrics/AbcSize
+      def apply_source_prefill_offer(offer) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+        return unless offer
+
+        source_type = params[:source_type] || params.dig(resource_name, :source_type)
+        source_id = params[:source_id] || params.dig(resource_name, :source_id)
+
+        return unless source_type == 'BetterTogether::Joatu::Request' && source_id.present?
+
+        source = BetterTogether::Joatu::Request.find_by(id: source_id)
+        return unless source
+        # Do not build nested response_link if source is not respondable
+        return unless source.respond_to?(:status) ? %w[open matched].include?(source.status) : true
+
+        offer.name ||= source.name
+        offer.description ||= source.description
+        offer.target_type ||= source.target_type if source.respond_to?(:target_type)
+        offer.target_id ||= source.target_id if source.respond_to?(:target_id)
+        offer.urgency ||= source.urgency if source.respond_to?(:urgency)
+        offer.address || offer.build_address
+        if source.respond_to?(:categories) && offer.category_ids.blank?
+          offer.category_ids = source.categories.pluck(:id)
+        end
+
+        return unless offer.response_links_as_response.blank?
+
+        offer.response_links_as_response.build(source_type: source.class.to_s, source_id: source.id,
+                                               creator_id: helpers.current_person&.id)
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
+
       protected
 
       def resource_class

app/controllers/better_together/joatu/requests_controller.rb

@@ -73,7 +73,74 @@
         @matches = BetterTogether::Joatu::Matchmaker.match(@joatu_request)
       end
 
-      protected
+      # Redirect to new offer form prefilled from a source Request
+      def respond_with_offer
+        source = set_resource_instance
+        authorize_resource
+        redirect_to new_joatu_offer_path(source_type: BetterTogether::Joatu::Request.to_s, source_id: source.id)
+      end
+
+      # Render new with optional prefill from a source Offer/Request
+      def new # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+        resource_instance
+        # If source params were provided, load and authorize the source so the view can safely render it
+        if (source_type = params[:source_type].presence) && (source_id = params[:source_id].presence)
+          source_klass = source_type.to_s.safe_constantize
+          @source = source_klass&.find_by(id: source_id)
+          begin
+            authorize @source if @source
+          rescue Pundit::NotAuthorizedError
+            render_not_found and return
+          end
+
+          # Only allow responding to sources that are open or already matched
+          if @source.respond_to?(:status) && !%w[open matched].include?(@source.status)
+            redirect_to url_for(@source.becomes(@source.class)),
+                        alert: 'Cannot create a response for a source that is not open or matched.' and return
+          end
+        end
+
+        apply_source_prefill(resource_instance)
+      end
+
+      private
+
+      # rubocop:todo Metrics/PerceivedComplexity
+      # rubocop:todo Metrics/MethodLength
+      # rubocop:todo Metrics/AbcSize
+      def apply_source_prefill(request) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+        return unless request
+
+        # Accept source params either at top-level (hidden_field_tag in new) or nested inside the form params
+        source_type = params[:source_type] || params.dig(resource_name, :source_type)
+        source_id = params[:source_id] || params.dig(resource_name, :source_id)
+
+        return unless source_type == 'BetterTogether::Joatu::Offer' && source_id.present?
+
+        source = BetterTogether::Joatu::Offer.find_by(id: source_id)
+        return unless source
+        # Do not build nested response_link if source is not respondable
+        return unless source.respond_to?(:status) ? %w[open matched].include?(source.status) : true
+
+        request.name ||= source.name
+        request.description ||= source.description
+        request.target_type ||= source.target_type if source.respond_to?(:target_type)
+        request.target_id ||= source.target_id if source.respond_to?(:target_id)
+        request.urgency ||= source.urgency if source.respond_to?(:urgency)
+        request.address || request.build_address
+        if source.respond_to?(:categories) && request.category_ids.blank?
+          request.category_ids = source.categories.pluck(:id)
+        end
+
+        # Build a nested response_link so the form's fields_for will render hidden fields
+        return unless request.response_links_as_response.blank?
+
+        request.response_links_as_response.build(source_type: source.class.to_s, source_id: source.id,
+                                                 creator_id: helpers.current_person&.id)
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
 
       def resource_class
         ::BetterTogether::Joatu::Request

app/controllers/better_together/joatu/response_links_controller.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module BetterTogether
+  module Joatu
+    class ResponseLinksController < JoatuController # rubocop:todo Style/Documentation
+      before_action :authenticate_user!
+      # This controller doesn't call Pundit's `authorize` in the create flow
+      # because it builds responses from an existing source. The global
+      # `after_action :verify_authorized` from ResourceController would raise
+      # an AuthorizationNotPerformedError after a redirect which can lead to a
+      # DoubleRenderError (redirect then error render). Skip the check here.
+      skip_after_action :verify_authorized
+
+      def create # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # Create a request from offer or offer from request, linking them via ResponseLink
+        source_type = params[:source_type]
+        source_id = params[:source_id]
+
+        unless source_type && source_id
+          return redirect_back fallback_location: joatu_hub_path,
+                               alert: 'Invalid source'
+        end
+
+        source = source_type.constantize.find_by(id: source_id)
+        return redirect_back fallback_location: joatu_hub_path, alert: 'Source not found' unless source
+
+        # Only allow creating responses against sources that are open or already matched
+        if source.respond_to?(:status) && !%w[open matched].include?(source.status)
+          return redirect_back fallback_location: joatu_hub_path,
+                               alert: 'Cannot respond to a source that is not open or matched.'
+        end
+
+        if source.is_a?(BetterTogether::Joatu::Offer)
+          # Build a new Request from offer details
+          request = BetterTogether::Joatu::Request.new
+          request.name = source.name
+          request.description = source.description
+          request.creator_id = helpers.current_person&.id
+          request.target_type = source.target_type if source.respond_to?(:target_type)
+          request.target_id = source.target_id if source.respond_to?(:target_id)
+          request.urgency = source.urgency if source.respond_to?(:urgency)
+          request.address_id = source.address_id if source.respond_to?(:address_id)
+          request.category_ids = source.categories.pluck(:id) if source.respond_to?(:categories)
+
+          if request.save
+            rl = ResponseLink.create(source: source, response: request, creator_id: helpers.current_person&.id)
+            if rl.persisted?
+              # mark_source_matched is handled in model callback
+            else
+              Rails.logger.error("Failed to create ResponseLink: #{rl.errors.full_messages.join(', ')}")
+            end
+            redirect_to joatu_request_path(request), notice: 'Request created in response to offer.'
+          else
+            redirect_back fallback_location: joatu_offer_path(source),
+                          alert: request.errors.full_messages.to_sentence
+          end
+        elsif source.is_a?(BetterTogether::Joatu::Request)
+          offer = BetterTogether::Joatu::Offer.new
+          offer.name = source.name
+          offer.description = source.description
+          offer.creator_id = helpers.current_person&.id
+          offer.target_type = source.target_type if source.respond_to?(:target_type)
+          offer.target_id = source.target_id if source.respond_to?(:target_id)
+          offer.urgency = source.urgency if source.respond_to?(:urgency)
+          offer.address_id = source.address_id if source.respond_to?(:address_id)
+          offer.category_ids = source.categories.pluck(:id) if source.respond_to?(:categories)
+
+          if offer.save
+            rl = ResponseLink.create(source: source, response: offer, creator_id: helpers.current_person&.id)
+            unless rl.persisted?
+              Rails.logger.error("Failed to create ResponseLink: #{rl.errors.full_messages.join(', ')}")
+            end
+            redirect_to joatu_offer_path(offer), notice: 'Offer created in response to request.'
+          else
+            redirect_back fallback_location: joatu_request_path(source),
+                          alert: offer.errors.full_messages.to_sentence
+          end
+        else
+          redirect_back fallback_location: joatu_hub_path, alert: 'Unsupported source type'
+        end
+      rescue StandardError => e
+        # Log full backtrace to surface errors during tests
+        Rails.logger.error(
+          "ResponseLinksController#create failed: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
+        )
+        raise
+      end
+    end
+  end
+end