《FastAPI零基础入门与进阶实战》第11篇:ORM之第一个案例-CSDN博客

# src/core/ormdb.py
# pip install  sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from src.core import crypt_utils as  cryptU
from src.core.config import Config
from urllib.parse import quote

# 数据库连接配置
# DATABASE_URL = "mysql+mysqlconnector://username:password@localhost/dbname"
# 构建数据库连接字符串
DB_TYPE=Config.DB_TYPE
DB_USER=cryptU.aes_decrypt(Config.DB_USERNAME)
DB_PASSWORD=quote(cryptU.aes_decrypt(Config.DB_PASSWORD))
DB_HOST=cryptU.aes_decrypt(Config.DB_HOST)
DB_NAME=cryptU.aes_decrypt(Config.DB_SID)

if DB_TYPE== 'mysql':
    DATABASE_URL = f"mysql+mysqlconnector://{DB_USER}:{DB_PASSWORD}@{DB_HOST}/{DB_NAME}"
elif DB_TYPE== 'oracle':
    DATABASE_URL = f"oracle+cx_oracle://{DB_USER}:{DB_PASSWORD}@{DB_HOST}/{DB_NAME}"
elif DB_TYPE=='sql_server':
    DATABASE_URL = f"mssql+pyodbc://{DB_USER}:{DB_PASSWORD}@{DB_HOST}/{DB_NAME}?driver=ODBC Driver 17 for SQL Server"
# 创建数据库引擎
# print(DATABASE_URL)
engine = create_engine(DATABASE_URL)

# 创建会话类
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# 声明基类
Base = declarative_base()

功能性说明
模块概述
`src/core/ormdb.py`是一个用于配置和初始化数据库连接以及对象关系映射（ORM）的 Python 模块。它通过 SQLAlchemy 库实现了与多种数据库的连接，并为后续的数据库操作提供了基础框架。

依赖关系

• SQLAlchemy：通过`pip install sqlalchemy`安装，用于实现数据库的连接、ORM 映射以及会话管理等功能。

• crypt_utils：从`src.core`模块中导入，用于对数据库用户名和密码进行 AES 解密操作。

• Config：从`src.core.config`模块中导入，包含了数据库连接的相关配置信息。

• urllib.parse：用于对数据库密码进行 URL 编码，防止密码中包含特殊字符导致连接字符串解析错误。

数据库连接配置

• 数据库类型判断：

• 根据`Config.DB_TYPE`的值判断数据库类型，支持三种数据库：MySQL、Oracle 和 SQL Server。

• 根据不同的数据库类型，使用不同的连接字符串格式构建`DATABASE_URL`。

• 连接字符串构建：

• 从配置中获取数据库用户名、密码、主机地址和数据库名。

• 使用`cryptU.aes_decrypt`对加密的用户名和密码进行解密。

• 对解密后的密码使用`quote`函数进行 URL 编码，确保连接字符串的正确性。

• 根据数据库类型，分别构建对应的连接字符串：

• MySQL：`mysql+mysqlconnector://username:password@localhost/dbname`

• Oracle：`oracle+cx_oracle://username:password@localhost/dbname`

• SQL Server：`mssql+pyodbc://username:password@localhost/dbname?driver=ODBC Driver 17 for SQL Server`

数据库引擎与会话管理

• 创建数据库引擎：

• 使用`create_engine`函数根据`DATABASE_URL`创建数据库引擎`engine`。该引擎用于管理数据库连接池，提供与数据库的交互接口。

• 创建会话类：

• 使用`sessionmaker`工厂函数创建`SessionLocal`会话类。该会话类用于生成数据库会话对象，通过会话对象可以执行数据库的增、删、改、查等操作。

• 设置`autocommit=False`和`autoflush=False`，表示会话不会自动提交事务和自动刷新数据，需要手动管理事务和数据同步。

声明基类

• 使用`declarative_base`函数创建`Base`声明基类。该基类是 SQLAlchemy ORM 的核心，所有映射到数据库表的类都需要继承自该基类。通过继承`Base`，可以将 Python 类与数据库表进行映射，实现对象与数据库记录的相互转换。

总结
该模块通过配置文件和加密工具实现了对数据库连接信息的管理，支持多种数据库类型，并提供了数据库引擎、会话管理和 ORM 基类，为应用程序的数据库操作提供了基础支持。

