fix(trails): sync from Visit Azores instead of unreachable ArcGIS WFS

Switch trail ingestion to trails.visitazores.com (same source as azores-hub.net),
filtered to São Miguel, with optional azores-hub metadata merge. Deploy bootstrap
now queues every enabled external feed (news, seismic, trails) via feature flags.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: hc-sousa

src/shared/feed_syncs.py

@@ -36,13 +36,33 @@ def _run_trails(island_key: str | None) -> dict[str, Any]:
     return {'status': 'ok', **sync_all_open_data(island_key=island_key)}
 
 
+FEED_MODULE_FLAGS: dict[str, str] = {
+    'news': 'news',
+    'seismic': 'seismic',
+    'trails': 'trails',
+}
+
 FEED_RUNNERS: dict[str, FeedRunner] = {
     'news': _run_news,
     'seismic': _run_seismic,
     'trails': _run_trails,
 }
 
 
+def enabled_feed_labels() -> list[str]:
+    """Feeds to refresh on deploy when at least one live island enables the module."""
+    from tenancy.models import Island
+
+    enabled: set[str] = set()
+    for island in Island.objects.filter(is_live=True):
+        flags = island.feature_flags or {}
+        for label, module_key in FEED_MODULE_FLAGS.items():
+            if flags.get(module_key):
+                enabled.add(label)
+    labels = [label for label in FEED_LABELS if label in enabled]
+    return labels or list(FEED_LABELS)
+
+
 def _queue_news(island_key: str | None):
     from news.tasks import poll_sources_task
 

src/shared/management/commands/bootstrap_feed_syncs.py

@@ -6,7 +6,7 @@
 
 from django.core.management.base import BaseCommand
 
-from shared.feed_syncs import FEED_LABELS, queue_feed_sync
+from shared.feed_syncs import enabled_feed_labels, queue_feed_sync
 
 logger = logging.getLogger(__name__)
 
@@ -15,15 +15,18 @@ class Command(BaseCommand):
     help = 'Queue initial news, seismic, and trails feed sync tasks (runs after migrate on deploy).'
 
     def handle(self, *args: object, **options: object) -> None:
+        labels = enabled_feed_labels()
         queued: list[str] = []
-        for label in FEED_LABELS:
+        for label in labels:
             try:
                 info = queue_feed_sync(label)
                 queued.append(info['task'])
             except Exception:
                 logger.exception('bootstrap_feed_syncs failed to queue %s', label)
 
         if queued:
-            self.stdout.write(f'Queued feed sync tasks: {", ".join(queued)}')
+            self.stdout.write(
+                f'Queued feed sync tasks ({", ".join(labels)}): {", ".join(queued)}',
+            )
         else:
             self.stdout.write('No feed sync tasks were queued (check Celery broker).')

src/shared/tests/test_bootstrap_feed_syncs.py

@@ -0,0 +1,51 @@
+"""Deploy bootstrap feed sync command tests."""
+
+from io import StringIO
+from unittest.mock import patch
+
+from django.core.management import call_command
+from django.test import TestCase
+
+from shared.feed_syncs import enabled_feed_labels
+from tenancy.services import get_or_create_default_island
+
+
+class BootstrapFeedSyncsTestCase(TestCase):
+    def setUp(self):
+        self.island = get_or_create_default_island()
+        self.island.is_live = True
+        self.island.feature_flags = {
+            **(self.island.feature_flags or {}),
+            'news': True,
+            'seismic': True,
+            'trails': True,
+        }
+        self.island.save()
+
+    def test_enabled_feed_labels_includes_all_external_modules(self):
+        labels = enabled_feed_labels()
+        self.assertEqual(labels, ['news', 'seismic', 'trails'])
+
+    def test_enabled_feed_labels_omits_disabled_modules(self):
+        self.island.feature_flags = {
+            **(self.island.feature_flags or {}),
+            'news': True,
+            'seismic': False,
+            'trails': False,
+        }
+        self.island.save(update_fields=['feature_flags'])
+        self.assertEqual(enabled_feed_labels(), ['news'])
+
+    @patch('shared.management.commands.bootstrap_feed_syncs.queue_feed_sync')
+    def test_bootstrap_command_queues_enabled_feeds(self, mock_queue):
+        mock_queue.side_effect = [
+            {'task': 'news.poll_sources', 'celery_task_id': 'a'},
+            {'task': 'seismic.sync_events', 'celery_task_id': 'b'},
+            {'task': 'trails.sync_open_data', 'celery_task_id': 'c'},
+        ]
+        out = StringIO()
+        call_command('bootstrap_feed_syncs', stdout=out)
+        self.assertEqual(mock_queue.call_count, 3)
+        output = out.getvalue()
+        self.assertIn('news.poll_sources', output)
+        self.assertIn('trails.sync_open_data', output)

src/trails/services.py

@@ -490,13 +490,14 @@ def sync_open_data_for_island(island: Island) -> dict[str, int]:
         'skipped': 0,
     }
     try:
-        trails_collection = fetch_dataset_geojson(_trails_dataset_id())
-        trail_counts = sync_trails_for_island(island, collection=trails_collection)
+        from trails.visitazores_sync import sync_visitazores_trails_for_island
+
+        trail_counts = sync_visitazores_trails_for_island(island)
         totals['trails_created'] += trail_counts['created']
         totals['trails_updated'] += trail_counts['updated']
         totals['skipped'] += trail_counts['skipped']
     except Exception:
-        logger.exception('trails sync failed for island=%s', island.key)
+        logger.exception('visitazores trails sync failed for island=%s', island.key)
         raise
 
     try:
