定义模型并生成接口

.idea/file-receive-backend.iml

@@ -13,4 +13,11 @@
     <option name="format" value="PLAIN" />
     <option name="myDocStringFormat" value="Plain" />
   </component>
+  <component name="PyNamespacePackagesService">
+    <option name="namespacePackageFolders">
+      <list>
+        <option value="$MODULE_DIR$/mods/receive" />
+      </list>
+    </option>
+  </component>
 </module>

mods/receive/common.py

@@ -0,0 +1,4 @@
+from context.common import common_db
+
+get_db = common_db.get_db
+Base = common_db.Base

mods/receive/models.py

@@ -0,0 +1,117 @@
+import string
+import uuid
+from datetime import datetime
+from random import random
+from typing import Set
+from sqlalchemy import String, DateTime, func, Boolean, JSON, ForeignKey, Enum, TEXT, Double, Integer, create_engine
+from sqlalchemy.orm import mapped_column, Mapped, declarative_base, relationship
+from mods.rate.schemas import ReceiveSubjectState, ReceiveOrderState, NoticeType
+from utils.random_utils import get_random_letter_and_num_code, get_random_num_code, time_now_to_code
+from utils.sqlalchemy_common_utils import SalBase
+from .common import Base
+
+
+def make_rate_serve_id():
+    random_str = ''.join(random.choice(string.ascii_uppercase) for _ in range(5))
+    time_str = datetime.now().strftime('%Y%m%dmm')
+    return f"XP{random_str}{time_str}"
+
+
+class ReceiveSubjectFile(Base, SalBase):
+    """
+    主题文件
+    """
+    __tablename__ = "receive_subject_file"
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, comment='id')
+    subject_id: Mapped[int] = mapped_column(ForeignKey("receive_subject.id", ondelete="CASCADE", onupdate="CASCADE"),
+                                            comment="主题ID", nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False, comment='名称')
+    type: Mapped[str] = mapped_column(String(255), nullable=False, comment='类型')
+    des: Mapped[str] = mapped_column(TEXT, nullable=True, comment='说明')
+    template_path: Mapped[str] = mapped_column(String(255), nullable=True, comment="模板文件链接")
+    file_size_limit: Mapped[float] = mapped_column(Double, nullable=True, default=10, comment='文件大小限制mb')
+
+
+class ReceiveSubject(Base, SalBase):
+    """
+    接收主题
+    """
+    __tablename__ = "receive_subject"
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, comment='主题ID')
+    name: Mapped[str] = mapped_column(String(255), nullable=False, unique=True, comment='主题名称')
+    start_time: Mapped[datetime] = mapped_column(DateTime, server_default=func.now(), nullable=True,
+                                                 comment='开始时间')
+    finish_time: Mapped[datetime] = mapped_column(DateTime, nullable=True,
+                                                  comment='结束时间')
+    state: Mapped[ReceiveSubjectState] = mapped_column(Enum(ReceiveSubjectState),
+                                                       default=ReceiveSubjectState.receiving, comment="主题状态")
+    folder_name: Mapped[str] = mapped_column(String(255), default=lambda: (lambda: get_random_letter_and_num_code(10)),
+                                             comment="文件接收目录名称", nullable=False)
+
+    create_time: Mapped[datetime] = mapped_column(DateTime, server_default=func.now(), nullable=True,
+                                                  comment='创建时间')
+    des: Mapped[str] = mapped_column(TEXT, nullable=True, comment='说明')
+    files: Mapped[Set[ReceiveSubjectFile]] = relationship()
+
+
+class ReceiveFile(Base, SalBase):
+    """
+    主题文件
+    """
+    __tablename__ = "receive_file"
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, comment='id')
+    receive_order_id: Mapped[int] = mapped_column(
+        ForeignKey("receive_order.id", ondelete="CASCADE", onupdate="CASCADE"),
+        comment="接收单id", nullable=False)
+    receive_subject_file_id: Mapped[int] = mapped_column(
+        ForeignKey("receive_subject_file.id", ondelete="CASCADE", onupdate="CASCADE"),
+        comment="模板ID", nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False, comment='文件名称')
+    file_path: Mapped[str] = mapped_column(String(255), nullable=True, comment="文件链接")
+
+
+class ReceiveOrderNoticeLog(Base, SalBase):
+    """
+    接收通知日志
+    """
+    __tablename__ = "receive_order_notice_log"
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, comment='id')
+    subject_id: Mapped[int] = mapped_column(ForeignKey("receive_order.id", ondelete="CASCADE", onupdate="CASCADE"),
+                                            comment="主题ID", nullable=False)
+    account: Mapped[str] = mapped_column(String(255), nullable=False, comment='通知账户')
+    notice_type: Mapped[NoticeType] = mapped_column(Enum(NoticeType), nullable=False, comment='通知类型')
+    notice_time: Mapped[datetime] = mapped_column(DateTime, server_default=func.now(), comment='通知时间')
+
+
+class ReceiveOrder(Base, SalBase):
+    """
+    接收单
+    """
+    __tablename__ = "receive_order"
+    id: Mapped[str] = mapped_column(String(255), primary_key=True, default=lambda: make_rate_serve_id, comment='id')
+    subject_id: Mapped[int] = mapped_column(ForeignKey("receive_subject.id", ondelete="CASCADE", onupdate="CASCADE"),
+                                            comment="主题ID", nullable=False)
+    subject: Mapped[ReceiveSubject] = relationship()
+    sender_company: Mapped[str] = mapped_column(String(255), nullable=False, comment='接收公司')
+    sender_phone: Mapped[str] = mapped_column(String(255), nullable=True, comment='接收人手机')
+    sender_email: Mapped[str] = mapped_column(String(255), nullable=True, comment='接收人邮箱')
+    sender_name: Mapped[str] = mapped_column(String(255), nullable=True, comment='接收人')
+    sender_wx: Mapped[str] = mapped_column(String(255), nullable=True, comment='接收人微信')
+    contact_user_id: Mapped[str] = mapped_column(ForeignKey("user.id", ondelete="SET NULL", onupdate="CASCADE"),
+                                                 comment="对接人", nullable=True)
+
+    url_code: Mapped[str] = mapped_column(String(255), default=lambda: time_now_to_code,
+                                          comment='接收链接后缀')
+    code: Mapped[str] = mapped_column(String(255), default=lambda: (lambda: get_random_num_code(4)),
+                                      comment='接收链接后缀')
+
+    state: Mapped[ReceiveOrderState] = mapped_column(Enum(ReceiveOrderState),
+                                                     default=ReceiveOrderState.receiving, comment="接收单状态")
+    files: Mapped[Set[ReceiveFile]] = relationship()
+
+    create_time: Mapped[datetime] = mapped_column(DateTime, server_default=func.now(), nullable=True,
+                                                  comment='创建时间')
+    finish_time: Mapped[datetime] = mapped_column(DateTime, nullable=True,
+                                                  comment='完成时间')
+
+    notice_logs: Mapped[Set[ReceiveOrderNoticeLog]] = relationship()