数据模型

需要在 Models 目录下建立 sys_user.py 文件

# models/sys_user.py
from sqlalchemy import Column, String, Date, DateTime, Boolean, Integer
from sqlalchemy.ext.declarative import declarative_base
from src.core.ormdb import Base
from src.core import str_utils as strU


class SysUser(Base):
    __tablename__ = "sys_user"
    __table_args__ = {'comment': '登录用户表'}  # 表的注释

    # id = Column(String(36), primary_key=True, default=uuid.uuid4(), comment="用户唯一标识ID")
    # id = Column(String(36), primary_key=True, default=strU.generate_id(), comment="用户唯一标识ID")
    # id = Column(String(36), primary_key=True , default=lambda: str(uuid.uuid4()), comment="用户唯一标识ID")
    id = Column(String(36), primary_key=True, default=lambda: strU.generate_id(), comment="用户唯一标识ID")
    api_id = Column(String(36), nullable=True, comment="API主键，用于关联其他系统")
    login_id = Column(String(255), nullable=True, comment="登录账号，用户登录时使用的账号")
    user_name = Column(String(255), nullable=True, comment="用户的名称，显示名称")
    login_password = Column(String(255), nullable=True, comment="密码，用户登录时使用的密码")
    email = Column(String(255), nullable=True, comment="邮箱地址，用户的电子邮箱")
    person_id = Column(String(36), nullable=True, comment="个人ID，关联到个人实体")
    is_superuser = Column(Boolean, default=False, comment="是否为超级用户，0表示非超级用户，1表示超级用户")
    is_staff = Column(Boolean, default=True, comment="是否为工作用户，1表示工作用户，0表示非工作用户")
    effective_date = Column(Date, default="curdate()", comment="生效日期，用户生效的日期")
    expiry_date = Column(Date, nullable=True, comment="失效日期，用户失效的日期")
    deletion_mark = Column(Boolean, default=False, comment="删除标志，0表示未删除，1表示已删除")
    deletion_reason = Column(String(255), nullable=True, comment="删除原因，记录删除的具体原因")
    deletion_date = Column(DateTime, nullable=True, comment="删除日期，记录删除的时间")
    deletion_by = Column(String(255), nullable=True, comment="删除者，记录删除操作的执行者")
    # create_date = Column(DateTime, default="now()", comment="创建日期，记录创建的时间")
    create_date = Column(DateTime, default=lambda: strU.now(), comment="创建日期，记录创建的时间")
    creator_by = Column(String(255), nullable=True, comment="创建者，记录创建操作的执行者")
    last_updated_date = Column(DateTime, nullable=True, comment="最后更新时间，记录最后更新的时间")
    last_updated_by = Column(String(255), nullable=True, comment="最后更新者，记录最后更新操作的执行者")

功能描述该模块定义了一个名为 SysUser 的数据库模型类，用于表示系统中的登录用户信息。该模型通过 SQLAlchemy 框架实现，继承自 Base 类（定义在 src.core.ormdb 模块中），并使用 declarative_base 声明方式构建。

主要功能：

• __tablename__ = "sys_user"：定义数据库表

•__table_args__ = {'comment': '登录用户表'} ：表的注释

•id = Column(...)

SQLAlchemy 中定义数据库表字段的方式。 Column 是 SQLAlchemy 提供的一个类，用于声明表中的字段

• String(36) ：指定字段类型为字符串，最大长度为36个字符。

• primary_key=True ：将该字段设置为主键。主键是表中唯一标识每一行记录的字段，不能重复。

• default=lambda: strU.generate_id() ：指定该字段的默认值。如果在插入数据时没有显式提供 id 的值，就会使用 default 指定的值。

• comment="用户唯一标识ID" ：为该字段添加注释，方便在数据库中查看字段的用途。

• default=lambda: strU.generate_id() 这是设置字段默认值的部分，其中 lambda 是一个匿名函数。

• lambda: strU.generate_id() ：

• 这是一个匿名函数，它没有参数。

• 函数体是 strU.generate_id() ，表示调用 strU 模块中的 generate_id() 函数。

• 每次调用这个匿名函数时，都会执行 strU.generate_id() ，生成一个新的唯一ID。

