Add leaderboard and user contribution endpoints

src/api/endpoints/contributions/leaderboard/query.py

@@ -0,0 +1,39 @@
+from typing import Sequence
+
+from sqlalchemy import select, RowMapping
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.api.endpoints.contributions.leaderboard.response import ContributionsLeaderboardResponse, \
+    ContributionsLeaderboardInnerResponse
+from src.api.endpoints.contributions.shared.contributions import ContributionsCTEContainer
+from src.db.helpers.session import session_helper as sh
+from src.db.queries.base.builder import QueryBuilderBase
+
+
+class GetContributionsLeaderboardQueryBuilder(QueryBuilderBase):
+
+    async def run(self, session: AsyncSession) -> ContributionsLeaderboardResponse:
+        cte = ContributionsCTEContainer()
+
+        query = (
+            select(
+                cte.user_id,
+                cte.count,
+            )
+            .order_by(
+                cte.count.desc()
+            )
+        )
+
+        mappings: Sequence[RowMapping] = await sh.mappings(session, query=query)
+        inner_responses = [
+            ContributionsLeaderboardInnerResponse(
+                user_id=mapping["user_id"],
+                count=mapping["count"]
+            )
+            for mapping in mappings
+        ]
+
+        return ContributionsLeaderboardResponse(
+            leaderboard=inner_responses
+        )

src/api/endpoints/contributions/leaderboard/response.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+
+class ContributionsLeaderboardInnerResponse(BaseModel):
+    user_id: int
+    count: int
+
+class ContributionsLeaderboardResponse(BaseModel):
+    leaderboard: list[ContributionsLeaderboardInnerResponse]

src/api/endpoints/contributions/routes.py

@@ -0,0 +1,33 @@
+from fastapi import APIRouter, Depends
+
+from src.api.dependencies import get_async_core
+from src.api.endpoints.contributions.leaderboard.query import GetContributionsLeaderboardQueryBuilder
+from src.api.endpoints.contributions.leaderboard.response import ContributionsLeaderboardResponse
+from src.api.endpoints.contributions.user.queries.core import GetUserContributionsQueryBuilder
+from src.api.endpoints.contributions.user.response import ContributionsUserResponse
+from src.core.core import AsyncCore
+from src.security.dtos.access_info import AccessInfo
+from src.security.manager import get_access_info
+
+contributions_router = APIRouter(
+    prefix="/contributions",
+    tags=["Contributions"],
+)
+
+@contributions_router.get("/leaderboard")
+async def get_leaderboard(
+    core: AsyncCore = Depends(get_async_core),
+    access_info: AccessInfo = Depends(get_access_info)
+) -> ContributionsLeaderboardResponse:
+    return await core.adb_client.run_query_builder(
+        GetContributionsLeaderboardQueryBuilder()
+    )
+
+@contributions_router.get("/user")
+async def get_user_contributions(
+    core: AsyncCore = Depends(get_async_core),
+    access_info: AccessInfo = Depends(get_access_info)
+) -> ContributionsUserResponse:
+    return await core.adb_client.run_query_builder(
+        GetUserContributionsQueryBuilder(access_info.user_id)
+    )

src/api/endpoints/contributions/shared/contributions.py

@@ -0,0 +1,31 @@
+from sqlalchemy import select, func, CTE, Column
+
+from src.db.models.impl.url.suggestion.relevant.user import UserURLTypeSuggestion
+
+
+class ContributionsCTEContainer:
+
+    def __init__(self):
+        self._cte = (
+            select(
+                UserURLTypeSuggestion.user_id,
+                func.count().label("count")
+            )
+            .group_by(
+                UserURLTypeSuggestion.user_id
+            )
+            .cte("contributions")
+        )
+
+    @property
+    def cte(self) -> CTE:
+        return self._cte
+
+    @property
+    def count(self) -> Column[int]:
+        return self.cte.c.count
+
+    @property
+    def user_id(self) -> Column[int]:
+        return self.cte.c.user_id
+

src/api/endpoints/contributions/user/queries/agreement/agency.py

