Merge branch 'main' into 1082-sort-feeds-page-by-created_at

Author: qcdyx

functions-python/gbfs_validator/src/gbfs_data_processor.py

@@ -30,6 +30,18 @@
 from shared.database.database import with_db_session
 from shared.helpers.utils import create_http_task
 
+FEATURE_ENDPOINTS = [
+    "manifest",
+    "gbfs_versions",
+    "vehicle_types",
+    "station_status",
+    "vehicle_status",
+    "system_regions",
+    "system_pricing_plans",
+    "system_alerts",
+    "geofencing_zones",
+]
+
 
 class GBFSDataProcessor:
     def __init__(self, stable_id: str, feed_id: str):
@@ -298,7 +310,9 @@ def update_or_create_gbfs_endpoint(
             )
 
         gbfs_endpoint_orm.url = endpoint.url  # Update the URL
-        gbfs_endpoint_orm.is_feature = endpoint.name in features
+        gbfs_endpoint_orm.is_feature = (
+            endpoint.name in features and endpoint.name in FEATURE_ENDPOINTS
+        )
         return gbfs_endpoint_orm
 
     def validate_gbfs_feed_versions(self) -> None:

liquibase/changelog.xml

@@ -56,4 +56,5 @@
     <include file="changes/feat_1124.sql" relativeToChangelogFile="true"/>
     <!-- Materialized view updated. Added versions of GBFS feeds-->
     <include file="changes/feat_1118.sql" relativeToChangelogFile="true"/>
+    <include file="changes/feat_1125.sql" relativeToChangelogFile="true"/>
 </databaseChangeLog>

liquibase/changes/feat_1125.sql

@@ -0,0 +1,16 @@
+-- Update gbfsendpoint table to set is_feature = false for specific endpoints
+UPDATE gbfsendpoint
+SET is_feature = CASE
+    WHEN name IN (
+        'manifest',
+        'gbfs_versions',
+        'vehicle_types',
+        'station_status',
+        'vehicle_status',
+        'system_regions',
+        'system_pricing_plans',
+        'system_alerts',
+        'geofencing_zones'
+    ) THEN true
+    ELSE false
+END;

web-app/public/locales/en/common.json

@@ -20,6 +20,7 @@
     },
     "loading": "Loading...",
     "download": "Download",
+    "updated": "Updated",
     "errors": {
         "generic": "We are unable to complete your request at the moment."
     },

web-app/public/locales/en/feeds.json

@@ -67,6 +67,7 @@
   "detailedCoveredAreaView": "Detailed",
   "detailedCoveredAreaViewTooltip": "View the detailed covered area of the feed",
   "unableToGenerateBoundingBox": "Unable to generate bounding box from the feed's stops.txt file.",
+  "unableToGetGbfsMap": "Error fetching GBFS Map",
   "areYouOfficialProducer": "Are you the official producer or transit agency responsible for this data ?",
   "isOfficialSource": "Is this an official data source?",
   "isOfficialSourceDetails": "Select \"Yes\" if the inputted feed is the official source of information by the transit provider and should be used to display to riders.",

web-app/src/app/components/ContentBox.tsx

@@ -31,7 +31,7 @@ export const ContentBox = (
         ...props.sx,
       }}
     >
