Merge branch 'development' into develop/xp

# Conflicts:
#	app/api/account/views.py
#	app/api/margin/views.py
#	app/api/role/views.py
#	app/api/statement/crud.py
#	app/api/statement/guild.py
#	app/api/statement/views.py
#	app/api/users/schemas.py
#	app/api/users/views.py
#	core/config/env.py
#	libs/functions.py
#	libs/token_verify.py

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
@@ -72,13 +75,19 @@ class Recovery_fix(PublicModel):
 
 
 class RecoveryTable(BaseModel):
-    uuid: Optional[str] = None
-    type: Optional[int] = None
-    out_money: Optional[int] = None
-    entry_money: Optional[float] = None
-    from_time: Optional[str] = None
-    cont: Optional[str] = None
+    uuid: str
+    type: int
+    out_money: int
+    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
\ No newline at end of file
+    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,79 +12,99 @@ 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)):
+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")
-def finance_info_excel(data: schemas.FinanceInfo, request: Request, db: Session = Depends(get_db)):
+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, db: Session = Depends(get_db)):
-    """账户财务明细导出"""
+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, 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)
 
 
 @router.post("/type/update")
-def finance_fix(data: schemas.AccountTypeList, db: Session = Depends(get_db)):
+def finance_fix(data: schemas.AccountTypeList, token=Depends(login_required), db: Session = Depends(get_db)):
     """出入账目类型修改"""
     res = crud.update_account_type(db, data)
     if res:
@@ -91,7 +113,7 @@ def finance_fix(data: schemas.AccountTypeList, db: Session = Depends(get_db)):
 
 
 @router.post("/create/type")
-def create_user(data: schemas.CreateType, db: Session = Depends(get_db)):
+def create_user(data: schemas.CreateType, token=Depends(login_required), db: Session = Depends(get_db)):
     """添加账目类型"""
     res_type = crud.get_account_type_value(db, data.key_value)
     if res_type:

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"))
-    if param.get("end_time"):
-        export_filters.append(ExportFile.create_time <= param.get("end_time"))
+    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
@@ -72,16 +73,22 @@ class CalculationMonthlyBill(object):
         self.structure_list = []
         self.structure_key = []
 
-    def month_statistics_task(self, date, key_type, page, size):
+    def month_statistics_task(self, date, key_type, name, page, size):
         """主函数"""
-        db = env.MysqlDB
-        db["database"] = env.DB_HISTORY
-        if key_type:
+        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"
-        else:
+        if name and not key_type:
+            sql = f"SELECT reference_type, type, SUM(cast(amount as decimal(20,6)))/1000 as money FROM {date} where reference_type='{name}' GROUP BY reference_type, type ORDER BY reference_type"
+            for k, v in TYPE_NAME.items():
+                if v == name:
+                    sql = f"SELECT reference_type, type, SUM(cast(amount as decimal(20,6)))/1000 as money FROM {date} where reference_type='{k}' GROUP BY reference_type, type ORDER BY reference_type"
+                    break
+        if name and 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"
+        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:
@@ -123,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]}"
@@ -147,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
 
 
@@ -168,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:
@@ -199,4 +201,5 @@ class MonthDataDerive(object):
             }
             self.derive_key.append(res["reference_type"])
             self.derive_list.append(a)
-        return self.data_to_table(self.derive_list)
+
+        return self.derive_list

app/api/export/schemas.py

@@ -19,6 +19,7 @@ class ExportUpdateData(BaseModel):
 class MonthStatistics(BaseModel):
     date: str = ""
     type: str = ""
+    name: str = ""
     page: int = None
     size: int = None
 

app/api/export/views.py

 from datetime import datetime
+from typing import Optional
+
 from dateutil.relativedelta import relativedelta
-from fastapi import Depends, APIRouter
+from fastapi import Depends, APIRouter, Request
 from sqlalchemy.orm import Session
 from app import get_db
 from app.api.export import schemas, crud
+from app.api.statement import crud as statement_crud
 from libs.result_format import HttpResultResponse, HttpMessage