• 使用 lambda 可以确保每次插入数据时都调用 strU.generate_id() ，生成一个新的唯一ID，而不是使用一个固定的默认值。

• lambda ： lambda 是Python中用于创建匿名函数的关键字。匿名函数是一种没有名字的函数，通常用于简单的操作。它的语法是：

lambda arguments: expression

• lambda ：开始未使用lambda ，在每次插入的时，都是app启动时候生成ID值，没有每次插入时生成一个新的ID

数据验证模型

创建 schema 文件夹，并在其中建立 sys_user.py 文件

# schemas/sys_user.py
from pydantic import BaseModel
from datetime import date, datetime


class SysUserBase(BaseModel):
    api_id: str | None = None
    login_id: str | None = None
    user_name: str | None = None
    login_password: str | None = None
    email: str | None = None
    person_id: str | None = None
    is_superuser: bool = False
    is_staff: bool = True
    effective_date: date | None = None
    expiry_date: date | None = None
    deletion_mark: bool = False
    deletion_reason: str | None = None
    deletion_date: datetime | None = None
    deletion_by: str | None = None
    creator_by: str | None = None
    last_updated_date: datetime | None = None
    last_updated_by: str | None = None


class SysUserCreate(SysUserBase):
    pass


class SysUser(SysUserBase):
    id: str

    class Config:
        from_attributes = True
        # orm_mode = True

功能描述

该模块定义了与 SysUser 相关的Pydantic模型，用于处理用户数据的验证和序列化。这些模型基于 Pydantic 的 BaseModel 类，提供了数据验证、类型检查以及数据转换的功能。

基础模型 SysUserBase

功能： SysUserBase 模型定义了用户数据的基本结构，适用于用户数据的验证和序列化。所有字段均为可选字段，除了 is_superuser 和 is_staff 字段有默认值

创建模型 SysUserCreate

• 继承自： SysUserBase

• 功能： SysUserCreate 模型用于处理用户创建时的数据验证。它继承了 SysUserBase 的所有字段，但没有额外的字段或配置。这意味着在创建用户时，可以使用 SysUserBase 定义的所有字段。

完整模型 SysUser

• 继承自： SysUserBase

• 额外字段：

• id ：用户唯一标识ID，类型为 str 。

• 配置：

• from_attributes = True ：启用 from_attributes 模式，允许从ORM模型直接加载数据。

• 功能： SysUser 模型用于处理完整的用户数据，包括用户唯一标识ID。它适用于从数据库中读取用户数据并进行序列化，同时支持从ORM模型直接加载数据。

依赖模块

• Pydantic ：用于定义数据模型，提供数据验证和序列化功能。

• datetime ：用于处理日期和时间类型。总结该模块定义了三个Pydantic模型，分别用于处理用户数据的基础结构、用户创建时的数据验证以及完整的用户数据序列化。这些模型通过继承和扩展，提供了灵活的数据处理能力，适用于不同的业务场景。

数据库交互

创建 CRUD文件夹，并在其中建立 sys_user.py 文件

# crud/sys_user.py
from sqlalchemy.orm import Session
from src.models import sys_user as models
from src.schemas import sys_user as schemas

def create_user(db: Session, user: schemas.SysUserCreate):
    db_user = models.SysUser(**user.dict())
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

def get_user(db: Session, user_id: str):
    return db.query(models.SysUser).filter(models.SysUser.id == user_id).first()

def get_users(db: Session, skip: int = 0, limit: int = 100):
    return db.query(models.SysUser).offset(skip).limit(limit).all()

def update_user(db: Session, user_id: str, user: schemas.SysUserCreate):
    db_user = db.query(models.SysUser).filter(models.SysUser.id == user_id).first()
    if db_user is None:
        return None
    db_user.api_id = user.api_id
    db_user.login_id = user.login_id
    db_user.user_name = user.user_name
    db_user.login_password = user.login_password
    db_user.email = user.email
    db_user.person_id = user.person_id
    db_user.is_superuser = user.is_superuser
    db_user.is_staff = user.is_staff
    db_user.effective_date = user.effective_date
    db_user.expiry_date = user.expiry_date
    db_user.deletion_mark = user.deletion_mark
    db_user.deletion_reason = user.deletion_reason
    db_user.deletion_date = user.deletion_date
    db_user.deletion_by = user.deletion_by
    db_user.creator_by = user.creator_by
    db_user.last_updated_date = user.last_updated_date
    db_user.last_updated_by = user.last_updated_by
    db.commit()
    db.refresh(db_user)
    return db_user