-      {props.title.trim() !== '' && (
+      {(props.title.trim() !== '' || props.action != null) && (
         <Typography
           variant='h5'
           sx={{
@@ -42,7 +42,7 @@ export const ContentBox = (
             mb: 1,
           }}
         >
-          {props.title}
+          <span>{props.title}</span>
           {props.action != null && props.action}
         </Typography>
       )}

web-app/src/app/components/CoveredAreaMap.tsx

@@ -6,19 +6,28 @@ import {
   Tooltip,
   Skeleton,
   Button,
+  Typography,
 } from '@mui/material';
 import MapIcon from '@mui/icons-material/Map';
 import TravelExploreIcon from '@mui/icons-material/TravelExplore';
 import { ContentBox } from './ContentBox';
 import { WarningContentBox } from './WarningContentBox';
 import { mapBoxPositionStyle } from '../screens/Feed/Feed.styles';
-import { type GeoJSONData, MapGeoJSON } from './MapGeoJSON';
+import {
+  type GeoJSONData,
+  type GeoJSONDataGBFS,
+  MapGeoJSON,
+} from './MapGeoJSON';
 import { Map } from './Map';
 import { useTranslation } from 'react-i18next';
 import type { LatLngExpression } from 'leaflet';
 import { useTheme } from '@mui/material/styles';
 import { type GBFSFeedType, type AllFeedType } from '../services/feeds/utils';
 import { OpenInNew } from '@mui/icons-material';
+import { computeBoundingBox } from '../screens/Feed/Feed.functions';
+import { displayFormattedDate } from '../utils/date';
+import { useSelector } from 'react-redux';
+import { selectLatestGbfsVersion } from '../store/feed-selectors';
 
 interface CoveredAreaMapProps {
   boundingBox?: LatLngExpression[];
@@ -28,7 +37,7 @@ interface CoveredAreaMapProps {
 
 export const fetchGeoJson = async (
   latestDatasetUrl: string,
-): Promise<GeoJSONData> => {
+): Promise<GeoJSONData | GeoJSONDataGBFS> => {
   const geoJsonUrl = latestDatasetUrl
     .split('/')
     .slice(0, -2)
@@ -49,36 +58,57 @@ const CoveredAreaMap: React.FC<CoveredAreaMapProps> = ({
   const { t } = useTranslation('feeds');
   const theme = useTheme();
 
-  const [geoJsonData, setGeoJsonData] = useState<GeoJSONData | null>(null);
+  const [geoJsonData, setGeoJsonData] = useState<
+    GeoJSONData | GeoJSONDataGBFS | null
+  >(null);
   const [geoJsonError, setGeoJsonError] = useState(false);
   const [geoJsonLoading, setGeoJsonLoading] = useState(false);
   const [view, setView] = useState<
     'boundingBoxView' | 'detailedCoveredAreaView'
   >('detailedCoveredAreaView');
+  const latestGbfsVersion = useSelector(selectLatestGbfsVersion);
+
+  const getAndSetGeoJsonData = (urlToExtract: string): void => {
+    setGeoJsonLoading(true);
+    fetchGeoJson(urlToExtract)
+      .then((data) => {
+        setGeoJsonData(data);
+        setGeoJsonError(false);
+        setView('detailedCoveredAreaView');
+      })
+      .catch(() => {
+        setGeoJsonError(true);
+        setView('boundingBoxView');
+      })
+      .finally(() => {
+        setGeoJsonLoading(false);
+      });
+  };
 
   useEffect(() => {
-    if (latestDataset?.hosted_url !== undefined && boundingBox != undefined) {
-      setGeoJsonLoading(true);
-      fetchGeoJson(latestDataset.hosted_url)
-        .then((data) => {
-          setGeoJsonData(data);
-          setGeoJsonError(false);
-          setView('detailedCoveredAreaView');
-        })
-        .catch(() => {
-          setGeoJsonError(true);
-          setView('boundingBoxView');
-        })
-        .finally(() => {
-          setGeoJsonLoading(false);
-        });
-    } else {
-      // No dataset, fallback to bounding box
-      setGeoJsonData(null);
-      setGeoJsonError(true);
-      setView('boundingBoxView');
+    if (feed?.data_type === 'gbfs') {
+      const latestGbfsVersionReportUrl =
+        latestGbfsVersion?.latest_validation_report?.report_summary_url;
+      if (latestGbfsVersionReportUrl === undefined) {
+        setGeoJsonData(null);
+        setGeoJsonError(true);
+        return;
+      }
+      getAndSetGeoJsonData(latestGbfsVersionReportUrl);
+      return;
     }
-  }, [latestDataset]);
+    if (
+      feed?.data_type === 'gtfs' &&
+      latestDataset?.hosted_url != undefined &&
+      boundingBox != undefined
+    ) {
+      getAndSetGeoJsonData(latestDataset.hosted_url);
+      return;
+    }
+    setGeoJsonData(null);
+    setGeoJsonError(true);
+    setView('boundingBoxView');
+  }, [latestDataset, feed]);
 
   const handleViewChange = (
     _: React.MouseEvent<HTMLElement>,
@@ -87,11 +117,47 @@ const CoveredAreaMap: React.FC<CoveredAreaMapProps> = ({
     if (newView !== null) setView(newView);
   };
 
-  const getGbfsLatestVersionVisualizationUrl = (feed: GBFSFeedType): string => {
-    // TODO: Redo logic when versions all have the auto discovery
-    return `https://gbfs-validator.mobilitydata.org/visualization?url=${feed?.source_info?.producer_url}`;
+  const getGbfsLatestVersionVisualizationUrl = (
+    feed: GBFSFeedType,
+  ): string | undefined => {
+    const latestAutodiscoveryUrl = latestGbfsVersion?.endpoints?.find(
+      (endpoint) => endpoint.name === 'gbfs',
+    )?.url;
+    if (latestAutodiscoveryUrl != undefined) {
+      return `https://gbfs-validator.mobilitydata.org/visualization?url=${latestAutodiscoveryUrl}`;
+    }
+    return undefined;
   };
 
+  const renderMap = (): JSX.Element => {
+    const displayBoundingBoxMap =
+      view === 'boundingBoxView' && feed?.data_type === 'gtfs';
+    let gbfsBoundingBox: LatLngExpression[] = [];
+    if (feed?.data_type === 'gbfs') {
+      gbfsBoundingBox = computeBoundingBox(geoJsonData) ?? [];
+      if (gbfsBoundingBox.length === 0) {
+        setGeoJsonError(true);
+      }
+    }
+    return (
+      <>
+        {displayBoundingBoxMap ? (
+          <Map polygon={boundingBox ?? []} />
+        ) : (
+          <MapGeoJSON
+            geoJSONData={geoJsonData}
+            polygon={boundingBox ?? gbfsBoundingBox}
+            displayMapDetails={feed?.data_type === 'gtfs'}
+          />
+        )}
+      </>
+    );
+  };
+
+  const mapDisplayError = boundingBox == undefined && geoJsonError;
+  const latestAutodiscoveryUrl = getGbfsLatestVersionVisualizationUrl(
+    feed as GBFSFeedType,
+  );
   return (
     <ContentBox
       sx={{
@@ -102,22 +168,39 @@ const CoveredAreaMap: React.FC<CoveredAreaMapProps> = ({
           xs: '100%',
           md: '70vh',
         },
+        minHeight: '50vh',
       }}
-      title={t('coveredAreaTitle') + ' - ' + t(view)}
+      title={mapDisplayError ? '' : t('coveredAreaTitle') + ' - ' + t(view)}
       width={{ xs: '100%' }}
       outlineColor={theme.palette.primary.dark}
       padding={2}
       action={
         <>
           {feed?.data_type === 'gbfs' ? (
-            <Button
-              href={getGbfsLatestVersionVisualizationUrl(feed as GBFSFeedType)}
-              target='_blank'
-              rel='noreferrer'
-              endIcon={<OpenInNew />}
-            >
-              {t('viewRealtimeVisualization')}
-            </Button>
+            <Box sx={{ textAlign: 'right' }}>
+              {latestAutodiscoveryUrl != undefined && (
+                <Button
+                  href={latestAutodiscoveryUrl}
+                  target='_blank'
+                  rel='noreferrer'
+                  endIcon={<OpenInNew />}
+                >
+                  {t('viewRealtimeVisualization')}
+                </Button>
+              )}
+              {(geoJsonData as GeoJSONDataGBFS)?.extracted_at != undefined && (
+                <Typography
+                  variant='caption'
+                  color='text.secondary'
+                  sx={{ display: 'block', px: 1 }}
+                >
+                  {t('common:updated')}:{' '}
+                  {displayFormattedDate(
+                    (geoJsonData as GeoJSONDataGBFS).extracted_at,
+                  )}
+                </Typography>
+              )}
+            </Box>
           ) : (
             <ToggleButtonGroup
               value={view}
@@ -150,13 +233,19 @@ const CoveredAreaMap: React.FC<CoveredAreaMapProps> = ({
         </>
       }
     >
-      {boundingBox === undefined && view === 'boundingBoxView' && (
-        <WarningContentBox>
-          {t('unableToGenerateBoundingBox')}
-        </WarningContentBox>
+      {feed?.data_type === 'gtfs' &&
+        boundingBox === undefined &&
+        view === 'boundingBoxView' && (
+          <WarningContentBox>
+            {t('unableToGenerateBoundingBox')}
+          </WarningContentBox>
+        )}
+
+      {feed?.data_type === 'gbfs' && geoJsonError && (
+        <WarningContentBox>{t('unableToGetGbfsMap')}</WarningContentBox>
       )}
 
-      {boundingBox !== undefined && (
+      {(boundingBox != undefined || !geoJsonError) && (
         <Box sx={mapBoxPositionStyle}>
           {geoJsonLoading ? (
             <Skeleton
@@ -165,10 +254,8 @@ const CoveredAreaMap: React.FC<CoveredAreaMapProps> = ({
               height='100%'
               animation='wave'
             />
-          ) : view === 'boundingBoxView' ? (
-            <Map polygon={boundingBox} />
           ) : (
-            <MapGeoJSON geoJSONData={geoJsonData} polygon={boundingBox} />
+            <>{geoJsonData !== null && <>{renderMap()}</>}</>
           )}
         </Box>
       )}