VAOS: add AvailabilityAdapter

Add AvailabilityAdapter for VA clinic and EPS slot fetches.

Author: JunTaoLuo

modules/vaos/app/services/vaos/v2/unified/slot_adapter.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module VAOS
+  module V2
+    module Unified
+      # Fetches appointment availability (slots) for unified scheduling: VA clinic providers via
+      # VAOS SystemsService, community care via EPS ProviderService. VA providers must include
+      # +location_id+ and +id+ (clinic IEN; see VAProvider).
+      class SlotAdapter
+        def initialize(user)
+          @user = user
+        end
+
+        ##
+        # @param provider [BaseProvider] VAProvider or EpsProvider
+        # @param start_dt [String] ISO8601 start of search window
+        # @param end_dt [String] ISO8601 end of search window
+        # @param clinical_service [String, nil] VAOS clinical service (required for VA)
+        # @param eps_opts [Hash] options for Eps::ProviderService#get_provider_slots
+        # @return [Array<BaseSlot>]
+        #
+        def slots_for(provider:, start_dt:, end_dt:, clinical_service: nil, eps_opts: {})
+          case provider
+          when VAProvider
+            fetch_va_slots(provider, start_dt, end_dt, clinical_service)
+          when EpsProvider
+            fetch_eps_slots(provider, eps_opts)
+          else
+            raise ArgumentError, "Unsupported provider type: #{provider.class.name}"
+          end
+        end
+
+        private
+
+        attr_reader :user
+
+        def fetch_va_slots(provider, start_dt, end_dt, clinical_service)
+          raise Common::Exceptions::ParameterMissing, 'service_type' if clinical_service.blank?
+
+          if provider.location_id.blank? || provider.id.blank?
+            raise Common::Exceptions::UnprocessableEntity.new(
+              detail: 'VA provider requires location_id and id (clinic IEN) for slot lookup'
+            )
+          end
+
+          raw = systems_service.get_available_slots(
+            location_id: provider.location_id,
+            clinic_id: provider.id,
+            clinical_service:,
+            provider_id: nil,
+            start_dt:,
+            end_dt:
+          )
+          Array(raw).map { |slot| VASlot.from_vaos_slot(slot, location_id: provider.location_id) }
+        end
+
+        def fetch_eps_slots(provider, eps_opts)
+          provider_id = provider.provider_service_id.presence || provider.id
+          response = eps_provider_service.get_provider_slots(provider_id, eps_opts)
+          slots = response&.slots
+          Array(slots).map { |slot| EpsSlot.from_eps_slot(slot) }
+        end
+
+        def systems_service
+          @systems_service ||= VAOS::V2::SystemsService.new(user)
+        end
+
+        def eps_provider_service
+          @eps_provider_service ||= Eps::ProviderService.new(user)
+        end
+      end
+    end
+  end
+end

modules/vaos/spec/controllers/v2/providers_controller_index_spec.rb