@@ -0,0 +1,54 @@
+from sqlalchemy import select, func, exists
+
+from src.api.endpoints.contributions.user.queries.annotated_and_validated import AnnotatedAndValidatedCTEContainer
+from src.api.endpoints.contributions.user.queries.templates.agreement import AgreementCTEContainer
+from src.db.models.impl.link.url_agency.sqlalchemy import LinkURLAgency
+from src.db.models.impl.url.suggestion.agency.user import UserUrlAgencySuggestion
+
+
+def get_agency_agreement_cte_container(
+    inner_cte: AnnotatedAndValidatedCTEContainer
+) -> AgreementCTEContainer:
+
+    count_cte = (
+        select(
+            inner_cte.user_id,
+            func.count()
+        )
+        .join(
+            UserUrlAgencySuggestion,
+            inner_cte.user_id == UserUrlAgencySuggestion.user_id
+        )
+        .group_by(
+            inner_cte.user_id
+        )
+        .cte("agency_count_total")
+    )
+
+    agreed_cte = (
+        select(
+            inner_cte.user_id,
+            func.count()
+        )
+        .join(
+            UserUrlAgencySuggestion,
+            inner_cte.user_id == UserUrlAgencySuggestion.user_id
+        )
+        .where(
+            exists()
+            .where(
+                LinkURLAgency.url_id == UserUrlAgencySuggestion.url_id,
+                LinkURLAgency.agency_id == UserUrlAgencySuggestion.agency_id
+            )
+        )
+        .group_by(
+            inner_cte.user_id
+        )
+        .cte("agency_count_agreed")
+    )
+
+    return AgreementCTEContainer(
+        count_cte=count_cte,
+        agreed_cte=agreed_cte,
+        name="agency"
+    )

src/api/endpoints/contributions/user/queries/agreement/record_type.py

@@ -0,0 +1,54 @@
+from sqlalchemy import select, func, and_
+
+from src.api.endpoints.contributions.user.queries.annotated_and_validated import AnnotatedAndValidatedCTEContainer
+from src.api.endpoints.contributions.user.queries.templates.agreement import AgreementCTEContainer
+from src.db.models.impl.url.record_type.sqlalchemy import URLRecordType
+from src.db.models.impl.url.suggestion.record_type.user import UserRecordTypeSuggestion
+
+
+def get_record_type_agreement_cte_container(
+    inner_cte: AnnotatedAndValidatedCTEContainer
+) -> AgreementCTEContainer:
+
+    count_cte = (
+        select(
+            inner_cte.user_id,
+            func.count()
+        )
+        .join(
+            UserRecordTypeSuggestion,
+            UserRecordTypeSuggestion.url_id == inner_cte.url_id
+        )
+        .group_by(
+            inner_cte.user_id
+        )
+        .cte("record_type_count_total")
+    )
+
+    agreed_cte = (
+        select(
+            inner_cte.user_id,
+            func.count()
+        )
+        .join(
+            UserRecordTypeSuggestion,
+            UserRecordTypeSuggestion.url_id == inner_cte.url_id
+        )
+        .join(
+            URLRecordType,
+            and_(
+                URLRecordType.url_id == inner_cte.url_id,
+                URLRecordType.record_type == UserRecordTypeSuggestion.record_type
+            )
+        )
+        .group_by(
+            inner_cte.user_id
+        )
+        .cte("record_type_count_agreed")
+    )
+
+    return AgreementCTEContainer(
+        count_cte=count_cte,
+        agreed_cte=agreed_cte,
+        name="record_type"
+    )

src/api/endpoints/contributions/user/queries/agreement/url_type.py

@@ -0,0 +1,61 @@
+from sqlalchemy import select, func, and_
+
+from src.api.endpoints.contributions.user.queries.annotated_and_validated import AnnotatedAndValidatedCTEContainer
+from src.api.endpoints.contributions.user.queries.templates.agreement import AgreementCTEContainer
+from src.db.models.impl.flag.url_validated.sqlalchemy import FlagURLValidated
+from src.db.models.impl.url.suggestion.relevant.user import UserURLTypeSuggestion
+
+
+def get_url_type_agreement_cte_container(
+    inner_cte: AnnotatedAndValidatedCTEContainer
+) -> AgreementCTEContainer:
+
+    # Count CTE is number of User URL Type Suggestions
+    count_cte = (
+        select(
+            inner_cte.user_id,
+            func.count()
+        )
+        .join(
+            UserURLTypeSuggestion,
+            UserURLTypeSuggestion.url_id == inner_cte.url_id
+        )
+        .join(
+            FlagURLValidated,
+            FlagURLValidated.url_id == inner_cte.url_id
+        )
+        .group_by(
+            inner_cte.user_id
+        )
+        .cte("url_type_count_total")
+    )
+
+    agreed_cte = (
+        select(
+            inner_cte.user_id,
+            func.count()
+        )
+        .join(
+            UserURLTypeSuggestion,
+            UserURLTypeSuggestion.url_id == inner_cte.url_id
+        )
+        .join(
+            FlagURLValidated,
+            and_(
+                FlagURLValidated.url_id == inner_cte.url_id,
+                UserURLTypeSuggestion.type == FlagURLValidated.type
+
+            )
+        )
+        .group_by(
+            inner_cte.user_id
+        )
+        .cte("url_type_count_agreed")
+    )
+
+    return AgreementCTEContainer(
+        count_cte=count_cte,
+        agreed_cte=agreed_cte,
+        name="url_type"
+    )
+

