async def do_review( schema_in: ReviewResult, current_user: MarketAdminUser = Depends(require_super_scope_admin), ): """审核结果:通过 / 拒绝""" review = await ReviewRecord.get_or_404(schema_in.id) if review.review_status != int(ReviewStatus.wait): return CommonOut(errCode=-2, errMsg="操作失败,已完成审核") if review.product_type == int(ProductType.qstrategy): product = await QStrategy.get(review.product_id) elif review.product_type == int(ProductType.package): product = await StrategyPackage.get(review.product_id) if not product: return CommonOut(errCode=-2, errMsg="操作失败,没找到对应的策略 / 套餐") if product.status not in (int(ListStatus.online_review), int(ListStatus.offline_review)): return CommonOut(errCode=-2, errMsg="操作失败,策略 / 套餐已完成审核") if schema_in.accept: review = review.update(review_status=int(ReviewStatus.accepted)) if review.operation == int(ReviewOP.online): product = product.update(status=int(ListStatus.online)) else: product = product.update(status=int(ListStatus.offline)) else: review = review.update(review_status=int(ReviewStatus.rejected)) if review.operation == int(ReviewOP.online): product = product.update(status=int(ListStatus.online_rejected)) else: product = product.update(status=int(ListStatus.offline_rejected)) await review.update(review_msg=schema_in.msg).apply() await product.apply() return CommonOut()
async def change_admin_status( schema_in: AdminUserChangeStatusIn, current_user: MarketAdminUser = Depends(require_super_scope_su), ): """禁用管理员""" if current_user.scope1 != "aq" or current_user.scope2 != int( UserScope2.su): return CommonOut(errCode=-100, errMsg="添加失败,没有权限") #try: # # #await MarketAdminUser.update(status=int(schema_in.status)).where( # # MarketAdminUser.id == schema_in.id # #) # user = await MarketAdminUser.query.where(MarketAdminUser.id == schema_in.id).gino.first() # await user.update(status=int(schema_in.status)).apply() #except Exception: # logger.exception("更新管理员信息失败:%s", schema_in.json()) # return CommonOut(errCode=-1, errMsg="更新失败,请检查名字是否重复") if schema_in.status == UserStatus.deleted: user1 = await MarketAdminUser.query.where( MarketAdminUser.id == schema_in.id).gino.first() await user1.delete() else: try: user = await MarketAdminUser.query.where( MarketAdminUser.id == schema_in.id).gino.first() await user.update(status=int(schema_in.status)).apply() except Exception: logger.exception("更新管理员信息失败:%s", schema_in.json()) return CommonOut(errCode=-1, errMsg="更新失败,请检查名字是否重复") return CommonOut()
async def edit_strategy(product_id: str, changed: QStrategyUpdateFields): """编辑上架策略""" try: await QStrategy.filter(product_id=product_id).update(**changed.dict()) except Exception: logger.exception("更新策略 (%s) 失败:%s", product_id, changed.json()) return CommonOut(errCode=-1, errMsg="更新失败,请检查名字是否重复") return CommonOut()
async def check_buyed(task_id: str, request: Request): """检查是否需要因此策略信息""" try: if await check_task_permission(TaskType.PAPER_TRADING, task_id, request): return CommonOut() except Exception: pass return CommonOut(errCode=-1, errMsg="没有权限")
async def edit_strategy(product_id: str, changed: QStrategyUpdateFields): """编辑上架策略""" try: await QStrategy.update.values(**changed.dict()).where( QStrategy.product_id == product_id).gino.status() except Exception: logger.exception("更新策略 (%s) 失败:%s", product_id, changed.json()) return CommonOut(errCode=-1, errMsg="更新失败,请检查名字是否重复") return CommonOut()
async def edit_admin( schema_in: AdminUserUpdate, current_user: MarketAdminUser = Depends(require_active_admin), ): """编辑管理员信息""" try: await MarketAdminUser.filter(id=schema_in.id ).update(**schema_in.changed.dict()) except Exception: logger.exception("更新管理员信息失败:%s", schema_in.json()) return CommonOut(errCode=-1, errMsg="更新失败,请检查名字是否重复") return CommonOut()
async def change_admin_status( schema_in: AdminUserChangeStatusIn, current_user: MarketAdminUser = Depends(require_super_scope_su), ): """禁用管理员""" if current_user.scope1 != "aq" or current_user.scope2 != UserScope2.su: return CommonOut(errCode=-100, errMsg="添加失败,没有权限") try: await MarketAdminUser.filter(id=schema_in.id ).update(status=schema_in.status) except Exception: logger.exception("更新管理员信息失败:%s", schema_in.json()) return CommonOut(errCode=-1, errMsg="更新失败,请检查名字是否重复") return CommonOut()
async def add_package( schema_in: PkgCreate, current_user: MarketAdminUser = Depends(require_super_scope_admin), ): """添加套餐""" schema_in.product_id = uuid.uuid1() try: await StrategyPackage.create(**schema_in.dict()) except IntegrityError: return CommonOut(errCode=-1, errMsg="添加失败,请检查名字是否重复") except Exception: logger.exception("create package failed: %s", schema_in.json()) return CommonOut(errCode=-1, errMsg="添加失败,请检查名字是否重复") return CommonOut()
async def change_strategy_status(id_list: Union[str, List[str]], status: ListStatus): """直接重新上架策略""" if isinstance(id_list, str): id_list = [id_list] await QStrategy.filter(product_id__in=id_list).update(status=status) return CommonOut()
async def open_push( schema_in: PushCreate, request: Request, current_user: MarketUser = Depends(require_active_user), ): """开启推送""" if schema_in.push_method != PushMethod.wechat: raise HTTPException(status.HTTP_400_BAD_REQUEST, "push_id is needed") try: strategy = await QStrategy.get_or_none( product_id=schema_in.qstrategy_id) except DoesNotExist: raise HTTPException(status.HTTP_404_NOT_FOUND, "没找到对应策略") if await check_task_permission(TaskType.PAPER_TRADING, strategy.task_id, request): raise HTTPException(status.HTTP_401_UNAUTHORIZED, "没有权限") push_id = schema_in.push_id # TODO: check wechat bind for wechat push, check push_id for other method push = PushInfo( qstrategy_id=strategy.product_id, task_id=strategy.task_id, user_id=current_user.id, status=PushStatus.normal, push_method=schema_in.push_method, push_id=push_id, ) await push.save() return CommonOut()
async def cancel_pay( order_id: int, current_user: MarketAdminUser = Depends(require_super_scope_admin) ): """取消支付(线下订单)""" api_info = {} try: order = await UserOrder.get(id=order_id) except DoesNotExist: raise HTTPException(404, detail="订单未找到") if order.pay_method != PayMethod.offline: raise HTTPException(400, detail="仅线下支付订单支持支付确认") if order.status != OrderStatus.unpayed: raise HTTPException(400, detail="订单已支付 / 取消") order.status = OrderStatus.calceled await order.save() product = {} strategy_list = await StrategyPackage.filter(product_id=order.product_id) for i in strategy_list: product.update({'name':i.name}) user_phone = await MarketUser.get(id = order.user_id) api_info.update({ 'phone': user_phone.phone, 'actuallyPaid': order.payed_cash, 'completeTime': int(time.time() * 1000), 'costOfProduction': order.pay_cash, 'orderNumber': order.id, 'orderStatus': '取消支付', 'packageName': product['name'], 'paymentMethod': '线下支付', }) res = await requests_url(api_info) print(res, 'res66666666666666') return CommonOut()
async def add_market( schema_in: MarketCreate, current_user: MarketAdminUser = Depends(require_super_scope_su), ): """添加新的策略超市""" await StrategyMarket.create(**schema_in.dict(), status=MarketStatus.normal) return CommonOut()
async def check_email_dup(email: str): """检查邮箱是否重复""" try: await MarketUser.get_or_none(email=email) except DoesNotExist: raise HTTPException(status_code=404, detail="邮箱已注册") return CommonOut()
async def check_username_dup(user_name: str): """检查用户名是否重复""" try: await MarketUser.get_or_none(name=user_name) except DoesNotExist: raise HTTPException(status_code=404, detail="用户名已注册") return CommonOut()
async def check_phone_dup(phone: str): """检查手机号是否重复""" try: await MarketUser.get_or_none(phone=phone) except DoesNotExist: raise HTTPException(status_code=404, detail="手机号已注册") return CommonOut()
async def del_tag(schema_in: TagBatDel): """删除标签或风格,可传单个 id 或者 id 列表""" id_list = schema_in.id if isinstance(id_list, int): id_list = [id_list] await Tag.filter(id__in=id_list).update(deleted=True) return CommonOut()
async def recover_password(schema_in: ResetPassword): """ Password Recovery """ await verify_code(schema_in.vcode_id, schema_in.vcode) await verify_auth_code(schema_in.phone, schema_in.email, schema_in.sms_code) if schema_in.phone: user = await MarketUser.get_or_none(phone=schema_in.phone) else: user = await MarketUser.get_or_none(email=schema_in.email) if not user: raise HTTPException( status_code=404, detail= "The user with this email/phone does not exist in the system.", ) user.password = get_password_hash(schema_in.password, user.uuid.hex) await user.save() # verify_code = "1234" # if schema_in.phone: # send_sms(verify_code) # else: # send_email(verify_code) return CommonOut(msg="Password recovery message sent")
async def recover_password(schema_in: ResetPassword): """ Password Recovery """ await verify_code(schema_in.vcode_id, schema_in.vcode) await verify_auth_code(schema_in.phone, schema_in.email, schema_in.sms_code) if schema_in.phone: user = await MarketUser.query.where(MarketUser.phone == schema_in.phone ).gino.first() #password = await MarketUser.select('password').where(MarketUser.phone==schema_in.phone).gino.scalar() else: user = await MarketUser.query.where(MarketUser.email == schema_in.email ).gino.first() #password = await MarketUser.select('password').where(MarketUser==schema_in.email).gino.scalar() if not user: #if not password: raise HTTPException( status_code=404, detail= "The user with this email/phone does not exist in the system.", ) #await user.password == get_password_hash(schema_in.password) await user.update( password=get_password_hash(schema_in.password, user.uuid.hex)).apply() #await user.save() # verify_code = "1234" # if schema_in.phone: # send_sms(verify_code) # else: # send_email(verify_code) return CommonOut(msg="Password recovery message sent")
async def get_strategy_code(task_id: str, request: Request): """检查是否需要因此策略信息""" if not await check_task_permission(TaskType.PAPER_TRADING, task_id, request): raise HTTPException(status.HTTP_403_FORBIDDEN, "没有权限") # get code query_str = "SELECT backtest_id FROM wk_simulation WHERE task_id=%s" client = Tortoise.get_connection("qpweb") try: rows = await client.execute_query_dict(query_str, task_id) except TypeError: raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="复制错误,策略已不存在") if len(rows) != 1: raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="复制错误,策略已不存在") backtest_id = rows[0]["backtest_id"] query_str = f"SELECT code FROM wk_strategy_backtest WHERE id=%s" try: rows = await client.execute_query_dict(query_str, backtest_id) except TypeError: raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="复制错误,策略已不存在") if len(rows) != 1: raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="复制错误,策略已不存在") code = rows[0]["code"] return CommonOut(data=code)
async def del_tag(schema_in: TagBatDel): """删除标签或风格,可传单个 id 或者 id 列表""" id_list = schema_in.id if isinstance(id_list, int): id_list = [id_list] await Tag.update.values(deleted=True).where(Tag.id.in_(id_list) ).gino.status() return CommonOut()
async def generate_verification_code(): """生成验证码并存储到 redis""" code = generate_random_verify() data = get_image_verify(code) redis_id = "verify_" + str(time.time() % 10000) code = code.lower() await ctx.redis_client.set(redis_id, code, expire=config.VERIFY_CODE_TIMEOUT) return CommonOut(data={"id": redis_id, "code": data})
async def change_pkg_status(product_id: UUID, change_status: ListStatus): """更改套餐状态""" try: await StrategyPackage.filter(product_id=product_id ).update(status=change_status) except Exception: logger.exception("更新套餐 (%s) 状态失败:%s", product_id, change_status) raise HTTPException(status_code=400, detail="数据库错误") return CommonOut()
async def confirm_pay( schema_in:OrderSearch, order_id: int, current_user: MarketAdminUser = Depends(require_super_scope_admin) ): """确认支付(线下订单)""" api_info = {} try: order = await UserOrder.get(id=order_id) except DoesNotExist: raise HTTPException(404, detail="订单未找到") if order.pay_method != PayMethod.offline: raise HTTPException(400, detail="仅线下支付订单支持支付确认") if order.status != OrderStatus.unpayed: raise HTTPException(400, detail="订单已支付 / 取消") order.payed_cash = order.pay_cash order.pay_dt = datetime.datetime.now() order.expire_dt = datetime.datetime.now() + datetime.timedelta( days=order.total_days + order.coupon_days ) order.status = OrderStatus.payed await order.save() await search_order_fake(schema_in) await search_order(schema_in) total_cash = [] total_cash1 = {} order1 = await UserOrder.filter(user_id=order.user_id,status=OrderStatus.payed).prefetch_related('user') for i in order1: total_cash.append(i.total_cash) total_cash1.update({"phone":str(i.user.phone)}) total_cash1.update({"strategicCost":str(sum(total_cash))}) ress = await request_url(total_cash1) print(order.user_id,'user_id') print(order_id,'user_id22222222222222222') print(order1,'order11111111111111111111') print(total_cash1,'total_cash1') #print(ress,'ress') product = {} strategy_list = await StrategyPackage.filter(product_id=order.product_id) for i in strategy_list: product.update({'name':i.name}) user_phone = await MarketUser.get(id = order.user_id) api_info.update({ 'phone': user_phone.phone, 'actuallyPaid': order.payed_cash, 'completeTime': int(time.time() * 1000), 'costOfProduction': order.pay_cash, 'orderNumber': order.id, 'orderStatus': '支付成功', 'packageName': product['name'], 'paymentMethod': '线下支付', } ) print(api_info, 'fake_api_info') res = await requests_url(api_info) print(res, 'res444444444444444') return CommonOut()
async def change_strategy_status(id_list: Union[str, List[str]], status: ListStatus): """直接重新上架策略""" if isinstance(id_list, str): id_list = [id_list] await QStrategy.filter(product_id__in=id_list).update( status=status, update_dt=datetime.datetime.now() - datetime.timedelta(hours=8)) return CommonOut()
async def add_admin( schema_in: AdminUserCreate, current_user: MarketAdminUser = Depends(require_super_scope_su), ): """添加管理员,需要总后台超管权限""" if current_user.scope1 != "aq" or current_user.scope2 != UserScope2.su: return CommonOut(errCode=-100, errMsg="添加失败,没有权限") data = schema_in.dict() data["uuid"] = uuid.uuid1() data["password"] = get_password_hash(data["password"], data["uuid"].hex) try: await MarketAdminUser.create(**data) except Exception: logger.exception("create package failed: %s", schema_in.json()) return CommonOut(errCode=-1, errMsg="添加失败,请检查名字是否重复") return CommonOut()
async def change_pkg_status(product_id: str, change_status: ListStatus): """更改套餐状态""" try: await StrategyPackage.update.values(status=change_status).where( StrategyPackage.product_id == product_id).gino.status() except Exception: logger.exception("更新套餐 (%s) 状态失败:%s", product_id, change_status) raise HTTPException(status_code=400, detail="数据库错误") return CommonOut()
async def change_strategy_status(id_list: Union[str, List[str]], status: ListStatus): """直接重新上架策略""" if isinstance(id_list, str): id_list = [id_list] await QStrategy.update.values(status=int(status) ).where(QStrategy.product_id.in_(id_list) ).gino.status() return CommonOut()
async def edit_tag(schema_in: TagUpdate): """编辑标签或者风格的名字""" try: await Tag.filter(id=schema_in.id).update(name=schema_in.name) except IntegrityError: raise HTTPException(status_code=400, detail="更新标签 / 风格失败,请检查名字是否重复") except Exception: logger.exception("create tag failed: %s", schema_in.json()) raise HTTPException(status_code=400, detail="数据库错误") return CommonOut()
async def update_password( update_in: UpdatePassword, current_user: MarketAdminUser = Depends(require_active_admin)): if not verify_password(update_in.old_pwd, current_user.password, current_user.uuid.hex): raise HTTPException(status_code=400, detail="密码错误") user = await MarketAdminUser.get(id=current_user.id) user.password = get_password_hash(update_in.new_pwd, current_user.uuid.hex) await user.save() return CommonOut()
async def disable_market( schema_in: MarketDisable, current_user: MarketAdminUser = Depends(require_super_scope_su), ): """禁用 / 删除超市""" id_list = schema_in.id if isinstance(id_list, int): id_list = [id_list] await StrategyMarket.filter(id__in=id_list).update(status=schema_in.status) return CommonOut()