fix:improve error message

api/router/book.py

@@ -88,14 +88,20 @@ async def upload_file(
         logging.info("Database Inserted")
 
         return {
+            "status": "success",
             "filename": file.filename,
             "response": response,
             "info": "upload file successfully",
         }
 
     except Exception as e:
-        return handle_exception(e)
-
+        return {
+            "status": "error",
+            "filename": "",
+            "response": "",
+            "info": "upload file failed",
+            "error_message":handle_exception(e)
+        }
 
 @router.put("/book/{metadata_id}")
 async def update_metadata(
@@ -147,7 +153,6 @@ async def update_metadata(
 
         # Update existing metadata entry
         metadata = db.query(Metadata).filter(Metadata.id == metadata_id).first()
-        print(metadata)
 
         if not metadata:
             return JSONResponse(status_code=404, content="Metadata not found")
@@ -155,11 +160,10 @@ async def update_metadata(
         updated_metadata = book_query.update_metadata_entry(
             db, metadata_id, title, author, category_id, year, publisher
         )
-        print(updated_metadata)
         updated_category = category_query.get_category(db, updated_metadata.category_id)
-        print(updated_category)
 
         return MetadataResponse(
+            status="success",
             id=metadata_id,
             title=updated_metadata.title,
             author=updated_metadata.author,
@@ -175,7 +179,10 @@ async def update_metadata(
         )
 
     except Exception as e:
-        return handle_exception(e)
+        return {
+            "status":"error",
+            "error_message":handle_exception(e)
+        }
 
 @router.delete("/book/{metadata_id}")
 async def delete_metadata(user: user_dependency, db: db_dependency, metadata_id: int):
@@ -196,8 +203,12 @@ async def delete_metadata(user: user_dependency, db: db_dependency, metadata_id:
         db.delete(metadata)
         db.commit()
 
-        return {"Status": "delete successfully"}
+        return {"status": "delete successfully"}
 
     except Exception as e:
-        return handle_exception(e)
+        return {
+            "status": "error",
+            "message": "delete failed",
+            "error_message": handle_exception(e)       
+        }
     

api/router/book_collection.py

@@ -31,9 +31,9 @@ async def get_book_collection(user: user_dependency, db: db_dependency):
         }
     except Exception as e:
         return {
-            "status": "false",
+            "status": "error",
             "book_collection": [],
-            "message": handle_exception(e)
+            "error_message": handle_exception(e)
         }
 
 
@@ -52,7 +52,12 @@ async def request_book_collection(
         return user_meta_query.insert_user_meta_entries(db, metadata_ids)
 
     except Exception as e:
-        return handle_exception(e)
+        return {
+            "status": "error",
+            "message": "User meta entries failed to added.",
+            "metadata_ids": [],  # Include the metadata IDs in the result
+            "error_message":handle_exception(e)
+        }
 
 
 @router.put("/book_collection")
@@ -69,7 +74,13 @@ async def update_book_collection(
         return user_meta_query.update_user_meta_entries(db, metadata_ids)
 
     except Exception as e:
-        return handle_exception(e)
+        return {
+            "status": "error",
+            "added_meta": [],
+            "deleted_meta": [],
+            "kept_meta": [],
+            "message":handle_exception(e)
+        }
 
 
 @router.delete("/book_collection/{metadata_id}")
@@ -87,7 +98,11 @@ async def delete_book_collection(
             db, metadata_id=metadata_id
         )
     except Exception as e:
-        return handle_exception(e)
+        return {
+            "status": "error",
+            "message": f"Book user with id {metadata_id} deleted successfully.",
+            "error_message": handle_exception(e)
+            }
 
 
 @router.delete("/all_collections")
@@ -106,4 +121,8 @@ async def delete_all_book(user: user_dependency, db: db_dependency):
             "message": f"Deleted book collection for user {user.get('id')}",
         }
     except Exception as e:
-        return handle_exception(e)
+        return {
+            "status": "error",
+            "message": f"Delete failed for user {user.get('id')}",
+            "error_message": handle_exception(e)
+        }

db/fetching.py

@@ -42,6 +42,7 @@ class DataFetching:
         
         return [
             MetadataResponse(
+                status="success",
                 id = id,
                 title=title,
                 author=author,

db/query/base_query.py

@@ -49,10 +49,12 @@ class BaseQuery:
         db.add_all(entries)
         return self._handle_commit(db)
 
-    def delete(self, db, model, id, filter_conditions=None):
+    def delete(self, db, model, id=None, filter_conditions=None):
         """Delete an entry by ID with optional filter conditions."""
         # Build the query to select the entry
-        query = select(model).where(model.id == id)
+        if id :
+            query = select(model).where(model.id == id)
+            
         if filter_conditions:
             query = query.where(*filter_conditions)
         

db/query/query_user_meta.py

@@ -6,7 +6,7 @@ from db.query.base_query import BaseQuery
 class UserMetaQuery(BaseQuery):
     def __init__(self, user):
         super().__init__(user)
-    
+
     def get_user_meta_entries(self, db):
         """Fetch all user meta entries joined with metadata and category."""
         join_models = [Metadata, Category]
@@ -14,7 +14,7 @@ class UserMetaQuery(BaseQuery):
             User_Meta.metadata_id == Metadata.id,
             Metadata.category_id == Category.id,
         ]
-        
+
         filter_conditions = [User_Meta.user_id == self.user_id]
 
         result = self.get_with_joins(
@@ -23,11 +23,10 @@ class UserMetaQuery(BaseQuery):
             join_models=join_models,
             join_conditions=join_conditions,
             filter_conditions=filter_conditions,
-            multiple=True
+            multiple=True,
         )
         return result
 
-
     def insert_user_meta_entries(self, db, metadata_ids):
         """Insert new user meta entries."""
         user_meta_entries = [
@@ -38,16 +37,19 @@ class UserMetaQuery(BaseQuery):
         # Use the method from BaseQuery to insert entries
         self.insert_entries(db, user_meta_entries)
         return {
+            "status":"success",
             "message": "User meta entries added successfully.",
             "metadata_ids": metadata_ids,  # Include the metadata IDs in the result
         }
-    
+
     def update_user_meta_entries(self, db, metadata_ids):
         """Update user meta entries: keep, delete, or add new entries based on metadata_ids."""
         filter_conditions = [User_Meta.user_id == self.user_id]
-        
+
         # Fetch existing user meta entries
-        existing_user_meta = self.get(db, model=User_Meta, filter_conditions=filter_conditions, multiple=True)
+        existing_user_meta = self.get(
+            db, model=User_Meta, filter_conditions=filter_conditions, multiple=True
+        )
         existing_user_meta = [user_meta[0] for user_meta in existing_user_meta]
         existing_meta_ids = [entry.metadata_id for entry in existing_user_meta]
 
@@ -62,7 +64,10 @@ class UserMetaQuery(BaseQuery):
 
         # Delete entries that are no longer in the updated metadata_ids list
         if metadata_to_delete:
-            db.query(User_Meta).filter(User_Meta.user_id == self.user_id, User_Meta.metadata_id.in_(metadata_to_delete)).delete(synchronize_session=False)
+            db.query(User_Meta).filter(
+                User_Meta.user_id == self.user_id,
+                User_Meta.metadata_id.in_(metadata_to_delete),
+            ).delete(synchronize_session=False)
 
         # Add new entries for metadata that are not in the existing user meta
         for meta_id in metadata_to_add:
@@ -70,7 +75,7 @@ class UserMetaQuery(BaseQuery):
             self.add(db, new_entry)
 
         db.commit()
-        
+
         return {
             "status": "success",
             "added_meta": list(metadata_to_add),
@@ -80,10 +85,15 @@ class UserMetaQuery(BaseQuery):
 
     def delete_user_meta(self, db, metadata_id):
         """Delete user meta entries by metadata_id."""
-        filter_conditions = [User_Meta.metadata_id==metadata_id,
-                             User_Meta.user_id==self.user_id]
+        filter_conditions = [
+            User_Meta.metadata_id == metadata_id,
+            User_Meta.user_id == self.user_id,
+        ]
         self.delete(db, model=User_Meta, filter_conditions=filter_conditions)
-        return {"message": f"Book user with id {metadata_id} deleted successfully."}
+        return {
+            "status": "success",
+            "message": f"Book user with id {metadata_id} deleted successfully.",
+        }
 
     def delete_all_user_meta(self, db):
         """Delete all user meta entries for a user."""

service/dto.py

@@ -69,6 +69,7 @@ class MetadataRequest(BaseModel):
 
 
 class MetadataResponse(BaseModel):
+    status:str
     id : int
     title: str
     author: str

utils/error_handlers.py

@@ -4,17 +4,31 @@ from fastapi.responses import JSONResponse
 def handle_exception(e: Exception):
     """Helper function to handle exceptions in a consistent way."""
     return JSONResponse(
-        status_code=500, content=f"An unexpected error occurred: {str(e)}"
+        status_code=500,
+        content={
+            "status": "exception error",
+            "message": "An unexpected error occurred",
+            "details": str(e),
+        },
     )
 
 
 def handle_error(e, message):
-    return JSONResponse(status_code=500, content={"error occurs": f"{message}: {str(e)}"})
+    return JSONResponse(
+        status_code=500,
+        content={"status": "error", "error": f"error in {message}", "details": str(e)},
+    )
 
 
 def not_found_error(message):
-    return JSONResponse(status_code=404, content={"not found message": message})
+    return JSONResponse(
+        status_code=404,
+        content={"status": "error", "error": "Not Found", "details": message},
+    )
 
 
 def no_entries_found(message):
-    return JSONResponse(status_code=404, content={"no entries found": message})
+    return JSONResponse(
+        status_code=404,
+        content={"status": "error", "error": "No Entries Found", "details": message},
+    )