def delete_user(db: Session, user_id: str):
    db_user = db.query(models.SysUser).filter(models.SysUser.id == user_id).first()
    if db_user is None:
        return None
    db.delete(db_user)
    db.commit()
    return db_user

功能性说明
功能描述
该模块定义了与`SysUser`相关的数据库操作函数，用于实现用户数据的创建、读取、更新和删除（CRUD）操作。这些函数基于`SQLAlchemy`框架，通过操作数据库会话（`Session`）来管理用户数据。
主要功能
• 创建用户

• 函数：`create_user(db: Session, user: schemas.SysUserCreate)`

• 功能：

• 接收一个`SysUserCreate`对象（包含用户数据）。

• 将用户数据转换为`models.SysUser`对象。

• 将该对象添加到数据库会话中。

• 提交会话以保存数据到数据库。

• 刷新会话以获取数据库中生成的完整对象（例如自动生成的ID）。

• 返回创建的用户对象。

• 获取单个用户

• 函数：`get_user(db: Session, user_id: str)`

• 功能：

• 根据用户ID查询数据库。

• 返回匹配的用户对象，如果没有找到则返回`None`。

• 获取用户列表

• 函数：`get_users(db: Session, skip: int = 0, limit: int = 100)`

• 功能：

• 查询数据库中的用户数据。

• 使用`skip`和`limit`参数实现分页功能。

• 返回用户列表。

• 更新用户

• 函数：`update_user(db: Session, user_id: str, user: schemas.SysUserCreate)`

• 功能：

• 根据用户ID查询数据库，获取用户对象。

• 如果用户不存在，返回`None`。

• 将传入的用户数据更新到数据库对象中。

• 提交会话以保存更改。

• 刷新会话以获取更新后的用户对象。

• 返回更新后的用户对象。

• 删除用户

• 函数：`delete_user(db: Session, user_id: str)`

• 功能：

• 根据用户ID查询数据库，获取用户对象。

• 如果用户不存在，返回`None`。

• 从数据库中删除该用户对象。

• 提交会话以保存更改。

• 返回被删除的用户对象。

依赖模块

• `SQLAlchemy`：用于数据库操作，包括会话管理、查询和数据操作。

• `src.models.sys_user`：定义了`SysUser`数据库模型。

• `src.schemas.sys_user`：定义了`SysUserCreate`和`SysUser`Pydantic模型，用于数据验证和序列化。
总结
该模块提供了一组函数，用于实现用户数据的CRUD操作。这些函数通过`SQLAlchemy`操作数据库，确保数据的一致性和完整性。每个函数都有明确的功能，便于在应用程序中进行用户管理。

用户管理API构建

修改Main.py文件，增加下面内容：

from src.crud import sys_user as crud
from src.schemas import sys_user as schemas
from sqlalchemy.orm import Session

app = FastAPI()
# 创建数据库表
Base.metadata.create_all(bind=engine)


# 依赖项：获取数据库会话
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()


# 创建用户
@app.post("/users/", response_model=schemas.SysUser)
def create_user(user: schemas.SysUserCreate, db: Session = Depends(get_db)):
    return crud.create_user(db, user)


# 获取用户
@app.get("/users/{user_id}", response_model=schemas.SysUser)
def read_user(user_id: str, db: Session = Depends(get_db)):
    db_user = crud.get_user(db, user_id)
    if db_user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return db_user


# 获取所有用户
@app.get("/users/", response_model=list[schemas.SysUser])
def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    return crud.get_users(db, skip, limit)


# 更新用户
@app.put("/users/{user_id}", response_model=schemas.SysUser)
def update_user(user_id: str, user: schemas.SysUserCreate, db: Session = Depends(get_db)):
    db_user = crud.update_user(db, user_id, user)
    if db_user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return db_user


# 删除用户
@app.delete("/users/{user_id}")
def delete_user(user_id: str, db: Session = Depends(get_db)):
    db_user = crud.delete_user(db, user_id)
    if db_user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return {"message": "User deleted"}

