Further cleanup

classquiz/oauth/__init__.py

@@ -22,7 +22,7 @@ router.include_router(github.router, prefix="/github")
 router.include_router(custom.router, prefix="/custom")
 
 
-async def rememberme_middleware(request: Request, call_next):
+async def rememberme_middleware(request: Request, call_next) -> Response:
     rememberme_cookie = request.cookies.get("rememberme_token")
     bearer_token = request.cookies.get("access_token")
     conditions_to_handle_met = True
@@ -41,13 +41,13 @@ async def rememberme_middleware(request: Request, call_next):
 
     # Verifying the bearer
     try:
-        jwt.decode(
+        _ = jwt.decode(
             param, settings.secret_key, algorithms=["HS256"]
         )  # checking if the token is valid, throws error if not
         conditions_to_handle_met = False
     except JWTError:
         try:
-            jws.verify(
+            _ = jws.verify(
                 param, settings.secret_key, algorithms=["HS256"]
             )  # Verifying only the signature of the jwt, throws error if signature is invalid
         except JWSError:

classquiz/oauth/authenticate_user.py

@@ -14,18 +14,19 @@ from classquiz.auth import create_access_token
 settings = settings()
 
 
-async def log_user_in(user: User, request: Request, response: Response):
+async def log_user_in(user: User | None, request: Request, response: Response):
     if user is None:
         raise HTTPException(status_code=401, detail="User not matched!")
     remote_ip = None
-    if request.headers.get("X-Forwarded-For") is None:
+    forwarded_for_header = request.headers.get("X-Forwarded-For")
+    if forwarded_for_header is None:
         remote_ip = request.client.host
 
     else:
-        if "," in request.headers.get("X-Forwarded-For"):
-            remote_ip = request.headers.get("X-Forwarded-For").split(", ")[0]
+        if "," in forwarded_for_header:
+            remote_ip = forwarded_for_header.split(", ")[0]
         else:
-            remote_ip = request.headers.get("X-Forwarded-For")
+            remote_ip = forwarded_for_header
     session_key = os.urandom(32).hex()
     user_session = UserSession(
         user=user,
@@ -47,7 +48,11 @@ async def log_user_in(user: User, request: Request, response: Response):
         max_age=60 * 60 * 24 * 365,
     )
     response.set_cookie(
-        key="rememberme_token", value=session_key, httponly=True, samesite="lax", max_age=60 * 60 * 24 * 365
+        key="rememberme_token",
+        value=session_key,
+        httponly=True,
+        samesite="lax",
+        max_age=60 * 60 * 24 * 365,
     )
     return {"access_token": access_token, "token_type": "bearer"}
 

classquiz/oauth/custom.py

@@ -77,43 +77,27 @@ async def auth(request: Request, response: Response):
     except (TypeError, ValidationError):
         raise HTTPException(status_code=401, detail="Something went wrong.")
 
-    user_in_db = await User.objects.get_or_none(email=user_data.email)
-    if user_in_db is None:
-        # REGISTER USER
-        try:
-            await User.objects.create(
-                id=uuid.uuid4(),
-                email=user_data.email,
-                username=user_data.preferred_username,
-                verified=user_data.email_verified,
-                auth_type=UserAuthTypes.CUSTOM,
-                google_uid=user_data.sub.hex,
-                avatar=gzipped_user_avatar(),
-            )
-        # skipcq: PYL-W0703
-        except Exception as e:
-            if type(e) is asyncpg.exceptions.UniqueViolationError:
-                error = True
-                counter = 1
-                while error:
-                    try:
-                        await User.objects.create(
-                            id=uuid.uuid4(),
-                            email=user_data.email,
-                            username=f"{user_data.preferred_username}{counter}",
-                            verified=user_data.email_verified,
-                            auth_type=UserAuthTypes.CUSTOM,
-                            google_uid=user_data.sub.hex,
-                            avatar=gzipped_user_avatar(),
-                        )
-                        error = False
-                    except asyncpg.exceptions.UniqueViolationError:
-                        counter += 1
-                        error = True
-            else:
-                raise HTTPException(status_code=500, detail=str(e))
+    try:
+        await User.objects.create(
+            id=uuid.uuid4(),
+            email=user_data.email,
+            username=user_data.preferred_username,
+            verified=user_data.email_verified,
+            auth_type=UserAuthTypes.CUSTOM,
+            google_uid=user_data.sub.hex,
+            avatar=gzipped_user_avatar(),
+        )
+    # skipcq: PYL-W0703
+    except asyncpg.exceptions.UniqueViolationError:
+        # Most likely a duplicate email/username, not UUID.
+        raise HTTPException(status_code=400, detail="User already exists.")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
     user = await User.objects.get_or_none(
-        email=user_data.email, google_uid=user_data.sub.hex, auth_type=UserAuthTypes.CUSTOM, verified=True
+        email=user_data.email,
+        google_uid=user_data.sub.hex,
+        auth_type=UserAuthTypes.CUSTOM,
+        verified=True,
     )
     print(user_data)
 

classquiz/oauth/github.py

@@ -4,7 +4,6 @@
 
 
 import uuid
-from typing import Optional
 
 import asyncpg
 import authlib.integrations.base_client
@@ -35,43 +34,43 @@ class Plan(BaseModel):
 class GitHubOauthResponse(BaseModel):
     login: str
     id: int
-    email: Optional[str] = None
-    node_id: Optional[str] = None
-    avatar_url: Optional[str] = None
-    gravatar_id: Optional[str] = None
-    url: Optional[str] = None
-    html_url: Optional[str] = None
-    followers_url: Optional[str] = None
-    following_url: Optional[str] = None
-    gists_url: Optional[str] = None
-    starred_url: Optional[str] = None
-    subscriptions_url: Optional[str] = None
-    organizations_url: Optional[str] = None
-    repos_url: Optional[str] = None
-    events_url: Optional[str] = None
-    received_events_url: Optional[str] = None
-    type: Optional[str] = None
-    site_admin: Optional[bool] = None
-    name: Optional[str] = None
-    company: Optional[str] = None
-    blog: Optional[str] = None
-    location: Optional[str] = None
-    hireable: Optional[bool] = None
-    bio: Optional[str] = None
-    twitter_username: Optional[str] = None
-    public_repos: Optional[int] = None
-    public_gists: Optional[int] = None
-    followers: Optional[int] = None
-    following: Optional[int] = None
+    email: str | None = None
+    node_id: str | None = None
+    avatar_url: str | None = None
+    gravatar_id: str | None = None
+    url: str | None = None
+    html_url: str | None = None
+    followers_url: str | None = None
+    following_url: str | None = None
+    gists_url: str | None = None
+    starred_url: str | None = None
+    subscriptions_url: str | None = None
+    organizations_url: str | None = None
+    repos_url: str | None = None
+    events_url: str | None = None
+    received_events_url: str | None = None
+    type: str | None = None
+    site_admin: bool | None = None
+    name: str | None = None
+    company: str | None = None
+    blog: str | None = None
+    location: str | None = None
+    hireable: bool | None = None
+    bio: str | None = None
+    twitter_username: str | None = None
+    public_repos: int | None = None
+    public_gists: int | None = None
+    followers: int | None = None
+    following: int | None = None
     created_at: datetime
     updated_at: datetime
-    private_gists: Optional[int] = None
-    total_private_repos: Optional[int] = None
-    owned_private_repos: Optional[int] = None
-    disk_usage: Optional[int] = None
-    collaborators: Optional[int] = None
-    two_factor_authentication: Optional[bool] = None
-    plan: Optional[Plan] = None
+    private_gists: int | None = None
+    total_private_repos: int | None = None
+    owned_private_repos: int | None = None
+    disk_usage: int | None = None
+    collaborators: int | None = None
+    two_factor_authentication: bool | None = None
+    plan: Plan | None = None
 
 
 @router.get("/login")
@@ -107,39 +106,20 @@ async def auth(request: Request, response: Response):
     user_data = GitHubOauthResponse(**data)
     if user_data.email is None:
         return RedirectResponse("/account/oauth-error?error=email")
-    user_in_db = await User.objects.get_or_none(email=user_data.email)
-    if user_in_db is None:
         # REGISTER USER
-        try:
-            await User.objects.create(
-                id=uuid.uuid4(),
-                email=user_data.email,
-                username=user_data.login,
-                verified=True,
-                auth_type=UserAuthTypes.GITHUB,
-                avatar=gzipped_user_avatar(),
-            )
-        # skipcq: PYL-W0703
-        except Exception as e:
-            if type(e) is asyncpg.exceptions.UniqueViolationError:
-                error = True
-                counter = 1
-                while error:
-                    try:
-                        await User.objects.create(
-                            id=uuid.uuid4(),
-                            email=user_data.email,
-                            username=user_data.login,
-                            verified=True,
-                            auth_type=UserAuthTypes.GITHUB,
-                            avatar=gzipped_user_avatar(),
-                        )
-                        error = False
-                    except asyncpg.exceptions.UniqueViolationError:
-                        counter += 1
-                        error = True
-            else:
-                raise HTTPException(status_code=500, detail=str(e))
+    try:
+        await User.objects.create(
+            id=uuid.uuid4(),
+            email=user_data.email,
+            username=user_data.login,
+            verified=True,
+            auth_type=UserAuthTypes.GITHUB,
+            avatar=gzipped_user_avatar(),
+        )
+    except asyncpg.exceptions.UniqueViolationError:
+        raise HTTPException(status_code=400, detail="User already exists.")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
     user = await User.objects.get_or_none(
         email=user_data.email,
         username=user_data.login,

classquiz/oauth/google.py

@@ -79,43 +79,26 @@ async def auth(request: Request, response: Response):
         user_data = OauthGoogleResponse(**user_data).userinfo
     except (TypeError, ValidationError):
         raise HTTPException(status_code=401, detail="Something went wrong.")
-    user_in_db = await User.objects.get_or_none(email=user_data.email)
-    if user_in_db is None:
         # REGISTER USER
-        try:
-            await User.objects.create(
-                id=uuid.uuid4(),
-                email=user_data.email,
-                username=user_data.name,
-                verified=user_data.email_verified,
-                auth_type=UserAuthTypes.GOOGLE,
-                google_uid=user_data.sub,
-                avatar=gzipped_user_avatar(),
-            )
-        # skipcq: PYL-W0703
-        except Exception as e:
-            if type(e) is asyncpg.exceptions.UniqueViolationError:
-                error = True
-                counter = 1
-                while error:
-                    try:
-                        await User.objects.create(
-                            id=uuid.uuid4(),
-                            email=user_data.email,
-                            username=f"{user_data.name}{counter}",
-                            verified=user_data.email_verified,
-                            auth_type=UserAuthTypes.GOOGLE,
-                            google_uid=user_data.sub,
-                            avatar=gzipped_user_avatar(),
-                        )
-                        error = False
-                    except asyncpg.exceptions.UniqueViolationError:
-                        counter += 1
-                        error = True
-            else:
-                raise HTTPException(status_code=500, detail=str(e))
+    try:
+        await User.objects.create(
+            id=uuid.uuid4(),
+            email=user_data.email,
+            username=user_data.name,
+            verified=user_data.email_verified,
+            auth_type=UserAuthTypes.GOOGLE,
+            google_uid=user_data.sub,
+            avatar=gzipped_user_avatar(),
+        )
+    except asyncpg.exceptions.UniqueViolationError:
+        raise HTTPException(status_code=400, detail="User already exists.")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
     user = await User.objects.get_or_none(
-        email=user_data.email, google_uid=user_data.sub, auth_type=UserAuthTypes.GOOGLE, verified=True
+        email=user_data.email,
+        google_uid=user_data.sub,
+        auth_type=UserAuthTypes.GOOGLE,
+        verified=True,
     )
 
     await log_user_in(user=user, request=request, response=response)