Merge pull request #38 from PythonFloripa/feature/#29

Feature/#29

Author: Gildofj

.gitignore

@@ -207,4 +207,4 @@ marimo/_lsp/
 __marimo__/
 
 # SQLiteDB
-pynewsdb.db
+pynewsdb.db

app/main.py

@@ -27,6 +27,6 @@ async def lifespan(app: FastAPI):
 )
 
 
-app.include_router(setup_router_v2(), prefix="/api") 
+app.include_router(setup_router_v2(), prefix="/api")
 
 logger.info("PyNews Server Starter")

app/routers/authentication.py

@@ -31,6 +31,7 @@ async def authenticate_community(
             return None
         return found_community
 
+    # Teste
     async def get_current_community(
         request: Request,
         token: Annotated[str, Depends(oauth2_scheme)],

app/routers/libraries/routes.py

@@ -1,15 +1,24 @@
-from fastapi import APIRouter, Request, status
+from fastapi import APIRouter, HTTPException, Request, status
 from pydantic import BaseModel
 
 from app.schemas import Library as LibrarySchema
-from app.services.database.models.libraries import Library
-from app.services.database.orm.library import insert_library
+from app.schemas import Subscription as SubscriptionSchema
+from app.services.database.models import Library, Subscription
+from app.services.database.orm.library import (
+    get_library_ids_by_multiple_names,
+    insert_library,
+)
+from app.services.database.orm.subscription import upsert_multiple_subscription
 
 
 class LibraryResponse(BaseModel):
     status: str = "Library created successfully"
 
 
+class SubscribeLibraryResponse(BaseModel):
+    status: str = "Subscribed in libraries successfully"
+
+
 def setup():
     router = APIRouter(prefix="/libraries", tags=["libraries"])
 
@@ -24,16 +33,51 @@ async def create_library(
         request: Request,
         body: LibrarySchema,
     ):
-        await insert_library(
-            Library(
-                library_name=body.library_name,
-                user_email="",
-                releases_url=body.releases_url.encoded_string(),
-                logo=body.logo.encoded_string(),
-            ),
-            request.app.db_session_factory,
+        library = Library(
+            library_name=body.library_name,
+            user_email="",  # TODO: Considerar obter o email do usuário autenticado
+            releases_url=body.releases_url.encoded_string(),
+            logo=body.logo.encoded_string(),
         )
+        try:
+            await insert_library(library, request.app.db_session_factory)
+            return LibraryResponse()
+        except Exception as e:
+            raise HTTPException(
+                status_code=500, detail=f"Failed to create library: {e}"
+            )
+
+    @router.post(
+        "/subscribe",
+        response_model=SubscribeLibraryResponse,
+        status_code=status.HTTP_200_OK,
+        summary="Subscribe to receive library updates",
+        description=(
+            "Subscribe to multiple libs and tags to receive libs updates"
+        ),
+    )
+    async def subscribe_libraries(
+        request: Request,
+        body: SubscriptionSchema,
+    ):
+        try:
+            library_ids = await get_library_ids_by_multiple_names(
+                body.libraries_list, request.app.db_session_factory
+            )
+
+            subscriptions = [
+                Subscription(email=body.email, tags=body.tags, library_id=id)
+                for id in library_ids
+            ]
+
+            await upsert_multiple_subscription(
+                subscriptions, request.app.db_session_factory
+            )
 
-        return LibraryResponse()
+            return SubscribeLibraryResponse()
+        except Exception as e:
+            raise HTTPException(
+                status_code=500, detail=f"Subscription failed: {e}"
+            )
 
     return router

app/schemas.py

@@ -32,14 +32,14 @@ class TokenPayload(BaseModel):
 
 
 # Subscription Class
-class TagEnum(str, Enum):
-    bug_fix = "bug_fix"
-    update = "update"
-    deprecate = "deprecate"
-    new_feature = "new_feature"
-    security_fix = "security_fix"
+class SubscriptionTagEnum(str, Enum):
+    UPDATE = "update"
+    BUG_FIX = "bug_fix"
+    NEW_FEATURE = "new_feature"
+    SECURITY_FIX = "security_fix"
 
 
 class Subscription(BaseModel):
-    tags: List[TagEnum]
+    email: str
+    tags: List[SubscriptionTagEnum]
     libraries_list: List[str]

app/services/database/models/subscriptions.py

@@ -1,12 +1,17 @@
-from typing import Optional
+from typing import List, Optional
 
-from sqlmodel import SQLModel, Field
+from schemas import SubscriptionTagEnum
+from sqlalchemy import JSON, Column
+from sqlmodel import Field, SQLModel
 
 
 class Subscription(SQLModel, table=True):
-    __tablename__ = 'subscriptions'
+    __tablename__ = "subscriptions"  # type: ignore
 
     id: Optional[int] = Field(default=None, primary_key=True)
     email: str
-    tags: str
-    community_id: Optional[int] = Field(default=None, foreign_key="communities.id")
+    tags: List[SubscriptionTagEnum] = Field(sa_column=Column(JSON))
+    community_id: Optional[int] = Field(
+        default=None, foreign_key="communities.id"
+    )
+    library_id: Optional[int] = Field(default=None, foreign_key="libraries.id")

app/services/database/orm/library.py

@@ -1,13 +1,28 @@
+from typing import List
+
+from sqlmodel import func, select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from app.services.database.models.libraries import Library
+from app.services.database.models import Library
 
 
 async def insert_library(
     library: Library,
     session: AsyncSession,
-):
+) -> Library:
     session.add(library)
     await session.commit()
     await session.refresh(library)
     return library
+
+
+async def get_library_ids_by_multiple_names(
+    names: List[str],
+    session: AsyncSession,
+) -> List[int]:
+    lower_case_names = [name.lower() for name in names]
+    statement = select(Library.id).where(
+        func.lower(Library.library_name).in_(lower_case_names)
+    )
+    result = await session.exec(statement)
+    return [id for id in result.all() if id is not None]

app/services/database/orm/subscription.py

@@ -0,0 +1,46 @@
+from typing import Dict, List, Tuple
+
+from sqlalchemy import tuple_
+from sqlmodel import select
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from app.services.database.models.subscriptions import Subscription
+
+
+async def upsert_multiple_subscription(
+    subscriptions: List[Subscription],
+    session: AsyncSession,
+) -> List[Subscription]:
+    if not subscriptions:
+        return []
+
+    incoming_map: Dict[Tuple[str, int], Subscription] = {
+        (sub.email, sub.library_id): sub for sub in subscriptions
+    }
+
+    keys_to_check = incoming_map.keys()
+    stmt = select(Subscription).where(
+        tuple_(Subscription.email, Subscription.library_id).in_(keys_to_check)
+    )
+    result = await session.exec(stmt)
+    existing_subscriptions = result.all()
+    existing_map: Dict[Tuple[str, int], Subscription] = {
+        (sub.email, sub.library_id): sub for sub in existing_subscriptions
+    }
+
+    new_subscriptions: List[Subscription] = []
+    for key, sub_to_upsert in incoming_map.items():
+        if existing_sub := existing_map.get(key):
+            existing_sub.tags = sub_to_upsert.tags
+        else:
+            new_subscriptions.append(sub_to_upsert)
+
+    session.add_all(new_subscriptions)
+    await session.commit()
+
+    all_subs = list(existing_subscriptions) + new_subscriptions
+
+    for sub in all_subs:
+        await session.refresh(sub)
+
+    return all_subs

tests/test_libraries.py

@@ -1,5 +1,6 @@
 import pytest
 import pytest_asyncio
+from httpx import AsyncClient
 from services.database.models import Community, Library
 from sqlmodel import select
 from sqlmodel.ext.asyncio.session import AsyncSession
@@ -17,22 +18,52 @@ async def community(session: AsyncSession):
 @pytest.mark.asyncio
 async def test_insert_libraries(session: AsyncSession, community: Community):
     library = Library(
-       library_name="DevOps",
-       user_email="[email protected]",
-       releases_url="http://teste.com",
-       logo="logo",
-       community_id=community.id,
-   )
+        library_name="Python",
+        user_email="[email protected]",
+        releases_url="http://teste.com",
+        logo="logo",
+        community_id=community.id,
+    )
     session.add(library)
     await session.commit()
 
-    statement = select(Library).where(Library.library_name == "DevOps")
+    statement = select(Library).where(Library.library_name == "Python")
     result = await session.exec(statement)
     found = result.first()
 
     assert found is not None
-    assert found.library_name == "DevOps"
+    assert found.library_name == "Python"
     assert found.user_email == "[email protected]"
     assert found.releases_url == "http://teste.com"
     assert found.logo == "logo"
     assert found.community_id == community.id
+
+
+@pytest.mark.asyncio
+async def test_post_libraries_endpoint(
+    async_client: AsyncClient, session: AsyncSession
+):
+    body = {
+        "library_name": "Python from API",
+        "releases_url": "http://teste.com/",
+        "logo": "http://teste.com/",
+    }
+
+    response = await async_client.post(
+        "/api/libraries",
+        json=body,
+        headers={"Content-Type": "application/json"},
+    )
+
+    assert response.status_code == 200
+    assert response.json()["status"] == "Library created successfully"
+
+    statement = select(Library).where(
+        Library.library_name == body["library_name"]
+    )
+    result = await session.exec(statement)
+    created_library = result.first()
+
+    assert created_library is not None
+    assert created_library.releases_url == body["releases_url"]
+    assert created_library.logo == body["logo"]

tests/test_subscriptions.py

@@ -1,5 +1,7 @@
 import pytest
 import pytest_asyncio
+from httpx import AsyncClient
+from schemas import SubscriptionTagEnum
 from services.database.models import Community, Subscription
 from sqlmodel import select
 from sqlmodel.ext.asyncio.session import AsyncSession
@@ -18,12 +20,15 @@ async def community(session: AsyncSession):
 async def test_insert_subscription(session: AsyncSession, community: Community):
     subscription = Subscription(
         email="[email protected]",
-        tags="teste,Python",
+        tags=[SubscriptionTagEnum.BUG_FIX, SubscriptionTagEnum.UPDATE],
         community_id=community.id,
     )
     session.add(subscription)
     await session.commit()
 
+    statement = select(Subscription).where(
+        Subscription.email == "[email protected]"
+    )
     statement = select(Subscription).where(
         Subscription.email == "[email protected]"
     )
@@ -32,5 +37,57 @@ async def test_insert_subscription(session: AsyncSession, community: Community):
 
     assert found is not None
     assert found.email == "[email protected]"
-    assert found.tags == "teste,Python"
+    assert found.tags == [
+        SubscriptionTagEnum.BUG_FIX,
+        SubscriptionTagEnum.UPDATE,
+    ]
     assert found.community_id == community.id
+
+
+@pytest_asyncio.fixture
+async def preset_library(async_client: AsyncClient):
+    body1 = {
+        "library_name": "Python",
+        "releases_url": "http://teste.com/",
+        "logo": "http://teste.com/",
+    }
+
+    response1 = await async_client.post(
+        "/api/libraries",
+        json=body1,
+        headers={"Content-Type": "application/json"},
+    )
+
+    assert response1.status_code == 200
+
+    body2 = {
+        "library_name": "Django",
+        "releases_url": "http://teste.com/",
+        "logo": "http://teste.com/",
+    }
+
+    response2 = await async_client.post(
+        "/api/libraries",
+        json=body2,
+        headers={"Content-Type": "application/json"},
+    )
+
+    assert response2.status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_post_subscribe_endpoint(async_client: AsyncClient):
+    body = {
+        "email": "[email protected]",
+        "tags": ["bug_fix", "update"],
+        "libraries_list": ["Python", "Django"],
+    }
+
+    response = await async_client.post(
+        "/api/libraries/subscribe",
+        json=body,
+        headers={"Content-Type": "application/json"},
+    )
+
+    assert response.status_code == 200
+    assert response.json()["status"] == "Subscribed in libraries successfully"