From 4ac39717c6b90938277a730c6a430ac3bafe868a Mon Sep 17 00:00:00 2001
From: Backend IM Bot <bot@backend.im>
Date: Tue, 25 Mar 2025 11:45:41 +0100
Subject: [PATCH] Update code in endpoints/aiderman.post.py

---
 endpoints/aiderman.post.py | 89 ++++++++++++++++++++++++++++++--------
 1 file changed, 71 insertions(+), 18 deletions(-)

diff --git a/endpoints/aiderman.post.py b/endpoints/aiderman.post.py
index 0382ee4..83c0896 100644
--- a/endpoints/aiderman.post.py
+++ b/endpoints/aiderman.post.py
@@ -1,27 +1,80 @@
+Sure, here's an example of a FastAPI endpoint that saves a list of books to the database using SQLAlchemy and Pydantic schemas:
+
 ```python
-from fastapi import APIRouter, HTTPException
 from typing import List
-from models.book import Book
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from sqlalchemy import Column, Integer, String, create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
 
-router = APIRouter()
-books = []  # In-memory storage
+from app.api.models.aiderman_model import *
+from app.api.schemas.aiderman_schema import *
+app = FastAPI()
 
-@router.post("/aiderman", status_code=201)
-async def save_books(book_list: List[Book]):
-    """Save a list of books to the database"""
-    if request.method != "POST":
-        raise HTTPException(status_code=405, detail="Method Not Allowed")
+# SQLAlchemy setup
+engine = create_engine('sqlite:///books.db', echo=True)
+Session = sessionmaker(bind=engine)
+Base = declarative_base()
 
-    books.extend(book_list)
+# SQLAlchemy model
 
-    return {
-        "method": "POST",
-        "_verb": "post",
-        "message": "Books saved successfully",
-        "books_saved": len(book_list)
-    }
+    id = Column(Integer, primary_key=True)
+    title = Column(String)
+    author = Column(String)
+
+    def __repr__(self):
+        return f"Book(id={self.id}, title='{self.title}', author='{self.author}')"
+
+Base.metadata.create_all(engine)
+
+# Pydantic schema
+
+    class Config:
+        orm_mode = True
+
+# Endpoint to save a list of books
+@app.post("/aiderman")
+def save_books(books: List[BookSchema]):
+    session = Session()
+
+    try:
+        book_instances = [Book(title=book.title, author=book.author) for book in books]
+        session.add_all(book_instances)
+        session.commit()
+        return {"message": "Books saved successfully"}
+    except Exception as e:
+        session.rollback()
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        session.close()
 ```
 
-This endpoint accepts a list of `Book` objects in the request body and saves them to an in-memory list called `books`. It returns a JSON response with the number of books saved and the required method metadata.
+Here's how it works:
 
-Ensure that the `Book` model is defined in `models/book.py` with the necessary fields, and imported correctly in this file.
\ No newline at end of file
+1. We define a SQLAlchemy model `Book` with `id`, `title`, and `author` columns.
+2. We create a Pydantic schema `BookSchema` that defines the structure of a book object.
+3. The `save_books` endpoint accepts a list of `BookSchema` objects as input.
+4. Inside the endpoint, we create a SQLAlchemy session and iterate over the list of books.
+5. For each book, we create a `Book` instance using the data from the `BookSchema` object.
+6. We add all the `Book` instances to the session using `session.add_all`.
+7. We commit the changes to the database using `session.commit()`.
+8. If any exception occurs during the process, we rollback the transaction using `session.rollback()`.
+9. Finally, we close the session.
+
+To use this endpoint, you can send a POST request to `/aiderman` with a JSON payload containing a list of book objects, like this:
+
+```json
+[
+  {
+    "title": "The Great Gatsby",
+    "author": "F. Scott Fitzgerald"
+  },
+  {
+    "title": "To Kill a Mockingbird",
+    "author": "Harper Lee"
+  }
+]
+```
+
+This will save the list of books to the `books` table in the `books.db` SQLite database.
\ No newline at end of file