+from libs.token_verify import login_required
 
 router = APIRouter()
 
 
-@router.post("/list")
-def export_list(data: schemas.ExportList, 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)
 
 
 @router.post("/update")
-def update_export_list(data: schemas.ExportUpdateData, db: Session = Depends(get_db)):
+def update_export_list(data: schemas.ExportUpdateData, token=Depends(login_required), db: Session = Depends(get_db)):
     """导出记录修改"""
     result = crud.update_export(db, data)
     if result:
@@ -26,7 +35,7 @@ def update_export_list(data: schemas.ExportUpdateData, db: Session = Depends(get
 
 
 @router.delete("/delete/{id}")
-def delete_export_one(id:int, db: Session = Depends(get_db)):
+def delete_export_one(id:int, token=Depends(login_required), db: Session = Depends(get_db)):
     """导出记录删除"""
     is_delete = crud.delete_export(db, id)
     if is_delete:
@@ -35,45 +44,57 @@ def delete_export_one(id:int, db: Session = Depends(get_db)):
 
 
 @router.get("/source")
-def export_source_query(db: Session = Depends(get_db)):
+def export_source_query(db: Session = Depends(get_db), token=Depends(login_required)):
     """导出来源查询"""
     result = crud.get_source_data(db)
     return HttpResultResponse(data=result)
 
 
-@router.post("/month/total")
-def month_query_total_export(param: schemas.MonthStatistics):
+@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.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):
+@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:
-        return HttpResultResponse(msg='查询月份不能为空')
-    result, num = crud.CalculationMonthlyDetails().statement_income_expenditure(param)
+    if not date:
+        return HttpResultResponse(code=500, msg='查询月份不能为空')
+    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)
 
 
 @router.post("/error/data")
-def month_query_error_data(param: schemas.MonthDetails):
+def month_query_error_data(param: schemas.MonthDetails, token=Depends(login_required)):
     """月度计算,异常数据"""
     if not param.date:
-        return HttpResultResponse(msg='查询月份不能为空')
+        return HttpResultResponse(code=500, msg='查询月份不能为空')
     result = crud.CalculationMonthlyDetails().query_error_data('assets_log_' + param.date, param.key)
     return HttpResultResponse(total=len(result), data=result)
 
 
 @router.post("/month")
-def month_to_export(param: schemas.MonthStatistics):
+def month_to_export(param: schemas.MonthStatistics, request: Request, token=Depends(login_required),
+                    db: Session = Depends(get_db)):
     """月度表导出"""
+    headers = request.get("headers")
     if not param.date:
-        return HttpResultResponse(msg='查询月份不能为空')
+        return HttpResultResponse(code=500, msg='查询月份不能为空')
     result = crud.MonthDataDerive().derive_data('assets_log_' + param.date, param.type)
-    return result
+    return statement_crud.data_to_file(db, result, "业务类型汇总", headers)

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, 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.page * 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
@@ -55,7 +55,7 @@ def update_role(db: Session, role_info):
 
     db.query(models.Role).filter(models.Role.id == role_info.id).update(
             {models.Role.role_name: role_info.role_name,
-             models.Role.authority: ','.join(map(str, role_info.authority)),
+             models.Role.authority: ','.join(map(str, role_info.authority)) if role_info.authority else '',
              models.Role.remark: role_info.remark})
 
     db.commit()

app/api/role/schemas.py

@@ -4,7 +4,7 @@ from typing import Optional
 
 class RoleCreate(BaseModel):
     role_name: str
-    authority: list
+    authority: Optional[list] = []
     remark: Optional[str] = ""
 
 

app/api/role/views.py

+from typing import Optional
+
 from fastapi import Depends, APIRouter
 from sqlalchemy.orm import Session
 from app import get_db
@@ -9,7 +11,7 @@ router = APIRouter()
 
 
 @router.post("/create")
