第二版提交

app/api/account/schemas.py

 from typing import Optional
-from pydantic import BaseModel
+
+from fastapi import HTTPException
+from pydantic import BaseModel, validator
 
 
 class PublicModel(BaseModel):
@@ -33,17 +35,18 @@ class AccountUpdate(BaseModel):
 
 
 class FinanceInfo(PublicModel):
-    aid: int
+    unique_tag: str
 
 
 class FinanceDetails(PublicModel):
     type: Optional[int] = None
-    gift_type: Optional[str] = None
+    gift_type: Optional[str] = ""
+    uuid: str
 
 
 class FixTable(BaseModel):
     type: int
-    account_id: int
+    unique_tag: str
     money: float
     amount_type: str = ""
     remark: str
@@ -75,10 +78,16 @@ class RecoveryTable(BaseModel):
     uuid: str
     type: int
     out_money: int
-    entry_money: float
+    entry_money: int
     from_time: str
     cont: str
 
+    @validator('cont')
+    def cont_must_contain_space(cls, c):
+        if len(c) > 200:
+            raise HTTPException(status_code=500, detail="备注太长，限制200个字符")
+        return c
+
 
 class RecoveryupdateTable(RecoveryTable):
     id: int

app/api/account/views.py

-from fastapi import Depends, APIRouter, Request
+from typing import Optional
+
+from fastapi import Depends, APIRouter, Request, Query
 from sqlalchemy.orm import Session
 from app import get_db
 from app.api.account import schemas, crud
@@ -10,45 +12,51 @@ router = APIRouter()
 
 
 @router.post("/create")
-def create_account(data: schemas.AccountCreate, token=Depends(login_required), db: Session = Depends(get_db)):
+def create_account(data: schemas.AccountCreate, token=Depends(login_required)):
     """添加账户"""
-    db_info = crud.get_account(db, name=data.name)
+    db_info = crud.get_account(data.name)
     if db_info:
         return HttpResultResponse(code=400, msg=HttpMessage.ACCOUNT_EXIST)
-    res = crud.create_account(db=db, param=data)
+    res = crud.create_account(data)
     if not res:
         return HttpResultResponse(code=500, msg=res)
-    return HttpResultResponse(data=res.id)
+    return HttpResultResponse(data=res)
 
 
-@router.post("/list")
-def user_list(data: schemas.AccountList, token=Depends(login_required), db: Session = Depends(get_db)):
+@router.get("/list")
+def user_list(page: int, size: int, name: Optional[str] = None, token=Depends(login_required)):
     """账户列表"""
-    result, num = crud.get_account_list(db, data)
+    result, num = crud.HDUd().get_account_list(name, page, size)
     return HttpResultResponse(total=num, data=result)
 
 
 @router.get("/gift/type")
-def gift_type_list(db: Session = Depends(get_db), token=Depends(login_required)):
+def gift_type_list(token=Depends(login_required)):
     """礼物类型配置返回"""
-    result = crud.get_gift_type(db)
+    result = crud.get_gift_type()
     return HttpResultResponse(data=result)
 
 
 @router.post("/update")
-def read_account(data: schemas.AccountUpdate, token=Depends(login_required), db: Session = Depends(get_db)):
+def read_account(data: schemas.AccountUpdate, token=Depends(login_required)):
     """账户修改"""
     if not data.name:
         return HttpResultResponse(code=500, msg="账户名不能为空")
-    crud.update_account_info(db, data)
+    crud.update_account_info(data)
     return HttpResultResponse()
 
 
-@router.post("/finance/info")
-def finance_information(data: schemas.FinanceInfo, token=Depends(login_required), db: Session = Depends(get_db)):
+@router.get("/finance/info")
+def finance_information(unique_tag: str,
+                        page: int,
+                        size: int,
+                        start_time: Optional[str] = "",
+                        end_time: Optional[str] = "",
+                        token=Depends(login_required)):
+    # unique_tag:Optional[str] = Query(None, min_length=3, max_length=50, regex="^xiao\d+$") 参数验证
     """账户财务信息"""
