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)