fix: adjust lenders endpoints

app/routers/lenders.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 
 import app.utils.lenders as utils
@@ -13,19 +13,29 @@
 
 
 @router.post(
-    "/lenders/",
+    "/lenders",
     tags=["lenders"],
     response_model=core.Lender,
 )
 @OCP_only()
 async def create_lender(
-    lender: core.Lender,
+    lender: core.LenderBase,
     current_user: core.User = Depends(get_current_user),
     session: Session = Depends(get_db),
-    user: core.User = None,
 ):
     with transaction_session(session):
-        return utils.create_lender(session, lender, user)
+        return utils.create_lender(session, lender)
+
+
+@router.get("/lenders/{lender_id}", tags=["lenders"], response_model=core.Lender)
+async def get_lender(lender_id: int, db: Session = Depends(get_db)):
+    lender = db.query(core.Lender).filter(core.Lender.id == lender_id).first()
+
+    if not lender:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Lender not found"
+        )
+    return lender
 
 
 @router.put(
@@ -39,23 +49,17 @@ async def update_lender(
     lender: core.Lender,
     current_user: core.User = Depends(get_current_user),
     session: Session = Depends(get_db),
-    user: core.User = None,
 ):
     with transaction_session(session):
         return utils.update_lender(session, lender, id)
 
 
 @router.get(
-    "/lenders/",
+    "/lenders",
     tags=["lenders"],
-    response_model=ApiSchema.LenderPagination,
+    response_model=ApiSchema.LenderListResponse,
 )
-@OCP_only()
 async def get_lenders_list(
-    page: int = Query(1, gt=0),
-    page_size: int = Query(10, gt=0),
-    current_user: core.User = Depends(get_current_user),
     session: Session = Depends(get_db),
-    user: core.User = None,
 ):
-    return utils.get_all_lenders(page, page_size, session)
+    return utils.get_all_lenders(session)

app/schema/core.py

@@ -259,10 +259,7 @@ class Borrower(SQLModel, table=True):
     )
 
 
-class Lender(SQLModel, table=True):
-    id: Optional[int] = Field(default=None, primary_key=True)
-    applications: Optional[List["Application"]] = Relationship(back_populates="lender")
-    users: Optional[List["User"]] = Relationship(back_populates="lender")
+class LenderBase(SQLModel):
     name: str = Field(default="", nullable=False, unique=True)
     email_group: str = Field(default="")
     status: str = Field(default="")
@@ -293,6 +290,12 @@ class Lender(SQLModel, table=True):
     )
 
 
+class Lender(LenderBase, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    applications: Optional[List["Application"]] = Relationship(back_populates="lender")
+    users: Optional[List["User"]] = Relationship(back_populates="lender")
+
+
 class Award(SQLModel, table=True):
     id: Optional[int] = Field(default=None, primary_key=True)
     applications: Optional[List["Application"]] = Relationship(back_populates="award")
@@ -443,3 +446,4 @@ class SetupMFA(BaseModel):
 class ApplicationWithRelations(ApplicationRead):
     borrower: Optional["Borrower"] = None
     award: Optional["Award"] = None
+    lender: Optional["Lender"] = None

app/utils/lenders.py

@@ -1,42 +1,58 @@
+import logging
+
+from fastapi import HTTPException, status
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
 
-from app.schema.api import LenderPagination
+from app.schema.api import LenderListResponse
 
 from ..schema import core
 from .general_utils import update_models
 
 
-def get_all_lenders(page: int, page_size: int, session: Session) -> LenderPagination:
+def get_all_lenders(session: Session) -> LenderListResponse:
     lenders_query = session.query(core.Lender)
 
     total_count = lenders_query.count()
 
-    lenders = lenders_query.offset((page - 1) * page_size).limit(page_size).all()
+    lenders = lenders_query.all()
 
-    return LenderPagination(
+    return LenderListResponse(
         items=lenders,
         count=total_count,
-        page=page,
-        page_size=page_size,
+        page=0,
+        page_size=total_count,
     )
 
 
-def create_lender(session: Session, payload: dict, user: core.User) -> core.Lender:
-    lender = core.Lender(**payload.dict())
-    lender.users.append(user)
+def create_lender(session: Session, payload: dict) -> core.Lender:
+    try:
+        lender = core.Lender(**payload.dict())
 
-    session.add(lender)
-    session.flush()
+        session.add(lender)
+        session.flush()
 
-    return lender
+        return lender
+    except IntegrityError as e:
+        logging.error(e)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="Lender already exists",
+        )
 
 
 def update_lender(session: Session, payload: dict, lender_id: int) -> core.Lender:
-    lender = session.query(core.Lender).filter(core.Lender.id == lender_id).first()
-
-    update_models(payload, lender)
-
-    session.add(lender)
-    session.flush()
-
-    return lender
+    try:
+        lender = session.query(core.Lender).filter(core.Lender.id == lender_id).first()
+        update_models(payload, lender)
+
+        session.add(lender)
+        session.flush()
+
+        return lender
+    except IntegrityError as e:
+        logging.error(e)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="Lender already exists",
+        )