Enhance available_addresses_for and available_buildings_for methods with context-based logic and comprehensive specs

Author: rsmithlal

app/models/better_together/geography/locatable_location.rb

@@ -66,16 +66,65 @@ def building?
       end
 
       # Helper method for forms - get available addresses for the user/context
-      def self.available_addresses_for(_context = nil)
-        # This would be customized based on your business logic
-        # For example, user's addresses, community addresses, etc.
-        BetterTogether::Address.includes(:string_translations)
+      def self.available_addresses_for(context = nil)
+        return BetterTogether::Address.none unless context
+
+        case context
+        when BetterTogether::Person
+          # Use policy to get authorized addresses for the person
+          user = context.user
+          if user
+            policy_scope = BetterTogether::AddressPolicy::Scope.new(user, BetterTogether::Address).resolve
+            policy_scope.includes(:contact_detail)
+          else
+            # Person without user - only public addresses
+            BetterTogether::Address.where(privacy: 'public').includes(:contact_detail)
+          end
+        when BetterTogether::Community
+          # Communities can access public addresses and their own addresses
+          community_address_ids = BetterTogether::Address
+                                  .joins(:contact_detail)
+                                  .where(better_together_contact_details: { contactable: context })
+                                  .pluck(:id)
+
+          public_address_ids = BetterTogether::Address.where(privacy: 'public').pluck(:id)
+
+          # Combine IDs and query with includes
+          all_address_ids = (community_address_ids + public_address_ids).uniq
+          BetterTogether::Address.where(id: all_address_ids).includes(:contact_detail)
+        else
+          # Default: return public addresses only
+          BetterTogether::Address.where(privacy: 'public').includes(:contact_detail)
+        end
       end
 
       # Helper method for forms - get available buildings for the user/context
-      def self.available_buildings_for(_context = nil)
-        # This would be customized based on your business logic
-        BetterTogether::Infrastructure::Building.includes(:string_translations)
+      def self.available_buildings_for(context = nil)
+        return BetterTogether::Infrastructure::Building.none unless context
+
+        case context
+        when BetterTogether::Person
+          if context.user
+            # Person with user can access buildings they created and public buildings
+            BetterTogether::Infrastructure::Building
+              .where(creator: context)
+              .or(BetterTogether::Infrastructure::Building.where(privacy: 'public'))
+              .includes(:string_translations, :address)
+          else
+            # Person without user - only public buildings
+            BetterTogether::Infrastructure::Building
+              .where(privacy: 'public')
+              .includes(:string_translations, :address)
+          end
+        when BetterTogether::Community
+          # Communities get public buildings for now
+          BetterTogether::Infrastructure::Building
+            .where(privacy: 'public')
+            .includes(:string_translations, :address)
+        else
+          # Fallback: return empty scope for unsupported context types
+          BetterTogether::Infrastructure::Building.none
+        end
       end
 
       private

spec/models/better_together/geography/locatable_location_spec.rb

@@ -206,14 +206,143 @@ module Geography # rubocop:todo Metrics/ModuleLength
 
       describe 'class methods' do
         describe '.available_addresses_for' do
-          it 'returns addresses with translations' do
-            expect(described_class.available_addresses_for).to respond_to(:includes)
+          let(:user) { create(:better_together_user, :confirmed) }
+          let(:person) { user.person }
+          let(:community) { create(:better_together_community) }
+          let!(:public_address) { create(:better_together_address, privacy: 'public') }
+          let!(:private_address) { create(:better_together_address, privacy: 'private') }
+
+          context 'when context is nil' do
+            it 'returns empty scope' do
+              expect(described_class.available_addresses_for(nil)).to eq(BetterTogether::Address.none)
+            end
+          end
+
+          context 'when context is a Person with user' do
+            let!(:person_contact_detail) do
+              create(:better_together_contact_detail, contactable: person)
+            end
+
+            let!(:person_address) do
+              create(:better_together_address, privacy: 'private', contact_detail: person_contact_detail)
+            end
+
+            it 'uses policy scope to return authorized addresses' do
+              result = described_class.available_addresses_for(person)
+
+              # Should include public addresses at minimum
+              expect(result).to include(public_address)
+            end
+
+            it 'includes proper associations' do
+              result = described_class.available_addresses_for(person)
+
+              expect(result.includes_values).to include(:contact_detail)
+            end
+          end
+
+          context 'when context is a Person without user' do
+            let(:person_without_user) { create(:better_together_person) }
+
+            it 'returns only public addresses' do
+              result = described_class.available_addresses_for(person_without_user)
+
+              expect(result).to include(public_address)
+              expect(result).not_to include(private_address)
+            end
+          end
+
+          context 'when context is a Community' do
+            let!(:community_contact_detail) do
+              create(:better_together_contact_detail, contactable: community)
+            end
+
+            let!(:community_address) do
+              create(:better_together_address, privacy: 'private', contact_detail: community_contact_detail)
+            end
+
+            it 'returns community addresses and public addresses' do
+              result = described_class.available_addresses_for(community)
+
+              expect(result).to include(community_address)
+              expect(result).to include(public_address)
+              expect(result).not_to include(private_address)
+            end
+          end
+
+          context 'when context is unsupported type' do
+            it 'returns only public addresses' do
+              result = described_class.available_addresses_for('unsupported')
+
+              expect(result).to include(public_address)
+              expect(result).not_to include(private_address)
+            end
           end
         end
 
         describe '.available_buildings_for' do
-          it 'returns buildings with translations' do
-            expect(described_class.available_buildings_for).to respond_to(:includes)
+          let(:user) { create(:better_together_user, :confirmed) }
+          let(:person) { user.person }
+          let(:community) { create(:better_together_community) }
+          let!(:public_building) { create(:better_together_infrastructure_building, privacy: 'public') }
+          let!(:private_building) { create(:better_together_infrastructure_building, privacy: 'private') }
+
+          context 'when context is nil' do
+            it 'returns empty scope' do
+              expect(described_class.available_buildings_for(nil)).to eq(BetterTogether::Infrastructure::Building.none)
+            end
+          end
+
+          context 'when context is a Person with user' do
+            let!(:person_building) do
+              create(:better_together_infrastructure_building,
+                     creator: person,
+                     privacy: 'private')
+            end
+
+            it 'uses policy scope to return authorized buildings' do
+              result = described_class.available_buildings_for(person)
+
+              # Should include public buildings and person's own buildings
+              expect(result).to include(public_building)
+              expect(result).to include(person_building)
+              expect(result).not_to include(private_building)
+            end
+
+            it 'includes proper associations' do
+              result = described_class.available_buildings_for(person)
+
+              expect(result.includes_values).to include(:string_translations)
+              expect(result.includes_values).to include(:address)
+            end
+          end
+
+          context 'when context is a Person without user' do
+            let(:person_without_user) { create(:better_together_person) }
+
+            it 'returns only public buildings' do
+              result = described_class.available_buildings_for(person_without_user)
+
+              expect(result).to include(public_building)
+              expect(result).not_to include(private_building)
+            end
+          end
+
+          context 'when context is a Community' do
+            it 'returns only public buildings' do
+              result = described_class.available_buildings_for(community)
+
+              expect(result).to include(public_building)
+              expect(result).not_to include(private_building)
+            end
+          end
+
+          context 'when context is unsupported type' do
+            it 'returns empty scope' do
+              result = described_class.available_buildings_for('unsupported')
+
+              expect(result).to eq(BetterTogether::Infrastructure::Building.none)
+            end
           end
         end