@@ -551,7 +552,7 @@ def serialize_trail_detail(trail: Trail) -> dict[str, Any]:
         **serialize_trail_summary(trail),
         'geojson': trail.geojson,
         'stages': stages,
-        'attribution': OPEN_DATA_ATTRIBUTION,
+        'attribution': trails_attribution(),
     }
 
 
@@ -565,14 +566,23 @@ def serialize_poi(poi: POI) -> dict[str, Any]:
     }
 
 
+def trails_attribution() -> str:
+    try:
+        from trails.visitazores_sync import VISITAZORES_ATTRIBUTION
+
+        return VISITAZORES_ATTRIBUTION
+    except ImportError:
+        return OPEN_DATA_ATTRIBUTION
+
+
 def list_trails(*, difficulty: str = '', limit: int = 50) -> dict[str, Any]:
     qs = Trail.objects.order_by('name')
     if difficulty:
         qs = qs.filter(difficulty__iexact=difficulty.strip())
     limit = max(1, min(limit, 100))
     return {
         'trails': [serialize_trail_summary(trail) for trail in qs[:limit]],
-        'attribution': OPEN_DATA_ATTRIBUTION,
+        'attribution': trails_attribution(),
     }
 
 
@@ -591,5 +601,5 @@ def list_pois(*, category: str = '', limit: int = 50) -> dict[str, Any]:
     limit = max(1, min(limit, 100))
     return {
         'pois': [serialize_poi(poi) for poi in qs[:limit]],
-        'attribution': OPEN_DATA_ATTRIBUTION,
+        'attribution': trails_attribution(),
     }

src/trails/tests/test_services.py

@@ -119,8 +119,10 @@ def test_sync_empty_collection(self):
         self.assertEqual(Trail.objects.count(), 0)
 
     @patch('trails.services.fetch_dataset_geojson')
-    def test_sync_open_data_for_island(self, mock_fetch):
-        mock_fetch.side_effect = [SAMPLE_TRAIL_COLLECTION, SAMPLE_POI_COLLECTION]
+    @patch('trails.visitazores_sync.sync_visitazores_trails_for_island')
+    def test_sync_open_data_for_island(self, mock_trails, mock_fetch):
+        mock_trails.return_value = {'created': 1, 'updated': 0, 'skipped': 0}
+        mock_fetch.return_value = SAMPLE_POI_COLLECTION
         totals = sync_open_data_for_island(self.island)
         self.assertEqual(totals['trails_created'], 1)
         self.assertEqual(totals['pois_created'], 1)

src/trails/tests/test_visitazores_sync.py

@@ -0,0 +1,61 @@
+"""Visit Azores trails sync tests."""
+
+from unittest.mock import patch
+
+from django.test import TestCase
+
+from trails.visitazores_sync import (
+    gpx_to_linestring,
+    parse_trail_detail_page,
+    sync_visitazores_trails_for_island,
+)
+from tenancy.services import get_or_create_default_island
+
+SAMPLE_DETAIL_HTML = """
+<html><head>
+<meta property="og:title" content="Caldeiras da Ribeira Grande - Salto do Cabrito | Azores Trails" />
+<script>jQuery.extend(Drupal.settings, {"geofieldMap":{"map":{"data":{"type":"LineString","coordinates":[[-25.50,37.78],[-25.49,37.79]],"properties":{"description":"Caldeiras"}}}}});</script>
+</head><body>
+<div class="field field-name-field-difficulty"><div class="field-item even">Difficulty - Medium</div></div>
+<div class="field field-name-field-extension"><div class="field-item even">Extension - 8.6 km</div></div>
+PRC29SMI
+<a href="https://trails.visitazores.com/sites/default/files/trails/sao-miguel/prc29smi.gpx">GPS</a>
+</body></html>
+"""
+
+SAMPLE_GPX = """<?xml version="1.0"?>
+<gpx xmlns="http://www.topografix.com/GPX/1/1">
+<trk><trkseg>
+<trkpt lat="37.78" lon="-25.50"/>
+<trkpt lat="37.79" lon="-25.49"/>
+</trkseg></trk>
+</gpx>"""
+
+
+class VisitAzoresSyncTestCase(TestCase):
+    def setUp(self):
+        self.island = get_or_create_default_island()
+        self.island.feature_flags = {**self.island.feature_flags, 'trails': True}
+        self.island.save()
+
+    def test_parse_trail_detail_page_extracts_fields(self):
+        row = parse_trail_detail_page(SAMPLE_DETAIL_HTML, page_url='https://example.test/trail')
+        assert row is not None
+        self.assertEqual(row['source_ref'], 'PRC29SMI')
+        self.assertEqual(row['name'], 'Caldeiras da Ribeira Grande - Salto do Cabrito')
+        self.assertEqual(row['difficulty'], 'moderate')
+        self.assertEqual(row['distance_km'], 8.6)
+        self.assertEqual(row['geojson']['type'], 'LineString')
+
+    def test_gpx_to_linestring(self):
+        geometry = gpx_to_linestring(SAMPLE_GPX)
+        assert geometry is not None
+        self.assertEqual(geometry['coordinates'][0], [-25.50, 37.78])
+
+    @patch('trails.visitazores_sync.fetch_feed_trail_summaries', return_value={})
+    @patch('trails.visitazores_sync.fetch_island_trail_paths', return_value=['/en/trails-azores/sao-miguel/test'])
+    @patch('trails.visitazores_sync._get_html', return_value=SAMPLE_DETAIL_HTML)
+    def test_sync_visitazores_trails_for_island(self, *_mocks):
+        counts = sync_visitazores_trails_for_island(self.island)
+        self.assertEqual(counts['created'], 1)
+        self.assertEqual(counts['skipped'], 0)