角色优化，充值报表接口

app/api/role/crud.py

 from datetime import datetime
+from fastapi import HTTPException, status
 from sqlalchemy.orm import Session
 from app.api.role import schemas
+from libs.functions import wrapper_out
 from models import roles as models
 
 
@@ -8,15 +10,30 @@ def get_role_by_name(db: Session, role_name: str):
     return db.query(models.Role).filter(models.Role.role_name == role_name).first()
 
 
+def get_id_to_authority(db: Session, role_id: int):
+    return db.query(models.Role).filter(models.Role.id == role_id).first()
+
+
+@wrapper_out()
 def get_roles(db: Session, param):
-    page = param.page if param.page else 1
-    size = param.size if param.size else 10
+    result_list = []
     name = param.role_name if param.role_name else ""
     if name:
-        return db.query(models.Role).filter(models.Role.role_name.like(f'%{name}%')).offset((int(page) - 1) * size).\
-            limit(page * size).all()
+        query_res = db.query(models.Role).filter(models.Role.role_name.like(f'%{name}%')).\
+            offset((int(param.page) - 1) * param.size).limit(param.page * param.size).all()
     else:
-        return db.query(models.Role).offset((int(page) - 1) * size).limit(page * size).all()
+        query_res = db.query(models.Role).offset((int(param.page) - 1) * param.size).limit(param.page * param.size).all()
+    if not query_res:
+        return []
+    for i in query_res:
+        serializer_info = i.to_dict(only=('id', 'role_name', 'authority', 'remark', 'create_time'))
+        if i.authority:
+            auth_list = serializer_info.get('authority').split(',')
+            serializer_info['authority'] = [int(i) for i in auth_list]
+        else:
+            serializer_info['authority'] = []
+        result_list.append(serializer_info)
+    return result_list
 
 
 def create_role(db: Session, user: schemas.RoleCreate):
@@ -47,6 +64,10 @@ def update_role(db: Session, role_info):
 
 
 def delete_role(db: Session, role_id: int):
-
+    from models import users as model
+    user_info = db.query(model.User).filter(model.User.role_id == role_id).first()
+    if user_info:
+        return False
     db.query(models.Role).filter(models.Role.id == role_id).delete()
     db.commit()
+    return True

app/api/role/views.py

@@ -29,7 +29,9 @@ def read_user(data: schemas.RoleUpdate, db: Session = Depends(get_db)):
 @router.delete("/delete/{role_id}")
 def delete_user(role_id: int, db: Session = Depends(get_db)):
     """角色删除"""
-    crud.delete_role(db, role_id)
+    res_bool = crud.delete_role(db, role_id)
+    if not res_bool:
+        return HttpResultResponse(code=422, msg=HttpMessage.NO_DELETE_ROLE)
     return HttpResultResponse()
 
 
@@ -37,4 +39,4 @@ def delete_user(role_id: int, db: Session = Depends(get_db)):
 def role_list(data: schemas.RoleList, db: Session = Depends(get_db)):
     """用户列表"""
     result = crud.get_roles(db, data)
-    return {"code": 200, "msg": "操作成功", "count": len(result), "data": result}
+    return HttpResultResponse(count=len(result), data=result)

app/api/statement/crud.py

+import math
+import threading
+
 import pandas as pd
+
+from app.api.statement import schemas
 from core.config.env import env
 from libs.db_link import LinkMysql
 from starlette.responses import StreamingResponse
 
 
