(PC-32268)[API] feat: Return individual or collective statistics only if offerer is concerned

Author: pcharlet-pass

api/src/pcapi/connectors/clickhouse/queries/__init__.py

@@ -1,2 +1,4 @@
+from .yearly_revenue import YearlyAggregatedCollectiveRevenueQuery
+from .yearly_revenue import YearlyAggregatedIndividualRevenueQuery
 from .yearly_revenue import YearlyAggregatedRevenueModel
 from .yearly_revenue import YearlyAggregatedRevenueQuery

api/src/pcapi/connectors/clickhouse/queries/yearly_revenue.py

@@ -7,18 +7,30 @@
 from pcapi.routes.serialization.offers_serialize import to_camel
 
 
-class Revenue(pydantic_v1.BaseModel):
-    total: Decimal
+class IndividualRevenue(pydantic_v1.BaseModel):
     individual: Decimal
+
+    class Config:
+        extra = "forbid"
+
+
+class CollectiveRevenue(pydantic_v1.BaseModel):
     collective: Decimal
 
     class Config:
         extra = "forbid"
 
 
+class CollectiveAndIndividualRevenue(IndividualRevenue, CollectiveRevenue):
+    total: Decimal
+
+    class Config:
+        extra = "forbid"
+
+
 class AggregatedRevenue(pydantic_v1.BaseModel):
-    revenue: Revenue
-    expected_revenue: Revenue
+    revenue: CollectiveAndIndividualRevenue | CollectiveRevenue | IndividualRevenue
+    expected_revenue: CollectiveAndIndividualRevenue | CollectiveRevenue | IndividualRevenue
 
     class Config:
         extra = "forbid"
@@ -33,7 +45,7 @@ class Config:
         alias_generator = to_camel
 
 
-class YearlyAggregatedRevenueQuery(BaseQuery[YearlyAggregatedRevenueModel]):
+class YearlyAggregatedRevenueQueryMixin:
     def _format_result(self, results: list) -> dict:
         return {
             "incomeByYear": {
@@ -45,6 +57,54 @@ def _format_result(self, results: list) -> dict:
             }
         }
 
+    @property
+    def model(self) -> type[YearlyAggregatedRevenueModel]:
+        return YearlyAggregatedRevenueModel
+
+
+class YearlyAggregatedCollectiveRevenueQuery(
+    YearlyAggregatedRevenueQueryMixin, BaseQuery[YearlyAggregatedRevenueModel]
+):
+    @property
+    def raw_query(self) -> str:
+        return """
+            SELECT
+                EXTRACT(YEAR FROM creation_year) AS year,
+                toJSONString(map(
+                    'collective', ROUND(SUM(revenue),2),
+                ) as revenue,
+                toJSONString(map(
+                    'collective', ROUND(SUM(expected_revenue),2),
+                ) as expected_revenue
+            FROM analytics.yearly_aggregated_venue_collective_revenue
+            WHERE "venue_id" in %s
+            GROUP BY year
+            ORDER BY year
+        """
+
+
+class YearlyAggregatedIndividualRevenueQuery(
+    YearlyAggregatedRevenueQueryMixin, BaseQuery[YearlyAggregatedRevenueModel]
+):
+    @property
+    def raw_query(self) -> str:
+        return """
+            SELECT
+                EXTRACT(YEAR FROM creation_year) AS year,
+                toJSONString(map(
+                    'individual', ROUND(SUM(revenue),2),
+                ) as revenue,
+                toJSONString(map(
+                    'individual', ROUND(SUM(expected_revenue),2),
+                ) as expected_revenue
+            FROM analytics.yearly_aggregated_venue_individual_revenue
+            WHERE "venue_id" in %s
+            GROUP BY year
+            ORDER BY year
+        """
+
+
+class YearlyAggregatedRevenueQuery(YearlyAggregatedRevenueQueryMixin, BaseQuery[YearlyAggregatedRevenueModel]):
     @property
     def raw_query(self) -> str:
         return """
@@ -65,7 +125,3 @@ def raw_query(self) -> str:
             GROUP BY year
             ORDER BY year
         """
-
-    @property
-    def model(self) -> type[YearlyAggregatedRevenueModel]:
-        return YearlyAggregatedRevenueModel

api/src/pcapi/core/offers/repository.py

@@ -1326,3 +1326,14 @@ def merge_products(to_keep: models.Product, to_delete: models.Product) -> models
     db.session.delete(to_delete)
 
     return to_keep