-    res, total = crud.get_finance_info(db, data, 1)
-    return HttpResultResponse(total=total, data=res[int(data.page-1)*data.size:data.page*data.size])
+    res, total = crud.get_finance_info(unique_tag, page, size, start_time, end_time, 1)
+    return HttpResultResponse(total=total.get("num"), data=res)
 
 
 @router.post("/finance/info/excel")
@@ -56,30 +64,42 @@ def finance_info_excel(data: schemas.FinanceInfo, request: Request,
                        token=Depends(login_required), db: Session = Depends(get_db)):
     """账户财务信息导出"""
     headers = request.get("headers")
-    statement_list = crud.get_finance_info(db, data)
+    statement_list = crud.get_finance_info(data)
     return statement_crud.data_to_file(db, statement_list, "财务信息", headers)
 
 
-@router.post("/finance/details")
-def finance_details(data: schemas.FinanceDetails, token=Depends(login_required), db: Session = Depends(get_db)):
-    """账户财务明细"""
-    res, total, count = crud.get_finance_details(db, data, 1)
+@router.get("/finance/details")
+def finance_details(page: int,
+                    size: int,
+                    uuid: str,
+                    start_time: Optional[str] = "",
+                    end_time: Optional[str] = "",
+                    type: Optional[int] = None,
+                    gift_type: Optional[str] = "",
+                    token=Depends(login_required)):
+    """账户财务详情"""
+    res, total, count = crud.get_finance_details(page, size, uuid, start_time, end_time, type, gift_type, is_list=1)
     return HttpResultResponse(total=total, data=res, count=count)
 
 
 @router.post("/finance/details/excel")
 def finance_info_excel(data: schemas.FinanceDetails, request: Request,
                        token=Depends(login_required), db: Session = Depends(get_db)):
-    """账户财务明细导出"""
+    """账户财务详情导出"""
     headers = request.get("headers")
     statement_list = crud.get_finance_details(db, data)
     return statement_crud.data_to_file(db, statement_list, "财务明细", headers)
 
 
-@router.post("/type")
-def finance_fix(data: schemas.AccountTypeList, token=Depends(login_required), db: Session = Depends(get_db)):
+@router.get("/type")
+def finance_fix(page: int,
+                size: int,
+                key_name: str = "",
+                key_value: str = "",
+                type: int = None,
+                token=Depends(login_required), db: Session = Depends(get_db)):
     """出入账目配置列表"""
-    res, num = crud.get_account_type(db, data.dict(exclude_none=True))
+    res, num = crud.get_account_type(db, key_name=key_name, key_value=key_value, type=type, page=page, size=size)
     return HttpResultResponse(total=num, data=res)
 
 

app/api/export/crud.py

@@ -11,15 +11,16 @@ import pandas as pd
 from starlette.responses import StreamingResponse
 
 
-def get_export_list(db: Session, param):
+def get_export_list(db: Session, source, start_time, end_time, page, size):
     """导出列表"""
     export_filters = []
-    if param.get("source"):
-        export_filters.append(ExportFile.source == param.get("source"))
-    if param.get("start_time"):
-        export_filters.append(ExportFile.create_time >= param.get("start_time") + " 00:00:00")
-    if param.get("end_time"):
-        export_filters.append(ExportFile.create_time < param.get("end_time") + " 24:00:00")
+    if source:
+        export_filters.append(ExportFile.source == source)
+    if start_time:
+        export_filters.append(ExportFile.create_time >= start_time + " 00:00:00")
+    if end_time:
+        export_filters.append(ExportFile.create_time < end_time + " 24:00:00")
+    param = {"source": source, "start_time": start_time, "end_time": end_time, "page": page, "size": size}
     querydata, count = QueryAllData(db, ExportFile, param, export_filters).query_data()
     data = [QueryAllData.serialization(item) for item in querydata]
     return data, count
@@ -74,8 +75,6 @@ class CalculationMonthlyBill(object):
 
     def month_statistics_task(self, date, key_type, name, page, size):
         """主函数"""