mods/receive/mods/receive_file/crud.py

@@ -0,0 +1,36 @@
+from typing import List
+
+from sqlalchemy.orm import Session
+
+from utils.sqlalchemy_common_utils import ModelCRUD
+from . import schemas
+from ...models import ReceiveFile
+
+model_crud = ModelCRUD(ReceiveFile)
+
+
+def receive_file_add(db: Session, data: schemas.ReceiveFileAdd) -> ReceiveFile:
+    return model_crud.add(db, data)
+
+
+def receive_file_delete(db: Session, data: schemas.ReceiveFileId):
+    return model_crud.delete(db, data)
+
+
+def receive_file_update(db: Session, data: schemas.ReceiveFileUpdate) -> ReceiveFile:
+    return model_crud.update(db, data)
+
+
+def receive_file_query(db: Session, query_data: schemas.ReceiveFileQuery) -> (int, List[ReceiveFile]):
+    count, query, page, page_size = model_crud.query(db, query_data)
+    query = query.offset((page - 1) * page_size).limit(page_size)
+    return count, query
+
+
+def receive_file_get(db: Session, data: schemas.ReceiveFileId) -> ReceiveFile:
+    return model_crud.get(db, data)
+
+
+def receive_file_all(db: Session):
+    return db.query(ReceiveFile).all()
+

mods/receive/mods/receive_file/router.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ...common import get_db
+from . import crud
+from . import schemas
+
+router = APIRouter(tags=["接收文件"], prefix='/receive_file')
+
+
+@router.post("/add", summary="添加接收文件", response_model=schemas.ReceiveFileAddRes)
+def receive_file_add(req: schemas.ReceiveFileAddReq, db: Session = Depends(get_db)):
+    item = crud.receive_file_add(db, req)
+    return schemas.ReceiveFileAddRes(**item.to_dict())
+
+
+@router.post("/delete", summary="删除接收文件")
+def receive_file_delete(req: schemas.ReceiveFileDeleteReq, db: Session = Depends(get_db)):
+    crud.receive_file_delete(db, req)
+    return "删除成功"
+
+
+@router.post("/update", summary="更新接收文件", response_model=schemas.ReceiveFileUpdateRes)
+def receive_file_update(req: schemas.ReceiveFileUpdateReq, db: Session = Depends(get_db)):
+    item = crud.receive_file_update(db, req)
+    return schemas.ReceiveFileUpdateRes(**item.to_dict())
+
+
+@router.post("/get", summary="获取接收文件", response_model=schemas.ReceiveFileGetRes)
+def receive_file_get(req: schemas.ReceiveFileGetReq, db: Session = Depends(get_db)):
+    item = crud.receive_file_get(db, req)
+    if not item:
+        raise HTTPException(detail="未查询到信息", status_code=404)
+    return schemas.ReceiveFileGetRes(**item.to_full_dict())
+
+
+@router.post("/query", summary="查询接收文件", response_model=schemas.ReceiveFileQueryRes)
+def receive_file_query(req: schemas.ReceiveFileQueryReq, db: Session = Depends(get_db)):
+    count, query = crud.receive_file_query(db, req)
+    items = [schemas.ReceiveFileInfo(**item.to_full_dict(include=req.include,
+                                                                ex_include=req.ex_include,
+                                                                relation_use_id=req.relation_use_id)) for item in query]
+    return schemas.ReceiveFileQueryRes(count=count, items=items)
+
+
+@router.post("/all", summary="获取所有接收文件", response_model=schemas.ReceiveFileAllRes)
+def receive_file_all(req: schemas.ReceiveFileAllReq, db: Session = Depends(get_db)):
+    query = crud.receive_file_all(db)
+    items = [schemas.ReceiveFileInfo(**item.to_full_dict(include=req.include,
+                                                                ex_include=req.ex_include,
+                                                                relation_use_id=req.relation_use_id)) for item in query]
+    return schemas.ReceiveFileAllRes(items=items)
+#########

mods/receive/mods/receive_file/schemas.py

@@ -0,0 +1,86 @@
+from typing import Optional, List, Union, Any, Set, Dict
+from pydantic import BaseModel
+from utils.pydantic_utils import AllOptional
+from utils.sqlalchemy_common_utils import QueryParams, QueryInclude
+from datetime import date, datetime
+
+
+class ReceiveFileId(BaseModel):
+    id: int
+
+
+class ReceiveFileAdd(BaseModel):
+    name:  str
+    receive_order_id:  str
+    receive_subject_file_id:  int
+    file_path:  Optional[str]
+
+
+class ReceiveFileAddOptional(ReceiveFileAdd, metaclass=AllOptional):
+    pass
+
+
+class ReceiveFileInfo(ReceiveFileId, ReceiveFileAddOptional):
+    pass
+
+
+class ReceiveFileUpdate(ReceiveFileId, ReceiveFileAddOptional):
+    pass
+
+
+class ReceiveFileQuery(QueryParams[ReceiveFileInfo]):
+    pass
+
+
+###################
+# 接口定义
+
+
+class ReceiveFileAddReq(ReceiveFileAdd):
+    pass
+
+
+class ReceiveFileAddRes(ReceiveFileInfo):
+    pass
+
+
+class ReceiveFileDeleteReq(ReceiveFileId):
+    pass
+
+
+class ReceiveFileDeleteRes(BaseModel):
+    pass
+
+
+class ReceiveFileUpdateReq(ReceiveFileUpdate):
+    pass
+
+
+class ReceiveFileUpdateRes(ReceiveFileInfo):
+    pass
+
+
+class ReceiveFileGetReq(ReceiveFileId):
+    pass
+
+
+class ReceiveFileGetRes(ReceiveFileInfo):
+    pass
+
+
+class ReceiveFileQueryReq(ReceiveFileQuery):
+    pass
+
+
+class ReceiveFileQueryRes(BaseModel):
+    count: int
+    items: List[ReceiveFileInfo]
+    pass
+
+
+class ReceiveFileAllReq(QueryInclude):
+    pass
+
+
+class ReceiveFileAllRes(BaseModel):
+    items: List[ReceiveFileInfo]