+
+
+def venues_have_individual_and_collective_offers(venue_ids: list[int]) -> tuple[bool, bool]:
+    return (
+        db.session.query(offers_model.Offer.query.filter(offers_model.Offer.venueId.in_(venue_ids)).exists()).scalar(),
+        db.session.query(
+            educational_models.CollectiveOffer.query.filter(
+                educational_models.CollectiveOffer.venueId.in_(venue_ids)
+            ).exists()
+        ).scalar(),
+    )

api/src/pcapi/core/users/repository.py

@@ -89,7 +89,7 @@ def has_access(user: models.User, offerer_id: int) -> bool:
 
 
 def has_access_to_venues(user: models.User, venue_ids: list[int]) -> bool:
-    """Return whether the user has access to the requested venues' data."""
+    """Return whether the user has access to all the requested venues' data."""
     query = offerers_models.UserOfferer.query
     query = query.options(
         joinedload(offerers_models.UserOfferer).load_only(
@@ -107,10 +107,9 @@ def has_access_to_venues(user: models.User, venue_ids: list[int]) -> bool:
         offerers_models.UserOfferer.isValidated,
         offerers_models.Venue.id.in_(venue_ids),
     ]
+    have_access_to_all_venues = query.filter(*filters).count() == len(venue_ids)
 
-    query = db.session.query(query.filter(*filters).exists()).scalar()
-
-    return query
+    return have_access_to_all_venues
 
 
 def get_newly_eligible_age_18_users(since: date) -> list[models.User]:

api/src/pcapi/routes/pro/statistics.py

@@ -2,6 +2,7 @@
 from flask_login import login_required
 
 from pcapi.connectors.clickhouse import queries as clickhouse_queries
+from pcapi.core.offers.repository import venues_have_individual_and_collective_offers
 from pcapi.models.api_errors import ApiErrors
 from pcapi.routes.apis import private_api
 from pcapi.routes.serialization.statistics_serialize import StatisticsModel
@@ -26,5 +27,11 @@ def get_statistics(query: StatisticsQueryModel) -> StatisticsModel:
             status_code=422,
         )
     check_user_has_access_to_venues(current_user, venue_ids)
-    result = clickhouse_queries.YearlyAggregatedRevenueQuery().execute(tuple(venue_ids))
+    venues_have_individual, venues_have_collective = venues_have_individual_and_collective_offers(venue_ids)
+    if not venues_have_individual:
+        result = clickhouse_queries.YearlyAggregatedCollectiveRevenueQuery().execute(tuple(venue_ids))
+    elif not venues_have_collective:
+        result = clickhouse_queries.YearlyAggregatedIndividualRevenueQuery().execute(tuple(venue_ids))
+    else:
+        result = clickhouse_queries.YearlyAggregatedRevenueQuery().execute(tuple(venue_ids))
     return StatisticsModel.from_query(income_by_year=result.income_by_year)

api/tests/connectors/clickhouse/fixtures.py

@@ -14,18 +14,27 @@ def __init__(
         collective: Decimal = Decimal("12.12"),
         expected_individual: Decimal = Decimal("13.12"),
         expected_collective: Decimal = Decimal("13.12"),
+        only_collective: bool = False,
+        only_individual: bool = False,
     ) -> object:
         self.year = year
-        self.revenue = json.dumps(
-            {"individual": str(individual), "collective": str(collective), "total": str(individual + collective)}
-        )
-        self.expected_revenue = json.dumps(
-            {
-                "individual": str(expected_individual),
-                "collective": str(expected_collective),
-                "total": str(expected_individual + expected_collective),
-            }
-        )
+        if only_collective:
+            self.revenue = json.dumps({"collective": str(collective)})
+            self.expected_revenue = json.dumps({"collective": str(expected_collective)})
+        elif only_individual:
+            self.revenue = json.dumps({"individual": str(individual)})
+            self.expected_revenue = json.dumps({"individual": str(expected_individual)})
+        else:
+            self.revenue = json.dumps(
+                {"individual": str(individual), "collective": str(collective), "total": str(individual + collective)}
+            )
+            self.expected_revenue = json.dumps(
+                {
+                    "individual": str(expected_individual),
+                    "collective": str(expected_collective),
+                    "total": str(expected_individual + expected_collective),
+                }
+            )
 
 
 YEARLY_AGGREGATED_VENUE_REVENUE = [MockYearlyAggregatedRevenueQueryResult()]
@@ -35,3 +44,15 @@ def __init__(
         2022, Decimal("22.12"), Decimal("22.12"), Decimal("22.12"), Decimal("22.12")
     ),
 ]
