118645 append ids of active appts to referral details (#24665)

* remove has_appointments attribute

add appointments attribute with empty array default value

* update method to accept optional arg for referral number

* update default value to be empty object

* add uri encoding for request params

* update call for referral appointment check to include referral number

* enahance return with appointment data

* update default value

* update method documentation

* add unit spec for missing provider scenario

* fix for line length

* add public method for fetching active vaos and eps appointments by referral

* remove public method for fetching active appointments by referral, now handled in vaos appointment service

* update details show action to use vaos appointment service for appending active appointment ids to response payload

* update active appointments return to indicate discrepancy between sources

* update appts fetch to return a list of all de-duped appointments for both VAOS and EPS

* log and re-raise appointments fetch errors

* add time metrics tracking

* reverse ordering of active appointments collection

* remove error message from log

* re-add has_appointments attribute to referral details data model

* remove state check for eps appt status normallization

Author: PhilipDeFraties

modules/vaos/app/controllers/vaos/v2/referrals_controller.rb

@@ -40,12 +40,38 @@ def show
         response.uuid = referral_uuid
 
         log_referral_provider_metrics(response)
+        add_appointment_data_to_referral(response)
 
         render json: Ccra::ReferralDetailSerializer.new(response)
       end
 
       private
 
+      def add_appointment_data_to_referral(referral)
+        result = appointments_service.get_active_appointments_for_referral(referral.referral_number)
+
+        eps_appointments = result[:EPS][:data]
+        vaos_appointments = result[:VAOS][:data]
+
+        referral.appointments = {
+          EPS: {
+            data: eps_appointments.map { |appt| { id: appt[:id], status: appt[:status], start: appt[:start] } }
+          },
+          VAOS: {
+            data: vaos_appointments.map { |appt| { id: appt[:id], status: appt[:status], start: appt[:start] } }
+          }
+        }
+
+        # Only set has_appointments to true if there are appointments with status "active"
+        eps_has_active = eps_appointments.any? { |appt| appt[:status] == 'active' }
+        vaos_has_active = vaos_appointments.any? { |appt| appt[:status] == 'active' }
+        referral.has_appointments = eps_has_active || vaos_has_active
+      end
+
+      def appointments_service
+        @appointments_service ||= VAOS::V2::AppointmentsService.new(current_user)
+      end
+
       # Logs the count of referrals returned from CCRA
       #
       # @param referrals [Array<Ccra::ReferralListEntry>] The collection of referrals

modules/vaos/app/models/ccra/referral_detail.rb

@@ -9,18 +9,21 @@ class ReferralDetail
                 :provider_specialty, :provider_telephone, :treating_facility, :referral_number,
                 :referring_facility_name,
                 :referring_facility_phone, :referring_facility_code,
-                :referring_facility_address, :has_appointments,
+                :referring_facility_address,
                 :referral_date, :station_id, :referral_consult_id,
                 :treating_facility_name, :treating_facility_code, :treating_facility_phone,
                 :treating_facility_address
-    attr_accessor :uuid
+    attr_accessor :uuid, :appointments, :has_appointments
 
     ##
     # Initializes a new instance of ReferralDetail.
     #
     # @param attributes [Hash] A hash containing the referral details from the CCRA response.
     # @option attributes [Hash] :referral The main referral data container.
     def initialize(attributes = {})
+      @uuid = nil # Will be set by controller
+      @appointments = {} # Will be populated by controller
+
       return if attributes.blank?
 
       @expiration_date = attributes[:referral_expiration_date]
@@ -30,8 +33,6 @@ def initialize(attributes = {})
       @referral_consult_id = attributes[:referral_consult_id]
       @referral_date = attributes[:referral_date]
       @station_id = attributes[:station_id]
-      @uuid = nil # Will be set by controller
-      @has_appointments = attributes[:appointments].present?
 
       # Parse provider and facility info
       parse_referring_facility_info(attributes[:referring_facility_info])
@@ -73,6 +74,7 @@ def referral_attributes
         'provider_specialty' => @provider_specialty,
         'referral_number' => @referral_number,
         'has_appointments' => @has_appointments,
+        'appointments' => @appointments,
         'referral_date' => @referral_date,
         'station_id' => @station_id,
         'referral_consult_id' => @referral_consult_id,
@@ -106,6 +108,7 @@ def assign_basic_attributes(hash)
       @referral_date = hash['referral_date']
       @station_id = hash['station_id']
       @has_appointments = hash['has_appointments']
+      @appointments = hash['appointments'] || {}
       @referral_consult_id = hash['referral_consult_id']
       @uuid = hash['uuid']
     end

modules/vaos/app/serializers/ccra/referral_detail_serializer.rb

@@ -16,6 +16,7 @@ class ReferralDetailSerializer
     attribute :referral_consult_id
     attribute :uuid
     attribute :has_appointments
+    attribute :appointments
     attribute :referral_date
     attribute :station_id
 

modules/vaos/app/services/eps/appointment_service.rb

@@ -32,11 +32,17 @@ def get_appointment(appointment_id:, retrieve_latest_details: false)
     ##
     # Get appointments data from EPS
     #
+    # @param referral_number [String] Optional referral number to filter appointments
     # @return [Array<Hash>] Array of appointment hashes from EPS
     #
-    def get_appointments
+    def get_appointments(referral_number: nil)
+      params = { patientId: patient_id }
+      params[:referralNumber] = referral_number if referral_number.present?
+
+      query_string = URI.encode_www_form(params)
+
       with_monitoring do
-        response = perform(:get, "/#{config.base_path}/appointments?patientId=#{patient_id}",
+        response = perform(:get, "/#{config.base_path}/appointments?#{query_string}",
                            {}, request_headers_with_correlation_id)
 
         # Check for error field in successful responses using reusable helper

modules/vaos/app/services/vaos/v2/appointments_service.rb

@@ -160,11 +160,38 @@ def referral_appointment_already_exists?(referral_id, pagination_params = {})
           return { exists: true } if vaos_response[:data].any? { |appt| appt[:referral_id] == referral_id }
         end
 
-        eps_appointments = eps_appointments_service.get_appointments
+        eps_appointments = eps_appointments_service.get_appointments(referral_number: referral_id)
 
         # Filter out draft EPS appointments when checking referral usage
         non_draft_eps_appointments = eps_appointments&.reject { |appt| appt[:state] == 'draft' } || []
-        { exists: appointment_with_referral_exists?(non_draft_eps_appointments, referral_id) }
+        { exists: non_draft_eps_appointments.any? }
+      end
+
+      ##
+      # Get appointments for a referral from both EPS and VAOS
+      #
+      # Returns appointments from both sources with normalized status (active/cancelled)
+      # Deduplicates appointments within each source by start time + providerServiceId (EPS) or start time (VAOS)
+      # Logs discrepancies when same start time has different status across sources
+      #
+      # @param referral_number [String] The referral number to search for
+      # @return [Hash] Contains EPS and VAOS data: { EPS: { data: [...] }, VAOS: { data: [...] } }
+      # @raise [BackendServiceException] If either EPS or VAOS fails
+      #
+      def get_active_appointments_for_referral(referral_number)
+        start_time = Time.current
+        eps_appointments = fetch_and_normalize_eps_appointments(referral_number)
+        vaos_appointments = fetch_and_normalize_vaos_appointments(referral_number)
+
+        StatsD.histogram('vaos.get_active_appointments_for_referral.duration',
+                         (Time.current - start_time) * 1000)
+
+        log_status_discrepancies(eps_appointments, vaos_appointments, referral_number)
+
+        {
+          EPS: { data: eps_appointments },
+          VAOS: { data: vaos_appointments }
+        }
       end
 
       # rubocop:enable Metrics/MethodLength
@@ -371,6 +398,122 @@ def extract_facility_identifiers(appointments)
 
       private
 
+      def fetch_and_normalize_eps_appointments(referral_number)
+        raw_appointments = eps_appointments_service.get_appointments(referral_number:)
+        filtered = raw_appointments.reject { |appt| appt[:state] == 'draft' }
+        normalized = filtered.map do |appt|
+          {
+            id: appt[:id],
+            status: normalize_eps_status(appt),
+            start: appt.dig(:appointment_details, :start),
+            provider_service_id: appt[:provider_service_id],
+            last_retrieved: appt.dig(:appointment_details, :last_retrieved)
+          }
+        end
+
+        deduplicated = deduplicate_eps_appointments(normalized)
+        deduplicated.sort_by { |appt| appt[:start] || '' }.reverse
+      rescue Common::Exceptions::BackendServiceException => e
+        log_fetch_error('EPS', referral_number, e.class.name.to_s)
+        raise
+      end
+
+      def fetch_and_normalize_vaos_appointments(referral_number)
+        vaos_response = get_all_appointments({})
+        check_vaos_response_for_failures(vaos_response, referral_number)
+        process_vaos_appointments(vaos_response[:data], referral_number)
+      rescue Common::Exceptions::BackendServiceException => e
+        log_fetch_error('VAOS', referral_number, e.class.name.to_s)
+        raise
+      end
+
+      def check_vaos_response_for_failures(vaos_response, referral_number)
+        return if vaos_response[:meta][:failures].blank?
+
+        log_fetch_error('VAOS', referral_number, vaos_response[:meta][:failures])
+        raise Common::Exceptions::BackendServiceException.new('VAOS_502',
+                                                              { detail: vaos_response[:meta][:failures].to_s })
+      end
+
+      def process_vaos_appointments(appointments_data, referral_number)
+        filtered = appointments_data.select { |appt| appt[:referral_id] == referral_number }
+        normalized = filtered.map do |appt|
+          {
+            id: appt[:id],
+            status: normalize_vaos_status(appt),
+            start: appt[:start],
+            created: appt[:created]
+          }
+        end
+
+        deduplicated = deduplicate_vaos_appointments(normalized)
+        deduplicated.sort_by { |appt| appt[:start] || '' }.reverse
+      end
+
+      def log_fetch_error(source, referral_number, error_details)
+        masked_referral = "***#{referral_number.to_s.last(4)}"
+        Rails.logger.error("Failed to fetch #{source} appointments for referral #{masked_referral}: #{error_details}")
+      end
+
+      def normalize_eps_status(appointment)
+        if appointment.dig(:appointment_details, :status) == 'cancelled'
+          'cancelled'
+        else
+          'active'
+        end
+      end
+
+      def normalize_vaos_status(appointment)
+        appointment[:status] == 'cancelled' ? 'cancelled' : 'active'
+      end
+
+      def deduplicate_eps_appointments(appointments)
+        grouped = appointments.group_by { |appt| [appt[:start], appt[:provider_service_id]] }
+
+        grouped.map do |_key, duplicates|
+          next duplicates.first if duplicates.size == 1
+
+          active = duplicates.select { |appt| appt[:status] == 'active' }
+          candidates = active.any? ? active : duplicates
+
+          # Choose most recent lastRetrieved
+          candidates.max_by { |appt| appt[:last_retrieved] || '' }
+        end
+      end
+
+      def deduplicate_vaos_appointments(appointments)
+        grouped = appointments.group_by { |appt| appt[:start] }
+
+        grouped.map do |_key, duplicates|
+          next duplicates.first if duplicates.size == 1
+
+          active = duplicates.select { |appt| appt[:status] == 'active' }
+          candidates = active.any? ? active : duplicates
+          candidates.max_by { |appt| appt[:created] || '' }
+        end
+      end
+
+      def log_status_discrepancies(eps_appointments, vaos_appointments, referral_number)
+        eps_by_start = eps_appointments.group_by { |appt| appt[:start] }
+        vaos_by_start = vaos_appointments.group_by { |appt| appt[:start] }
+
+        common_start_times = eps_by_start.keys & vaos_by_start.keys
+
+        common_start_times.each do |start_time|
+          eps_statuses = eps_by_start[start_time].map { |appt| appt[:status] }.uniq
+          vaos_statuses = vaos_by_start[start_time].map { |appt| appt[:status] }.uniq
+
+          next if eps_statuses == vaos_statuses
+
+          masked_referral = referral_number&.last(4) || 'unknown'
+          Rails.logger.warn('Appointment status discrepancy between EPS and VAOS',
+                            { referral_ending_in: masked_referral,
+                              start_time:,
+                              eps_statuses:,
+                              vaos_statuses: })
+        end
+      end
+
       # Fetches appointments and travel claims in parallel using Concurrent::Promises
       # @return [Array] Array containing [response, travel_claims_result]
       def fetch_appointments_and_claims_parallel(start_date, end_date, statuses, pagination_params, tp_client)
@@ -1477,18 +1620,6 @@ def handle_appointment_request_error(exception, caller_name, pagination_params)
                                                     })
         }
       end
-
-      ##
-      # Checks if any appointment in the given list has a referral that matches the referral_id
-      #
-      # @param appointments [Array<Hash>] List of appointments to check
-      # @param referral_id [String] The referral ID to search for
-      # @return [Boolean] true if an appointment with matching referral exists, false otherwise
-      def appointment_with_referral_exists?(appointments, referral_id)
-        appointments.any? do |appt|
-          appt[:referral] && appt[:referral][:referral_number] == referral_id
-        end
-      end
     end
   end
 end