-def create_user(data: schemas.RoleCreate,token=Depends(login_required), db: Session = Depends(get_db)):
+def create_user(data: schemas.RoleCreate, token=Depends(login_required), db: Session = Depends(get_db)):
     """添加角色"""
     db_role = crud.get_role_by_name(db, role_name=data.role_name)
     if db_role:
@@ -21,14 +23,14 @@ def create_user(data: schemas.RoleCreate,token=Depends(login_required), db: Sess
 
 
 @router.post("/update")
-def read_user(data: schemas.RoleUpdate,token=Depends(login_required), db: Session = Depends(get_db)):
+def read_user(data: schemas.RoleUpdate, token=Depends(login_required), db: Session = Depends(get_db)):
     """角色权限分配"""
     crud.update_role(db, data)
     return HttpResultResponse()
 
 
 @router.delete("/delete/{role_id}")
-def delete_user(role_id: int,token=Depends(login_required), db: Session = Depends(get_db)):
+def delete_user(role_id: int, token=Depends(login_required), db: Session = Depends(get_db)):
     """角色删除"""
     res_bool = crud.delete_role(db, role_id)
     if not res_bool:
@@ -36,8 +38,11 @@ def delete_user(role_id: int,token=Depends(login_required), db: Session = Depend
     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
@@ -8,6 +10,9 @@ from sqlalchemy.orm import Session
 from app.api.export import crud
 from core.config.env import env
 from libs.db_link import LinkMysql
+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
 
@@ -75,9 +80,9 @@ class RechargeStatement(object):
         if param.user_id:
             not_null_filters.append(Recharge.user_id == param.user_id)
         if param.sid:
-            not_null_filters.append(Recharge.sid.like(param.sid))
+            not_null_filters.append(Recharge.sid.like(f'%{param.sid}%'))
         if param.pay_channel:
-            not_null_filters.append(Recharge.pay_channel.like(param.pay_channel))
+            not_null_filters.append(Recharge.pay_channel.like(f'%{param.pay_channel}%'))
         if param.start_time:
             not_null_filters.append(Recharge.current >= param.start_time)
         if param.end_time:
@@ -110,7 +115,6 @@ class WithdrawStatement(object):
     """提现报表"""
     def __init__(self):
         self.derive_user_list = []
-        self.linkmysql = LinkMysql(env.MysqlDB)
         self.derive_guild_list = []
 
     def thread_to_data(self, db, num):
@@ -252,17 +256,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/schemas.py

@@ -92,8 +92,8 @@ class PaymentAdd(BaseModel):
 
 class PaymentAccountlList(PaymentWithdrawalList):
     uuid: int = None
-    transfer_id: int = None
-    dst_id: int = None
+    transfer_name: Optional[str] = ""
+    dst_name: Optional[str] = ""
 
 
 class GuildUpdate(BaseModel):
@@ -108,12 +108,24 @@ class UserNumber(BaseModel):
 
 
 class CreateBill(BaseModel):
-    dst_id: str
+    dst_id: Optional[str] = ""
     dst_name: str = ""
     amount: float
-    transfer_id: str
+    transfer_id: Optional[str] = ""
     transfer_name: str = ""
-    remark: str
+    remark: Optional[str] = ""
     type: int
     nick_name: Optional[str] = ""
     transfer_type: Optional[str] = ""
+
+    # @validator('transfer_id')
+    # def transfer_id_must_contain_space(cls, v):
+    #     if not v:
+    #         raise ValueError('缺少必传参数')
+    #     return v
+    #
+    # @validator('remark')
+    # def remark_must_contain_space(cls, v):
+    #     if not v:
+    #         raise ValueError('缺少必传参数remark')
+    #     return v

app/api/statement/views.py

 import json
 from datetime import datetime
-
-from charset_normalizer.md import Optional
+from typing import Optional
 
 from app.api.statement import crud, schemas, guild
 from app.api.account import schemas as acc_schemas
@@ -113,20 +112,23 @@ def query_account_money(data: UserNumber,token=Depends(login_required),db: Sessi
 
 
 @router.post("/query/uuid")
-def query_uuid_account(data: UserNumber, db: Session = Depends(get_db)):
+def query_uuid_account(data: UserNumber, token=Depends(login_required), db: Session = Depends(get_db)):
     """uuid user_number查询"""
     user_info = query_uuid_or_user_number(db, data)
     return HttpResultResponse(data=user_info)
 
 
 @router.post("/transfer/money")
-def account_transfer_money(data: CreateBill, request: Request, db: Session = Depends(get_db)):
+def account_transfer_money(data: CreateBill, request: Request,
+                           token=Depends(login_required), db: Session = Depends(get_db)):
     """账户转账"""
+    if not all([data.dst_id, data.transfer_id, data.amount, data.remark]):
+        return HttpResultResponse(code=500, msg="缺少必传参数")
     header_list = request.get("headers")
     res_info = transfer_money(db, data, header_list)
-    if not res_info:
-        return HttpResultResponse(code=500, msg='创建失败')
-    return HttpResultResponse(data=res_info.id)
+    if res_info:
+        return HttpResultResponse(code=500, msg=res_info)
+    return HttpResultResponse()
 
 
 @router.post("/guild/update")
@@ -136,37 +138,53 @@ def guild_update_list(data: schemas.GuildUpdate,token=Depends(login_required)):
     return HttpResultResponse()
 
 
-@router.post("/finance/fix")
-def finance_fix(data: acc_schemas.PublicModel, 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)
 
 
 @router.post("/submit/fixTable")
-def finance_fix(data: acc_schemas.FixTable, request: Request, db: Session = Depends(get_db)):
+def finance_fix(data: acc_schemas.FixTable, request: Request,
+                token=Depends(login_required), db: Session = Depends(get_db)):
     """新增修复报表"""
     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, 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, db: Session = Depends(get_db)):
+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, 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.page * 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.page * 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/login_verification.py

@@ -7,6 +7,7 @@ from core.config.env import env
 from libs.functions import md5
 from libs.img_code import session
 from models import users as users
+from app.api.role import crud as role_crud
 
 
 def get_user(db, username: str):
@@ -51,13 +52,16 @@ def authenticate_user(db: Session, form_data: UserLoginForm):
     # 如果获取为空,返回False
     if not user_data:
         return {"result": False, "msg": "用户不存在"}
+    if not user_data.role_id:
+        return {"result": False, "msg": "用户没有权限，请先添加角色"}
+    role_info = role_crud.get_id_to_authority(db, user_data.role_id)
+    if not role_info.authority:
+        return {"result": False, "msg": "用户无权限!请先添加权限"}
     # 如果密码不正确,也是返回False
     md5_password = md5(form_data.password)
     if md5_password != user_data.hashed_password:
         return {"result": False, "msg": "密码错误"}
     # 验证码检查
-    print(form_data.verify)
-    print(session.headers)
     # if form_data.verify.lower() != session.headers.get("verify").lower():
     #     return {"result": False, "msg": "验证码错误"}
     if user_data.google_key:

app/api/users/schemas.py

-from pydantic import BaseModel
+from fastapi import HTTPException
+from pydantic import BaseModel, validator
 from typing import Optional
 
 
 class UserBase(BaseModel):
     username: str
 
+    @validator('username')
+    def username_must_contain_space(cls, v):
+        if len(v) > 50:
+            raise HTTPException(status_code=500, detail="用户名太长")
+        return v
+
 
 class UserCreate(UserBase):
-    remark: Optional[str] = None
+    remark: Optional[str] = ""
     role_id: int
 
 
@@ -21,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
-from typing import List
+import socket
+from typing import List, Optional
 from fastapi import Depends, APIRouter, Request
 from datetime import timedelta
 from sqlalchemy.orm import Session
@@ -8,6 +9,7 @@ from app.api.statement.guild import query_token
 from app.api.users import crud, schemas
 from app.api.users.login_verification import authenticate_user, create_access_token, get_user, authenticate_pwd
 from app.api.users.schemas import UserLoginForm, GoogleCode, GoogleLogin
+from core.config.env import red
 from libs.google_code import get_qrcode, google_verify_result
 from libs.img_code import imageCode
 from libs.result_format import HttpResultResponse, HttpMessage
@@ -23,9 +25,18 @@ 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())
+    code = red.get(res + '-VerifyCode')
+    if not code:
+        return HttpResultResponse(code=500, msg="验证码已过期")
+    if form_data.verify.lower() != code.lower():
+        return HttpResultResponse(code=500, msg="验证码错误")
     if not user_info.get("result"):
-        return HttpResultResponse(code=500, msg=user_info.get("msg"), data={})
+        return HttpResultResponse(code=500, msg=user_info.get("msg"))
     return HttpResultResponse(msg=HttpMessage.LOGIN_SUCCESS, data={"google_key": user_info.get("google_key")})
 
 
@@ -63,40 +74,44 @@ def token_user(token=Depends(auth_token), db: Session = Depends(get_db)):
 
 
 @router.post("/create")
-def create_user(data: schemas.UserCreate,token=Depends(login_required), db: Session = Depends(get_db)):
+def create_user(data: schemas.UserCreate, db: Session = Depends(get_db)):
     """添加用户"""
     db_user = crud.get_user_by_name(db, username=data.username)
     if db_user:
         return HttpResultResponse(code=400, msg=HttpMessage.USER_EXIST)
     res = crud.create_user(db=db, user=data)
     if not res:
-        return HttpResultResponse(code=500, msg=res)
+        return HttpResultResponse(code=500, msg=HttpMessage.LOSE)
     return HttpResultResponse(data=res.id)
 
 
 @router.post("/permission/allocation")
-def read_user(data: schemas.PermissionCreate,token=Depends(login_required), db: Session = Depends(get_db)):
+def read_user(data: schemas.PermissionCreate, token=Depends(login_required), db: Session = Depends(get_db)):
     """用户修改"""
     crud.update_user(db, data)
     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)
 
 
 @router.delete("/delete/{user_id}")
