Implement eligibility check

Author: JunTaoLuo

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

@@ -141,9 +141,13 @@ def assign_distance(provider, user_address)
         def filter_supported_facilities(facilities, category_of_care)
           return facilities if category_of_care.blank?
 
-          # We'll need to filter based on category of care and eligibility
+          vaos_service_type = ServiceTypeMapper.to_vaos(category_of_care)
+          return facilities if vaos_service_type.nil?
 
-          facilities
+          facilities.select do |facility|
+            va_stub = VAProvider.new(location_id: facility.unique_id)
+            eligibility_service.check_eligibility(va_stub, category_of_care)[:direct_eligible]
+          end
         end
 
         def fetch_clinics_for_facility(facility, clinical_service)
@@ -167,6 +171,10 @@ def systems_service
           @systems_service ||= VAOS::V2::SystemsService.new(current_user)
         end
 
+        def eligibility_service
+          @eligibility_service ||= EligibilityService.new(current_user)
+        end
+
         def combine_and_sort(va_providers, eps_providers, referral)
           referral_provider, other_eps = partition_referral_provider(eps_providers, referral)
 

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

@@ -62,6 +62,7 @@
   end
 
   let(:systems_service) { instance_double(VAOS::V2::SystemsService) }
+  let(:eligibility_service) { instance_double(VAOS::V2::Unified::EligibilityService) }
 
   before do
     allow(user).to receive(:vet360_contact_info).and_return(vet360_contact_info)
@@ -75,6 +76,8 @@
       allow(FacilitiesApi::V2::Lighthouse::Client).to receive(:new).and_return(lighthouse_client)
       allow(Eps::ProviderService).to receive(:new).and_return(eps_provider_service)
       allow(VAOS::V2::SystemsService).to receive(:new).with(user).and_return(systems_service)
+      allow(VAOS::V2::Unified::EligibilityService).to receive(:new).with(user).and_return(eligibility_service)
+      allow(eligibility_service).to receive(:check_eligibility).and_return({ direct_eligible: true })
 
       allow(lighthouse_client).to receive(:get_facilities).and_return([lighthouse_facility])
       allow(eps_provider_service).to receive(:search_by_location).and_return([eps_provider_hash])
@@ -199,7 +202,7 @@
       expect(results.first.provider_type).to eq('va')
     end
 
-    it 'requests clinics for each Lighthouse facility (filter_supported_facilities is not yet applied)' do
+    it 'includes all Lighthouse facilities when category_of_care does not map to a VAOS service (no eligibility filter)' do
       non_matching_facility = double(
         'Facility',
         id: 'vha_984', unique_id: '984', name: 'Other VA',
@@ -217,6 +220,36 @@
       expect(va_providers.size).to eq(2)
       expect(va_providers.map(&:location_id).sort).to eq(%w[983 984])
       expect(systems_service).to have_received(:get_facility_clinics).twice
+      expect(eligibility_service).not_to have_received(:check_eligibility)
+    end
+
+    it 'excludes VA facilities that fail direct-scheduling eligibility when category maps to VAOS' do
+      non_matching_facility = double(
+        'Facility',
+        id: 'vha_984', unique_id: '984', name: 'Other VA',
+        address: nil, phone: nil, lat: 28.12, long: -80.65,
+        facility_type: 'va_health_facility',
+        services: { 'health' => [{ 'serviceId' => 'audiology' }] }
+      )
+      allow(lighthouse_client).to receive(:get_facilities).and_return(
+        [lighthouse_facility, non_matching_facility]
+      )
+      audio_referral = double('Referral', category_of_care: 'audiology', provider_npi: '91560381x')
+
+      allow(eligibility_service).to receive(:check_eligibility) do |va_provider, category_of_care_arg|
+        expect(category_of_care_arg).to eq('audiology')
+        {
+          facility_id: va_provider.location_id,
+          vaos_service_type: 'audiology',
+          direct_eligible: va_provider.location_id == '983'
+        }
+      end
+
+      results = service.search(referral: audio_referral)
+
+      va_providers = results.select { |p| p.provider_type == 'va' }
+      expect(va_providers.map(&:location_id)).to eq(['983'])
+      expect(systems_service).to have_received(:get_facility_clinics).once
     end
 
     it 'returns no VA providers when get_facility_clinics returns no clinics' do