done

app/dependencies.py

@@ -1,31 +1,36 @@
 from fastapi import Depends, HTTPException, status
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
-from jwt import InvalidTokenError
-from app import logger
 from firebase_admin import auth
+from firebase_admin.auth import ExpiredIdTokenError, InvalidIdTokenError
 
 security = HTTPBearer()
 
 
-async def get_current_user(
+def get_current_user(
     credentials: HTTPAuthorizationCredentials = Depends(security),
 ):
-    credentials_exception = HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Could not validate credentials",
-        headers={"WWW-Authenticate": "Bearer "},
-    )
     try:
         payload = auth.verify_id_token(credentials.credentials)
-    except InvalidTokenError as e:
-        logger.info(e)
-        raise credentials_exception
+    except ExpiredIdTokenError as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token expired",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    except InvalidIdTokenError as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid token",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
     except ValueError as e:
-        logger.info(e)
-        raise credentials_exception
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid token",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
     except Exception as e:
-        logger.info(e)
-        print(e)
-        raise credentials_exception
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
     return payload

app/graphdb/main.py

@@ -1,28 +1,29 @@
-from app import driver
+from app import driver, logger
 
 
 def match_person_nodes(tx, uid1: str, uid2: str):
-    tx.run("MERGE (p1:Person {uid: " + uid1 + "})")
-    tx.run("MERGE (p2:Person {uid: " + uid2 + "})")
+    tx.run('MERGE (p1:Person {uid: "' + uid1 + '"})')
+    tx.run('MERGE (p2:Person {uid: "' + uid2 + '"})')
     tx.run(
-        "MATCH (p1:Person {uid: "
+        'MATCH (p1:Person {uid: "'
         + uid1
-        + "}) MATCH (p2:Person {uid: "
+        + '"}) MATCH (p2:Person {uid: "'
         + uid2
-        + "}) MERGE (p1)-[:FRIEND]-(p2)"
+        + '"}) MERGE (p1)-[:FRIEND]-(p2)'
     )
 
 
 async def insert2PersonAndSetFriend(uid1: str, uid2: str):
+    logger.info(uid1 + " " + uid2)
     with driver.session() as session:
         session.write_transaction(match_person_nodes, uid1, uid2)
 
 
 async def deleteFriend(uid1: str, uid2: str):
