upload

app/__init__.py

@@ -1,11 +1,14 @@
 import os
+import json
+import logging
+
 from dotenv import load_dotenv
 from mmdeploy_runtime import Detector
 from supabase import create_client, Client
 from firebase_admin import credentials, initialize_app
-import json
+from firebase_admin import firestore
+from neo4j import GraphDatabase
 
-import logging
 
 logger = logging.getLogger("uvicorn")
 logger.setLevel(logging.INFO)
@@ -13,16 +16,29 @@ logger.setLevel(logging.INFO)
 
 load_dotenv()
 
+# LOAD MODEL
 model_path = "./model"
 detector = Detector(model_path=model_path, device_name="cpu", device_id=0)
 
+# LOAD SUPABASE
 url: str = os.environ.get("SUPABASE_URL")
 key: str = os.environ.get("SUPABASE_KEY")
 supabase: Client = create_client(url, key)
 
-
+# LOAD FIREBASE ADMIN SDK
 firebase_app = initialize_app(
     credential=credentials.Certificate(
         json.loads(os.environ.get("FIREBASE_CREDENTIALS"))
     )
 )
+
+db = firestore.client()
+
+# LOAD NEO4J DB
+URI = os.environ.get("NEO4J_URI")
+AUTH = (os.environ.get("NEO4J_USERNAME"), os.environ.get("NEO4J_PASSWORD"))
+driver = GraphDatabase.driver(URI, auth=AUTH)
+driver.verify_connectivity()
+driver.execute_query(
+    "CREATE CONSTRAINT uid IF NOT EXISTS FOR (p:Person) REQUIRE p.uid IS UNIQUE"
+)

app/graphdb/main.py

@@ -0,0 +1,28 @@
+from app import driver
+
+
+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(
+        "MATCH (p1:Person {uid: "
+        + uid1
+        + "}) MATCH (p2:Person {uid: "
+        + uid2
+        + "}) MERGE (p1)-[:FRIEND]-(p2)"
+    )
+
+
+async def insert2PersonAndSetFriend(uid1: str, uid2: str):
+    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: "
+        + uid1
+        + "})-[r:FRIEND]-(p2:Person {uid: "
+        + uid2
+        + "}) DELETE r"
+    )

app/main.py

@@ -1,23 +1,25 @@
-from typing_extensions import Annotated
-from fastapi import Depends, FastAPI
+from fastapi import FastAPI
 from fastapi.responses import RedirectResponse
 
-from app.dependencies import get_current_user
-from .routers import image, video
+from app.graphdb.main import insert2PersonAndSetFriend, deleteFriend
+from .routers import image, video, friend_request, me
 
 
 app = FastAPI()
 
 app.include_router(image.router)
 app.include_router(video.router)
-
-
-@app.get("/me")
-def getProfile(current_user: Annotated[any, Depends(get_current_user)]):
-    return current_user
+app.include_router(friend_request.router)
+app.include_router(me.router)
 
 
 @app.get("/", include_in_schema=False)
 def hello():
     response = RedirectResponse(url="/docs")
     return response
+
+
+@app.get("/test")
+async def test():
+    await insert2PersonAndSetFriend("1", "2")
+    await deleteFriend("1", "2")

app/routers/friend_request.py

