Feat: update operational status endpoint to include 'published' (#927)

Author: AlfredNwolisa

api/src/feeds/impl/feeds_api_impl.py

@@ -75,8 +75,7 @@ def get_feed(self, id: str, db_session: Session) -> BasicFeed:
             .filter(Feed.data_type != "gbfs")  # Filter out GBFS feeds
             .filter(
                 or_(
-                    Feed.operational_status == None,  # noqa: E711
-                    Feed.operational_status != "wip",
+                    Feed.operational_status == "published",
                     not is_email_restricted,  # Allow all feeds to be returned if the user is not restricted
                 )
             )
@@ -110,8 +109,7 @@ def get_feeds(
         feed_query = feed_query.filter(Feed.data_type != "gbfs")  # Filter out GBFS feeds
         feed_query = feed_query.filter(
             or_(
-                Feed.operational_status == None,  # noqa: E711
-                Feed.operational_status != "wip",
+                Feed.operational_status == "published",
                 not is_email_restricted,  # Allow all feeds to be returned if the user is not restricted
             )
         )
@@ -147,8 +145,7 @@ def _get_gtfs_feed(stable_id: str, db_session: Session) -> Optional[Gtfsfeed]:
             .filter(db_session.query(Gtfsfeed))
             .filter(
                 or_(
-                    Gtfsfeed.operational_status == None,  # noqa: E711
-                    Gtfsfeed.operational_status != "wip",
+                    Gtfsfeed.operational_status == "published",
                     not is_user_email_restricted(),  # Allow all feeds to be returned if the user is not restricted
                 )
             )
@@ -191,8 +188,7 @@ def get_gtfs_feed_datasets(
             .filter(Database().get_query_model(db_session, Gtfsfeed))
             .filter(
                 or_(
-                    Feed.operational_status == None,  # noqa: E711
-                    Feed.operational_status != "wip",
+                    Feed.operational_status == "published",
                     not is_user_email_restricted(),  # Allow all feeds to be returned if the user is not restricted
                 )
             )
@@ -273,8 +269,7 @@ def get_gtfs_rt_feed(self, id: str, db_session: Session) -> GtfsRTFeed:
             db_session.query(Gtfsrealtimefeed, t_location_with_translations_en)
             .filter(
                 or_(
-                    Gtfsrealtimefeed.operational_status == None,  # noqa: E711
-                    Gtfsrealtimefeed.operational_status != "wip",
+                    Gtfsrealtimefeed.operational_status == "published",
                     not is_user_email_restricted(),  # Allow all feeds to be returned if the user is not restricted
                 )
             )
@@ -361,8 +356,7 @@ def get_gtfs_rt_feeds(
             .filter(Gtfsrealtimefeed.id.in_(subquery))
             .filter(
                 or_(
-                    Gtfsrealtimefeed.operational_status == None,  # noqa: E711
-                    Gtfsrealtimefeed.operational_status != "wip",
+                    Gtfsrealtimefeed.operational_status == "published",
                     not is_user_email_restricted(),  # Allow all feeds to be returned if the user is not restricted
                 )
             )

api/src/feeds/impl/search_api_impl.py

@@ -40,8 +40,7 @@ def add_search_query_filters(query, search_query, data_type, feed_id, status, is
         query = query.filter(t_feedsearch.c.data_type != "gbfs")  # Filter out GBFS feeds
         query = query.filter(
             or_(
-                t_feedsearch.c.operational_status == None,  # noqa: E711
-                t_feedsearch.c.operational_status != "wip",
+                t_feedsearch.c.operational_status == "published",
                 not is_user_email_restricted(),
             )
         )

api/src/scripts/populate_db_gbfs.py

@@ -80,6 +80,7 @@ def populate_db(self):
                             data_type="gbfs",
                             stable_id=stable_id,
                             created_at=datetime.now(pytz.utc),
+                            operational_status="published",
                         )
                         gbfs_feed.externalids = [self.get_external_id(feed_id, row["System ID"])]
                         session.add(gbfs_feed)

api/src/scripts/populate_db_gtfs.py

@@ -198,6 +198,7 @@ def populate_db(self, session: "Session"):
                     stable_id=stable_id,
                     # Current timestamp with UTC timezone
                     created_at=datetime.now(pytz.utc),
+                    operational_status="published",
                 )
                 self.logger.info(f"Creating {feed.__class__.__name__}: {stable_id}")
                 session.add(feed)

api/src/scripts/populate_db_test_data.py

@@ -158,6 +158,7 @@ def populate_test_feeds(self, feeds_data, db_session: "Session"):
                 license_url=None,
                 feed_contact_email=feed_data["feed_contact_email"],
                 producer_url=feed_data["source_info"]["producer_url"],
+                operational_status="published",
             )
             locations = []
             for location_data in feed_data["locations"]:

api/src/shared/common/db_utils.py

@@ -58,9 +58,7 @@ def get_gtfs_feeds_query(
 
     feed_query = db_session.query(Gtfsfeed).filter(Gtfsfeed.id.in_(subquery))
     if not include_wip:
-        feed_query = feed_query.filter(
-            or_(Gtfsfeed.operational_status == None, Gtfsfeed.operational_status != "wip")  # noqa: E711
-        )
+        feed_query = feed_query.filter(Gtfsfeed.operational_status == "published")
 
     feed_query = feed_query.options(
         joinedload(Gtfsfeed.gtfsdatasets)
@@ -91,7 +89,7 @@ def get_all_gtfs_feeds(
     """
     feed_query = db_session.query(Gtfsfeed).order_by(Gtfsfeed.stable_id).yield_per(batch_size)
     if not include_wip:
-        feed_query = feed_query.filter(Gtfsfeed.operational_status.is_distinct_from("wip"))
+        feed_query = feed_query.filter(Gtfsfeed.operational_status == "published")
 
     for batch in batched(feed_query, batch_size):
         stable_ids = (f.stable_id for f in batch)
@@ -153,12 +151,7 @@ def get_gtfs_rt_feeds_query(
     feed_query = db_session.query(Gtfsrealtimefeed).filter(Gtfsrealtimefeed.id.in_(subquery))
 
     if not include_wip:
-        feed_query = feed_query.filter(
-            or_(
-                Gtfsrealtimefeed.operational_status == None,  # noqa: E711
-                Gtfsrealtimefeed.operational_status != "wip",
-            )
-        )
+        feed_query = feed_query.filter(Gtfsrealtimefeed.operational_status == "published")
 
     feed_query = feed_query.options(
         joinedload(Gtfsrealtimefeed.entitytypes),
@@ -188,7 +181,7 @@ def get_all_gtfs_rt_feeds(
     """
     feed_query = db_session.query(Gtfsrealtimefeed.stable_id).order_by(Gtfsrealtimefeed.stable_id).yield_per(batch_size)
     if not include_wip:
-        feed_query = feed_query.filter(Gtfsrealtimefeed.operational_status.is_distinct_from("wip"))
+        feed_query = feed_query.filter(Gtfsrealtimefeed.operational_status == "published")
 
     for batch in batched(feed_query, batch_size):
         stable_ids = (f.stable_id for f in batch)

functions-python/export_csv/tests/conftest.py

@@ -14,23 +14,23 @@
 #  limitations under the License.
 #
 
-from faker import Faker
 from datetime import datetime
 
+from faker import Faker
 from geoalchemy2 import WKTElement
 
-from shared.database_gen.sqlacodegen_models import (
-    Validationreport,
-    Feature,
-    Redirectingid,
-)
 from shared.database_gen.sqlacodegen_models import (
     Gtfsfeed,
     Gtfsrealtimefeed,
     Gtfsdataset,
     Location,
     Entitytype,
 )
+from shared.database_gen.sqlacodegen_models import (
+    Validationreport,
+    Feature,
+    Redirectingid,
+)
 from test_shared.test_utils.database_utils import clean_testing_db, get_testing_session
 
 
@@ -48,7 +48,6 @@ def populate_database():
     session = get_testing_session()
     fake = Faker()
 
-    feed_reference = None
     feeds = []
     # We create 3 feeds. The first one is active. The third one is inactive and redirected to the first one.
     # The second one is active but not redirected.
@@ -65,9 +64,9 @@ def populate_database():
             stable_id=f"gtfs-{i}",
             feed_contact_email=f"gtfs-{i}[email protected]",
             provider=f"gtfs-{i} Some fake company",
+            operational_status="published",
+            official=True,
         )
-        if i == 0:
-            feed_reference = feed
         feeds.append(feed)
 
     # Then fill the specific parameters for each feed
@@ -112,6 +111,8 @@ def populate_database():
             status="deprecated",
             feed_contact_email=f"gtfs-deprecated-{i}[email protected]",
             provider=f"gtfs-deprecated-{i} Some fake company",
+            operational_status="published",
+            official=True,
         )
         session.add(feed)
 
@@ -187,46 +188,46 @@ def populate_database():
         session.add(tu_entitytype)
 
     # GTFS Realtime feeds
-    rt_feeds = []
+    gtfs_rt_feeds = []
     for i in range(3):
-        rt_feeds.append(
-            Gtfsrealtimefeed(
-                id=fake.uuid4(),
-                data_type="gtfs_rt",
-                feed_name=f"gtfs-rt-{i} Some fake name",
-                note=f"gtfs-rt-{i} Some fake note",
-                producer_url=f"https://gtfs-rt-{i}_some_fake_producer_url",
-                authentication_type=str(i),
-                authentication_info_url=f"https://gtfs-rt-{i}_some_fake_authentication_info_url",
-                api_key_parameter_name=f"gtfs-rt-{i}_fake_api_key_parameter_name",
-                license_url=f"https://gtfs-rt-{i}_some_fake_license_url",
-                stable_id=f"gtfs-rt-{i}",
-                status="inactive" if i == 1 else "active",
-                feed_contact_email=f"gtfs-rt-{i}[email protected]",
-                provider=f"gtfs-rt-{i} Some fake company",
-                entitytypes=[vp_entitytype, tu_entitytype]
-                if i == 0
-                else [vp_entitytype],
-                gtfs_feeds=[feed_reference] if i == 0 else [],
-            )
+        feed = Gtfsrealtimefeed(
+            id=fake.uuid4(),
+            data_type="gtfs_rt",
+            feed_name=f"gtfs-rt-{i} Some fake name",
+            note=f"gtfs-rt-{i} Some fake note",
+            producer_url=f"https://gtfs-rt-{i}_some_fake_producer_url",
+            authentication_type=str(i),
+            authentication_info_url=f"https://gtfs-rt-{i}_some_fake_authentication_info_url",
+            api_key_parameter_name=f"gtfs-rt-{i}_fake_api_key_parameter_name",
+            license_url=f"https://gtfs-rt-{i}_some_fake_license_url",
+            stable_id=f"gtfs-rt-{i}",
+            status="inactive" if i == 1 else "active",
+            feed_contact_email=f"gtfs-rt-{i}[email protected]",
+            provider=f"gtfs-rt-{i} Some fake company",
+            entitytypes=[vp_entitytype, tu_entitytype] if i == 0 else [vp_entitytype],
+            operational_status="published",
+            official=True,
+            gtfs_feeds=[active_gtfs_feeds[0]] if i == 0 else [],
         )
-    # rt_feeds[1] is inactive and redirected to rt_feeds[0] and rt_feee[2]
-    rt_feeds[1].redirectingids = [
+        gtfs_rt_feeds.append(feed)
+
+    # Add redirecting IDs (from main branch logic)
+    gtfs_rt_feeds[1].redirectingids = [
         Redirectingid(
-            source_id=rt_feeds[1].id,
-            target_id=rt_feeds[0].id,
+            source_id=gtfs_rt_feeds[1].id,
+            target_id=gtfs_rt_feeds[0].id,
             redirect_comment="comment 1",
-            target=rt_feeds[0],
+            target=gtfs_rt_feeds[0],
         ),
         Redirectingid(
-            source_id=rt_feeds[1].id,
-            target_id=rt_feeds[2].id,
+            source_id=gtfs_rt_feeds[1].id,
+            target_id=gtfs_rt_feeds[2].id,
             redirect_comment="comment 2",
-            target=rt_feeds[2],
+            target=gtfs_rt_feeds[2],
         ),
     ]
 
-    session.add_all(rt_feeds)
+    session.add_all(gtfs_rt_feeds)
 
     session.commit()
 

functions-python/feed_sync_process_transitland/src/feed_processor_utils.py

@@ -61,7 +61,7 @@ def create_new_feed(session: Session, stable_id: str, payload: FeedPayload) -> F
         api_key_parameter_name=payload.auth_param_name,
         status="active",
         provider=payload.operator_name,
-        operational_status="wip",
+        operational_status="wip",  # Default to of wip
         created_at=datetime.now(),
     )
 

functions-python/operations_api/src/feeds_operations/impl/feeds_operations_impl.py

@@ -23,7 +23,6 @@
 from pydantic import Field
 from starlette.responses import Response
 
-from shared.database_gen.sqlacodegen_models import Gtfsfeed, t_feedsearch
 from feeds_operations.impl.models.update_request_gtfs_feed_impl import (
     UpdateRequestGtfsFeedImpl,
 )
@@ -33,6 +32,7 @@
 from feeds_operations_gen.models.update_request_gtfs_rt_feed import (
     UpdateRequestGtfsRtFeed,
 )
+from shared.database_gen.sqlacodegen_models import Gtfsfeed, t_feedsearch
 from shared.helpers.database import Database, refresh_materialized_view
 from shared.helpers.query_helper import query_feed_by_stable_id
 from .models.update_request_gtfs_rt_feed_impl import UpdateRequestGtfsRtFeedImpl
@@ -171,7 +171,10 @@ async def _populate_feed_values(feed, impl_class, session, update_request_feed):
         action = update_request_feed.operational_status_action
         # This is a temporary solution as the operational_status is not visible in the diff
         if action is not None and not action.lower() == "no_change":
-            feed.operational_status = "wip" if action.lower() == "wip" else None
+            if action.lower() == "wip":
+                feed.operational_status = "wip"
+            elif action.lower() == "published":
+                feed.operational_status = "published"
         session.add(feed)
 
     @staticmethod

functions-python/operations_api/tests/feeds_operations/impl/test_feeds_operations_impl_gtfs.py

@@ -6,14 +6,14 @@
 from fastapi import HTTPException
 from starlette.responses import Response
 
-from shared.database_gen.sqlacodegen_models import Gtfsfeed
+from conftest import feed_mdb_40
 from feeds_operations.impl.feeds_operations_impl import OperationsApiImpl
 from feeds_operations_gen.models.authentication_type import AuthenticationType
 from feeds_operations_gen.models.external_id import ExternalId
 from feeds_operations_gen.models.feed_status import FeedStatus
 from feeds_operations_gen.models.source_info import SourceInfo
 from feeds_operations_gen.models.update_request_gtfs_feed import UpdateRequestGtfsFeed
-from conftest import feed_mdb_40
+from shared.database_gen.sqlacodegen_models import Gtfsfeed
 from test_shared.test_utils.database_utils import get_testing_session, default_db_url
 
 
@@ -115,19 +115,19 @@ async def test_update_gtfs_feed_set_wip(_, update_request_gtfs_feed):
     },
 )
 @pytest.mark.asyncio
-async def test_update_gtfs_feed_set_wip_publish(_, update_request_gtfs_feed):
-    update_request_gtfs_feed.operational_status_action = "published"
+async def test_update_gtfs_feed_set_wip_nochange(_, update_request_gtfs_feed):
+    update_request_gtfs_feed.operational_status_action = "no_change"
     with get_testing_session() as session:
         api = OperationsApiImpl()
         response: Response = await api.update_gtfs_feed(update_request_gtfs_feed)
-        assert response.status_code == 200
+        assert response.status_code == 204
 
         db_feed = (
             session.query(Gtfsfeed)
             .filter(Gtfsfeed.stable_id == feed_mdb_40.stable_id)
             .one()
         )
-        assert db_feed.operational_status is None
+        assert db_feed.operational_status == "wip"
 
 
 @patch("shared.helpers.logger.Logger")
@@ -138,19 +138,19 @@ async def test_update_gtfs_feed_set_wip_publish(_, update_request_gtfs_feed):
     },
 )
 @pytest.mark.asyncio
-async def test_update_gtfs_feed_set_wip_nochange(_, update_request_gtfs_feed):
-    update_request_gtfs_feed.operational_status_action = "no_change"
+async def test_update_gtfs_feed_set_published(_, update_request_gtfs_feed):
+    update_request_gtfs_feed.operational_status_action = "published"
     with get_testing_session() as session:
         api = OperationsApiImpl()
         response: Response = await api.update_gtfs_feed(update_request_gtfs_feed)
-        assert response.status_code == 204
+        assert response.status_code == 200
 
         db_feed = (
             session.query(Gtfsfeed)
             .filter(Gtfsfeed.stable_id == feed_mdb_40.stable_id)
             .one()
         )
-        assert db_feed.operational_status is None
+        assert db_feed.operational_status == "published"
 
 
 @patch("shared.helpers.logger.Logger")