-        db = env.MysqlDB
-        db["database"] = env.DB_HISTORY
         if key_type and not name:
             sql = f"SELECT reference_type, type, SUM(cast(amount as decimal(20,6)))/1000 as money FROM {date} where reference_type='{key_type}' GROUP BY reference_type, type ORDER BY reference_type"
         if name and not key_type:
@@ -89,7 +88,7 @@ class CalculationMonthlyBill(object):
         if not name and not key_type:
             sql = f"SELECT reference_type, type, SUM(cast(amount as decimal(20,6)))/1000 as money FROM {date} GROUP BY reference_type, type ORDER BY reference_type"
         try:
-            res_data = LinkMysql(db).query_mysql(sql)
+            res_data = LinkMysql(env.DB_HISTORY).query_mysql(sql)
         except Exception as e:
             return [], 0
         for res in res_data:
@@ -131,23 +130,20 @@ class CalculationMonthlyDetails(object):
         result = LinkMysql(db).query_mysql(sql)
         return len(result)
 
-    def statement_income_expenditure(self, param):
+    def statement_income_expenditure(self, **param):
 
-        database = env.MysqlDB
-        database["database"] = env.DB_HISTORY
         with ThreadPoolExecutor(max_workers=2) as pool:
-            future1 = pool.submit(self.data_query, database, 'assets_log_' + param.date, param.key, param.is_income, param.page, param.size)
-            future2 = pool.submit(self.acquired_total, database, 'assets_log_' + param.date, param.key, param.is_income)
+            future1 = pool.submit(self.data_query, env.DB_HISTORY, 'assets_log_' + param.get("date"), param.get("key"), param.get("is_income"), param.get("page"), param.get("size"))
+            future2 = pool.submit(self.acquired_total, env.DB_HISTORY, 'assets_log_' + param.get("date"), param.get("key"), param.get("is_income"))
         data = future1.result()
         num = future2.result()
         return data, num
 
     @staticmethod
     def query_error_data(date, reference_type):
-        database = env.MysqlDB
-        database["database"] = env.DB_HISTORY
+
         group_sql = f"SELECT order_id, COUNT(order_id) as num FROM {date} where reference_type='{reference_type}' GROUP BY order_id"
-        result = LinkMysql(database).query_mysql(group_sql)
+        result = LinkMysql(env.DB_HISTORY).query_mysql(group_sql)
         error_list = [str(i.get("order_id")) for i in result if i.get("num") != 2]
         if len(error_list) == 1:
             sql = f"SELECT uuid,reference_type,order_number,order_id,type,cast(amount as decimal(20,6))/1000 as money,amount_type,create_time FROM {date} where order_id={error_list[0]}"
@@ -155,7 +151,7 @@ class CalculationMonthlyDetails(object):
             sql = f"SELECT uuid,reference_type,order_number,order_id,type,cast(amount as decimal(20,6))/1000 as money,amount_type,create_time FROM {date} where order_id in({','.join(error_list)})"
         if len(error_list) == 0:
             return []
-        result = LinkMysql(database).query_mysql(sql)
+        result = LinkMysql(env.DB_HISTORY).query_mysql(sql)
         return result
 
 