-    driver.execute_query(
-        "MATCH (p1:Person {uid: "
+    await driver.execute_query(
+        'MATCH (p1:Person {uid: "'
         + uid1
-        + "})-[r:FRIEND]-(p2:Person {uid: "
+        + '"})-[r:FRIEND]-(p2:Person {uid: "'
         + uid2
-        + "}) DELETE r"
+        + '"}) DELETE r'
     )

app/routers/friend_request.py

@@ -1,8 +1,8 @@
 import datetime
 import io
-import cv2
-from fastapi.responses import StreamingResponse
 import qrcode
+
+from fastapi.responses import StreamingResponse
 from fastapi import APIRouter, Depends, HTTPException, Response
 from app.dependencies import get_current_user
 from app import db, logger
@@ -24,13 +24,20 @@ EXPIRE_MINUTES = 15
 
 
 @router.get("")
-def getFriendRequest(user=Depends(get_current_user)):
-    if user["sub"] is None:
-        raise HTTPException(status_code=400, detail="User not found")
+def getFriendRequest(current_user=Depends(get_current_user)):
+    if current_user["sub"] is None:
+        return HTTPException(status_code=400, detail="User not found")
     friend_requests = (
-        db.collection(COLLECTION_NAME).where("inviter", "==", user["sub"]).stream()
+        db.collection(COLLECTION_NAME)
+        .where("inviter", "==", current_user["sub"])
+        .stream()
     )
-    return {"friend_requests": [Request.to_dict() for Request in friend_requests]}
+
+    return {
+        "friend_requests": [
+            {**Request.to_dict(), "id": Request.id} for Request in friend_requests
+        ]
+    }
 
 
 @router.post("")
@@ -39,9 +46,9 @@ def createRequest(user=Depends(get_current_user)):
         raise HTTPException(status_code=400, detail="User not found")
     _, fr_ref = db.collection(COLLECTION_NAME).add(
         {
-            "invitor": user["sub"],
+            "inviter": user["sub"],
             "status": RequestStatus.WAITING_INVITEE.value,
-            "expire_at": datetime.datetime.now()
+            "expire_at": datetime.datetime.now(tz=datetime.timezone.utc)
             + datetime.timedelta(minutes=EXPIRE_MINUTES),
         }
     )
@@ -59,7 +66,7 @@ def createRequest(user=Depends(get_current_user)):
 
 
 @router.patch("/{RequestId}")
-def acceptRequest(RequestId: str, user=Depends(get_current_user)):
+async def acceptRequest(RequestId: str, user=Depends(get_current_user)):
     if user["sub"] is None:
         raise HTTPException(status_code=400, detail="User not found")
 
@@ -69,6 +76,8 @@ def acceptRequest(RequestId: str, user=Depends(get_current_user)):
     if not fr.exists:
         raise HTTPException(status_code=404, detail="Friend request not found")
 
+    fr = fr.to_dict()
+
     if isRequestExpired(fr):
         raise HTTPException(status_code=400, detail="Friend request expired")
 
@@ -76,19 +85,21 @@ def acceptRequest(RequestId: str, user=Depends(get_current_user)):
         raise HTTPException(status_code=400, detail="Friend request already done")
 
     if isInviter(user, fr):
+        if isInviteeEmpty(fr):
+            raise HTTPException(status_code=400, detail="Invitee is empty")
         fr_ref.update({"status": RequestStatus.COMPLETE.value})
-        makeFriend(fr.invitee, fr.inviter)
+        await makeFriend(fr["invitee"], fr["inviter"])
         return {"status": "OK"}
 
     if isInviteeEmpty(fr) and not isInviter(user, fr):
         fr_ref.update(
             {"invitee": user["sub"], "status": RequestStatus.WAITING_INVITER.value}
         )
-        sendNotificationToInviter(fr.inviter, user)
+        sendNotificationToInviter(fr["inviter"], user)
         return {"status": "OK"}
 
 
-async def sendNotificationToInviter(inviterId: str, invitee):
+def sendNotificationToInviter(inviterId: str, invitee):
     return HTTPException(status_code=501, detail="Not implemented yet")
 
 
@@ -98,11 +109,11 @@ async def makeFriend(inviteeId: str, inviterId: str):
 
 @router.delete("/{RequestId}")
 def deleteRequest(RequestId: str, user=Depends(get_current_user)):
-    if user["sub"] is None:
+    if user.sub is None:
         raise HTTPException(status_code=400, detail="User not found")
 
     Request_ref = db.collection(COLLECTION_NAME).document(RequestId)
-    Request = Request_ref.get()
+    Request = Request_ref.get().to_dict()
 
     if not Request.exists:
         raise HTTPException(status_code=404, detail="Friend request not found")
@@ -115,16 +126,16 @@ def deleteRequest(RequestId: str, user=Depends(get_current_user)):
 
 
 def isRequestExpired(request):
-    return request.expire_at < datetime.now()
+    return request["expire_at"] < datetime.datetime.now(tz=datetime.timezone.utc)
 
 
 def isInviter(user, Request):
-    return Request.inviter == user["sub"]
+    return Request["inviter"] == user["sub"]
 
 
 def isRequestDone(Request):
-    return Request.status == RequestStatus.COMPLETE.value
+    return Request["status"] == RequestStatus.COMPLETE.value
 
 
 def isInviteeEmpty(Request):
-    return Request.invitee is None
+    return True if Request.get("invitee", None) is None else False

app/routers/image.py

@@ -19,7 +19,7 @@ async def handleImageRequest(
     try:
         img = imfrombytes(file, cv2.IMREAD_COLOR)
     except:
-        return Response(content="Failed to read image", status_code=400)
+        raise Response(content="Failed to read image", status_code=400)
 
     if raw:
         bboxes, labels = inferenceImage(img, threshold, raw)