+YEARLY_AGGREGATED_VENUE_REVENUE_MULTIPLE_YEARS_ONLY_COLLECTIVE = [
+    MockYearlyAggregatedRevenueQueryResult(only_collective=True),
+    MockYearlyAggregatedRevenueQueryResult(
+        2022, Decimal("22.12"), Decimal("22.12"), Decimal("22.12"), Decimal("22.12"), only_collective=True
+    ),
+]
+YEARLY_AGGREGATED_VENUE_REVENUE_MULTIPLE_YEARS_ONLY_INDIVIDUAL = [
+    MockYearlyAggregatedRevenueQueryResult(only_individual=True),
+    MockYearlyAggregatedRevenueQueryResult(
+        2022, Decimal("22.12"), Decimal("22.12"), Decimal("22.12"), Decimal("22.12"), only_individual=True
+    ),
+]

api/tests/routes/pro/get_statistics_test.py

@@ -3,7 +3,9 @@
 import pytest
 
 from pcapi.core import testing
+import pcapi.core.educational.factories as educational_factories
 import pcapi.core.offerers.factories as offerers_factories
+import pcapi.core.offers.factories as offers_factories
 import pcapi.core.users.factories as users_factories
 
 from tests.connectors.clickhouse import fixtures
@@ -18,10 +20,14 @@ def test_get_statistics_from_one_venue(self, run_query, client):
         offerers_factories.UserOffererFactory(user=user, offerer=offerer)
         venue = offerers_factories.VenueFactory(managingOfferer=offerer)
         venue_id = venue.id
+        educational_factories.CollectiveOfferFactory(venue=venue)
+        offers_factories.OfferFactory(venue=venue)
 
         test_client = client.with_session_auth(email=user.email)
         num_queries = testing.AUTHENTICATION_QUERIES
         num_queries += 1  # select Offerer
+        num_queries += 1  # select Offer
+        num_queries += 1  # select CollectiveOffer
         with testing.assert_num_queries(num_queries):
             run_query.return_value = fixtures.YEARLY_AGGREGATED_VENUE_REVENUE
             response = test_client.get(f"/get-statistics/?venue_ids={venue_id}")
@@ -44,10 +50,14 @@ def test_get_statistics_from_multiple_venues(self, run_query, client):
         venue2 = offerers_factories.VenueFactory(managingOfferer=offerer)
         venue_id = venue.id
         venue2_id = venue2.id
+        educational_factories.CollectiveOfferFactory(venue=venue)
+        offers_factories.OfferFactory(venue=venue)
 
         test_client = client.with_session_auth(email=user.email)
         num_queries = testing.AUTHENTICATION_QUERIES
         num_queries += 1  # select Offerer
+        num_queries += 1  # select Offer
+        num_queries += 1  # select CollectiveOffer
         with testing.assert_num_queries(num_queries):
             run_query.return_value = fixtures.YEARLY_AGGREGATED_VENUE_REVENUE
             response = test_client.get(f"/get-statistics/?venue_ids={venue_id}&venue_ids={venue2_id}")
@@ -70,10 +80,14 @@ def test_get_statistics_multiple_years(self, run_query, client):
         venue2 = offerers_factories.VenueFactory(managingOfferer=offerer)
         venue_id = venue.id
         venue2_id = venue2.id
+        educational_factories.CollectiveOfferFactory(venue=venue)
+        offers_factories.OfferFactory(venue=venue)
 
         test_client = client.with_session_auth(email=user.email)
         num_queries = testing.AUTHENTICATION_QUERIES
         num_queries += 1  # select Offerer
+        num_queries += 1  # select Offer
+        num_queries += 1  # select CollectiveOffer
         with testing.assert_num_queries(num_queries):
             run_query.return_value = fixtures.YEARLY_AGGREGATED_VENUE_REVENUE_MULTIPLE_YEARS
             response = test_client.get(f"/get-statistics/?venue_ids={venue_id}&venue_ids={venue2_id}")
@@ -92,16 +106,84 @@ def test_get_statistics_multiple_years(self, run_query, client):
             }
         }
 