mods/receive/mods/receive_order/crud.py

@@ -0,0 +1,36 @@
+from typing import List
+
+from sqlalchemy.orm import Session
+
+from utils.sqlalchemy_common_utils import ModelCRUD
+from . import schemas
+from ...models import ReceiveOrder
+
+model_crud = ModelCRUD(ReceiveOrder)
+
+
+def receive_order_add(db: Session, data: schemas.ReceiveOrderAdd) -> ReceiveOrder:
+    return model_crud.add(db, data)
+
+
+def receive_order_delete(db: Session, data: schemas.ReceiveOrderId):
+    return model_crud.delete(db, data)
+
+
+def receive_order_update(db: Session, data: schemas.ReceiveOrderUpdate) -> ReceiveOrder:
+    return model_crud.update(db, data)
+
+
+def receive_order_query(db: Session, query_data: schemas.ReceiveOrderQuery) -> (int, List[ReceiveOrder]):
+    count, query, page, page_size = model_crud.query(db, query_data)
+    query = query.offset((page - 1) * page_size).limit(page_size)
+    return count, query
+
+
+def receive_order_get(db: Session, data: schemas.ReceiveOrderId) -> ReceiveOrder:
+    return model_crud.get(db, data)
+
+
+def receive_order_all(db: Session):
+    return db.query(ReceiveOrder).all()
+

mods/receive/mods/receive_order/router.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ...common import get_db
+from . import crud
+from . import schemas
+
+router = APIRouter(tags=["接收单"], prefix='/receive_order')
+
+
+@router.post("/add", summary="添加接收单", response_model=schemas.ReceiveOrderAddRes)
+def receive_order_add(req: schemas.ReceiveOrderAddReq, db: Session = Depends(get_db)):
+    item = crud.receive_order_add(db, req)
+    return schemas.ReceiveOrderAddRes(**item.to_dict())
+
+
+@router.post("/delete", summary="删除接收单")
+def receive_order_delete(req: schemas.ReceiveOrderDeleteReq, db: Session = Depends(get_db)):
+    crud.receive_order_delete(db, req)
+    return "删除成功"
+
+
+@router.post("/update", summary="更新接收单", response_model=schemas.ReceiveOrderUpdateRes)
+def receive_order_update(req: schemas.ReceiveOrderUpdateReq, db: Session = Depends(get_db)):
+    item = crud.receive_order_update(db, req)
+    return schemas.ReceiveOrderUpdateRes(**item.to_dict())
+
+
+@router.post("/get", summary="获取接收单", response_model=schemas.ReceiveOrderGetRes)
+def receive_order_get(req: schemas.ReceiveOrderGetReq, db: Session = Depends(get_db)):
+    item = crud.receive_order_get(db, req)
+    if not item:
+        raise HTTPException(detail="未查询到信息", status_code=404)
+    return schemas.ReceiveOrderGetRes(**item.to_full_dict())
+
+
+@router.post("/query", summary="查询接收单", response_model=schemas.ReceiveOrderQueryRes)
+def receive_order_query(req: schemas.ReceiveOrderQueryReq, db: Session = Depends(get_db)):
+    count, query = crud.receive_order_query(db, req)
+    items = [schemas.ReceiveOrderInfo(**item.to_full_dict(include=req.include,
+                                                                ex_include=req.ex_include,
+                                                                relation_use_id=req.relation_use_id)) for item in query]
+    return schemas.ReceiveOrderQueryRes(count=count, items=items)
+
+
+@router.post("/all", summary="获取所有接收单", response_model=schemas.ReceiveOrderAllRes)
+def receive_order_all(req: schemas.ReceiveOrderAllReq, db: Session = Depends(get_db)):
+    query = crud.receive_order_all(db)
+    items = [schemas.ReceiveOrderInfo(**item.to_full_dict(include=req.include,
+                                                                ex_include=req.ex_include,
+                                                                relation_use_id=req.relation_use_id)) for item in query]
+    return schemas.ReceiveOrderAllRes(items=items)
+#########

mods/receive/mods/receive_order/schemas.py

@@ -0,0 +1,97 @@
+from typing import Optional, List, Union, Any, Set, Dict
+from pydantic import BaseModel
+from utils.pydantic_utils import AllOptional
+from utils.sqlalchemy_common_utils import QueryParams, QueryInclude
+from datetime import date, datetime
+
+
+class ReceiveOrderId(BaseModel):
+    id: int
+
+
+class ReceiveOrderAdd(BaseModel):
+    subject:  Optional[Any]
+    subject_id:  int
+    sender_company:  str
+    sender_phone:  Optional[str]
+    sender_email:  Optional[str]
+    sender_name:  Optional[str]
+    sender_wx:  Optional[str]
+    contact_user_id:  Optional[str]
+    url_code:  Optional[str]
+    code:  Optional[str]
+    state:  Any
+    files:  Optional[List[Any]]
+    create_time:  Optional[datetime]
+    finish_time:  Optional[datetime]
+    notice_logs:  Optional[List[Any]]
+
+
+class ReceiveOrderAddOptional(ReceiveOrderAdd, metaclass=AllOptional):
+    pass
+
+
+class ReceiveOrderInfo(ReceiveOrderId, ReceiveOrderAddOptional):
+    pass
+
+
+class ReceiveOrderUpdate(ReceiveOrderId, ReceiveOrderAddOptional):
+    pass
+
+
+class ReceiveOrderQuery(QueryParams[ReceiveOrderInfo]):
+    pass
+
+
+###################
+# 接口定义
+
+
+class ReceiveOrderAddReq(ReceiveOrderAdd):
+    pass
+
+
+class ReceiveOrderAddRes(ReceiveOrderInfo):
+    pass
+
+
+class ReceiveOrderDeleteReq(ReceiveOrderId):
+    pass
+
+
+class ReceiveOrderDeleteRes(BaseModel):
+    pass
+
+
+class ReceiveOrderUpdateReq(ReceiveOrderUpdate):
+    pass
+
+
+class ReceiveOrderUpdateRes(ReceiveOrderInfo):
+    pass
+
+
+class ReceiveOrderGetReq(ReceiveOrderId):
+    pass
+
+
+class ReceiveOrderGetRes(ReceiveOrderInfo):
+    pass
+
+
+class ReceiveOrderQueryReq(ReceiveOrderQuery):
+    pass
+
+
+class ReceiveOrderQueryRes(BaseModel):
+    count: int
+    items: List[ReceiveOrderInfo]
+    pass
+
+
+class ReceiveOrderAllReq(QueryInclude):
+    pass
+
+
+class ReceiveOrderAllRes(BaseModel):
+    items: List[ReceiveOrderInfo]