-# def get_statement(db: Session, user_id: int):
-#     return db.query(models.Statement).filter(models.Statement.id == user_id)
+# 写入文件
+def data_to_file(data, name):
+    bk = pd.DataFrame(data)
+    with pd.ExcelWriter(f'static/{name}.xlsx') as writer:
+        bk.to_excel(writer, sheet_name='Sheet1', index=False)
+    file = open(writer, 'rb')
+    return StreamingResponse(file, media_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
 
 
-# def get_statement_by_name(db: Session, username: str):
-#     return db.query(models.Statement).filter(models.Statement.username == username).first()
+class RechargeStatement(object):
+    """充值报表"""
+    def __init__(self):
+        self.derive_list = []
 
+    def check_out(self, ch_sql):
+        once_res = LinkMysql(env.MysqlDB).query_mysql(ch_sql)
+        self.derive_list += once_res
 
-def get_statements(param):
-    page = param.page if param.page else 1
-    size = param.size if param.size else 10
-    query_list = []
-    if param.order_number:
-        query_list.append(f"o.order_number LIKE '%{param.order_number}%'")
-    if param.user_id:
-        query_list.append(f"o.userid={param.user_id}")
-    if param.sid:
-        query_list.append(f"o.sid LIKE '%{param.sid}%'")
-    if param.paychannel:
-        query_list.append(f"o.paychannel LIKE '%{param.paychannel}%'")
-    if param.start_time:
-        query_list.append(f"o.current>='{param.start_time}'")
-    if param.end_time:
-        query_list.append(f"o.current <= '{param.end_time}'")
-    if not query_list:
-        sql = f"select order_number,userid,user_number,nick_name,cast(money as char) as money,paychannel,sid,lastupdate,cast(current as char) as current,payment_time from orders o INNER JOIN v2_user v on o.userid = v.user_id LIMIT {(int(page) - 1) * size},{page * size}"
-    elif len(query_list) == 1:
-        sql = f"select order_number,userid,user_number,nick_name,cast(money as char) as money,paychannel,sid,lastupdate,cast(current as char) as current,payment_time from orders o INNER JOIN v2_user v on o.userid = v.user_id where {query_list[0]} LIMIT {(int(page)-1) * size},{page * size}"
-    else:
-        sql = f"select order_number,userid,user_number,nick_name,cast(money as char) as money,paychannel,sid,lastupdate,cast(current as char) as current,payment_time from orders o INNER JOIN v2_user v on o.userid = v.user_id where {' and '.join(query_list)} LIMIT {(int(page) - 1) * size},{page * size}"
+    def derive_query_data(self, condition_list, old_sql):
+        if not condition_list:
+            der_sql = f"select count(*) as total from orders o INNER JOIN v2_user v on o.userid = v.user_id order by o.id desc"
+        elif len(condition_list) == 1:
+            der_sql = f"select count(*) as total from orders o INNER JOIN v2_user v on o.userid = v.user_id where {condition_list[0]} order by o.id desc"
+        else:
+            der_sql = f"select count(*) as total from orders o INNER JOIN v2_user v on o.userid = v.user_id where {' and '.join(condition_list)} order by o.id desc"
+        total = LinkMysql(env.MysqlDB).query_mysql(der_sql)
+        if total:
+            to = total[0].get('total')
+            num = math.ceil(to / 10000)
+            # 多线程
+            ths = []
+            # 创建线程
+            for x in range(num):
+                query_sql = old_sql + f" LIMIT {x*10000},{10000}"
+                ths.append(threading.Thread(target=self.check_out, args=[(query_sql)]))
+            # 启动线程
+            for y in range(num):
+                ths[y].start()
+            # 等待子进程结束
+            for z in range(num):
+                ths[z].join()
+        return self.derive_list
 
-    query_res = LinkMysql(env.MysqlDB).query_mysql(sql)
-    return query_res
+    def get_statements(self, param, sp=None):
+        query_list = []
+        if not sp:
+            param: schemas.StatementList
+        if param.order_number:
+            query_list.append(f"o.order_number LIKE '%{param.order_number}%'")
+        if param.user_id:
+            query_list.append(f"o.userid={int(param.user_id)}")
+        if param.sid:
+            query_list.append(f"o.sid LIKE '%{param.sid}%'")
+        if param.paychannel:
+            query_list.append(f"o.paychannel LIKE '%{param.paychannel}%'")
+        if param.start_time:
+            query_list.append(f"o.current>='{param.start_time}'")
+        if param.end_time:
+            query_list.append(f"o.current <= '{param.end_time}'")
+        fields = ["order_number", "userid", "user_number", "nick_name", "cast(money as char) as money", "paychannel",
+                  "sid", "lastupdate", "cast(current as char) as current", "payment_time"]
+        if not query_list:
+            sql = f"select {','.join(fields)} from orders o INNER JOIN v2_user v on o.userid = v.user_id order by o.id desc"
+        elif len(query_list) == 1:
+            sql = f"select {','.join(fields)} from orders o INNER JOIN v2_user v on o.userid = v.user_id where {query_list[0]} order by o.id desc"
+        else:
+            sql = f"select {','.join(fields)} from orders o INNER JOIN v2_user v on o.userid = v.user_id where {' and '.join(query_list)} order by o.id desc"
+
+        if sp:
+            sql += f" LIMIT {(int(param.page) - 1) * param.size},{param.page * param.size}"
+            query_res = LinkMysql(env.MysqlDB).query_mysql(sql)
+        else:
+            query_res = self.derive_query_data(query_list, sql)
+        if query_res:
+            df = pd.DataFrame(query_res)
+            print(df)
+            count = df.groupby("money").sum()
+            # amount_list = list(count["money"].values)
+        else:
+            count = 0
+        return query_res, count
+
+
+class WithdrawStatement(object):
+    """提现报表"""
+    @staticmethod
+    def get_user_withdraw_cash(param, ty=None):
+        """用户提现"""
+        user_list = []
+        if param.user_id:
+            user_list.append(f"o.userid={param.user_id}")
+        if param.status:
+            user_list.append(f"o.status={param.status}")
+        if param.start_time:
+            user_list.append(f"o.current>='{param.start_time}'")
+        if param.end_time:
+            user_list.append(f"o.current <= '{param.end_time}'")
+        fields = ["id", "bank_code", "usernumber", "nickname", "truename", "idcard", "account", "status", "money",
+                 "platformServiceFee", "thirdServiceFee", "final_money", "cast(current as char) as current"]
+        if not user_list:
+            sql = f"select {','.join(fields)} from tixian_order order by id desc"
+        elif len(user_list) == 1:
+            sql = f"select {','.join(fields)} from tixian_order where {user_list[0]} order by id desc"
+        else:
+            sql = f"select {','.join(fields)} from tixian_order where {' and '.join(user_list)} order by id desc"
+
+        if ty:
+            sql += f" LIMIT {(int(param.page)-1) * param.size},{param.page * param.size}"
+        query_res = LinkMysql(env.MysqlDB).query_mysql(sql)
+        return query_res
+
+    @staticmethod
+    def get_guild_withdraw_cash(cond, co):
+        """公会提现"""
+        guild_list = []
+        if cond.guild_id:
+            guild_list.append(f"o.guild_id={cond.guild_id}")
+        if cond.status:
+            guild_list.append(f"o.status LIKE '%{cond.status}%'")
+        if cond.start_time:
+            guild_list.append(f"o.current>='{cond.start_time}'")
+        if cond.end_time:
+            guild_list.append(f"o.current <= '{cond.end_time}'")
+        gui_fields = ["account", "finalMoney", "guild_name", "x.id", "money", "parentid", "taxRate", "thirdServiceFee",
+                      "x.type", "x.update_time"]
+
+        if not guild_list:
+            sql = f"select {','.join(gui_fields)} from guild_ti_xian x INNER JOIN guild g on x.guild_id = g.id order by o.id desc"
+        elif len(guild_list) == 1:
+            sql = f"select {','.join(gui_fields)} from guild_ti_xian x INNER JOIN guild g on x.guild_id = g.id where {guild_list[0]} order by o.id desc"
+        else:
+            sql = f"select {','.join(gui_fields)} from guild_ti_xian x INNER JOIN guild g on x.guild_id = g.id where {' and '.join(guild_list)} order by o.id desc"
+
+        if co:
+            sql += f" LIMIT {(int(cond.page) - 1) * cond.size},{cond.page * cond.size}"
+        query_res = LinkMysql(env.MysqlDB).query_mysql(sql)
+        return query_res
 
 
-# 写入文件
-def data_to_file(data, name):
-    bk = pd.DataFrame(data)
-    with pd.ExcelWriter(f'static/{name}.xlsx') as writer:
-        bk.to_excel(writer, sheet_name='Sheet1', index=False)
-    file = open(writer, 'rb')
-    return StreamingResponse(file)

app/api/statement/schemas.py

@@ -22,7 +22,7 @@ class StatementList(BaseModel):
     start_time:  Optional[str] = ""
     end_time: Optional[str] = ""
     order_number: Optional[str] = ""
-    user_id: Optional[int] = None
+    user_id: Optional[str] = ""
     sid: Optional[str] = ""
     paychannel: Optional[str] = ""
 
@@ -32,3 +32,12 @@ class Statement(StatementBase):
 
     class Config:
         orm_mode = True
+
+
+class UserWithdrawalList(BaseModel):
+    page: Optional[int] = None
+    size: Optional[int] = None
+    start_time:  Optional[str] = ""
+    end_time: Optional[str] = ""
+    status: Optional[int] = None
+    user_id: Optional[int] = None

app/api/statement/views.py

 from app.api.statement import crud, schemas
 from fastapi import APIRouter
+
+from app.api.statement.crud import RechargeStatement, WithdrawStatement
 from libs.result_format import HttpResultResponse
 
 router = APIRouter()
@@ -8,19 +10,26 @@ router = APIRouter()
 @router.post("/recharge/list")
 def statement_recharge_list(data: schemas.StatementList):
     """充值报表列表"""
-    statement_list = crud.get_statements(data)
-    return HttpResultResponse(data=statement_list)
+    statement_list, money = RechargeStatement().get_statements(data, 1)
+    return HttpResultResponse(count=len(statement_list), total=money, data=statement_list)
 
 
 @router.post("/derive/excel")
-def statement_recharge_list(data: schemas.StatementList):
+def statement_derive_excel(data: schemas.StatementList):
     """充值报表导出"""
-    statement_list = crud.get_statements(data)
+    statement_list = RechargeStatement().get_statements(data)
     return crud.data_to_file(statement_list, "充值报表")
 
 
 @router.post("/userWithdrawal/list")
-def statement_recharge_list(data: schemas.StatementList):
+def user_withdrawal_list(data: schemas.UserWithdrawalList):
     """用户提现列表"""
-    statement_list = crud.get_statements(data)
+    statement_list = WithdrawStatement().get_user_withdraw_cash(data, 1)
     return HttpResultResponse(data=statement_list)
+
+
+@router.post("/userWithdrawal/excel")
+def user_withdrawal_excel(data: schemas.UserWithdrawalList):
+    """用户提现导出"""
+    user_list = WithdrawStatement().get_user_withdraw_cash(data)
+    return crud.data_to_file(user_list, "用户提现")

app/api/users/crud.py

+import random
 from datetime import datetime
 from sqlalchemy.orm import Session
+from app.api.role.crud import get_id_to_authority
 from app.api.users import schemas
-from libs.functions import md5, uuid
+from libs.functions import md5, uuid, wrapper_out
 from models import users as models
+from core.config.env import env
 
 
 def get_user_by_name(db: Session, username: str):
     return db.query(models.User).filter(models.User.username == username).first()
 
 
+@wrapper_out()
 def get_users(db: Session, param):
-    page = param.page if param.page else 1
-    size = param.size if param.size else 10
+    """
+    分组统计求和  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 ""
     if username:
-        return db.query(models.User).filter(models.User.username.like(f'%{username}%')).offset((int(page) - 1) * size).\
-            limit(page * size).all()
+        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)
     else:
-        return db.query(models.User).offset((int(page) - 1) * size).limit(page * size).all()
+        res = db.query(models.User).order_by(models.User.id.desc()).offset((int(param.page) - 1) * param.size).limit(param.page * param.size)
+    if not res:
+        return []
+    result_list = []
+    for i in res:
+        serializer_info = i.to_dict()
+        if i.role_id:
+            role_id = serializer_info.get('role_id')
+            role_info = get_id_to_authority(db, role_id)
+            if not role_info:
+                serializer_info['role_name'] = ''
+                continue
+            serializer_info['role_name'] = role_info.role_name
+        else:
+            serializer_info['role_name'] = ''
+        result_list.append(serializer_info)
+    return result_list
+
+
+def generate_random_str():
+    random_str = ""
+    base_str = 'ABCDEFGHIGKLMNOPQRSTUVWXYZabcdefghigklmnopqrstuvwxyz0123456789'
+    length = len(base_str) - 1
+    for i in range(10):
+        random_str += base_str[random.randint(0, length)]
+    return random_str
 
 
 def create_user(db: Session, user: schemas.UserCreate):
     try:
-        db_user = models.User(username=user.username, description=user.description, unique=user.unique,
-                              config_key=user.config_key, uuid=uuid(), hashed_password=md5("123456"),
-                              create_time=datetime.now())
+        db_user = models.User(username=user.username, remark=user.remark, unique=uuid(),
+                              config_key=generate_random_str(), uuid=uuid(), role_id=user.role_id,
+                              hashed_password=md5(env.PASSWORD), create_time=datetime.now())
         db.add(db_user)
         db.commit()
         db.refresh(db_user)
@@ -34,8 +65,16 @@ def create_user(db: Session, user: schemas.UserCreate):
     return db_user
 
 
-def update_user(db: Session, user_id: int, permissions: list):
+def update_user(db: Session, data):
+
+    if data.role_id:
+        db.query(models.User).filter(models.User.id == data.id).update({models.User.role_id: data.role_id})
+    if data.remark:
+        db.query(models.User).filter(models.User.id == data.id).update({models.User.remark: data.remark})
+    db.commit()
+
+
+def delete_user(db: Session, user_id: int):
 
-    db.query(models.User).filter(models.User.id == user_id).update({models.User.authority: ','.join(map(str,
-                                                                                                        permissions))})
+    db.query(models.User).filter(models.User.id == user_id).delete()
     db.commit()

app/api/users/schemas.py

@@ -7,9 +7,8 @@ class UserBase(BaseModel):
 
 
 class UserCreate(UserBase):
-    unique: str
-    description: str
-    config_key: str
+    remark: str
+    role_id: int
 
 
 class User(UserBase):
@@ -39,7 +38,8 @@ class GoogleLogin(BaseModel):
 class PermissionCreate(BaseModel):
 
     id: int
-    authority: list
+    remark: str
+    role_id: int
 
 
 class UserList(BaseModel):

app/api/users/views.py

@@ -73,8 +73,8 @@ def create_user(data: schemas.UserCreate, db: Session = Depends(get_db)):
 
 @router.post("/permission/allocation")
 def read_user(data: schemas.PermissionCreate, db: Session = Depends(get_db)):
-    """用户添加权限"""
-    crud.update_user(db, data.id, data.authority)
+    """用户修改"""
+    crud.update_user(db, data)
     return HttpResultResponse()
 
 
@@ -82,4 +82,11 @@ def read_user(data: schemas.PermissionCreate, db: Session = Depends(get_db)):
 def user_list(data: schemas.UserList, db: Session = Depends(get_db)):
     """用户列表"""
     result = crud.get_users(db, data)
-    return {"code": 200, "msg": "操作成功", "count": len(result), "data": result}
+    return HttpResultResponse(count=len(result), data=result)
+
+
+@router.delete("/delete/{user_id}")
+def delete_user(user_id: int, db: Session = Depends(get_db)):
+    """用户删除"""
+    crud.delete_user(db, user_id)
+    return HttpResultResponse()

core/config/env.py

@@ -20,8 +20,9 @@ class Env(BaseSettings):
         "pwd": "c1ea602311a369f6",
         "user": "root"
     }
-    SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
-    ALGORITHM = "HS256"
+    SECRET_KEY: str = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
+    ALGORITHM: str = "HS256"
+    PASSWORD: str = "fj123456"
 
 
 class TestingEnv(Env):

libs/functions.py

@@ -12,3 +12,15 @@ def md5(s):
 def uuid():
     """生成uuid"""
     return str(u.uuid4())
+
+
+# 页数页码校验
+def wrapper_out():
+    def wrapper(func):
+        def inner(db, param):
+            param.page = param.page if param.page else 1
+            param.size = param.size if param.size else 10
+            ret = func(db, param)
+            return ret
+        return inner
+    return wrapper

libs/result_format.py

@@ -10,6 +10,7 @@ class HttpMessage(object):
     LOGIN_SUCCESS = "登录成功"
 
     ROLE_EXIST = "角色已存在"
+    NO_DELETE_ROLE = "不能删除已绑定用户的角色！"
 
 
 class HttpResultResponse(Response):

libs/token_verify.py

@@ -3,6 +3,8 @@ from sqlalchemy.orm import Session
 from fastapi import Depends, APIRouter, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
 from jose import jwt, JWTError
+
+from app.api.role.crud import get_id_to_authority
 from app.api.users import crud
 from app.api.users.login_verification import get_user
 from core.config.env import env
@@ -34,6 +36,7 @@ def get_current_user(db: Session, token: str = Depends(oauth2_scheme)):
     :param token: 携带的token
     :return:
     """
+
     try:
         # 解密tokens
         payload = jwt.decode(token, env.SECRET_KEY, algorithms=[env.ALGORITHM])
@@ -41,7 +44,8 @@ def get_current_user(db: Session, token: str = Depends(oauth2_scheme)):
         username: str = payload.get('username')
         user_data = get_user(db=db, username=username)
         user_info = crud.get_user_by_name(db, user_data.username)
-        auth_list = user_info.authority.split(',')
+        role_info = get_id_to_authority(db, user_info.role_id)
+        auth_list = role_info.authority.split(',')
         json_data = {
             "username": user_data.username,
             "authority": [int(i) for i in auth_list],

models/roles.py

 from sqlalchemy import Column, Integer, String, DateTime, Text
 from core.storage.db import Base
+from sqlalchemy_serializer import SerializerMixin
 
 
-class Role(Base):
+class Role(Base, SerializerMixin):
     __tablename__ = "role"
 
     id = Column(Integer, primary_key=True, index=True)

models/users.py

 from sqlalchemy import Column, Integer, String, DateTime, Float
 from core.storage.db import Base
+from sqlalchemy_serializer import SerializerMixin
 
 
-class User(Base):
+class User(Base, SerializerMixin):
     __tablename__ = "users"
 
     id = Column(Integer, primary_key=True, index=True)
     username = Column(String(100), unique=True, index=True, comment="用户名")
-    description = Column(String(255), comment="描述")
+    remark = Column(String(255), comment="描述")
     unique = Column(String(50), unique=True, comment="唯一标识")
     hashed_password = Column(String(50), comment="密码")
     config_key = Column(String(50))
     uuid = Column(String(50))
-    authority = Column(String(50), comment="权限")
+    role_id = Column(Integer, comment="角色id")
     google_key = Column(String(255), comment="谷歌动态码secret标识")
     remaining_sum = Column(Float, comment="账户余额")
     entry_account = Column(String(255), comment="入账类目")