完成多对多,多对一的修改。

Author: Chise1

Makefile

@@ -1,4 +1,4 @@
-checkfiles = fast_tmp/
+checkfiles = fast_tmp/ tests/
 black_opts = -l 100 -t py38
 py_warn = PYTHONDEVMODE=1
 

docs/ModelAdmin.md

@@ -8,7 +8,7 @@ from sqlalchemy import Column
 
 
 class ModelAdmin:
-    model: Any  # sqlalchemy的model
+    model: Any  # sqlalchemy的model，如果model存在多对多字段，则model暂时只支持单主键
     # list
     list_display: Tuple[Column, ...] = ()  # 在前端显示的内容，注意，如果要支持修改和删除功能，这里必须有类的主键
     list_per_page: int = 10  # 每页显示数量

example/example/admin.py

@@ -14,7 +14,7 @@ class UserInfoAdmin(ModelAdmin):
 
 class AuthorAdmin(ModelAdmin):
     model = Author
-    create_fields = [Author.name]
+    create_fields = [Author.name, Author.books]
     list_display = create_fields
 
 

example/example/models.py

@@ -1,4 +1,5 @@
 import time
+from typing import List
 
 from sqlalchemy import String, Boolean, Integer, DateTime, DECIMAL, Float, JSON, Text, Time, Column, ForeignKey
 # todo Image,File
@@ -25,7 +26,7 @@ class Author(Base):
     __tablename__ = "author"
     id = Column(Integer, primary_key=True)
     name = Column(String(32),nullable=False)
-    # books: Author = relationship("Author", back_populates="books")
+    books: List['Book'] = relationship("Book", back_populates="author")
 
 
 class Book(Base):
@@ -34,4 +35,4 @@ class Book(Base):
     id = Column(Integer, primary_key=True)
     name = Column(String(128), nullable=False)
     author_id = Column(Integer, ForeignKey('author.id'), info={"admin_name": "name"},nullable=False)  # todo 增加提示
-    author: Author = relationship("Author", backref="books")
+    author: Author = relationship("Author", back_populates="books")

fast_tmp/admin/endpoint.py

@@ -15,19 +15,20 @@
     SmallInteger,
     delete,
     func,
+    inspect,
     select,
 )
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import MANYTOMANY, RelationshipProperty, Session
 from starlette.requests import Request
 from starlette.responses import RedirectResponse
 
+from fast_tmp.responses import BaseRes, key_error, not_found_instance, single_pk
 from fast_tmp.site import ModelAdmin, get_model_site
 
 from ..db import get_db_session
 from ..models import User
 from ..site.utils import clean_data_to_model, get_pk
 from .depends import decode_access_token_from_data
-from .responses import BaseRes, key_error, not_found_instance
 
 router = APIRouter()
 