mods/receive/mods/receive_order_notice_log/crud.py

@@ -0,0 +1,36 @@
+from typing import List
+
+from sqlalchemy.orm import Session
+
+from utils.sqlalchemy_common_utils import ModelCRUD
+from . import schemas
+from ...models import ReceiveOrderNoticeLog
+
+model_crud = ModelCRUD(ReceiveOrderNoticeLog)
+
+
+def receive_order_notice_log_add(db: Session, data: schemas.ReceiveOrderNoticeLogAdd) -> ReceiveOrderNoticeLog:
+    return model_crud.add(db, data)
+
+
+def receive_order_notice_log_delete(db: Session, data: schemas.ReceiveOrderNoticeLogId):
+    return model_crud.delete(db, data)
+
+
+def receive_order_notice_log_update(db: Session, data: schemas.ReceiveOrderNoticeLogUpdate) -> ReceiveOrderNoticeLog:
+    return model_crud.update(db, data)
+
+
+def receive_order_notice_log_query(db: Session, query_data: schemas.ReceiveOrderNoticeLogQuery) -> (int, List[ReceiveOrderNoticeLog]):
+    count, query, page, page_size = model_crud.query(db, query_data)
+    query = query.offset((page - 1) * page_size).limit(page_size)
+    return count, query
+
+
+def receive_order_notice_log_get(db: Session, data: schemas.ReceiveOrderNoticeLogId) -> ReceiveOrderNoticeLog:
+    return model_crud.get(db, data)
+
+
+def receive_order_notice_log_all(db: Session):
+    return db.query(ReceiveOrderNoticeLog).all()
+

mods/receive/mods/receive_order_notice_log/router.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ...common import get_db
+from . import crud
+from . import schemas
+
+router = APIRouter(tags=["通知日志"], prefix='/receive_order_notice_log')
+
+
+@router.post("/add", summary="添加通知日志", response_model=schemas.ReceiveOrderNoticeLogAddRes)
+def receive_order_notice_log_add(req: schemas.ReceiveOrderNoticeLogAddReq, db: Session = Depends(get_db)):
+    item = crud.receive_order_notice_log_add(db, req)
+    return schemas.ReceiveOrderNoticeLogAddRes(**item.to_dict())
+
+
+@router.post("/delete", summary="删除通知日志")
+def receive_order_notice_log_delete(req: schemas.ReceiveOrderNoticeLogDeleteReq, db: Session = Depends(get_db)):
+    crud.receive_order_notice_log_delete(db, req)
+    return "删除成功"
+
+
+@router.post("/update", summary="更新通知日志", response_model=schemas.ReceiveOrderNoticeLogUpdateRes)
+def receive_order_notice_log_update(req: schemas.ReceiveOrderNoticeLogUpdateReq, db: Session = Depends(get_db)):
+    item = crud.receive_order_notice_log_update(db, req)
+    return schemas.ReceiveOrderNoticeLogUpdateRes(**item.to_dict())
+
+
+@router.post("/get", summary="获取通知日志", response_model=schemas.ReceiveOrderNoticeLogGetRes)
+def receive_order_notice_log_get(req: schemas.ReceiveOrderNoticeLogGetReq, db: Session = Depends(get_db)):
+    item = crud.receive_order_notice_log_get(db, req)
+    if not item:
+        raise HTTPException(detail="未查询到信息", status_code=404)
+    return schemas.ReceiveOrderNoticeLogGetRes(**item.to_full_dict())
+
+
+@router.post("/query", summary="查询通知日志", response_model=schemas.ReceiveOrderNoticeLogQueryRes)
+def receive_order_notice_log_query(req: schemas.ReceiveOrderNoticeLogQueryReq, db: Session = Depends(get_db)):
+    count, query = crud.receive_order_notice_log_query(db, req)
+    items = [schemas.ReceiveOrderNoticeLogInfo(**item.to_full_dict(include=req.include,
+                                                                ex_include=req.ex_include,
+                                                                relation_use_id=req.relation_use_id)) for item in query]
+    return schemas.ReceiveOrderNoticeLogQueryRes(count=count, items=items)
+
+
+@router.post("/all", summary="获取所有通知日志", response_model=schemas.ReceiveOrderNoticeLogAllRes)
+def receive_order_notice_log_all(req: schemas.ReceiveOrderNoticeLogAllReq, db: Session = Depends(get_db)):
+    query = crud.receive_order_notice_log_all(db)
+    items = [schemas.ReceiveOrderNoticeLogInfo(**item.to_full_dict(include=req.include,
+                                                                ex_include=req.ex_include,
+                                                                relation_use_id=req.relation_use_id)) for item in query]
+    return schemas.ReceiveOrderNoticeLogAllRes(items=items)
+#########

mods/receive/mods/receive_order_notice_log/schemas.py