-def delete_user(user_id: int,token=Depends(login_required), db: Session = Depends(get_db)):
+def delete_user(user_id: int, token=Depends(login_required), db: Session = Depends(get_db)):
     """用户删除"""
     crud.delete_user(db, user_id)
     return HttpResultResponse()
 
 
 @router.post("/update")
-def update_individual_info(param: schemas.UserUpdate, request: Request, db: Session = Depends(get_db)):
+def update_individual_info(param: schemas.UserUpdate, request: Request,
+                           token=Depends(login_required), db: Session = Depends(get_db)):
     """个人信息修改"""
     headers = request.get("headers")
     user = query_token(db, headers)

core/config/env.py

@@ -4,7 +4,7 @@
 
 """
 import os
-
+import redis
 from pydantic import BaseSettings
 from qcloud_cos import CosConfig
 from qcloud_cos import CosS3Client
@@ -37,20 +37,34 @@ 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,
         "pwd": "c1ea602311a369f6",
         "user": "root"
     }
+    Redis: dict = {
+        "host": "43.138.132.9",
+        "password": "fanjiao2022",
+        "port": 6379,
+        "redis_db": 9
+    }
     SECRET_KEY: str = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
     ALGORITHM: str = "HS256"
     PASSWORD: str = "fj123456"
-    DB_HISTORY = "3yakj_v2"
+    # DB_HISTORY = "3yakj_v2"
     # guild_url=""
     oss_url='http://oss.3yakj.com/application_static_data'
     clear_url="http://192.168.4.124:8002"
+    CLEARING_CENTER_URL: str = 'http://106.55.103.148:6464/'
 
 
 class TestingEnv(Env):
@@ -68,3 +82,8 @@ class ProdEnv(Env):
 env = Env()  # 开发环境
 # env = TestingEnv()      # 测试环境
 # env = ProdEnv()         # 生产环境
+
+redis_data = env.Redis
+pool = redis.ConnectionPool(host=redis_data.get("host"), port=redis_data.get("port"), password=redis_data.get("password"),
+                            db=redis_data.get("redis_db"), decode_responses=True)
+red = redis.StrictRedis(connection_pool=pool)

libs/functions.py

@@ -24,6 +24,7 @@ def get_now_timestamp():
 def get_now_datetime():
     """
     获取现在时间