@@ -0,0 +1,127 @@
+import datetime
+import cv2
+import qrcode
+from fastapi import APIRouter, Depends, HTTPException, Response
+from app.dependencies import get_current_user
+from app import db
+from enum import Enum
+from app.graphdb.main import insert2PersonAndSetFriend
+
+
+router = APIRouter(prefix="/friend_request", tags=["friend_request"])
+
+
+class RequestStatus(Enum):
+    WAITING_INVITEE = "waiting_invitee"
+    WAITING_INVITER = "waiting_inviter"
+    COMPLETE = "complete"
+
+
+COLLECTION_NAME = "friend_request"
+EXPIRE_MINUTES = 15
+
+
+@router.get("")
+def getFriendRequest(user=Depends(get_current_user)):
+    if user.uid is None:
+        raise HTTPException(status_code=400, detail="User not found")
+    friend_requests = (
+        db.collection(COLLECTION_NAME).where("inviter", "==", user.uid).stream()
+    )
+    return {"friend_requests": [Request.to_dict() for Request in friend_requests]}
+
+
+@router.post("")
+def createRequest(user=Depends(get_current_user)):
+    if user.uid is None:
+        raise HTTPException(status_code=400, detail="User not found")
+    _, fr_ref = db.collection(COLLECTION_NAME).add(
+        {
+            "invitor": user.uid,
+            "status": RequestStatus.WAITING_INVITEE.value,
+            "expire_at": datetime.now() + datetime.timedelta(minutes=EXPIRE_MINUTES),
+        }
+    )
+    qr = qrcode.make(fr_ref.id)
+
+    ret, png = cv2.imencode(".jpg", qr)
+
+    if not ret:
+        fr_ref.delete()
+        return Response(content="Failed to encode image", status_code=500)
+
+    png_bytes = png.tobytes()
+
+    return Response(content=png_bytes, media_type="image/png")
+
+
+@router.patch("/{RequestId}")
+def acceptRequest(RequestId: str, user=Depends(get_current_user)):
+    if user.uid is None:
+        raise HTTPException(status_code=400, detail="User not found")
+
+    fr_ref = db.collection(COLLECTION_NAME).document(RequestId)
+    fr = fr_ref.get()
+
+    if not fr.exists:
+        raise HTTPException(status_code=404, detail="Friend request not found")
+
+    if isRequestExpired(fr):
+        raise HTTPException(status_code=400, detail="Friend request expired")
+
+    if isRequestDone(fr):
+        raise HTTPException(status_code=400, detail="Friend request already done")
+
+    if isInviter(user, fr):
+        fr_ref.update({"status": RequestStatus.COMPLETE.value})
+        makeFriend(fr.invitee, fr.inviter)
+        return {"status": "OK"}
+
+    if isInviteeEmpty(fr) and not isInviter(user, fr):
+        fr_ref.update(
+            {"invitee": user.uid, "status": RequestStatus.WAITING_INVITER.value}
+        )
+        sendNotificationToInviter(fr.inviter, user)
+        return {"status": "OK"}
+
+
+async def sendNotificationToInviter(inviterId: str, invitee):
+    pass
+
+
+async def makeFriend(inviteeId: str, inviterId: str):
+    await insert2PersonAndSetFriend(inviteeId, inviterId)
+
+
+@router.delete("/{RequestId}")
+def deleteRequest(RequestId: str, user=Depends(get_current_user)):
+    if user.uid is None:
+        raise HTTPException(status_code=400, detail="User not found")
+
+    Request_ref = db.collection(COLLECTION_NAME).document(RequestId)
+    Request = Request_ref.get()
+
+    if not Request.exists:
+        raise HTTPException(status_code=404, detail="Friend request not found")
+
+    if isInviter(user, Request):
+        Request_ref.delete()
+        return {"status": "OK"}
+    else:
+        raise HTTPException(status_code=400, detail="You are not inviter")
+
+
+def isRequestExpired(request):
+    return request.expire_at < datetime.now()
+
+
+def isInviter(user, Request):
+    return Request.inviter == user.uid
+
+
+def isRequestDone(Request):
+    return Request.status == RequestStatus.COMPLETE.value
+
+
+def isInviteeEmpty(Request):
+    return Request.invitee is None

app/routers/image.py

@@ -1,13 +1,13 @@
-from fastapi import APIRouter, File, Response, WebSocket, WebSocketDisconnect
 import cv2
 import numpy as np
+
+from fastapi import APIRouter, File, Response, WebSocket, WebSocketDisconnect
 from app.constants import classNames, colors
 from app import detector
-
 from mmcv import imfrombytes
 from app.custom_mmcv.main import imshow_det_bboxes
 
-router = APIRouter(prefix="/image")
+router = APIRouter(prefix="/image", tags=["Image"])
 
 
 @router.post("")

app/routers/me.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter, Depends
+
+from app.dependencies import get_current_user
+
+
+router = APIRouter(prefix="/me", tags=["Me"])
+
+
+@router.get("")
+def getProfile(current_user=Depends(get_current_user)):
+    return current_user
+
+
+@router.get("/friends")
+def getFriends(current_user=Depends(get_current_user)):
+    raise NotImplementedError()

app/routers/video.py

@@ -20,7 +20,7 @@ from app import supabase
 from app.dependencies import get_current_user
 from app.routers.image import inferenceImage
 
-router = APIRouter(prefix="/video")
+router = APIRouter(prefix="/video", tags=["Video"])
 
 
 @router.post("/{artifactId}")
@@ -29,7 +29,7 @@ async def handleVideoRequest(
     file: UploadFile,
     background_tasks: BackgroundTasks,
     threshold: float = 0.3,
-    user=Depends(get_current_user),
+    _=Depends(get_current_user),
 ):
     if re.search("^video\/", file.content_type) is None:
         raise HTTPException(