@@ -0,0 +1,86 @@
+from typing import Optional, List, Union, Any, Set, Dict
+from pydantic import BaseModel
+from utils.pydantic_utils import AllOptional
+from utils.sqlalchemy_common_utils import QueryParams, QueryInclude
+from datetime import date, datetime
+
+
+class ReceiveOrderNoticeLogId(BaseModel):
+    id: int
+
+
+class ReceiveOrderNoticeLogAdd(BaseModel):
+    subject_id:  str
+    account:  str
+    notice_type:  Any
+    notice_time:  Optional[datetime]
+
+
+class ReceiveOrderNoticeLogAddOptional(ReceiveOrderNoticeLogAdd, metaclass=AllOptional):
+    pass
+
+
+class ReceiveOrderNoticeLogInfo(ReceiveOrderNoticeLogId, ReceiveOrderNoticeLogAddOptional):
+    pass
+
+
+class ReceiveOrderNoticeLogUpdate(ReceiveOrderNoticeLogId, ReceiveOrderNoticeLogAddOptional):
+    pass
+
+
+class ReceiveOrderNoticeLogQuery(QueryParams[ReceiveOrderNoticeLogInfo]):
+    pass
+
+
+###################
+# 接口定义
+
+
+class ReceiveOrderNoticeLogAddReq(ReceiveOrderNoticeLogAdd):
+    pass
+
+
+class ReceiveOrderNoticeLogAddRes(ReceiveOrderNoticeLogInfo):
+    pass
+
+
+class ReceiveOrderNoticeLogDeleteReq(ReceiveOrderNoticeLogId):
+    pass
+
+
+class ReceiveOrderNoticeLogDeleteRes(BaseModel):
+    pass
+
+
+class ReceiveOrderNoticeLogUpdateReq(ReceiveOrderNoticeLogUpdate):
+    pass
+
+
+class ReceiveOrderNoticeLogUpdateRes(ReceiveOrderNoticeLogInfo):
+    pass
+
+
+class ReceiveOrderNoticeLogGetReq(ReceiveOrderNoticeLogId):
+    pass
+
+
+class ReceiveOrderNoticeLogGetRes(ReceiveOrderNoticeLogInfo):
+    pass
+
+
+class ReceiveOrderNoticeLogQueryReq(ReceiveOrderNoticeLogQuery):
+    pass
+
+
+class ReceiveOrderNoticeLogQueryRes(BaseModel):
+    count: int
+    items: List[ReceiveOrderNoticeLogInfo]
+    pass
+
+
+class ReceiveOrderNoticeLogAllReq(QueryInclude):
+    pass
+
+
+class ReceiveOrderNoticeLogAllRes(BaseModel):
+    items: List[ReceiveOrderNoticeLogInfo]

mods/receive/mods/receive_subject/crud.py

@@ -0,0 +1,36 @@
+from typing import List
+
+from sqlalchemy.orm import Session
+
+from utils.sqlalchemy_common_utils import ModelCRUD
+from . import schemas
+from ...models import ReceiveSubject
+
+model_crud = ModelCRUD(ReceiveSubject)
+
+
+def receive_subject_add(db: Session, data: schemas.ReceiveSubjectAdd) -> ReceiveSubject:
+    return model_crud.add(db, data)
+
+
+def receive_subject_delete(db: Session, data: schemas.ReceiveSubjectId):
+    return model_crud.delete(db, data)
+
+
+def receive_subject_update(db: Session, data: schemas.ReceiveSubjectUpdate) -> ReceiveSubject:
+    return model_crud.update(db, data)
+
+
+def receive_subject_query(db: Session, query_data: schemas.ReceiveSubjectQuery) -> (int, List[ReceiveSubject]):
+    count, query, page, page_size = model_crud.query(db, query_data)
+    query = query.offset((page - 1) * page_size).limit(page_size)
+    return count, query
+
+
+def receive_subject_get(db: Session, data: schemas.ReceiveSubjectId) -> ReceiveSubject:
+    return model_crud.get(db, data)
+
+
+def receive_subject_all(db: Session):
+    return db.query(ReceiveSubject).all()
+

mods/receive/mods/receive_subject/router.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ...common import get_db
+from . import crud
+from . import schemas
+
+router = APIRouter(tags=["接收主题"], prefix='/receive_subject')
+
+
+@router.post("/add", summary="添加接收主题", response_model=schemas.ReceiveSubjectAddRes)
+def receive_subject_add(req: schemas.ReceiveSubjectAddReq, db: Session = Depends(get_db)):
+    item = crud.receive_subject_add(db, req)
+    return schemas.ReceiveSubjectAddRes(**item.to_dict())
+
+
+@router.post("/delete", summary="删除接收主题")
+def receive_subject_delete(req: schemas.ReceiveSubjectDeleteReq, db: Session = Depends(get_db)):
+    crud.receive_subject_delete(db, req)
+    return "删除成功"
+
+
+@router.post("/update", summary="更新接收主题", response_model=schemas.ReceiveSubjectUpdateRes)
+def receive_subject_update(req: schemas.ReceiveSubjectUpdateReq, db: Session = Depends(get_db)):
+    item = crud.receive_subject_update(db, req)
+    return schemas.ReceiveSubjectUpdateRes(**item.to_dict())
+
+
+@router.post("/get", summary="获取接收主题", response_model=schemas.ReceiveSubjectGetRes)
+def receive_subject_get(req: schemas.ReceiveSubjectGetReq, db: Session = Depends(get_db)):
+    item = crud.receive_subject_get(db, req)
+    if not item:
+        raise HTTPException(detail="未查询到信息", status_code=404)
+    return schemas.ReceiveSubjectGetRes(**item.to_full_dict())
+
+
+@router.post("/query", summary="查询接收主题", response_model=schemas.ReceiveSubjectQueryRes)
+def receive_subject_query(req: schemas.ReceiveSubjectQueryReq, db: Session = Depends(get_db)):
+    count, query = crud.receive_subject_query(db, req)
+    items = [schemas.ReceiveSubjectInfo(**item.to_full_dict(include=req.include,
+                                                                ex_include=req.ex_include,
+                                                                relation_use_id=req.relation_use_id)) for item in query]
+    return schemas.ReceiveSubjectQueryRes(count=count, items=items)
+
+
+@router.post("/all", summary="获取所有接收主题", response_model=schemas.ReceiveSubjectAllRes)
+def receive_subject_all(req: schemas.ReceiveSubjectAllReq, db: Session = Depends(get_db)):
+    query = crud.receive_subject_all(db)
+    items = [schemas.ReceiveSubjectInfo(**item.to_full_dict(include=req.include,
+                                                                ex_include=req.ex_include,
+                                                                relation_use_id=req.relation_use_id)) for item in query]
+    return schemas.ReceiveSubjectAllRes(items=items)
+#########

mods/receive/mods/receive_subject/schemas.py