@@ -85,13 +86,13 @@ def update_data(
     if not user:
         return RedirectResponse(request.url_for("admin:login"))
     data = clean_data_to_model(page_model.get_clean_fields(page_model.update_fields), data)
-    w = get_pks(page_model, request)
+    w = get_pks(page_model.model, request)
     if isinstance(w, BaseRes):
         return w
     old_data = session.execute(select(page_model.model).where(*w)).scalar_one_or_none()
     if not old_data:
         return not_found_instance
-    page_model.update_model(old_data, data)
+    page_model.update_model(old_data, data, session)
     session.commit()
     return BaseRes()
 
@@ -106,13 +107,29 @@ def update_view(
     if not user:
         return RedirectResponse(request.url_for("admin:login"))
 
-    pks = get_pks(page_model, request)
+    pks = get_pks(page_model.model, request)
     if isinstance(pks, BaseRes):
         return pks
-    data = session.execute(page_model.get_one_sql(pks)).fetchone()
+    data = session.execute(select(page_model.model).where(*pks)).scalar_one_or_none()
     if not data:
         return not_found_instance
-    return BaseRes(data=dict(data))
+    res = {}
+    for i in page_model.update_fields:
+        if isinstance(i.property, RelationshipProperty):
+            prop = i.property
+            if prop.direction in (MANYTOMANY,):  # TODO need onetomany
+                pk = list(get_pk(prop.entity.class_).keys())[0]  # 只支持单主键
+                # subs: str = getattr(data, i.key, "")  # type: ignore
+                # if not subs:
+                #     raise not_found_model
+                # else:
+                #     # for sub in subs:
+                #     #     pk_v=getattr(sub,pk)
+                res[i.key] = [getattr(sub, pk) for sub in getattr(data, i.key)]  # type: ignore
+        else:
+            res[i.key] = getattr(data, i.key)  # type: ignore
+
+    return BaseRes(data=res)
 
 
 @router.post("/{resource}/create")
@@ -127,7 +144,7 @@ def create(
         return RedirectResponse(request.url_for("admin:login"))
 
     data = clean_data_to_model(page_model.create_fields, data)
-    instance = page_model.create_model(data)
+    instance = page_model.create_model(data, session)
     session.add(instance)
     session.commit()
     return BaseRes(data=data)
@@ -143,20 +160,31 @@ def delete_one(
     if not user:
         return RedirectResponse(request.url_for("admin:login"))
 
-    w = get_pks(page_model, request)
+    w = get_pks(page_model.model, request)
     if isinstance(w, BaseRes):
         return w
     session.execute(delete(page_model.model).where(*w))
     session.commit()
     return BaseRes()
 
 
-def get_pks(page_model: ModelAdmin, request: Request):
+def clean_param(field_type, param: str):
+    if isinstance(
+        field_type, (Integer, DECIMAL, BigInteger, Float, INTEGER, Numeric, SmallInteger)
+    ):
+        return int(param)
+    elif isinstance(field_type, DateTime):
+        return datetime.strptime(param, "%Y-%m-%dT%H:%M:%S")
+    else:
+        return param
+
+
+def get_pks(model, request: Request):
     """
     获取要查询的单个instance的主键
     """
     params = dict(request.query_params)
-    pks = get_pk(page_model.model)
+    pks = get_pk(model)
     w = []
     for k, v in params.items():
         if pks.get(k) is not None:
@@ -210,9 +238,62 @@ def get_selects(
     perPage: int = 10,
     page: int = 1,
 ):
+    mapper = inspect(page_model.model)
+    items = []
+    total = 0
+    for attr in mapper.attrs:
+        if attr.key == field:
+            relation_model = attr.entity.class_
+            secondary = attr.secondary
+            for col in secondary.foreign_key_constraints:
+                if col.referred_table in mapper.tables:
+                    params = dict(request.query_params)
+                    if len(params) > 1:
+                        raise single_pk
+                    col_name = col.column_keys[0]
+                    for c in secondary.c:
+                        if c.key == col_name:
+                            clean_value = clean_param(c.type, list(params.values())[0])
+                            sql = (
+                                select(*list(get_pk(relation_model).values()))
+                                .join(secondary)
+                                .where(c == clean_value)
+                                .limit(perPage)
+                                .offset((page - 1) * perPage)
+                            )
+                            datas = session.execute(sql)
+                            total_f = session.execute(
+                                select(func.count())
+                                .select_from(relation_model)
+                                .join(secondary)
+                                .where(col == list(params.values())[0])
+                            ).fetchone()
+                            if total_f is not None:
+                                total = total_f[0]
+                            for data in datas:
+                                items.append(dict(data))
+    return BaseRes(data={"total": total, "rows": items})
+
+
+@router.get("/{resource}/picks/{field}")
+def get_picks(
+    request: Request,
+    field: str = Path(...),  # type: ignore
+    page_model: ModelAdmin = Depends(get_model_site),
+    user: Optional[User] = Depends(decode_access_token_from_data),
+    session: Session = Depends(get_db_session),
+    perPage: int = 10,
+    page: int = 1,
+):
+    """
+    枚举选择
+    """
     source_field = getattr(page_model.model, field)
-    relation_model = source_field.property.mapper.class_
+    if isinstance(source_field.property, RelationshipProperty):
+        relation_model = source_field.property.mapper.class_
 
+    else:
+        relation_model = source_field.property.mapper.class_
     datas = session.execute(
         select(list(get_pk(relation_model).values())).limit(perPage).offset((page - 1) * perPage)
     )

fast_tmp/admin/schema/frame.py

@@ -12,7 +12,7 @@ class Dialog(BaseModel):
     nextCondition: bool = True
     size: DialogSize = DialogSize.md
     actions: Optional[List[_Action]]
-    body: Union[str, BaseModel]
+    body: Union[str, BaseModel, dict]
 
 
 # todo:尚未完成：https://baidu.gitee.io/amis/docs/components/dialog?page=1

fast_tmp/admin/schema/zs.py

@@ -14,3 +14,9 @@ class ZSTable(BaseModel):
     name: str
     source: str
     columns: List[Column]
+
+
+class ZS(BaseModel):
+    type: str = "service"
+    api: str
+    body: BaseModel

fast_tmp/admin/server.py

@@ -12,14 +12,14 @@
 from fast_tmp.conf import settings
 from fast_tmp.db import get_db_session
 from fast_tmp.models import User
-from fast_tmp.models.site import UserAdmin
+from fast_tmp.models.site import GroupAdmin, UserAdmin
+from fast_tmp.responses import BaseRes
 from fast_tmp.site import model_list, register_model_site
 from fast_tmp.utils.token import create_access_token
 
 from ..jinja_extension.tags import register_tags
 from .constant import crud_root_rooter, model_router
 from .endpoint import router
-from .responses import BaseRes
 
 base_path = os.path.dirname(__file__)
 templates = Jinja2Templates(directory=base_path + "/templates")
@@ -30,7 +30,7 @@
 else:
     admin.mount("/static", app=StaticFiles(directory=base_path + "/static"), name="static")
 
-register_model_site({"Auth": [UserAdmin]})
+register_model_site({"Auth": [UserAdmin, GroupAdmin]})
 admin.include_router(router, prefix=model_router)
 
 

fast_tmp/models/site.py

@@ -1,5 +1,7 @@
 from typing import Any
 
+from sqlalchemy.orm import Session
+
 from fast_tmp.models import Group, User
 from fast_tmp.site import ModelAdmin
 
@@ -11,19 +13,20 @@ class UserAdmin(ModelAdmin):
     update_fields = (User.password,)
 
     @classmethod
-    def create_model(cls, data: dict) -> Any:
-        user = super().create_model(data)
+    def create_model(cls, data: dict, session: Session) -> Any:
+        user = super().create_model(data, session)
         user.set_password(data["password"])
         return user
 
     @classmethod
-    def update_model(cls, model: User, data: dict) -> Any:
+    def update_model(cls, model: User, data: dict, session: Session) -> Any:
+        super().update_model(model, data, session)
         model.set_password(data["password"])
         return model
 
 
 class GroupAdmin(ModelAdmin):
     model = Group
-    list_display = (Group.id, Group.name)
-    create_fields = (Group.name,)
-    update_fields = (Group.name,)
+    list_display = (Group.id, Group.name, Group.users)
+    create_fields = (Group.name, Group.users)
+    update_fields = (Group.name, Group.users)

fast_tmp/responses.py

@@ -1,4 +1,5 @@
 from typing import Any
+
 from fastapi import HTTPException
 from pydantic import BaseModel
 
@@ -11,7 +12,5 @@ class BaseRes(BaseModel):
 
 key_error = BaseRes(status=400, msg="主键错误")
 not_found_instance = BaseRes(status=404, msg="找不到对象")
-not_found_model = HTTPException(
-    status_code=200,
-    detail=BaseRes(msg="找不到对象").dict()
-)
+not_found_model = HTTPException(status_code=200, detail=BaseRes(msg="找不到对象").dict())
+single_pk = HTTPException(status_code=200, detail=BaseRes(msg="暂时只支持单主键").dict())