async def search_pkg(schema_in: PkgSearch): """搜索套餐""" # TODO: support tag search, perphaps need to use raw sql count_query = db.select([db.func.count(StrategyPackage.product_id)]) fetch_query = StrategyPackage.query print(count_query, '3333333333333333333333333') print(fetch_query, '22222222222222222222') if schema_in.status: #count_query = count_query.filter( # StrategyPackage.status == int(schema_in.status) #) count_query = count_query.where( StrategyPackage.status == int(schema_in.status)) #fetch_query = fetch_query.filter( # StrategyPackage.status == int(schema_in.status) #) fetch_query = fetch_query.where( StrategyPackage.status == int(schema_in.status)) else: #count_query = count_query.filter( # StrategyPackage.status != int(ListStatus.deleted) #) count_query = count_query.where( StrategyPackage.status != int(ListStatus.deleted)) #fetch_query = fetch_query.filter( # StrategyPackage.status != int(ListStatus.deleted) #) fetch_query = fetch_query.where( StrategyPackage.status != int(ListStatus.deleted)) if schema_in.product_id: count_query = count_query.where( StrategyPackage.product_id == schema_in.product_id) fetch_query = fetch_query.where( StrategyPackage.product_id == schema_in.product_id) if schema_in.name: count_query = count_query.where( StrategyPackage.name.contains(schema_in.name)) fetch_query = fetch_query.where( StrategyPackage.name.contains(schema_in.name)) if schema_in.tag: # TODO: support tag search pass if schema_in.market_id: count_query = count_query.where( StrategyPackage.market_id == schema_in.market_id) fetch_query = fetch_query.where( StrategyPackage.market_id == schema_in.market_id) total_count = await db.scalar(count_query) print(total_count, '444444444444444444444') pkg_list = (await fetch_query.order_by(text("name")).offset( schema_in.offset).limit(schema_in.count).gino.all()) print(pkg_list, '1111111111111111111111111111111') return PkgSearchOut(total=total_count, data=[pkg for pkg in pkg_list])
async def search_admin( schema_in: AdminUserSearchIn, current_user: MarketAdminUser = Depends(require_super_scope_su), ): """根据名字和类型查询标签或者风格""" count_query = db.select([ db.func.count(MarketAdminUser.id) ]).where(MarketAdminUser.status != int(UserStatus.deleted)) fetch_query = MarketAdminUser.query.where( MarketAdminUser.status != int(UserStatus.deleted)) if schema_in.scope1: count_query = count_query.where( MarketAdminUser.scope1 == schema_in.scope1) fetch_query = fetch_query.where( MarketAdminUser.scope1 == schema_in.scope1) if schema_in.scope2: count_query = count_query.where( MarketAdminUser.scope2 == int(schema_in.scope2)) fetch_query = fetch_query.where( MarketAdminUser.scope2 == int(schema_in.scope2)) if schema_in.name: count_query = count_query.where( MarketAdminUser.name.contains(schema_in.name)) fetch_query = fetch_query.where( MarketAdminUser.name.contains(schema_in.name)) if schema_in.phone: count_query = count_query.where( MarketAdminUser.phone.contains(schema_in.phone)) fetch_query = fetch_query.where( MarketAdminUser.phone.contains(schema_in.phone)) if schema_in.email: count_query = count_query.where( MarketAdminUser.email.contains(schema_in.email)) fetch_query = fetch_query.where( MarketAdminUser.email.contains(schema_in.email)) total_count = await db.scalar(count_query) users = (await fetch_query.order_by(MarketAdminUser.name.desc() ).offset(schema_in.offset ).limit(schema_in.count).gino.all()) return AdminUserSearchOut(total=total_count, data=[ AdminUserInfo(**user.__dict__["__values__"]) for user in users if user.scope2 != UserScope2.su ])
async def search_market( schema_in: MarketSearch, current_user: MarketAdminUser = Depends(require_super_scope_admin), ): """查找超市""" count_query = db.select([ db.func.count(StrategyMarket.id) ]).where(StrategyMarket.status == int(MarketStatus.normal)) fetch_query = StrategyMarket.query.where( StrategyMarket.status == int(MarketStatus.normal)) if schema_in.id: count_query = count_query.where(StrategyMarket.id == schema_in.id) fetch_query = fetch_query.where(StrategyMarket.id == schema_in.id) if schema_in.name: count_query = count_query.where( StrategyMarket.name.contains(schema_in.name)) fetch_query = fetch_query.where( StrategyMarket.name.contains(schema_in.name)) total_count = await db.scalar(count_query) order_bys = [] for key in schema_in.order_bys: if not key.startswith("-"): if not hasattr(StrategyMarket, key): logger.warning( "get strategy market has invalid order_by key: %s", key) continue order_bys.append(getattr(StrategyMarket, key)) else: if not hasattr(StrategyMarket, key[1:]): logger.warning( "get strategy market has invalid order_by key: %s", key) continue order_bys.append(getattr(StrategyMarket, key[1:]).desc()) markets = (await fetch_query.order_by(*order_bys).offset(schema_in.offset ).limit(schema_in.count ).gino.all()) return MarketSearchOut(total=total_count, data=markets)
async def search_tag(schema_in: TagSearch): """根据名字和类型查询标签或者风格""" count_query = db.select([db.func.count(Tag.id) ]).where(Tag.deleted == False) fetch_query = Tag.query.where(Tag.deleted == False) if schema_in.tag_type: count_query = count_query.where( Tag.tag_type == int(schema_in.tag_type)) fetch_query = fetch_query.where( Tag.tag_type == int(schema_in.tag_type)) if schema_in.name: count_query = count_query.where(Tag.name.contains(schema_in.name)) fetch_query = fetch_query.where(Tag.name.contains(schema_in.name)) elif schema_in.fuzzy: count_query = count_query.where(Tag.name.contains(schema_in.fuzzy)) fetch_query = fetch_query.where(Tag.name.contains(schema_in.fuzzy)) total_count = await db.scalar(count_query) order_bys = [] for key in schema_in.order_bys: if not key.startswith("-"): if not hasattr(Tag, key): logger.warning("get tag has invalid order_by key: %s", key) continue order_bys.append(getattr(Tag, key)) else: if not hasattr(Tag, key[1:]): logger.warning("get tag has invalid order_by key: %s", key) continue order_bys.append(getattr(Tag, key[1:]).desc()) tags = (await fetch_query.order_by(*order_bys).offset(schema_in.offset ).limit(schema_in.count ).gino.all()) return TagSearchOut(total=total_count, data=tags)
async def search_review( schema_in: ReviewSearch, current_user: MarketAdminUser = Depends(require_super_scope_admin), ): """查找申请""" count_query = db.select([db.func.count(ReviewRecord.id)]) fetch_query = ReviewRecord.query if schema_in.review_id: count_query = count_query.where(ReviewRecord.id == schema_in.review_id) fetch_query = fetch_query.where(ReviewRecord.id == schema_in.review_id) if schema_in.review_status: count_query = count_query.where( ReviewRecord.review_status == int(schema_in.review_status)) fetch_query = fetch_query.where( ReviewRecord.review_status == int(schema_in.review_status)) else: count_query = count_query.where( ReviewRecord.review_status != int(ReviewStatus.deleted)) fetch_query = fetch_query.where( ReviewRecord.review_status != int(ReviewStatus.deleted)) if schema_in.operation: count_query = count_query.where( ReviewRecord.operation == int(schema_in.operation)) fetch_query = fetch_query.where( ReviewRecord.operation == int(schema_in.operation)) if schema_in.market_id: count_query = count_query.where( ReviewRecord.market_id == schema_in.market_id) fetch_query = fetch_query.where( ReviewRecord.market_id == schema_in.market_id) if schema_in.user_id: count_query = count_query.where( ReviewRecord.user_id == schema_in.user_id) fetch_query = fetch_query.where( ReviewRecord.user_id == schema_in.user_id) if schema_in.product_type: count_query = count_query.where( ReviewRecord.product_type == int(schema_in.product_type)) fetch_query = fetch_query.where( ReviewRecord.product_type == int(schema_in.product_type)) if schema_in.product_id: count_query = count_query.where( ReviewRecord.product_id == schema_in.product_id) fetch_query = fetch_query.where( ReviewRecord.product_id == schema_in.product_id) if schema_in.contact: count_query = count_query.where( ReviewRecord.contact.contains(schema_in.contact)) fetch_query = fetch_query.where( ReviewRecord.contact.contains(schema_in.contact)) total_count = await db.scalar(count_query) order_bys = [] for key in schema_in.order_bys: if not key.startswith("-"): if not hasattr(ReviewRecord, key): logger.warning( "get review record has invalid order_by key: %s", key) continue order_bys.append(getattr(ReviewRecord, key)) else: if not hasattr(ReviewRecord, key[1:]): logger.warning( "get review record has invalid order_by key: %s", key) continue order_bys.append(getattr(ReviewRecord, key[1:]).desc()) if not order_bys: order_bys.append(ReviewRecord.update_dt.desc()) review_list = (await fetch_query.order_by(*order_bys).offset( schema_in.offset).limit(schema_in.count).gino.all()) strategy_ids = [] package_ids = [] for review in review_list: if review.product_type == int(ProductType.qstrategy): strategy_ids.append(review.product_id) else: package_ids.append(review.product_id) strategy_rows = await QStrategy.select( "product_id", "name", "sim_name", "task_id", "bt_task_id", "sim_start_cash", "sim_start_dt", "category", ).where(QStrategy.product_id.in_(strategy_ids)).gino.all() pkg_rows = await StrategyPackage.select("name", "product_id").where( StrategyPackage.product_id.in_(package_ids)).gino.all() extras = {} for row in strategy_rows: extras[row["product_id"]] = { "name": row["name"], "sim_name": row["sim_name"], "task_id": row["task_id"], "bt_task_id": row["bt_task_id"], "sim_start_cash": row["sim_start_cash"], "sim_start_dt": row["sim_start_dt"], "category": row["category"], } for row in pkg_rows: extras[row["product_id"]] = {"name": row["name"]} return ReviewSearchOut( total=total_count, data=[{ **review.__dict__["__values__"], **extras.get(review.product_id, {}) } for review in review_list], )
async def search_strategy(schema_in: QStrategySearch, return_strategy_list=False): """搜索策略""" # TODO: support tag search, perphaps need to use raw sql count_query = db.select([db.func.count(QStrategy.product_id)]) fetch_query = QStrategy.query #if schema_in.status and schema_in.status != int(ListStatus.deleted): #if schema_in.status: # count_query = count_query.where(QStrategy.status == int(schema_in.status)) # fetch_query = fetch_query.where(QStrategy.status == int(schema_in.status)) #else: # #count_query = count_query.where(QStrategy.status != int(ListStatus.deleted)) # #fetch_query = fetch_query.where(QStrategy.status != int(ListStatus.deleted)) # count_query = count_query.where(QStrategy.status == int(ListStatus.online)) # fetch_query = fetch_query.where(QStrategy.status == int(ListStatus.online)) if not return_strategy_list: if schema_in.status: count_query = count_query.where( QStrategy.status == int(schema_in.status)) fetch_query = fetch_query.where( QStrategy.status == int(schema_in.status)) else: count_query = count_query fetch_query = fetch_query else: if schema_in.status: count_query = count_query.where( QStrategy.status == int(schema_in.status)) fetch_query = fetch_query.where( QStrategy.status == int(schema_in.status)) else: count_query = count_query.where( QStrategy.status == int(ListStatus.online)) fetch_query = fetch_query.where( QStrategy.status == int(ListStatus.online)) if schema_in.product_id: count_query = count_query.where( QStrategy.product_id == schema_in.product_id) fetch_query = fetch_query.where( QStrategy.product_id == schema_in.product_id) if schema_in.market_id: count_query = count_query.where( QStrategy.market_id == schema_in.market_id) fetch_query = fetch_query.where( QStrategy.market_id == schema_in.market_id) if schema_in.package_id: count_query = count_query.where( QStrategy.package_id == schema_in.package_id) fetch_query = fetch_query.where( QStrategy.package_id == schema_in.package_id) if schema_in.task_id: count_query = count_query.where( QStrategy.task_id.contains(schema_in.task_id)) fetch_query = fetch_query.where( QStrategy.task_id.contains(schema_in.task_id)) if schema_in.style: count_query = count_query.where( QStrategy.style.contains(schema_in.style)) fetch_query = fetch_query.where( QStrategy.style.contains(schema_in.style)) if schema_in.category: count_query = count_query.where( QStrategy.category == int(schema_in.category)) fetch_query = fetch_query.where( QStrategy.category == int(schema_in.category)) if schema_in.name: count_query = count_query.where(QStrategy.name.contains( schema_in.name)) fetch_query = fetch_query.where(QStrategy.name.contains( schema_in.name)) if return_strategy_list: if schema_in.fuzzy: #count_query = count_query.where(QStrategy.name.contains(schema_in.fuzzy)) count_query = count_query.where( or_( and_(QStrategy.name.contains(schema_in.fuzzy), QStrategy.status == ListStatus.online), and_(QStrategy.author_name.contains(schema_in.fuzzy), QStrategy.status == ListStatus.online), )) #print(await db.scalar(count_query),'qqqqqqqqqqqqqqqqqqqq') #print(schema_in.fuzzy,'fuzzy--------1111111111111111111') #fetch_query = fetch_query.where(QStrategy.name.in_(schema_in.fuzzy)).where(QStrategy.author_name.in_(schema_in.fuzzy)) fetch_query = fetch_query.where( or_( and_(QStrategy.name.contains(schema_in.fuzzy), QStrategy.status == ListStatus.online), and_(QStrategy.author_name.contains(schema_in.fuzzy), QStrategy.status == ListStatus.online), )) else: if schema_in.fuzzy: count_query = count_query.where( or_( QStrategy.name.contains(schema_in.fuzzy), QStrategy.author_name.contains(schema_in.fuzzy), QStrategy.product_id.contains(schema_in.fuzzy), )) fetch_query = fetch_query.where( or_( QStrategy.name.contains(schema_in.fuzzy), QStrategy.author_name.contains(schema_in.fuzzy), QStrategy.product_id.contains(schema_in.fuzzy), )) total_count = await db.scalar(count_query) order_bys = [] for key in schema_in.order_bys: if not key.startswith("-"): if not hasattr(QStrategy, key): logger.warning("search strategy has invalid order_by key: %s", key) continue order_bys.append(getattr(QStrategy, key)) else: if not hasattr(QStrategy, key[1:]): logger.warning("search strategy has invalid order_by key: %s", key) continue order_bys.append(getattr(QStrategy, key[1:]).desc()) #strategy_list = ( # await fetch_query.order_by(*order_bys) # .offset(schema_in.offset) # .limit(schema_in.count).gino.all() #) print(order_bys, 'order_bus---111111111111111') strategy_list = (await fetch_query.order_by(*order_bys).gino.all()) if return_strategy_list: return total_count, strategy_list # tag_names = [tag.name for tag in tags] return QStrategySearchOut( total=total_count, data=[strategy for strategy in strategy_list], )
async def list_strategies( schema_in: BuyedQStrategySearch, current_user: MarketUser = Depends(require_active_user), ): """列出已购买策略""" count_query = db.select([db.func.count(UserOrder.id)]).where( UserOrder.user_id == current_user.id, ).where( UserOrder.product_type == int(ProductType.package)) fetch_query = UserOrder.query.where( UserOrder.user_id == current_user.id, ).where( UserOrder.product_type == int(ProductType.package)) if schema_in.product_id: count_query = count_query.where( QStrategy.product_id == schema_in.product_id) fetch_query = fetch_query.where( QStrategy.product_id == schema_in.product_id) if schema_in.status: count_query = count_query.where( QStrategy.status == int(schema_in.status)) fetch_query = fetch_query.where( QStrategy.status == int(schema_in.status)) #if not schema_in.show_expired: # count_query = count_query.where(QStrategy.expire_dt >= datetime.datetime.now()) # fetch_query = fetch_query.where(QStrategy.expire_dt >= datetime.datetime.now()) #total_count = await db.scalar(count_query) total_count = 0 #orders = ( # await fetch_query.offset(schema_in.offset).limit(schema_in.count).gino.all() #) orders = (await fetch_query.gino.all()) product_ids = [] order_info_dict = {} for order in orders: product_ids.append((order.product_id)) order_info_dict[order.product_id] = { "order_id": order.id, "total_cash": order.total_cash, "total_days": order.total_days, "days": order.days, "gift_days": order.gift_days, "coupon_days": order.coupon_days, "coupon_cash": order.coupon_cash, "payed_cash": order.payed_cash, "expire_dt": order.expire_dt, "create_dt": order.create_dt, "pay_dt": order.pay_dt, } strategy_list = await QStrategy.query.where( QStrategy.package_id.in_(product_ids) ).where(QStrategy.status == int(ListStatus.online)).gino.all() strategy_list1 = [] strategy_list2 = [] for j in strategy_list: strategy_list1.append(j) for i in strategy_list1: if i not in strategy_list2: strategy_list2.append(i) data = [] for strategy in strategy_list2: total_count += 1 info = dict(**strategy.to_dict()) info.update(**order_info_dict[strategy.package_id]) data.append(BuyedQStrategyInfo(**info)) return BuyedQStrategySearchOut( total=total_count, data=data, )
async def search_order(schema_in: OrderSearch): """搜索用户的订单列表""" count_query = db.select([db.func.count( UserOrder.id)]).where(UserOrder.status != int(OrderStatus.deleted)) fetch_query = UserOrder.query.where( UserOrder.status != int(OrderStatus.deleted)) if schema_in.fuzzy: # 订单模糊搜索,账户和订单 ID fuzzy_check = (UserOrder.user_id.phone.contains(schema_in.fuzzy) | UserOrder.user_id.email.contains(schema_in.fuzzy) | UserOrder.user_id.name.contains(schema_in.fuzzy)) try: order_id = int(schema_in.fuzzy) fuzzy_check |= UserOrder.id == order_id except ValueError: pass fetch_query = fetch_query.where(fuzzy_check) count_query = count_query.where(fuzzy_check) if schema_in.product_id: product_id = schema_in.product_id try: fetch_query = fetch_query.where( UserOrder.product_id.contains(product_id)) count_query = count_query.where( UserOrder.product_id.contains(product_id)) except ValueError: pass if schema_in.order_id: fetch_query = fetch_query.where(UserOrder.id == schema_in.order_id) count_query = count_query.where(UserOrder.id == schema_in.order_id) if schema_in.user_id: fetch_query = fetch_query.where(UserOrder.user_id == schema_in.user_id) count_query = count_query.where(UserOrder.user_id == schema_in.user_id) if schema_in.product_id: fetch_query = fetch_query.filter( UserOrder.product_id == schema_in.product_id) count_query = count_query.where(UserOrder.user_id == schema_in.user_id) if schema_in.product_type: fetch_query = fetch_query.where( UserOrder.product_type == int(schema_in.product_type)) count_query = count_query.where( UserOrder.product_type == int(schema_in.product_type)) if schema_in.status: fetch_query = fetch_query.where( UserOrder.status == int(schema_in.status)) count_query = count_query.where( UserOrder.status == int(schema_in.status)) total_count = await db.scalar(count_query) orders = (await fetch_query.order_by(text("-id")).offset(schema_in.offset ).limit(schema_in.count ).gino.all()) data = [] print(orders, 'orders---222222222222222') for order in orders: print(order.__dict__, 'order----111111111111111') if order.user: mk = await MarketUser.get(int(order.user_id)) info = { "user_id": mk.id, "user_name": mk.name, "user_phone": mk.phone, } else: info = { "user_id": -1, "user_name": "deleted", "user_phone": "100000000000" } info.update(order.__dict__["__values__"]) data.append(info) return OrderSearchOut(total=total_count, data=data)