@@ -0,0 +1,90 @@
+from typing import Optional, List, Union, Any, Set, Dict
+from pydantic import BaseModel
+from utils.pydantic_utils import AllOptional
+from utils.sqlalchemy_common_utils import QueryParams, QueryInclude
+from datetime import date, datetime
+
+
+class ReceiveSubjectId(BaseModel):
+    id: int
+
+
+class ReceiveSubjectAdd(BaseModel):
+    name:  str
+    start_time:  Optional[datetime]
+    finish_time:  Optional[datetime]
+    state:  Any
+    folder_name:  Optional[str]
+    create_time:  Optional[datetime]
+    des:  Any
+    files:  Optional[List[Any]]
+
+
+class ReceiveSubjectAddOptional(ReceiveSubjectAdd, metaclass=AllOptional):
+    pass
+
+
+class ReceiveSubjectInfo(ReceiveSubjectId, ReceiveSubjectAddOptional):
+    pass
+
+
+class ReceiveSubjectUpdate(ReceiveSubjectId, ReceiveSubjectAddOptional):
+    pass
+
+
+class ReceiveSubjectQuery(QueryParams[ReceiveSubjectInfo]):
+    pass
+
+
+###################
+# 接口定义
+
+
+class ReceiveSubjectAddReq(ReceiveSubjectAdd):
+    pass
+
+
+class ReceiveSubjectAddRes(ReceiveSubjectInfo):
+    pass
+
+
+class ReceiveSubjectDeleteReq(ReceiveSubjectId):
+    pass
+
+
+class ReceiveSubjectDeleteRes(BaseModel):
+    pass
+
+
+class ReceiveSubjectUpdateReq(ReceiveSubjectUpdate):
+    pass
+
+
+class ReceiveSubjectUpdateRes(ReceiveSubjectInfo):
+    pass
+
+
+class ReceiveSubjectGetReq(ReceiveSubjectId):
+    pass
+
+
+class ReceiveSubjectGetRes(ReceiveSubjectInfo):
+    pass
+
+
+class ReceiveSubjectQueryReq(ReceiveSubjectQuery):
+    pass
+
+
+class ReceiveSubjectQueryRes(BaseModel):
+    count: int
+    items: List[ReceiveSubjectInfo]
+    pass
+
+
+class ReceiveSubjectAllReq(QueryInclude):
+    pass
+
+
+class ReceiveSubjectAllRes(BaseModel):
+    items: List[ReceiveSubjectInfo]

mods/receive/mods/receive_subject_file/crud.py

@@ -0,0 +1,36 @@
+from typing import List
+
+from sqlalchemy.orm import Session
+
+from utils.sqlalchemy_common_utils import ModelCRUD
+from . import schemas
+from ...models import ReceiveSubjectFile
+
+model_crud = ModelCRUD(ReceiveSubjectFile)
+
+
+def receive_subject_file_add(db: Session, data: schemas.ReceiveSubjectFileAdd) -> ReceiveSubjectFile:
+    return model_crud.add(db, data)
+
+
+def receive_subject_file_delete(db: Session, data: schemas.ReceiveSubjectFileId):
+    return model_crud.delete(db, data)
+
+
+def receive_subject_file_update(db: Session, data: schemas.ReceiveSubjectFileUpdate) -> ReceiveSubjectFile:
+    return model_crud.update(db, data)
+
+
+def receive_subject_file_query(db: Session, query_data: schemas.ReceiveSubjectFileQuery) -> (int, List[ReceiveSubjectFile]):
+    count, query, page, page_size = model_crud.query(db, query_data)
+    query = query.offset((page - 1) * page_size).limit(page_size)
+    return count, query
+
+
+def receive_subject_file_get(db: Session, data: schemas.ReceiveSubjectFileId) -> ReceiveSubjectFile:
+    return model_crud.get(db, data)
+
+
+def receive_subject_file_all(db: Session):
+    return db.query(ReceiveSubjectFile).all()
+

mods/receive/mods/receive_subject_file/router.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ...common import get_db
+from . import crud
+from . import schemas
+
+router = APIRouter(tags=["主题文件模板"], prefix='/receive_subject_file')
+
+
+@router.post("/add", summary="添加主题文件模板", response_model=schemas.ReceiveSubjectFileAddRes)
+def receive_subject_file_add(req: schemas.ReceiveSubjectFileAddReq, db: Session = Depends(get_db)):
+    item = crud.receive_subject_file_add(db, req)
+    return schemas.ReceiveSubjectFileAddRes(**item.to_dict())
+
+
+@router.post("/delete", summary="删除主题文件模板")
+def receive_subject_file_delete(req: schemas.ReceiveSubjectFileDeleteReq, db: Session = Depends(get_db)):
+    crud.receive_subject_file_delete(db, req)
+    return "删除成功"
+
+
+@router.post("/update", summary="更新主题文件模板", response_model=schemas.ReceiveSubjectFileUpdateRes)
+def receive_subject_file_update(req: schemas.ReceiveSubjectFileUpdateReq, db: Session = Depends(get_db)):
+    item = crud.receive_subject_file_update(db, req)
+    return schemas.ReceiveSubjectFileUpdateRes(**item.to_dict())
+
+
+@router.post("/get", summary="获取主题文件模板", response_model=schemas.ReceiveSubjectFileGetRes)
+def receive_subject_file_get(req: schemas.ReceiveSubjectFileGetReq, db: Session = Depends(get_db)):
+    item = crud.receive_subject_file_get(db, req)
+    if not item:
+        raise HTTPException(detail="未查询到信息", status_code=404)
+    return schemas.ReceiveSubjectFileGetRes(**item.to_full_dict())
+
+
+@router.post("/query", summary="查询主题文件模板", response_model=schemas.ReceiveSubjectFileQueryRes)
+def receive_subject_file_query(req: schemas.ReceiveSubjectFileQueryReq, db: Session = Depends(get_db)):
+    count, query = crud.receive_subject_file_query(db, req)
+    items = [schemas.ReceiveSubjectFileInfo(**item.to_full_dict(include=req.include,
+                                                                ex_include=req.ex_include,
+                                                                relation_use_id=req.relation_use_id)) for item in query]
+    return schemas.ReceiveSubjectFileQueryRes(count=count, items=items)
+
+
+@router.post("/all", summary="获取所有主题文件模板", response_model=schemas.ReceiveSubjectFileAllRes)
+def receive_subject_file_all(req: schemas.ReceiveSubjectFileAllReq, db: Session = Depends(get_db)):
+    query = crud.receive_subject_file_all(db)
+    items = [schemas.ReceiveSubjectFileInfo(**item.to_full_dict(include=req.include,
+                                                                ex_include=req.ex_include,
+                                                                relation_use_id=req.relation_use_id)) for item in query]
+    return schemas.ReceiveSubjectFileAllRes(items=items)
+#########

mods/receive/mods/receive_subject_file/schemas.py

