Prvni pokus o verejny pristup, sprava profilu

src/graphql_schema/entities/flight.py

@@ -15,7 +15,7 @@ from graphql_schema.entities.airport import Airport
 from graphql_schema.entities.photo import Photo
 from graphql_schema.entities.poi import PointOfInterest
 from graphql_schema.sqlalchemy_to_strawberry_type import strawberry_sqlalchemy_type, strawberry_sqlalchemy_input
-from upload_utils import get_public_url, handle_file_upload, check_directories, file_exists, delete_file
+from upload_utils import handle_file_upload, file_exists, delete_file
 from .helpers.flight import handle_aircraft_save, handle_track_edit, handle_copilot_edit, handle_weather_info
 from ..dataloaders.weather import airport_weather_info_loader
 from ..types import ComboboxInput
@@ -95,28 +95,40 @@ class Flight:
     gpx_track_url: Optional[str] = strawberry.field(resolver=load_gpx_track_url)
 
 
-def get_base_query(user_id: int):
-    return (
+def get_base_query(user_id: Optional[int], username: Optional[str] = None, is_auth: bool = False):
+    query = (
         select(models.Flight)
-        .filter(models.Flight.created_by_id == user_id)
         .filter(models.Flight.deleted.is_(False))
         .order_by(models.Flight.id.desc())
     )
 
+    if user_id:
+        query = query.filter(models.Flight.created_by_id == user_id)
+
+    if username:
+        query = query.filter(models.Flight.created_by.public_username == username)
+        
+    if not is_auth:
+        query = query.filter(models.Flight.is_public.is_(True))
+
+    return query
+
 
 @strawberry.type
 class FlightQueries:
 
     @strawberry.field
-    async def flights(root, info) -> List[Flight]:
-        query = get_base_query(info.context.user_id).order_by(models.Flight.id.desc())
-
+    async def flights(root, info, username: Optional[str] = None) -> List[Flight]:
+        query = (
+            get_base_query(user_id=info.context.user_id, username=username, is_auth=bool(info.context.user_id))
+            .order_by(models.Flight.id.desc())
+        )
         return (await info.context.db.scalars(query)).all()
 
     @strawberry.field
-    async def flight(root, info, id: int) -> Flight:
+    async def flight(root, info, id: int, username: Optional[str] = None) -> Flight:
         query = (
-            get_base_query(info.context.user_id)
+            get_base_query(user_id=info.context.user_id, username=username, is_auth=bool(info.context.user_id))
             .filter(models.Flight.id == id)
             .filter(models.Flight.deleted.is_(False))
         )
@@ -176,7 +188,7 @@ class EditFlightMutation:
         # TODO: umoznit editovat jen vlastni lety!
 
         flight = (await info.context.db.scalars(
-            get_base_query(info.context.user_id).filter(models.Flight.id == id)
+            get_base_query(user_id=info.context.user_id, is_auth=bool(info.context.user_id)).filter(models.Flight.id == id)
         )).one()
 
         data = input.to_dict()
@@ -221,7 +233,7 @@ class DeleteFlightMutation:
     async def delete_flight(self, info, id: int) -> Flight:
         flight = (
             (await info.context.db.scalars(
-                get_base_query(info.context.user_id)
+                get_base_query(user_id=info.context.user_id, is_auth=True)
                 .filter(models.Flight.id == id))
              )
             .one()

src/graphql_schema/entities/user.py

@@ -1,25 +1,90 @@
+from typing import Optional
 import strawberry
+from graphql import GraphQLError
+from passlib.hash import bcrypt
 from sqlalchemy import select
+from strawberry.file_uploads import Upload
+from database import models
 from database.models import User
-from graphql_schema.sqlalchemy_to_strawberry_type import strawberry_sqlalchemy_type
+from graphql_schema.sqlalchemy_to_strawberry_type import strawberry_sqlalchemy_type, strawberry_sqlalchemy_input
+from upload_utils import handle_file_upload, delete_file
 
 
 @strawberry_sqlalchemy_type(User, exclude_fields=['password_hashed'])
-class UserType:
-    pass
+class User:
 
+    async def load_avatar_image_url(root):
+        if not root.avatar_image_filename:
+            return None
 
-@strawberry.type
-class LoginResultType:
-    logged_user = UserType
-    access_token: str
-    refresh_token: str
+        return f"http://localhost:8000/uploads/profile/{root.id}/{root.avatar_image_filename}"
+
+    async def load_title_image_url(root):
+        if not root.title_image_filename:
+            return "http://localhost:8000/static/default-title-image.jpg"
+
+        return f"http://localhost:8000/uploads/profile/{root.id}/{root.title_image_filename}"
+
+    avatar_image_url: Optional[str] = strawberry.field(resolver=load_avatar_image_url)
+    title_image_url: str = strawberry.field(resolver=load_title_image_url)
 
 
 @strawberry.type
 class UserQueries:
+    @strawberry.field
+    async def user(root, info, username: str) -> User:
+        print("username")
+        if len(username) == 0:
+            raise GraphQLError("Username not set!")
+
+        return (await info.context.db.scalars(
+            select(models.User).filter_by(public_username=username)
+        )).one()
 
     @strawberry.field
-    async def logged_user(root, info) -> UserType:
-        query = select(User).filter_by(id=info.context.user_id)
-        return (await info.context.db.scalars(query)).first()
+    async def logged_user(root, info) -> User:
+        return (await info.context.db.scalars(
+            select(models.User).filter_by(id=info.context.user_id)
+        )).one()
+
+
+@strawberry.type
+class EditUserMutation:
+    @strawberry_sqlalchemy_input(
+        models.User,
+        exclude_fields=['id', 'email', 'avatar_image_filename', 'password_hashed', 'title_image_filename'],
+        all_optional=True
+    )
+    class EditUserInput:
+        old_password: Optional[str] = None
+        new_password: Optional[str] = None
+        avatar_image: Optional[Upload] = None
+        title_image: Optional[Upload] = None
+
+    @strawberry.mutation
+    async def edit_logged_user(root, info, input: EditUserInput) -> User:
+        user = (await info.context.db.scalars(
+            select(models.User).filter_by(id=info.context.user_id)
+        )).one()
+
+        user_image_path = f"/app/uploads/profile/{user.id}"
+        data = input.to_dict()
+        if input.avatar_image:
+            if user.avatar_image_filename:
+                delete_file(f"{user_image_path}/{user.avatar_image_filename}", silent=True)
+
+            data['avatar_image_filename'] = await handle_file_upload(input.avatar_image, user_image_path)
+
+        if input.title_image:
+            if user.title_image_filename:
+                delete_file(f"{user_image_path}/{user.title_image_filename}", silent=True)
+
+            data['title_image_filename'] = await handle_file_upload(input.title_image, user_image_path)
+
+        if input.old_password and input.new_password:
+            if not bcrypt.verify(input.old_password, user.password_hashed):
+                raise GraphQLError("Bad password")
+
+            data['password_hashed'] = bcrypt.hash(input.new_password)
+
+        return await models.User.update(info.context.db, obj=user, data=data)