+    return int eg:1667664000
     """
     return datetime.now().strftime('%Y-%m-%d %H:%M:%S')
 
@@ -65,9 +66,8 @@ def uuid():
 
 def get_order():
     """生成订单号"""
-    number = random.randint(10000000, 99999999)
     timestamp = get_now_timestamp()
-    return datetime.now().strftime('%Y%m%d%H%M%S') + str(timestamp) + number
+    return datetime.now().strftime('%Y%m%d%H%M%S') + str(timestamp)
 
 
 # 页数页码校验

libs/img_code.py

@@ -3,10 +3,11 @@ import os.path
 import random
 import string
 import requests
+import socket
 from PIL import Image, ImageFont, ImageDraw
 from six import BytesIO
 
-from core.config.env import client, Bucket, secret_key, region, secret_id, COS_PATH, COS_RERURN_PATH
+from core.config.env import client, Bucket, secret_key, region, secret_id, COS_PATH, COS_RERURN_PATH, red
 
 session = requests.session()
 
@@ -61,7 +62,8 @@ class imageCode():
         buf_str = buf.getvalue()
         img = b"data:image/png;base64," + base64.b64encode(buf_str)
         session.headers['verify'] = code
-        print(code)
+        res = socket.gethostbyname(socket.gethostname())
+        red.set(res + '-VerifyCode', code, 100)
         return img.decode('utf-8')
 
 

libs/token_verify.py

 import datetime
 import json
 
-from jose.exceptions import JWEError
+from jose.exceptions import JWEError, ExpiredSignatureError
 from sqlalchemy.orm import Session
 from fastapi import Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
-from jose import jwt, JWTError, ExpiredSignatureError
+from jose import jwt, JWTError
 
 from app import get_db
 from app.api.role.crud import get_id_to_authority
@@ -63,6 +63,7 @@ def get_current_user(db: Session, token: str = Depends(oauth2_scheme)):
     except JWTError as e:
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=f'{e}')
 
+
 def judgeToken(token):
     """
     判断token