@@ -0,0 +1,88 @@
+from typing import Optional, List, Union, Any, Set, Dict
+from pydantic import BaseModel
+from utils.pydantic_utils import AllOptional
+from utils.sqlalchemy_common_utils import QueryParams, QueryInclude
+from datetime import date, datetime
+
+
+class ReceiveSubjectFileId(BaseModel):
+    id: int
+
+
+class ReceiveSubjectFileAdd(BaseModel):
+    name:  str
+    subject_id:  int
+    type:  str
+    des:  Any
+    template_path:  Optional[str]
+    file_size_limit:  Optional[float]
+
+
+class ReceiveSubjectFileAddOptional(ReceiveSubjectFileAdd, metaclass=AllOptional):
+    pass
+
+
+class ReceiveSubjectFileInfo(ReceiveSubjectFileId, ReceiveSubjectFileAddOptional):
+    pass
+
+
+class ReceiveSubjectFileUpdate(ReceiveSubjectFileId, ReceiveSubjectFileAddOptional):
+    pass
+
+
+class ReceiveSubjectFileQuery(QueryParams[ReceiveSubjectFileInfo]):
+    pass
+
+
+###################
+# 接口定义
+
+
+class ReceiveSubjectFileAddReq(ReceiveSubjectFileAdd):
+    pass
+
+
+class ReceiveSubjectFileAddRes(ReceiveSubjectFileInfo):
+    pass
+
+
+class ReceiveSubjectFileDeleteReq(ReceiveSubjectFileId):
+    pass
+
+
+class ReceiveSubjectFileDeleteRes(BaseModel):
+    pass
+
+
+class ReceiveSubjectFileUpdateReq(ReceiveSubjectFileUpdate):
+    pass
+
+
+class ReceiveSubjectFileUpdateRes(ReceiveSubjectFileInfo):
+    pass
+
+
+class ReceiveSubjectFileGetReq(ReceiveSubjectFileId):
+    pass
+
+
+class ReceiveSubjectFileGetRes(ReceiveSubjectFileInfo):
+    pass
+
+
+class ReceiveSubjectFileQueryReq(ReceiveSubjectFileQuery):
+    pass
+
+
+class ReceiveSubjectFileQueryRes(BaseModel):
+    count: int
+    items: List[ReceiveSubjectFileInfo]
+    pass
+
+
+class ReceiveSubjectFileAllReq(QueryInclude):
+    pass
+
+
+class ReceiveSubjectFileAllRes(BaseModel):
+    items: List[ReceiveSubjectFileInfo]

mods/receive/router.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter
+from .mods.receive_subject.router import router as receive_subject_router
+from .mods.receive_order_notice_log.router import router as receive_order_notice_log_router
+from .mods.receive_order.router import router as receive_order_router
+from .mods.receive_subject_file.router import router as receive_subject_file_router
+from .mods.receive_file.router import router as receive_file_router
+
+router = APIRouter(prefix="/receive")
+router.include_router(receive_subject_router)
+router.include_router(receive_order_notice_log_router)
+router.include_router(receive_order_router)
+router.include_router(receive_subject_file_router)
+router.include_router(receive_file_router)

mods/receive/schemas.py

@@ -0,0 +1,28 @@
+from enum import Enum
+
+
+class RateServeState(Enum):
+    """
+    评级服务状态类型
+    """
+    examining = 'examining'  # 审核中
+    rating = 'rating'  # 评级中
+    cancel = 'cancel'  # 取消
+    finish = 'finish'  # 完成
+
+
+class NodeState(Enum):
+    """
+    节点状态
+    """
+    incomplete = "incomplete"  # 未完成
+    finish = "finish"  # 完成
+
+
+class FileSubType:
+    """
+    文件分类,不使用Enum,因为类型不限制
+    """
+    report = 'report'  # 报告
+    cert = 'cert'  # 证书
+    fill_sheet = 'fill_sheet'  # 企业填报文件

mods/router.py

@@ -1,6 +1,8 @@
 from fastapi import APIRouter
 
 from .user.router import router as user_router
+from .receive.router import router as receive_router
 
 router = APIRouter(prefix="")
 router.include_router(user_router)
+router.include_router(receive_router)

the_test.py