@@ -18,9 +18,8 @@
 
     let(:va_provider) do
       VAOS::V2::Unified::VAProvider.new(
-        id: '983:455',
+        id: '455',
         location_id: '983',
-        clinic_id: '455',
         facility_name: 'Cheyenne VA Medical Center',
         name: 'CHY UROLOGY',
         address: { street1: '2360 E Pershing Blvd', city: 'Cheyenne', state: 'WY', zip: '82001' },

modules/vaos/spec/services/vaos/v2/unified/slot_adapter_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe VAOS::V2::Unified::SlotAdapter do
+  let(:user) { build(:user, :vaos) }
+  let(:adapter) { described_class.new(user) }
+
+  describe '#slots_for' do
+    context 'with an unsupported provider' do
+      let(:provider) { VAOS::V2::Unified::BaseProvider.new(id: 'x') }
+
+      it 'raises ArgumentError' do
+        expect do
+          adapter.slots_for(provider:, start_dt: '2025-01-01T00:00:00Z', end_dt: '2025-01-02T00:00:00Z')
+        end.to raise_error(ArgumentError, /Unsupported provider type/)
+      end
+    end
+
+    context 'with VAProvider' do
+      let(:provider) do
+        VAOS::V2::Unified::VAProvider.new(
+          id: '1081',
+          location_id: '983'
+        )
+      end
+
+      let(:systems_service) { instance_double(VAOS::V2::SystemsService) }
+      let(:raw_slot) do
+        OpenStruct.new(
+          id: 'slot-1',
+          start: '2025-01-01T10:00:00Z',
+          end: '2025-01-01T10:30:00Z',
+          clinic: { clinic_ien: '1081' },
+          location: { vha_facility_id: '983' }
+        )
+      end
+
+      before do
+        allow(VAOS::V2::SystemsService).to receive(:new).with(user).and_return(systems_service)
+      end
+
+      it 'returns normalized VASlot records' do
+        allow(systems_service).to receive(:get_available_slots).and_return([raw_slot])
+
+        slots = adapter.slots_for(
+          provider:,
+          start_dt: '2025-01-01T00:00:00Z',
+          end_dt: '2025-01-02T00:00:00Z',
+          clinical_service: 'audiology'
+        )
+
+        expect(slots.size).to eq(1)
+        expect(slots.first).to be_a(VAOS::V2::Unified::VASlot)
+        expect(slots.first.id).to eq('slot-1')
+        expect(slots.first.location_id).to eq('983')
+      end
+
+      it 'raises when clinical_service is blank' do
+        expect do
+          adapter.slots_for(
+            provider:,
+            start_dt: '2025-01-01T00:00:00Z',
+            end_dt: '2025-01-02T00:00:00Z',
+            clinical_service: nil
+          )
+        end.to raise_error(Common::Exceptions::ParameterMissing)
+      end
+
+      it 'raises when id (clinic IEN) is blank' do
+        provider.id = nil
+
+        expect do
+          adapter.slots_for(
+            provider:,
+            start_dt: '2025-01-01T00:00:00Z',
+            end_dt: '2025-01-02T00:00:00Z',
+            clinical_service: 'audiology'
+          )
+        end.to raise_error(Common::Exceptions::UnprocessableEntity)
+      end
+
+      it 'returns an empty array when upstream returns no slots' do
+        allow(systems_service).to receive(:get_available_slots).and_return([])
+
+        slots = adapter.slots_for(
+          provider:,
+          start_dt: '2025-01-01T00:00:00Z',
+          end_dt: '2025-01-02T00:00:00Z',
+          clinical_service: 'audiology'
+        )
+
+        expect(slots).to eq([])
+      end
+    end
+
+    context 'with EpsProvider' do
+      let(:provider) do
+        VAOS::V2::Unified::EpsProvider.new(
+          id: '9mN718pH',
+          provider_service_id: '9mN718pH'
+        )
+      end
+
+      let(:eps_service) { instance_double(Eps::ProviderService) }
+      let(:eps_opts) do
+        {
+          appointmentTypeId: 'ov',
+          startOnOrAfter: '2025-01-01T00:00:00Z',
+          startBefore: '2025-01-02T00:00:00Z',
+          appointmentId: 'draft-1'
+        }
+      end
+
+      before do
+        allow(Eps::ProviderService).to receive(:new).with(user).and_return(eps_service)
+      end
+
+      it 'returns normalized EpsSlot records' do
+        allow(eps_service).to receive(:get_provider_slots).and_return(
+          OpenStruct.new(slots: [{ id: 'eps-slot', start: '2025-01-01T12:00:00Z', provider_service_id: '9mN718pH' }])
+        )
+
+        slots = adapter.slots_for(
+          provider:,
+          start_dt: 'ignored',
+          end_dt: 'ignored',
+          eps_opts:
+        )
+
+        expect(slots.size).to eq(1)
+        expect(slots.first).to be_a(VAOS::V2::Unified::EpsSlot)
+        expect(slots.first.id).to eq('eps-slot')
+      end
+
+      it 'returns an empty array when EPS returns no slots key' do
+        allow(eps_service).to receive(:get_provider_slots).and_return(OpenStruct.new(slots: nil))
+
+        slots = adapter.slots_for(provider:, start_dt: 'a', end_dt: 'b', eps_opts:)
+
+        expect(slots).to eq([])
+      end
+    end
+  end
+end