@@ -70,23 +71,23 @@ def judgeToken(token):
     :return: boolen
     """
     try:
-        db: Session =next(get_db())
+        db: Session = next(get_db())
         payload = jwt.decode(token, env.SECRET_KEY, algorithms=[env.ALGORITHM])
-        user_data = get_user(db,username= payload.get("username"))
-        old_password=md5(payload["password"])
-        if  old_password == user_data.hashed_password:
+        user_data = get_user(db, username=payload.get("username"))
+        old_password = md5(payload["password"])
+        if old_password == user_data.hashed_password:
             print(md5(payload["password"]))
             print(user_data.hashed_password)
-            return  True
+            return True
         else:
             print("token 身份错误")
             return False
     except ExpiredSignatureError as e:
         print("token 过期了,{}".format(str(e)))
-        return  False
+        return False
     except JWEError as e:
         print("token 验证失败,{}".format(str(e)))
-        return  False
+        return False
 
 
 def login_required(token=Depends(oauth2_scheme)):
@@ -98,9 +99,9 @@ def login_required(token=Depends(oauth2_scheme)):
     credentials_exception = HTTPException(
         status_code=status.HTTP_411_LENGTH_REQUIRED,
         detail="Authenticate fail！",
-        headers={"WWW-Authenticate":"Bearer"}
+        headers={"WWW-Authenticate": "Bearer"}
     )
     if judgeToken(token):
         return True
     else:
-        raise  credentials_exception
\ No newline at end of file
+        raise credentials_exception

models/recharge.py

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

requirements.txt

@@ -43,3 +43,4 @@ urllib3==1.26.14
 uvicorn==0.20.0
 xmltodict==0.13.0
 openpyxl==3.1.2
+redis==4.3.4