feat: New feature, support updating relational attributes.

Author: amisadmin

fastapi_amis_admin/crud/_sqlmodel.py

@@ -1,11 +1,13 @@
 import datetime
+import logging
 import re
 from enum import Enum
 from typing import Any, Callable, Dict, List, Optional, Pattern, Tuple, Type, Union
 
 from fastapi import APIRouter, Body, Depends, Query
+from fastapi.encoders import DictIntStrAny, SetIntStr
 from pydantic import BaseModel, Extra, Json
-from sqlalchemy import Column, Table, delete, func, insert, update
+from sqlalchemy import Column, Table, delete, func, insert
 from sqlalchemy.future import select
 from sqlalchemy.orm import InstrumentedAttribute, Session
 from sqlalchemy.sql import Select
@@ -206,7 +208,10 @@ class SQLModelCrud(BaseCrud, SQLModelSelector):
     engine: SqlalchemyDatabase = None
     create_fields: List[SQLModelField] = []  # 新增数据字段
     readonly_fields: List[SQLModelListField] = []  # 只读字段
+    """readonly fields, deprecated, not recommended, will be removed in version 0.4.0"""
     update_fields: List[SQLModelListField] = []  # 可编辑字段
+    update_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None
+    """update exclude fields, such as: {'id', 'key', 'name'} or {'id': True, 'category': {'id', 'name'}}"""
 
     def __init__(
         self,
@@ -220,6 +225,11 @@ def __init__(
         self.db = get_engine_db(self.engine)
         SQLModelSelector.__init__(self, model, fields)
         BaseCrud.__init__(self, self.model, router)
+        if self.readonly_fields:
+            logging.warning(
+                "readonly fields, deprecated, not recommended, will be removed in version 0.4.0."
+                "Please replace them with update_fields and update_exclude."
+            )
 
     def _create_schema_list(self):
         if self.schema_list:
@@ -291,11 +301,33 @@ def _create_schema_create(self):
         )
         return schema_create_by_modelfield(f"{self.schema_name_prefix}Create", modelfields)
 
-    def _read_items(self, session: Session, item_id: List[str]):
-        stmt = select(self.model).where(self.pk.in_(list(map(get_python_type_parse(self.pk), item_id))))
-        items = session.scalars(stmt).all()
+    def read_item(self, obj: SQLModel) -> BaseModel:
+        """read database data and parse to schema_read"""
         parse = self.schema_read.from_orm if self.schema_read.Config.orm_mode else self.schema_read.parse_obj
-        return [parse(obj) for obj in items]
+        return parse(obj)
+
+    def update_item(self, obj: SQLModel, values: Dict[str, Any]) -> None:
+        """update schema_update data to database,support relational attributes"""
+        for k, v in values.items():
+            if isinstance(v, dict) and hasattr(obj, k):
+                # Relational attributes, nested;such as: setattr(article.content, "body", "new body")
+                self.update_item(getattr(obj, k), v)
+            else:
+                setattr(obj, k, v)
+
+    def _fetch_item_scalars(self, session: Session, item_id: List[str]) -> List[SQLModel]:
+        stmt = select(self.model).where(self.pk.in_(list(map(get_python_type_parse(self.pk), item_id))))
+        return session.scalars(stmt).all()
+
+    def _read_items(self, session: Session, item_id: List[str]):
+        items = self._fetch_item_scalars(session, item_id)
+        return [self.read_item(obj) for obj in items]
+
+    def _update_items(self, session: Session, item_id: List[str], values: Dict[str, Any]):
+        items = self._fetch_item_scalars(session, item_id)
+        for item in items:
+            self.update_item(item, values)
+        return len(items)
 
     @property
     def schema_name_prefix(self):
@@ -316,7 +348,7 @@ async def on_update_pre(
         item_id: Union[List[str], List[int]],
         **kwargs,
     ) -> Dict[str, Any]:
-        data = obj.dict(exclude_unset=True, by_alias=True)
+        data = obj.dict(exclude=self.update_exclude, exclude_unset=True, by_alias=True)
         data = {key: val for key, val in data.items() if val is not None or self.model.__fields__[key].allow_none}
         return data
 
@@ -415,13 +447,11 @@ async def route(
             if not await self.has_update_permission(request, item_id, data):
                 return self.error_no_router_permission(request)
             item_id = list(map(get_python_type_parse(self.pk), item_id))
-            stmt = update(self.model).where(self.pk.in_(item_id))
             values = await self.on_update_pre(request, data, item_id=item_id)
             if not values:
                 return self.error_data_handle(request)
-            stmt = stmt.values(values)
-            result = await self.db.async_execute(stmt)
-            return BaseApiOut(data=getattr(result, "rowcount", None))
+            result = await self.db.async_run_sync(self._update_items, item_id, values)
+            return BaseApiOut(data=result)
 
         return route
 

tests/conftest.py

@@ -1,9 +1,11 @@
+import pytest
 from sqlalchemy_database import AsyncDatabase, Database
 
 # sqlite
 sync_db = Database.create("sqlite:///amisadmin.db?check_same_thread=False")
 async_db = AsyncDatabase.create("sqlite+aiosqlite:///amisadmin.db?check_same_thread=False")
 
+
 # mysql
 # sync_db = Database.create('mysql+pymysql://root:123456@127.0.0.1:3306/amisadmin?charset=utf8mb4')
 # async_db = AsyncDatabase.create('mysql+aiomysql://root:123456@127.0.0.1:3306/amisadmin?charset=utf8mb4')
@@ -17,3 +19,15 @@
 
 # SQL Server
 # sync_db = Database.create('mssql+pyodbc://scott:tiger@mydsn')
+
+
+@pytest.fixture
+def session():
+    with sync_db.session_maker() as session:
+        yield session
+
+
+@pytest.fixture
+async def async_session():
+    async with async_db.session_maker() as session:
+        yield session

tests/test_crud/conftest.py

@@ -4,11 +4,10 @@
 import pytest
 from fastapi import FastAPI
 from httpx import AsyncClient
-from sqlalchemy import insert
 from sqlmodel import SQLModel
 
 from tests.conftest import async_db as db
-from tests.models import Article, User
+from tests.models import Article, ArticleContent, Category, User
 
 pytestmark = pytest.mark.asyncio
 
@@ -33,30 +32,43 @@ async def async_client(app: FastAPI, prepare_database: Any) -> AsyncGenerator[As
 
 
 @pytest.fixture
-async def fake_users() -> List[User]:
+async def fake_users(async_session) -> List[User]:
     data = [
-        {
-            "id": i,
-            "username": f"User_{i}",
-            "password": f"password_{i}",
-            "create_time": datetime.datetime.strptime(f"2022-01-0{i} 00:00:00", "%Y-%m-%d %H:%M:%S"),
-        }
+        User(
+            id=i,
+            username=f"User_{i}",
+            password=f"password_{i}",
+            create_time=datetime.datetime.strptime(f"2022-01-0{i} 00:00:00", "%Y-%m-%d %H:%M:%S"),
+        )
         for i in range(1, 6)
     ]
-    await db.execute(insert(User).values(data))
-    return [User.parse_obj(item) for item in data]
+    async_session.add_all(data)
+    await async_session.commit()
+    return data
 
 
 @pytest.fixture
-async def fake_articles(fake_users) -> List[Article]:
+async def fake_categorys(async_session) -> List[Category]:
+    data = [Category(id=i, name=f"Category_{i}") for i in range(1, 6)]
+    async_session.add_all(data)
+    await async_session.commit()
+    return data
+
+
+@pytest.fixture
+async def fake_article_contents(async_session) -> List[ArticleContent]:
+    data = [ArticleContent(id=i, content=f"Content_{i}") for i in range(1, 6)]
+    async_session.add_all(data)
+    await async_session.commit()
+    return data
+
+
+@pytest.fixture
+async def fake_articles(async_session, fake_users, fake_categorys, fake_article_contents) -> List[Article]:
     data = [
-        {
-            "id": user.id,
-            "title": f"Article_{user.id}",
-            "description": f"Description_{user.id}",
-            "user_id": user.id,
-        }
-        for user in fake_users
+        Article(id=i, title=f"Article_{i}", description=f"Description_{i}", user_id=i, category_id=i, content_id=i)
+        for i in range(1, 6)
     ]
-    await db.execute(insert(Article).values(data))
-    return [Article.parse_obj(item) for item in data]
+    async_session.add_all(data)
+    await async_session.commit()
+    return data

tests/test_crud/test_SQLModelCrud_schemas.py

@@ -1,15 +1,13 @@
+from typing import Optional
+
 from fastapi import FastAPI
 from httpx import AsyncClient
 from pydantic import BaseModel
+from sqlmodel import SQLModel
 
 from fastapi_amis_admin.crud import SQLModelCrud
 from tests.conftest import async_db as db
-from tests.models import User
-
-
-class UserFilter(BaseModel):
-    id: int = None
-    name: str = None
+from tests.models import Article, ArticleContent, Category, User
 
 
 async def test_schema_update(app: FastAPI, async_client: AsyncClient, fake_users):
@@ -120,7 +118,7 @@ class UserCrud(SQLModelCrud):
     assert "password" not in items
 
 
-# todo perfect
+# todo perfect;test more comparison operators
 async def test_schema_filter(app: FastAPI, async_client: AsyncClient, fake_users):
     class UserFilter(BaseModel):
         id: int = None
@@ -152,3 +150,76 @@ class UserCrud(SQLModelCrud):
     res = await async_client.post("/user/list", json={"password": "new_password"})
     items = res.json()["data"]["items"]
     assert items
+
+
+async def test_schema_read_relationship(app: FastAPI, async_client: AsyncClient, fake_articles):
+    class ArticleRead(SQLModel):  # must be SQLModel, not BaseModel
+        id: int
+        title: str
+        description: str
+        category: Optional[Category] = None  # Relationship
+        content: Optional[ArticleContent] = None  # Relationship
+        user: Optional[User] = None  # Relationship
+
+    class ArticleCrud(SQLModelCrud):
+        router_prefix = "/article"
+        schema_read = ArticleRead
+
+    ins = ArticleCrud(Article, db.engine).register_crud()
+
+    app.include_router(ins.router)
+
+    # test schemas
+    openapi = app.openapi()
+    schemas = openapi["components"]["schemas"]
+    assert "category" in schemas["ArticleRead"]["properties"]
+    assert schemas["ArticleRead"]["properties"]["category"]["$ref"] == "#/components/schemas/Category"
+    assert "content" in schemas["ArticleRead"]["properties"]
+    assert "user" in schemas["ArticleRead"]["properties"]
+
+    # test api
+    res = await async_client.get("/article/item/1")
+    items = res.json()["data"]
+    assert items["id"] == 1
+    assert "category" in items
+    assert "content" in items
+    assert "user" in items
+    assert items["category"]["id"] == 1
+    assert items["content"]["id"] == 1
+    assert items["user"]["id"] == 1
+
+
+async def test_schema_update_relationship(app: FastAPI, async_client: AsyncClient, fake_articles, async_session):
+    class ArticleUpdate(SQLModel):  # must be SQLModel, not BaseModel
+        title: str = None
+        description: str = None
+        content: Optional[ArticleContent] = None  # Relationship
+
+    class ArticleCrud(SQLModelCrud):
+        router_prefix = "/article"
+        update_exclude = {"content": {"id"}}
+        schema_update = ArticleUpdate
+
+    ins = ArticleCrud(Article, db.engine).register_crud()
+
+    app.include_router(ins.router)
+
+    # test schemas
+    openapi = app.openapi()
+    schemas = openapi["components"]["schemas"]
+
+    assert "content" in schemas["ArticleUpdate"]["properties"]
+    assert schemas["ArticleUpdate"]["properties"]["content"]["$ref"] == "#/components/schemas/ArticleContent"
+
+    # test api
+    res = await async_client.put("/article/item/1", json={"title": "new_title"})
+    assert res.json()["data"] == 1
+    article = await async_session.get(Article, 1)
+    assert article.title == "new_title"
+
+    res = await async_client.put(
+        "/article/item/1", json={"content": {"id": 2, "content": "new_content"}}  # will be ignored by `update_exclude`
+    )
+    assert res.json()["data"] == 1
+    content = await async_session.get(ArticleContent, 1)
+    assert content.content == "new_content"