src/api/endpoints/contributions/user/queries/annotated_and_validated.py

@@ -0,0 +1,34 @@
+from sqlalchemy import select, Column, CTE
+
+from src.db.models.impl.flag.url_validated.sqlalchemy import FlagURLValidated
+from src.db.models.impl.url.suggestion.relevant.user import UserURLTypeSuggestion
+
+
+class AnnotatedAndValidatedCTEContainer:
+
+    def __init__(self, user_id: int | None):
+        self._cte = (
+            select(
+                UserURLTypeSuggestion.user_id,
+                UserURLTypeSuggestion.url_id
+            )
+            .join(
+                FlagURLValidated,
+                FlagURLValidated.url_id == UserURLTypeSuggestion.url_id
+            )
+        )
+        if user_id is not None:
+            self._cte = self._cte.where(UserURLTypeSuggestion.user_id == user_id)
+        self._cte = self._cte.cte("annotated_and_validated")
+
+    @property
+    def cte(self) -> CTE:
+        return self._cte
+
+    @property
+    def url_id(self) -> Column[int]:
+        return self.cte.c.url_id
+
+    @property
+    def user_id(self) -> Column[int]:
+        return self.cte.c.user_id

src/api/endpoints/contributions/user/queries/core.py

@@ -0,0 +1,59 @@
+from sqlalchemy import select, RowMapping
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.api.endpoints.contributions.shared.contributions import ContributionsCTEContainer
+from src.api.endpoints.contributions.user.queries.agreement.agency import get_agency_agreement_cte_container
+from src.api.endpoints.contributions.user.queries.agreement.record_type import get_record_type_agreement_cte_container
+from src.api.endpoints.contributions.user.queries.agreement.url_type import get_url_type_agreement_cte_container
+from src.api.endpoints.contributions.user.queries.annotated_and_validated import AnnotatedAndValidatedCTEContainer
+from src.api.endpoints.contributions.user.queries.templates.agreement import AgreementCTEContainer
+from src.api.endpoints.contributions.user.response import ContributionsUserResponse, ContributionsUserAgreement
+from src.db.helpers.session import session_helper as sh
+from src.db.queries.base.builder import QueryBuilderBase
+
+
+class GetUserContributionsQueryBuilder(QueryBuilderBase):
+
+    def __init__(self, user_id: int):
+        super().__init__()
+        self.user_id = user_id
+
+    async def run(self, session: AsyncSession) -> ContributionsUserResponse:
+        inner_cte = AnnotatedAndValidatedCTEContainer(self.user_id)
+
+        contributions_cte = ContributionsCTEContainer()
+        record_type_agree: AgreementCTEContainer = get_record_type_agreement_cte_container(inner_cte)
+        agency_agree: AgreementCTEContainer = get_agency_agreement_cte_container(inner_cte)
+        url_type_agree: AgreementCTEContainer = get_url_type_agreement_cte_container(inner_cte)
+
+        query = (
+            select(
+                contributions_cte.count,
+                record_type_agree.agreement.label("record_type"),
+                agency_agree.agreement.label("agency"),
+                url_type_agree.agreement.label("url_type")
+            )
+            .join(
+                record_type_agree.cte,
+                contributions_cte.user_id == record_type_agree.user_id
+            )
+            .join(
+                agency_agree.cte,
+                contributions_cte.user_id == agency_agree.user_id
+            )
+            .join(
+                url_type_agree.cte,
+                contributions_cte.user_id == url_type_agree.user_id
+            )
+        )
+
+        mapping: RowMapping = await sh.mapping(session, query=query)
+
+        return ContributionsUserResponse(
+            count_validated=mapping.count,
+            agreement=ContributionsUserAgreement(
+                record_type=mapping.record_type,
+                agency=mapping.agency,
+                url_type=mapping.url_type
+            )
+        )