功能性说明
功能描述
该文件是FastAPI应用程序的入口点，定义了用户管理相关的API端点，并配置了数据库连接、依赖项和中间件。它通过FastAPI框架提供用户数据的CRUD（创建、读取、更新、删除）操作接口。

主要功能

• FastAPI应用初始化

• `app = FastAPI()`：创建一个FastAPI应用实例。

• 数据库表创建

• `Base.metadata.create_all(bind=engine)`：使用`SQLAlchemy`的`Base.metadata.create_all`方法，根据定义的模型创建数据库表。如果表已存在，则不会重复创建。

• 依赖项：获取数据库会话

• `get_db()`：定义了一个依赖项函数，用于获取数据库会话（`SessionLocal`）。该函数在请求开始时创建会话，并在请求结束时关闭会话。通过`Depends(get_db)`，FastAPI会自动调用该函数，并将返回的会话对象注入到需要的路由函数中。

• API端点定义

• 创建用户

• `@app.post("/users/")`：定义了一个POST请求端点，用于创建新用户。

• 接收一个`SysUserCreate`对象作为请求体。

• 调用`crud.create_user`函数，将用户数据保存到数据库。

• 返回创建的用户对象。

• 获取单个用户

• `@app.get("/users/{user_id}")`：定义了一个GET请求端点，用于根据用户ID获取用户信息。

• 接收用户ID作为路径参数。

• 调用`crud.get_user`函数查询用户。

• 如果用户不存在，抛出`HTTPException`，状态码为404，提示“User not found”。

• 返回用户对象。

• 获取所有用户

• `@app.get("/users/")`：定义了一个GET请求端点，用于获取所有用户信息。

• 接收`skip`和`limit`作为查询参数，用于分页。

• 调用`crud.get_users`函数查询用户列表。

• 返回用户列表。

• 更新用户

• `@app.put("/users/{user_id}")`：定义了一个PUT请求端点，用于更新用户信息。

• 接收用户ID作为路径参数，`SysUserCreate`对象作为请求体。

• 调用`crud.update_user`函数更新用户数据。

• 如果用户不存在，抛出`HTTPException`，状态码为404，提示“User not found”。

• 返回更新后的用户对象。

• 删除用户

• `@app.delete("/users/{user_id}")`：定义了一个DELETE请求端点，用于删除用户。

• 接收用户ID作为路径参数。

• 调用`crud.delete_user`函数删除用户。

• 如果用户不存在，抛出`HTTPException`，状态码为404，提示“User not found”。

• 返回一个成功消息，提示“User deleted”。

依赖模块

• `FastAPI`：用于构建API端点和处理HTTP请求。

• `SQLAlchemy`：用于数据库操作，包括会话管理和数据模型定义。

• `Pydantic`：用于数据验证和序列化。

• `src.models.sys_user`：定义了`SysUser`数据库模型。

• `src.crud.sys_user`：定义了用户相关的CRUD操作函数。

• `src.schemas.sys_user`：定义了`SysUserCreate`和`SysUser`Pydantic模型。

• `src`：包含配置、日志、全局数据、登录管理器等模块。

总结
该文件定义了一个FastAPI应用程序，提供了用户管理的API端点，包括创建、读取、更新和删除用户。它通过`SQLAlchemy`管理数据库操作，并使用`Pydantic`模型进行数据验证和序列化。每个API端点都有明确的功能，确保用户数据的正确处理和响应。

运行程序

运行程序前，请到数据库中查询sys_user【无法查到该表】,运行程序后再查询sys_user【该表已经被查询】.

在项目终端运行以下命令来运行项目：

uvicorn main:app --reload --port 8080

验证与测试

用APIPOST工具验证：

创建用户：

在“apipost”新建一个POST接口

地址栏输入：http://127.0.0.1:8080/users/

在Body中选择RAW，格式Json，内容如下：

{
    "api_id": "some-api-id",
    "login_id": "some-login-id",
    "user_name": "some-user-name",
    "login_password": "some-password",
    "email": "user@example.com",
    "person_id": "some-person-id",
    "is_superuser": false,
    "is_staff": true,
    "effective_date": "2025-04-24",
    "expiry_date": null,
    "deletion_mark": false,
    "deletion_reason": null,
    "deletion_date": null,
    "deletion_by": null,
    "creator_by": null,
    "last_updated_date": null,
    "last_updated_by": null,
    "id":1

}