@@ -176,14 +172,12 @@ class MonthDataDerive(object):
         return StreamingResponse(file, media_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
 
     def derive_data(self, date, key_type):
-        db = env.MysqlDB
-        db["database"] = env.DB_HISTORY
         if key_type:
             sql = f"SELECT reference_type, type, SUM(cast(amount as decimal(20,6)))/1000 as money FROM {date} where reference_type='{key_type}' GROUP BY reference_type, type ORDER BY reference_type"
         else:
             sql = f"SELECT reference_type, type, SUM(cast(amount as decimal(20,6)))/1000 as money FROM {date} GROUP BY reference_type, type ORDER BY reference_type"
         try:
-            res_data = LinkMysql(db).query_mysql(sql)
+            res_data = LinkMysql(env.DB_HISTORY).query_mysql(sql)
         except Exception as e:
             return [], 0
         for res in res_data:

app/api/export/views.py

 from datetime import datetime
+from typing import Optional
+
 from dateutil.relativedelta import relativedelta
 from fastapi import Depends, APIRouter, Request
 from sqlalchemy.orm import Session
@@ -11,10 +13,15 @@ from libs.token_verify import login_required
 router = APIRouter()
 
 
-@router.post("/list")
-def export_list(data: schemas.ExportList, token=Depends(login_required), db: Session = Depends(get_db)):
+@router.get("/list")
+def export_list(page: int,
+                size: int,
+                source: Optional[str] = "",
+                start_time: Optional[str] = "",
+                end_time: Optional[str] = "",
+                token=Depends(login_required), db: Session = Depends(get_db)):
     """导出记录列表"""
-    result, total = crud.get_export_list(db, data.dict(exclude_none=True))
+    result, total = crud.get_export_list(db, source, start_time, end_time, page, size)
     return HttpResultResponse(total=total, data=result)
 
 
@@ -43,23 +50,33 @@ def export_source_query(db: Session = Depends(get_db), token=Depends(login_requi
     return HttpResultResponse(data=result)
 
 
-@router.post("/month/total")
-def month_query_total_export(param: schemas.MonthStatistics, token=Depends(login_required)):
+@router.get("/month/total")
+def month_query_total_export(page: int,
+                             size: int,
+                             date: str = "",
+                             type: str = "",
+                             name: str = "",
+                             token=Depends(login_required)):
     """月度表计算"""
-    if not param.date:
+    if not date:
         month_date = datetime.now().date() - relativedelta(months=1)
-        param.date = month_date.strftime("%Y%m")
-    result, num = crud.CalculationMonthlyBill().month_statistics_task('assets_log_' + param.date, param.type, param.name,
-                                                                      param.page, param.size)
+        date = month_date.strftime("%Y%m")
+    result, num = crud.CalculationMonthlyBill().month_statistics_task('assets_log_' + date, type, name,
+                                                                      page, size)
     return HttpResultResponse(total=num, data=result)
 
 
-@router.post("/month/details")
-def month_query_total_export(param: schemas.MonthDetails, token=Depends(login_required)):
+@router.get("/month/details")
+def month_query_total_export(key: str,
+                             is_income: int,
+                             page: int,
+                             size: int,
+                             date: str = "",
+                             token=Depends(login_required)):
     """月度计算,详情"""
-    if not param.date:
+    if not date:
         return HttpResultResponse(code=500, msg='查询月份不能为空')
-    result, num = crud.CalculationMonthlyDetails().statement_income_expenditure(param)
+    result, num = crud.CalculationMonthlyDetails().statement_income_expenditure(key=key, is_income=is_income, page=page, size=size, date=date)
     return HttpResultResponse(total=num, data=result)
 
 

app/api/margin/views.py

-from fastapi import Depends, APIRouter
+from typing import Optional
+
+from fastapi import Depends, APIRouter, Request
 from sqlalchemy.orm import Session
 from app import get_db
 from app.api.margin import schemas, crud
@@ -8,15 +10,23 @@ from libs.token_verify import login_required
 router = APIRouter()
 
 
-@router.post("/list")
-def guild_margin_list(data: schemas.GuildMarginList, token=Depends(login_required), db: Session = Depends(get_db)):
+@router.get("/list")
+def guild_margin_list(page: int,
+                      size: int,
+                      guild_id: Optional[int] = None,
+                      status: Optional[int] = None,
+                      start_time: Optional[str] = "",
+                      end_time: Optional[str] = "",
+                      token=Depends(login_required)):
     """保证金列表"""
-    result, total = crud.get_margin(db, data.dict(exclude_none=True))
-    return HttpResultResponse(total=total, data=result)
+    # result, total = crud.get_margin(data.dict(exclude_none=True))
+    result, total = crud.get_margin(guild_id, status, page, size, start_time, end_time)
+    return HttpResultResponse(total=total.get('num'), data=result)
 
 
 @router.post("/examine")
-def margin_examine(data: schemas.MarginExamine, token=Depends(login_required), db: Session = Depends(get_db)):
+def margin_examine(data: schemas.MarginExamine, request: Request, db: Session = Depends(get_db), token=Depends(login_required)):
     """保证金确认，拒绝"""
-    result = crud.margin_dispose(db, data.dict(exclude_none=True))
+    header_list = request.get("headers")
+    result = crud.GuildMargin(db, header_list).margin_dispose(data)
     return HttpResultResponse(msg=result)

app/api/role/crud.py

@@ -15,15 +15,15 @@ def get_id_to_authority(db: Session, role_id: int):
     return db.query(models.Role).filter(models.Role.id == role_id).first()
 
 
-def get_roles(db: Session, param):
+def get_roles(db: Session, **param):
     result_list = []
-    name = param.role_name if param.role_name else ""
+    name = param.get("role_name") if param.get("role_name") else ""
     if name:
         query_res = db.query(models.Role).filter(models.Role.role_name.like(f'%{name}%')).order_by(models.Role.id.desc()).\
-            offset((int(param.page) - 1) * param.size).limit(param.size).all()
+            offset((int(param.get("page")) - 1) * param.get("size")).limit(param.get("size")).all()
         count = db.query(func.count(models.Role.id)).filter(models.Role.role_name.like(f'%{name}%')).scalar()
     else:
-        query_res = db.query(models.Role).order_by(models.Role.id.desc()).offset((int(param.page) - 1) * param.size).limit(param.size).all()
+        query_res = db.query(models.Role).order_by(models.Role.id.desc()).offset((int(param.get("page")) - 1) * param.get("size")).limit(param.get("size")).all()
         count = db.query(func.count(models.Role.id)).scalar()
     if not query_res:
         return [], 0

app/api/role/views.py

+from typing import Optional
+
 from fastapi import Depends, APIRouter
 from sqlalchemy.orm import Session
 from app import get_db
@@ -36,8 +38,11 @@ def delete_user(role_id: int, token=Depends(login_required), db: Session = Depen
     return HttpResultResponse()
 
 
-@router.post("/list")
-def role_list(data: schemas.RoleList, token=Depends(login_required), db: Session = Depends(get_db)):
+@router.get("/list")
+def role_list(page: int,
+              size: int,
+              role_name: Optional[str] = "",
+              token=Depends(login_required), db: Session = Depends(get_db)):
     """角色列表"""
-    result, total = crud.get_roles(db, data)
+    result, total = crud.get_roles(db, role_name=role_name, page=page, size=size)
     return HttpResultResponse(total=total, data=result)

app/api/statement/crud.py

 import math
 import threading
+from concurrent.futures.thread import ThreadPoolExecutor
+
 import pandas as pd
 from sqlalchemy import and_, func
 from app.api.statement.guild import query_token
 from starlette.responses import StreamingResponse
 from sqlalchemy.orm import Session
 from app.api.export import crud
+from core.config.env import env
+from libs.db_link import LinkMysql
+from libs.functions import time_str_to_timestamp
 from libs.orm import QueryAllData
 from models.recharge import Recharge, UserWC, GuildWC, FinanceFixLog
 
@@ -225,17 +230,39 @@ class WithdrawStatement(object):
 class FinanceFix(object):
 
     @staticmethod
-    def get_finance_fix_data(db: Session, data):
+    def get_finance_fix_data(page, size, start_time, end_time):
         """财务修复"""
-        # total = db.query(func.count(FinanceFixLog.id)).scalar()
-        # output = db.query(FinanceFixLog).order_by(FinanceFixLog.id.desc()).offset((data.page - 1) *
-        #                                                                           data.size).limit(data.size).all()
-        # return [i.to_dict() for i in output], total
         finance_filters = []
-        if data.get("start_time"):
-            finance_filters.append(FinanceFixLog.create_time >= data.get("start_time") + " 00:00:00")
-        if data.get("end_time"):
-            finance_filters.append(FinanceFixLog.create_time <= data.get("end_time") + " 23:59:59")
-        querydata, count = QueryAllData(db, FinanceFixLog, data, finance_filters).query_data()
-        data = [QueryAllData.serialization(item) for item in querydata]
-        return data, count
+        if start_time:
+            finance_filters.append(f" create_time <= {time_str_to_timestamp(start_time + ' 00:00:00')} ")
+        if end_time:
+            finance_filters.append(f" create_time <= {time_str_to_timestamp(end_time + ' 23:59:59')} ")
+        if finance_filters:
+            count_sql = f"select count(id) as num from finance_fix_log where {' and '.join(finance_filters)}"
+            data_sql = f"select id,type,money,unique_tag,amount_type,operator,create_time,remark from finance_fix_log where {' and '.join(finance_filters)} order by id DESC limit {(int(page) - 1) * size},{size}"
+        else:
+            count_sql = f"select count(id) as num from finance_fix_log"
+            data_sql = f"select id,type,money,unique_tag,amount_type,operator,create_time,remark from finance_fix_log order by id DESC limit {(int(page) - 1) * size},{size}"
+        with ThreadPoolExecutor(max_workers=2) as pool:
+            future1 = pool.submit(LinkMysql(env.DB_3YV2).query_mysql, count_sql)
+            future2 = pool.submit(LinkMysql(env.DB_3YV2).query_mysql, data_sql)
+        total = future1.result()
+        res = future2.result()
+        if res:
+            result = []
+            for i in res:
+                if i['type'] != 0:
+                    # user_sql = f"select nick_name from v2_user where uuid='{i['unique_tag']}' limit 0,1"
+                    # v2_user_res = LinkMysql(env.DB_3YV2).query_mysql(user_sql)
+                    # if not v2_user_res:
+                    #     guild_sql = f"select guild_name as name  from guild where uuid='{i['unique_tag']}' limit 0,1"
+                    #     guild_res = LinkMysql(env.DB_3YV2).query_mysql(guild_sql)
+                    #     if not guild_res:
+                    #         i['name'] = i['unique_tag']
+                    #     i['name'] = guild_res[0]['guild_name']
+                    #     continue
+                    # i['name'] = v2_user_res[0]['nick_name']
+                    i['name'] = i['unique_tag']
+                result.append(i)
+            return result, total[0]['num']
+        return [], 0

app/api/statement/views.py

 import json
 from datetime import datetime
+from typing import Optional
+
 from app.api.statement import crud, schemas, guild
 from app.api.account import schemas as acc_schemas
 from app import get_db
@@ -131,10 +133,14 @@ def guild_update_list(data: schemas.GuildUpdate, token=Depends(login_required),
     return HttpResultResponse()
 
 
-@router.post("/finance/fix")
-def finance_fix(data: acc_schemas.PublicModel, token=Depends(login_required), db: Session = Depends(get_db)):
-    """账户修复报表"""
-    res, num = crud.FinanceFix.get_finance_fix_data(db, data.dict(exclude_none=True))
+@router.get("/finance/fix")
+def finance_fix(page: int,
+                size: int,
+                start_time: Optional[str] = "",
+                end_time: Optional[str] = "",
+                token=Depends(login_required)):
+    """账户修复报表列表"""
+    res, num = crud.FinanceFix.get_finance_fix_data(page, size, start_time, end_time)
     return HttpResultResponse(total=num, data=res)
 
 
@@ -144,25 +150,36 @@ def finance_fix(data: acc_schemas.FixTable, request: Request,
     """新增修复报表"""
     header_list = request.get("headers")
     res = guild.create_fix_table(db, data, header_list)
-    return HttpResultResponse(data=res.id)
+    if res:
+        return HttpResultResponse(code=500, msg=res)
+    return HttpResultResponse()
 
 
-@router.post("/data/recovery")
-def recovery_fix(data: acc_schemas.Recovery_fix, token=Depends(login_required), db: Session = Depends(get_db)):
-    """异常数据修复"""
-    recovery_list, total = guild.recovery_fix_data(db, Account_log, data.dict(exclude_none=True))
+@router.get("/data/recovery")
+def recovery_fix(page: int,
+                 size: int,
+                 uuid: Optional[str] = '',
+                 start_time: Optional[str] = "",
+                 end_time: Optional[str] = "",
+                 token=Depends(login_required)):
+    """异常数据修复列表"""
+    recovery_list, total = guild.recovery_fix_data(page=page, size=size, uuid=uuid, start_time=start_time, end_time=end_time)
     return HttpResultResponse(total=total, data=recovery_list)
 
 
 @router.post("/submit/recovery")
 def finance_fix(data: acc_schemas.RecoveryTable, token=Depends(login_required), db: Session = Depends(get_db)):
     """新增异常数据修复"""
-    res = guild.create_recovery_table(db, data)
-    return HttpResultResponse(data=res.id)
+    res = guild.create_recovery_table(data)
+    if res:
+        return HttpResultResponse(code=500, msg=res)
+    return HttpResultResponse()
 
 
 @router.post("/recovery/fix")
-def recovery_fix(data: acc_schemas.RecoveryupdateTable, token=Depends(login_required), db: Session = Depends(get_db)):
-    """异常数据修复"""
-    res = guild.update_recovery_table(db, data.dict(exclude_none=True))
-    return HttpResultResponse(data=res.get("id"))
+def recovery_fix(data: acc_schemas.RecoveryupdateTable, token=Depends(login_required)):
+    """修改异常数据"""
+    res = guild.update_recovery_table(data)
+    if res:
+        return HttpResultResponse(code=500, msg=res)
+    return HttpResultResponse()

app/api/users/crud.py

@@ -14,18 +14,18 @@ def get_user_by_name(db: Session, username: str):
     return db.query(models.User).filter(models.User.username == username).first()
 
 
-def get_users(db: Session, param):
+def get_users(db: Session, **param):
     """
     分组统计求和  from sqlalchemy import func as fc
     r = db.query(fc.sum(r_model.Rolesfsas.aority), fc.sum(r_model.Rolesfsas.remark)).having(r_model.Rolesfsas.goods >
     10).group_by(r_model.Rolesfsas.goods).all()
     """
-    username = param.username if param.username else ""
+    username = param.get("username") if param.get("username") else ""
     if username:
-        res = db.query(models.User).filter(models.User.username.like(f'%{username}%')).order_by(models.User.id.desc()).offset((int(param.page) - 1) * param.size).limit(param.size)
+        res = db.query(models.User).filter(models.User.username.like(f'%{username}%')).order_by(models.User.id.desc()).offset((int(param.get("page")) - 1) * param.get("size")).limit(param.get("size"))
         count = db.query(func.count(models.User.id)).filter(models.User.username.like(f'%{username}%')).scalar()
     else:
-        res = db.query(models.User).order_by(models.User.id.desc()).offset((int(param.page) - 1) * param.size).limit(param.size)
+        res = db.query(models.User).order_by(models.User.id.desc()).offset((int(param.get("page")) - 1) * param.get("size")).limit(param.get("size"))
         count = db.query(func.count(models.User.id)).scalar()
     if not res:
         return [], 0

app/api/users/schemas.py

@@ -28,7 +28,7 @@ class User(UserBase):
 class UserLoginForm(BaseModel):
     username: str
     password: str
-    verify: str
+    verify: Optional[str] = ''
 
 
 class GoogleCode(BaseModel):

app/api/users/views.py

 import pyotp
 import socket
-from typing import List
+from typing import List, Optional
 from fastapi import Depends, APIRouter, Request
 from datetime import timedelta
 from sqlalchemy.orm import Session
@@ -25,6 +25,8 @@ def img_code():
 
 @router.post("/login")
 def login(form_data: UserLoginForm, db: Session = Depends(get_db)):
+    if not form_data.verify:
+        return HttpResultResponse(code=500, msg="请输入验证码")
     user_info = authenticate_user(db=db, form_data=form_data)
     # 函数 gethostname() 返回当前正在执行 Python 的系统主机名
     res = socket.gethostbyname(socket.gethostname())
@@ -90,10 +92,13 @@ def read_user(data: schemas.PermissionCreate, token=Depends(login_required), db:
     return HttpResultResponse()
 
 
-@router.post("/list")
-def user_list(data: schemas.UserList, token=Depends(login_required), db: Session = Depends(get_db)):
+@router.get("/list")
+def user_list(page: int,
+              size: int,
+              username: Optional[str] = "",
+              token=Depends(login_required), db: Session = Depends(get_db)):
     """用户列表"""
-    result, total = crud.get_users(db, data)
+    result, total = crud.get_users(db, username=username, page=page, size=size)
     return HttpResultResponse(total=total, data=result)
 
 

core/config/env.py

@@ -37,7 +37,14 @@ class Env(BaseSettings):
     DATABASE_URI: str = 'sqlite://:memory:'
     DATABASE_USER: str = ''
     DATABASE_PWD: str = ''
-    MysqlDB: dict = {
+    DB_HISTORY: dict = {
+        "database": "3y_history",
+        "host": "106.55.103.148",
+        "port": 3398,
+        "pwd": "c1ea602311a369f6",
+        "user": "root"
+    }
+    DB_3YV2: dict = {
         "database": "3yakj_v2",
         "host": "106.55.103.148",
         "port": 3398,
@@ -53,7 +60,7 @@ class Env(BaseSettings):
     SECRET_KEY: str = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
     ALGORITHM: str = "HS256"
     PASSWORD: str = "fj123456"
-    DB_HISTORY = "3y_history"
+    CLEARING_CENTER_URL: str = 'http://106.55.103.148:6464/'
 
 
 class TestingEnv(Env):

libs/functions.py

 import hashlib
+import json
 import time
 import uuid as u
-from datetime import datetime
+from datetime import datetime, timedelta
+
+import requests
 
 
 def get_now_timestamp():
@@ -17,11 +20,33 @@ def get_now_timestamp():
 def get_now_datetime():
     """
     获取现在时间
-    return int eg:1667664000
     """
     return datetime.now().strftime('%Y-%m-%d %H:%M:%S')
 
 
+def get_before_timestamp(n):
+    """获取n天前时间"""
+    data_str = datetime.now() - timedelta(days=int(n))
+    before_n_days = data_str.strftime("%Y-%m-%d")
+    return before_n_days
+
+
+def get_yesterday_timestamp():
+    """获取昨天时间戳"""
+    data_str = datetime.now() - timedelta(days=1)
+    before_n_days = data_str.strftime("%Y-%m-%d")
+    time_array = time.strptime(f"{before_n_days} 00:00:00", "%Y-%m-%d %H:%M:%S")
+    today_str = datetime.now().strftime('%Y-%m-%d')
+    today_array = time.strptime(f"{today_str} 00:00:00", "%Y-%m-%d %H:%M:%S")
+    return int(time.mktime(time_array)), int(time.mktime(today_array))
+
+
+def time_str_to_timestamp(time_str):
+    """时间字符串类型  转为int"""
+    time_array = time.strptime(time_str, "%Y-%m-%d %H:%M:%S")
+    return int(time.mktime(time_array))
+
+
 def md5(s):
     """md5加密"""
     sign_str = hashlib.md5()
@@ -34,6 +59,12 @@ def uuid():
     return str(u.uuid4())
 
 
+def get_order():
+    """生成订单号"""
+    timestamp = get_now_timestamp()
+    return datetime.now().strftime('%Y%m%d%H%M%S') + str(timestamp)
+
+
 # 页数页码校验
 def wrapper_out():
     def wrapper(func):
@@ -44,3 +75,24 @@ def wrapper_out():
             return ret
         return inner
     return wrapper
+
+
+def search(params, method):
+    """
+    调用清算接口
+    :param params: 传入参数
+    :param method: 传入方法
+    """
+    url = "http://106.55.103.148:6464"
+    header = {
+        "RPC-METHOD": method,
+        "RPC-ID": '161',
+        "RPC-PROTOCOL": "jsonrpc",
+        "RPC-VERSION": "2.0"
+    }
+    response = requests.post(url=url, headers=header, json=params)
+    if response.status_code != 200:
+        return {"status": 0}
+    text = json.loads(response.text)
+    print(text)
+    return {"status": 1, 'data': text.get('result')}

models/recharge.py

@@ -133,7 +133,6 @@ class FinanceFixLog(Base, SerializerMixin):
     __table_args__ = {'comment': '财务修复日志'}
 
 
-
 class Account_log(Base, SerializerMixin):
     """账户修复记录表"""
     __tablename__ = "account_log"