Album covers added

classes/models.py

@@ -7,6 +7,12 @@ class Photo(BaseModel):
     hash: str
     filename: str
 
+class Video(BaseModel):
+    id: str
+    album: str
+    hash: str
+    filename: str
+
 class Album(BaseModel):
     id: str
     name: str

extensions/albums.py

@@ -30,7 +30,7 @@ async def album_create(name: str, title: str, current_user: User = Security(get_
 
     makedirs(path.join("data", "users", current_user.user, "albums", name), exist_ok=True)
 
-    uploaded = col_albums.insert_one( {"user": current_user.user, "name": name, "title": title} )
+    uploaded = col_albums.insert_one( {"user": current_user.user, "name": name, "title": title, "cover": None} )
 
     return UJSONResponse(
         {
@@ -52,7 +52,7 @@ async def album_find(q: str, current_user: User = Security(get_current_active_us
     return UJSONResponse(output)
 
 @app.patch("/albums/{id}", response_class=UJSONResponse, response_model=AlbumModified, description="Modify album's name or title by id")
-async def album_patch(id: str, name: Union[str, None] = None, title: Union[str, None] = None, current_user: User = Security(get_current_active_user, scopes=["albums.write"])):
+async def album_patch(id: str, name: Union[str, None] = None, title: Union[str, None] = None, cover: Union[str, None] = None, current_user: User = Security(get_current_active_user, scopes=["albums.write"])):
 
     try:
         album = col_albums.find_one( {"_id": ObjectId(id)} )
@@ -80,17 +80,24 @@ async def album_patch(id: str, name: Union[str, None] = None, title: Union[str,
     else:
         name = album["name"]
 
-    col_albums.update_one( {"_id": ObjectId(id)}, {"$set": {"name": name, "title": title}} )
+    if cover is not None:
+        image = col_photos.find_one( {"_id": ObjectId(cover), "album": album["name"]} )
+        cover = image["_id"].__str__() if image is not None else album["cover"]
+    else:
+        cover = album["cover"]
+
+    col_albums.update_one( {"_id": ObjectId(id)}, {"$set": {"name": name, "title": title, "cover": cover}} )
 
     return UJSONResponse(
         {
             "name": name,
-            "title": title
+            "title": title,
+            "cover": cover
         }
     )
 
 @app.put("/albums/{id}", response_class=UJSONResponse, response_model=AlbumModified, description="Modify album's name and title by id")
-async def album_put(id: str, name: str, title: str, current_user: User = Security(get_current_active_user, scopes=["albums.write"])):
+async def album_put(id: str, name: str, title: str, cover: str, current_user: User = Security(get_current_active_user, scopes=["albums.write"])):
 
     try:
         album = col_albums.find_one( {"_id": ObjectId(id)} )
@@ -108,18 +115,22 @@ async def album_put(id: str, name: str, title: str, current_user: User = Securit
     if 2 > len(title) > 40:
         return HTTPException(status_code=HTTP_406_NOT_ACCEPTABLE, detail="Album title must be >2 and <40 characters.")
 
+    image = col_photos.find_one( {"_id": ObjectId(cover), "album": album["name"]} )
+    cover = image["_id"].__str__() if image is not None else None # type: ignore
+    
     rename(
         path.join("data", "users", current_user.user, "albums", album["name"]),
         path.join("data", "users", current_user.user, "albums", name)
     )
 
     col_photos.update_many( {"user": current_user.user, "album": album["name"]}, {"$set": {"album": name}} )
-    col_albums.update_one( {"_id": ObjectId(id)}, {"$set": {"name": name, "title": title}} )
+    col_albums.update_one( {"_id": ObjectId(id)}, {"$set": {"name": name, "title": title, "cover": cover}} )
 
     return UJSONResponse(
         {
             "name": name,
-            "title": title
+            "title": title,
+            "cover": cover
         }
     )
 

extensions/photos.py

@@ -114,6 +114,11 @@ async def photo_delete(id: str, current_user: User = Security(get_current_active
     except InvalidId:
         return HTTPException(status_code=HTTP_404_NOT_FOUND, detail="Could not find an image with such id.")
 
+    album = col_albums.find_one( {"name": image["album"]} )
+
+    if album is not None and album["cover"] == image["_id"].__str__():
+        col_albums.update_one( {"name": image["album"]}, {"$set": {"cover": None}} )
+
     remove(path.join("data", "users", current_user.user, "albums", image["album"], image["filename"]))
 
     return Response(status_code=HTTP_204_NO_CONTENT)

extensions/videos.py

@@ -0,0 +1,129 @@
+import re
+import pickle
+from secrets import token_urlsafe
+from magic import Magic
+from datetime import datetime
+from os import makedirs, path, remove
+from classes.models import Video, SearchResults
+from modules.security import User, get_current_active_user
+from modules.app import app
+from modules.database import col_videos, col_albums, col_tokens
+from bson.objectid import ObjectId
+from bson.errors import InvalidId
+
+from fastapi import HTTPException, UploadFile, Security
+from fastapi.responses import UJSONResponse, Response
+from starlette.status import HTTP_204_NO_CONTENT, HTTP_400_BAD_REQUEST, HTTP_401_UNAUTHORIZED, HTTP_404_NOT_FOUND
+
+
+@app.post("/albums/{album}/videos", response_class=UJSONResponse, response_model=Video, description="Upload a video to album")
+async def video_upload(file: UploadFile, album: str, current_user: User = Security(get_current_active_user, scopes=["videos.write"])):
+
+    if col_albums.find_one( {"user": current_user.user, "name": album} ) is None:
+        return HTTPException(status_code=HTTP_404_NOT_FOUND, detail=f"Provided album '{album}' does not exist.")
+
+    # if not file.content_type.startswith("video"):
+    #     return HTTPException(status_code=HTTP_406_NOT_ACCEPTABLE, detail="Provided file is not a video, not accepting.")
+
+    makedirs(path.join("data", "users", current_user.user, "albums", album), exist_ok=True)
+
+    filename = file.filename
+
+    if path.exists(path.join("data", "users", current_user.user, "albums", album, file.filename)):
+        base_name = file.filename.split(".")[:-1]
+        extension = file.filename.split(".")[-1]
+        filename = ".".join(base_name)+f"_{int(datetime.now().timestamp())}."+extension
+
+    with open(path.join("data", "users", current_user.user, "albums", album, filename), "wb") as f:
+        f.write(await file.read())
+
+    # file_hash = await get_phash(path.join("data", "users", current_user.user, "albums", album, filename))
+    # duplicates = await get_duplicates(file_hash, album)
+
+    # if len(duplicates) > 0 and ignore_duplicates is False:
+    #     return UJSONResponse(
+    #         {
+    #             "detail": "video duplicates found. Pass 'ignore_duplicates=true' to ignore.",
+    #             "duplicates": duplicates
+    #         },
+    #         status_code=HTTP_409_CONFLICT
+    #     )
+
+    uploaded = col_videos.insert_one( {"user": current_user.user, "album": album, "filename": filename} )
+
+    return UJSONResponse(
+        {
+            "id": uploaded.inserted_id.__str__(),
+            "album": album,
+            "filename": filename
+        }
+    )
+
+@app.get("/videos/{id}", description="Get a video by id")
+async def video_get(id: str, current_user: User = Security(get_current_active_user, scopes=["videos.view"])):
+
+    try:
+        video = col_videos.find_one( {"_id": ObjectId(id)} )
+        if video is None:
+            raise InvalidId(id)
+    except InvalidId:
+        return HTTPException(status_code=HTTP_404_NOT_FOUND, detail="Could not find a video with such id.")
+
+    video_path = path.join("data", "users", current_user.user, "albums", video["album"], video["filename"])
+
+    mime = Magic(mime=True).from_file(video_path)
+
+    with open(video_path, "rb") as f: video_file = f.read() 
+
+    return Response(video_file, media_type=mime)
+
+@app.delete("/videos/{id}", description="Delete a video by id")
+async def video_delete(id: str, current_user: User = Security(get_current_active_user, scopes=["videos.write"])):
+
+    try:
+        video = col_videos.find_one_and_delete( {"_id": ObjectId(id)} )
+        if video is None:
+            raise InvalidId(id)
+    except InvalidId:
+        return HTTPException(status_code=HTTP_404_NOT_FOUND, detail="Could not find a video with such id.")
+
+    album = col_albums.find_one( {"name": video["album"]} )
+
+    remove(path.join("data", "users", current_user.user, "albums", video["album"], video["filename"]))
+
+    return Response(status_code=HTTP_204_NO_CONTENT)
+
+@app.get("/albums/{album}/videos", response_class=UJSONResponse, response_model=SearchResults, description="Find a video by filename")
+async def video_find(q: str, album: str, page: int = 1, page_size: int = 100, current_user: User = Security(get_current_active_user, scopes=["videos.list"])):
+
+    if col_albums.find_one( {"user": current_user.user, "name": album} ) is None:
+        return HTTPException(status_code=HTTP_404_NOT_FOUND, detail=f"Provided album '{album}' does not exist.")
+
+    if page <= 0 or page_size <= 0:
+        return HTTPException(status_code=HTTP_400_BAD_REQUEST, detail="Parameters 'page' and 'page_size' must be greater or equal to 1.")
+
+    output = {"results": []}
+    skip = (page-1)*page_size
+    videos = list(col_videos.find({"user": current_user.user, "album": album, "filename": re.compile(q)}, limit=page_size, skip=skip))
+
+    for video in videos:
+        output["results"].append({"id": video["_id"].__str__(), "filename": video["filename"]})
+
+    if col_videos.count_documents( {"user": current_user.user, "album": album, "filename": re.compile(q)} ) > page*page_size:
+        token = str(token_urlsafe(32))
+        col_tokens.insert_one( {"token": token, "query": q, "album": album, "page": page+1, "page_size": page_size, "user": pickle.dumps(current_user)} )
+        output["next_page"] = f"/albums/{album}/videos/token?token={token}" # type: ignore
+    else:
+        output["next_page"] = None # type: ignore
+
+    return UJSONResponse(output)
+
+@app.get("/albums/{album}/videos/token", response_class=UJSONResponse, response_model=SearchResults, description="Find a video by token")
+async def video_find_token(token: str):
+
+    found_record = col_tokens.find_one( {"token": token} )
+
+    if found_record is None:
+        return HTTPException(status_code=HTTP_401_UNAUTHORIZED, detail="Invalid search token.")
+
+    return await video_find(q=found_record["query"], album=found_record["album"], page=found_record["page"], page_size=found_record["page_size"], current_user=pickle.loads(found_record["user"]))

modules/database.py

@@ -24,11 +24,12 @@ db = db_client.get_database(name=db_config["name"])
 
 collections = db.list_collection_names()
 
-for collection in ["users", "albums", "photos", "tokens"]:
+for collection in ["users", "albums", "photos", "videos", "tokens"]:
     if not collection in collections:
         db.create_collection(collection)
 
 col_users = db.get_collection("users")
 col_albums = db.get_collection("albums")
 col_photos = db.get_collection("photos")
+col_videos = db.get_collection("videos")
 col_tokens = db.get_collection("tokens")

modules/security.py

@@ -49,7 +49,10 @@ oauth2_scheme = OAuth2PasswordBearer(
         "albums.write": "Modify albums.",
         "photos.list": "List photos.",
         "photos.read": "View photos.",
-        "photos.write": "Modify photos."
+        "photos.write": "Modify photos.",
+        "videos.list": "List videos.",
+        "videos.read": "View videos.",
+        "videos.write": "Modify videos."
     },
 )