发送后结果：

{
	"is_superuser": false,
	"deletion_by": null,
	"is_staff": true,
	"create_date": "2025-04-25T08:57:42",
	"id": "815070e5-0279-4899-a5e4-85c2b53b842a",
	"effective_date": "2025-04-24",
	"creator_by": null,
	"expiry_date": null,
	"last_updated_date": null,
	"last_updated_by": null,
	"login_id": "some-login-id",
	"api_id": "some-api-id",
	"deletion_mark": false,
	"login_password": "some-password",
	"deletion_reason": null,
	"user_name": "some-user-name",
	"email": "user@example.com",
	"deletion_date": null,
	"person_id": "some-person-id"
}

查询用户：

在“apipost”新建一个GET接口

地址栏输入：http://127.0.0.1:8080/users/

验证结果：

多次被创建用户，所以结果多笔。

[
	{
		"api_id": "some-api-id",
		"login_id": "some-login-id",
		"user_name": "some-user-name",
		"login_password": "some-password",
		"email": "user@example.com",
		"person_id": "some-person-id",
		"is_superuser": false,
		"is_staff": true,
		"effective_date": "2025-04-24",
		"expiry_date": null,
		"deletion_mark": false,
		"deletion_reason": null,
		"deletion_date": null,
		"deletion_by": null,
		"creator_by": null,
		"last_updated_date": null,
		"last_updated_by": null,
		"id": "0ae7435a-d18a-4387-90aa-4c2febde633a"
	},
	{
		"api_id": "some-api-id",
		"login_id": "some-login-id",
		"user_name": "some-user-name",
		"login_password": "some-password",
		"email": "user@example.com",
		"person_id": "some-person-id",
		"is_superuser": false,
		"is_staff": true,
		"effective_date": "2025-04-24",
		"expiry_date": null,
		"deletion_mark": false,
		"deletion_reason": null,
		"deletion_date": null,
		"deletion_by": null,
		"creator_by": null,
		"last_updated_date": null,
		"last_updated_by": null,
		"id": "37e5aea1-bcf5-458e-ad74-3604e1b55499"
	},
	{
		"api_id": "some-api-id",
		"login_id": "some-login-id",
		"user_name": "some-user-name",
		"login_password": "some-password",
		"email": "user@example.com",
		"person_id": "some-person-id",
		"is_superuser": false,
		"is_staff": true,
		"effective_date": "2025-04-24",
		"expiry_date": null,
		"deletion_mark": false,
		"deletion_reason": null,
		"deletion_date": null,
		"deletion_by": null,
		"creator_by": null,
		"last_updated_date": null,
		"last_updated_by": null,
		"id": "815070e5-0279-4899-a5e4-85c2b53b842a"
	},
	{
		"api_id": "some-api-id",
		"login_id": "some-login-id",
		"user_name": "some-user-name",
		"login_password": "some-password",
		"email": "user@example.com",
		"person_id": "some-person-id",
		"is_superuser": false,
		"is_staff": true,
		"effective_date": "2025-04-24",
		"expiry_date": null,
		"deletion_mark": false,
		"deletion_reason": null,
		"deletion_date": null,
		"deletion_by": null,
		"creator_by": null,
		"last_updated_date": null,
		"last_updated_by": null,
		"id": "a5232226-b012-4942-94b5-d0cb4ddd3462"
	},
	{
		"api_id": "some-api-id",
		"login_id": "some-login-id",
		"user_name": "some-user-name",
		"login_password": "some-password",
		"email": "user@example.com",
		"person_id": "some-person-id",
		"is_superuser": false,
		"is_staff": true,
		"effective_date": "2025-04-24",
		"expiry_date": null,
		"deletion_mark": false,
		"deletion_reason": null,
		"deletion_date": null,
		"deletion_by": null,
		"creator_by": null,
		"last_updated_date": null,
		"last_updated_by": null,
		"id": "c3601152-7ba7-46c4-a6fb-e2e68843d464"
	}
]

删除、修改、参数查询待验