@@ -0,0 +1,225 @@
+from context.common import common_db
+from mods.rate.utils.rate_utils import sheet_parse
+from mods.user.router import *
+from mods.user.mods.user.models import User
+from utils.sqlalchemy_common_utils import QueryParams, query_common
+
+
+def run_c():
+    db = common_db.get_db_i()
+    # d2=Department(id=3,name='d2')
+    # d = db.query(Department).filter_by(id=1).first()
+    # u = User(name="xxx2", departments={d,d2})
+    q = QueryParams.parse_obj({'include': ['name', 'id'], 'ex_include': ['id'], 'page': 1, 'page_size': 10})
+    count, query = query_common(db, User, q)
+    for u in query:
+        print(u.to_full_dict(include=['name', 'id'], ex_include='id'))
+        # print(u.to_dict())
+    db.close()
+
+
+def run_d():
+    db = common_db.get_db_i()
+    u = db.query(User).filter(User.name == '伍春全').first()
+    if not u.other_info:
+        u.other_info = u.__class__.other_info.property.entity.entity(address="xxx")
+    else:
+        u.other_info.address = "xcxcxcxc"
+
+    db.commit()
+    db.close()
+
+
+# def run_a():
+#     db = common_db.get_db_i()
+#     user_update(db, UserUpdate(id='c4316ba243c442aca42e37dbe0d8f476', departments=[1, 2, 3]))
+#     db.close()
+#
+#
+# def run_b():
+#     db = common_db.get_db_i()
+#     d = db.query(Department).first()
+#     u = db.query(User).first()
+#     u.departments.add(d)
+#     db.commit()
+#     db.close()
+
+#
+# run_b()
+# run_a()
+# run_c()
+# from mods.user.comment.models import Comment
+
+#
+# print(Comment.model_config)
+
+
+def test_json_manage():
+    """
+    [mongo]
+    host = 127.0.0.1
+    port = 27017
+    db = 三方数据
+    ;user = fecr
+    ;password = fecr1988.wcq
+    :return:
+    """
+    from utils.json_data_utils import JsonDataManage, json_schema_to_pydantic
+    from pymongo import MongoClient
+    client = MongoClient(host="127.0.0.1", port=27017)
+    jdm = JsonDataManage(client)
+    jdm.load_schemas()
+    json_schema_to_pydantic({'title': 'User', 'type': 'object',
+                             'properties': {'name': {'title': 'Name', 'type': 'string'},
+                                            'age': {'title': 'Age', 'type': 'integer'}},
+                             'required': ['name', 'age']}, 'User')
+    # jdm.add_schema("用户", {'title': 'User', 'type': 'object',
+    #                         'properties': {'name': {'title': 'Name', 'type': 'string'},
+    #                                        'age': {'title': 'Age', 'type': 'integer'}},
+    #                         'required': ['name', 'age']}
+    #                )
+    jdm.insert_data('用户', {"name": "张三", "age": 11}, index={"company_name": "远东"}, check_repeated=True)
+
+
+def test_user_json():
+    db = common_db.get_db_i()
+    # d2=Department(id=3,name='d2')
+    # d = db.query(Department).filter_by(id=1).first()
+    # u = User(name="xxx2", departments={d,d2})
+    q = QueryParams.parse_obj({'include': ['name', 'id'], 'ex_include': ['id'], 'page': 1, 'page_size': 10})
+    count, query, page, page_size = query_common(db, User, q)
+
+    query[0].config
+
+
+# test_user_json()
+# test_json_manage()
+# run_d()
+
+import re
+
+
+def replace_words(content, word_list):
+    # 对词语列表中的每个词，使用正则表达式找到所有的匹配项，并将它们替换为词语列表中的形式
+    for word in word_list:
+        content = re.sub(rf"(?<![A-Za-z]){word}(?![A-Za-z])", word, content, flags=re.IGNORECASE)
+
+    return content
+
+
+# 测试函数
+# content = "使用Absasd和abs还有Gep和GEP"
+
+# word_list = ["ABs", "GEP"]
+# new_content = replace_words(content, word_list)
+# print(new_content)
+
+import inspect
+
+
+def test_code_make():
+    from mods.uir.models import CompanyIndex, CompanyPlusProperty, CompanyBaseInfo
+    # print(inspect.getsource(User))
+    from utils.code_make_utils.make_from_model import make_code_from_model
+    # make_code_from_model("utils/code_make_utils/templates/crud", "temp", User, "用户")
+    make_code_from_model("utils/code_make_utils/templates/crud_without_model", "mods/uir", CompanyIndex, "企业索引")
+    make_code_from_model("utils/code_make_utils/templates/crud_without_model", "mods/uir", CompanyPlusProperty,
+                         "企业属性")
+    make_code_from_model("utils/code_make_utils/templates/crud_without_model", "mods/uir", CompanyBaseInfo,
+                         "企业工商信息")
+
+
+def test_code_make2():
+    from mods.receive.models import ReceiveSubject, ReceiveFile, ReceiveOrderNoticeLog, ReceiveOrder, ReceiveSubjectFile
+    # print(inspect.getsource(User))
+    from utils.code_make_utils.make_from_model import make_mod_from_models
+    make_mod_from_models("receive", "mods",
+                         [
+                             (ReceiveSubject, "接收主题"),
+                             (ReceiveOrderNoticeLog, "通知日志"),
+                             (ReceiveOrder, "接收单"),
+                             (ReceiveSubjectFile, "主题文件模板"),
+                             (ReceiveFile, "接收文件"),
+                         ],
+                         )
+
+
+test_code_make2()
+
+
+def test_make_table_model():
+    from mods.uir.models import CompanyIndex, CompanyPlusProperty, CompanyBaseInfo
+    # print(inspect.getsource(User))
+    from utils.code_make_utils.make_from_model import make_mod_from_models, make_table_model
+    make_table_model(CompanyIndex, "企业索引")
+    make_table_model(CompanyPlusProperty, "企业属性")
+    make_table_model(CompanyBaseInfo, "企业工商信息")
+
+
+# test_make_table_model()
+
+def extract_data_to_json(excel_path: str) -> dict:
+    import pandas as pd
+    # Load “经营问卷” data from Excel
+    business_data = pd.read_excel(excel_path, sheet_name="经营问卷")
+    business_dict = {row["问题"]: row["填写（文本类无则不填写）"] for _, row in business_data.iterrows()}
+    for k, v in business_dict.items():
+        if pd.isna(v):
+            business_dict[k] = None
+
+    # Load “财务问卷” data from Excel
+    finance_data = pd.read_excel(excel_path, sheet_name="财务问卷")
+
+    # Convert multi-year data into a nested dictionary format
+    finance_report_dict = {}
+    report = None
+    for i, item in enumerate(finance_data['报表']):
+        if item in ["单位", "是否审计", "会计事务所"]:
+            if item in ["单位"]:
+                continue
+            if item in ["是否审计", "会计事务所"]:
+                finance_report_dict[item] = finance_data['科目'][i]
+                continue
+
+        if not pd.isna(item):
+            report = item
+            finance_report_dict[report] = {}
+
+        subject = finance_data['科目'][i]
+        finance_report_dict[report][subject] = [
+            finance_data['2020年'][i],
+            finance_data['2021年'][i],
+            finance_data['2022年'][i],
+        ]
+        if pd.isna(subject):
+            continue
+
+    data_dict = {
+        "经营问卷": business_dict,
+        "财务问卷": finance_report_dict
+    }
+
+    return data_dict
+
+
+#
+# # Use the function to extract data
+# extracted_data = extract_data_to_json("填报问卷 (2).xlsx")
+#
+# print(extracted_data)
+
+
+def sheet_parsesheet_parse():
+    sheet_parse(r"C:\Users\wcq\Desktop\北京探路者户外用品股份有限公司.xlsx")
+
+
+# sheet_parsesheet_parse()
+
+
+def tasd():
+    from context.common import common_db_v2
+    db = common_db_v2.get_db_i()
+    from mods.rate.mods.rate_serve.utils import RateServeFlowNodeCheck
+    RateServeFlowNodeCheck.rate_post_data_check_node(db, 'XP23091648527424WFWOA')
+
+# tasd()

utils/random_utils.py

@@ -1,5 +1,6 @@
 import random
 import string
+import time
 
 
 def get_random_num_code(length=8):
@@ -11,4 +12,19 @@ def get_random_letter_code(length=8):
 
 
 def get_random_letter_and_num_code(length=4):
-    return ''.join(random.sample(string.ascii_letters + string.digits, 4))
+    return ''.join(random.sample(string.ascii_letters + string.digits, length))
+
+
+def time_now_to_code():
+    milliseconds = int(round(time.time() * 1000)) + random.randint(1000, 300000)
+    BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    if milliseconds == 0:
+        return '0'
+
+    result = ''
+    while milliseconds > 0:
+        remainder = milliseconds % 62
+        result = BASE62[remainder] + result
+        milliseconds //= 62
+
+    return result