+    @patch("pcapi.connectors.clickhouse.testing_backend.TestingBackend.run_query")
+    def test_get_statistics_only_collective(self, run_query, client):
+        user = users_factories.UserFactory()
+        offerer = offerers_factories.OffererFactory()
+        offerers_factories.UserOffererFactory(user=user, offerer=offerer)
+        venue = offerers_factories.VenueFactory(managingOfferer=offerer)
+        venue_id = venue.id
+        educational_factories.CollectiveOfferFactory(venue=venue)
+
+        test_client = client.with_session_auth(email=user.email)
+        num_queries = testing.AUTHENTICATION_QUERIES
+        num_queries += 1  # select Offerer
+        num_queries += 1  # select Offer
+        num_queries += 1  # select CollectiveOffer
+        with testing.assert_num_queries(num_queries):
+            run_query.return_value = fixtures.YEARLY_AGGREGATED_VENUE_REVENUE_MULTIPLE_YEARS_ONLY_COLLECTIVE
+            response = test_client.get(f"/get-statistics/?venue_ids={venue_id}")
+            assert response.status_code == 200
+        assert response.json == {
+            "incomeByYear": {
+                "2022": {
+                    "expectedRevenue": {"collective": 22.12},
+                    "revenue": {"collective": 22.12},
+                },
+                "2023": {},
+                "2024": {
+                    "expectedRevenue": {"collective": 13.12},
+                    "revenue": {"collective": 12.12},
+                },
+            }
+        }
+
+    @patch("pcapi.connectors.clickhouse.testing_backend.TestingBackend.run_query")
+    def test_get_statistics_only_individual(self, run_query, client):
+        user = users_factories.UserFactory()
+        offerer = offerers_factories.OffererFactory()
+        offerers_factories.UserOffererFactory(user=user, offerer=offerer)
+        venue = offerers_factories.VenueFactory(managingOfferer=offerer)
+        venue_id = venue.id
+        offers_factories.OfferFactory(venue=venue)
+
+        test_client = client.with_session_auth(email=user.email)
+        num_queries = testing.AUTHENTICATION_QUERIES
+        num_queries += 1  # select Offerer
+        num_queries += 1  # select Offer
+        num_queries += 1  # select CollectiveOffer
+        with testing.assert_num_queries(num_queries):
+            run_query.return_value = fixtures.YEARLY_AGGREGATED_VENUE_REVENUE_MULTIPLE_YEARS_ONLY_INDIVIDUAL
+            response = test_client.get(f"/get-statistics/?venue_ids={venue_id}")
+            assert response.status_code == 200
+        assert response.json == {
+            "incomeByYear": {
+                "2022": {
+                    "expectedRevenue": {"individual": 22.12},
+                    "revenue": {"individual": 22.12},
+                },
+                "2023": {},
+                "2024": {
+                    "expectedRevenue": {"individual": 13.12},
+                    "revenue": {"individual": 12.12},
+                },
+            }
+        }
+
     def test_get_statistics_empty_result(self, client):
         user = users_factories.UserFactory()
         offerer = offerers_factories.OffererFactory()
         offerers_factories.UserOffererFactory(user=user, offerer=offerer)
         venue = offerers_factories.VenueFactory(managingOfferer=offerer)
         venue_id = venue.id
+        educational_factories.CollectiveOfferFactory(venue=venue)
+        offers_factories.OfferFactory(venue=venue)
 
         test_client = client.with_session_auth(email=user.email)
         num_queries = testing.AUTHENTICATION_QUERIES
         num_queries += 1  # select Offerer
+        num_queries += 1  # select Offer
+        num_queries += 1  # select CollectiveOffer
         with testing.assert_num_queries(num_queries):
             response = test_client.get(f"/get-statistics/?venue_ids={venue_id}")
             assert response.status_code == 200
@@ -129,17 +211,18 @@ def test_get_statistics_with_no_venue_id_should_fail(self, client):
 class Returns403Test:
     def test_get_statistics_from_not_owned_venue_should_fail(self, client):
         user = users_factories.UserFactory()
-        user2 = users_factories.UserFactory()
         offerer = offerers_factories.OffererFactory()
-        offerers_factories.UserOffererFactory(user=user2, offerer=offerer)
+        offerers_factories.UserOffererFactory(user=user, offerer=offerer)
         venue = offerers_factories.VenueFactory(managingOfferer=offerer)
+        venue_not_belonging_to_user = offerers_factories.VenueFactory()
         venue_id = venue.id
+        foreign_venue = venue_not_belonging_to_user.id
 
         test_client = client.with_session_auth(email=user.email)
         num_queries = testing.AUTHENTICATION_QUERIES
         num_queries += 1  # select Offerer
         with testing.assert_num_queries(num_queries):
-            response = test_client.get(f"/get-statistics/?venue_ids={venue_id}")
+            response = test_client.get(f"/get-statistics/?venue_ids={venue_id}&venue_ids={foreign_venue}")
             assert response.status_code == 403
         assert response.json["global"] == [
             "Vous n'avez pas les droits d'accès suffisants pour accéder à cette information."