def get_platform_message(self):
data = parameter_required()
filter_args = {PlatformMessage.isdelete == False}
if common_user():
filter_args.add(
PlatformMessage.PMstatus == PlanetMessageStatus.publish.value)
if is_supplizer():
filter_args.add(PlatformMessage.PMcreate == request.user.id)
if data.get('PMstatus', None) is not None:
filter_args.add(PlatformMessage.PMstatus == data.get('pmstatus'))
pm_list = PlatformMessage.query.filter(*filter_args).order_by(
PlatformMessage.createtime.desc()).all_with_page()
for pm in pm_list:
self._fill_pm(pm)
if common_user():
self._fill_um(pm, request.user.id)
else:
um_read_count = UserPlatfromMessage.query.filter(
UserPlatfromMessage.isdelete == False,
UserPlatfromMessage.PMid == pm.PMid,
UserPlatfromMessage.UPMstatus ==
UserPlanetMessageStatus.read.value).count()
pm.fill('pmreadcount', um_read_count)
return Success(data=pm_list)
def _fill_raiders_list(raiders):
"""攻略列表"""
raiders.fields = ['TRid']
raiders.fill('trtitle', '{}游玩攻略'.format(raiders.TRlocation))
author = User.query.filter_by_(USid=raiders.AuthorID).first()
author_info = None if not author else {
'usname': author.USname,
'usheader': author.USheader,
'usid': author.USid,
'usminilevel': MiniUserGrade(author.USminiLevel).zh_value
}
raiders.fill('author', author_info)
raiders.fill('travelrecordtype_zh',
TravelRecordType(raiders.TRtype).zh_value)
img_path = PyQuery(raiders.TRcontent)('img').attr('src')
raiders.fill('picture', img_path)
followed = True if common_user() and UserCollectionLog.query.filter(
UserCollectionLog.UCLcoType == CollectionType.user.value,
UserCollectionLog.isdelete
== false(), UserCollectionLog.UCLcollector == getattr(
request, 'user').id, UserCollectionLog.UCLcollection
== raiders.AuthorID).first() else False
raiders.fill('followed', followed)
is_own = True if common_user() and raiders.AuthorID == getattr(
request, 'user').id else False
raiders.fill('is_own', is_own)
def list(self):
"""拼团/商品列表"""
args = request.args.to_dict()
now = datetime.datetime.now()
option = args.get('option')
gpstatus = args.get('gpstatus')
starttime, endtime = args.get('starttime', '2019-01-01') or '2019-01-01', args.get('endtime', '2100-01-01') or '2100-01-01'
if is_admin() or is_supplizer():
return self._back_group_product_list(gpstatus, starttime, endtime)
if str(option) == 'my':
my_group = []
if common_user():
my_group = self._filter_joined_group().all_with_page()
list(map(lambda x: self._fill_single_group(x), my_group))
return Success(data=my_group)
elif str(option) == 'all':
all_group = self._filter_not_joined_group().all_with_page()
list(map(lambda x: self._fill_single_group(x), all_group))
return Success(data=all_group)
my_group = []
if common_user():
my_group = self._filter_joined_group().distinct().limit(2).all()
list(map(lambda x: self._fill_single_group(x), my_group))
all_group = self._filter_not_joined_group().distinct().limit(2).all()
list(map(lambda x: self._fill_single_group(x), all_group))
group_goods = GroupGoodsProduct.query.filter(GroupGoodsProduct.isdelete == False,
GroupGoodsProduct.GPstatus == ApplyStatus.agree.value,
GroupGoodsProduct.GPday == now.date()
).order_by(GroupGoodsProduct.createtime.desc()).all_with_page()
for gp in group_goods:
gp.hide('SUid', 'PRid', 'GPfreight')
product = Products.query.filter(Products.PRid == gp.PRid, Products.isdelete == False).first()
if not product:
continue
gps_list = GroupGoodsSku.query.filter_by(GPid=gp.GPid, isdelete=False).all()
gpsku_price = [gps.SKUPrice for gps in gps_list]
gp.fill('gpstatus_en', ApplyStatus(gp.GPstatus).name)
gp.fill('gpstatus_zh', ApplyStatus(gp.GPstatus).zh_value)
gp.fill('prmainpic', product['PRmainpic'])
gp.fill('prtitle', product.PRtitle)
gp.fill('gpdeposit', max(gpsku_price))
res = {'my_group': my_group,
'all_group': all_group,
'group_goods': group_goods
}
return Success(data=res)
def list(self):
"""商品列表"""
args = parameter_required()
prtitle = args.get('prtitle')
ipstatus = args.get('status')
try:
ipstatus = getattr(ApplyStatus, ipstatus).value
except Exception as e:
current_app.logger.error(
'integral list status error : {}'.format(e))
ipstatus = None
integral_balance = 0
if common_user():
ipstatus = ApplyStatus.agree.value
user = User.query.filter_by_(USid=request.user.id).first()
integral_balance = getattr(user, 'USintegral', 0)
elif is_tourist():
ipstatus = ApplyStatus.agree.value
filter_args = [
IntegralProduct.isdelete == False,
IntegralProduct.IPstatus == ipstatus, Products.isdelete == False,
Products.PRstatus == ProductStatus.usual.value
]
if is_supplizer():
filter_args.append(Products.CreaterId == request.user.id),
if prtitle:
filter_args.append(Products.PRtitle.ilike('%{}%'.format(prtitle)))
ips = IntegralProduct.query.outerjoin(
Products, Products.PRid == IntegralProduct.PRid).filter_(
*filter_args).order_by(
IntegralProduct.createtime.desc()).all_with_page()
for ip in ips:
pr = Products.query.filter(Products.PRid == ip.PRid).first()
pb = ProductBrand.query.filter(
ProductBrand.PBid == pr.PBid).first()
ip.fill('prtitle', pr.PRtitle)
ip.fill('prmainpic', pr['PRmainpic'])
ip.fill('ipstatus_zh', ApplyStatus(ip.IPstatus).zh_value)
ip.fill('ipstatus_en', ApplyStatus(ip.IPstatus).name)
ip.fill('pbname', pb.PBname)
res = dict(product=ips)
if common_user() or is_tourist():
cfg = ConfigSettings()
rule = cfg.get_item('integralrule', 'rule')
integral = dict(balance=integral_balance, rule=rule)
res['integral'] = integral
return Success(data=res)
def _my_home_page_count(usid):
followed = UserCollectionLog.query.filter(
UserCollectionLog.isdelete == false(),
UserCollectionLog.UCLcollector == usid,
UserCollectionLog.UCLcoType == CollectionType.user.value,
).count()
fens = UserCollectionLog.query.filter(
UserCollectionLog.isdelete == false(),
UserCollectionLog.UCLcollection == usid,
UserCollectionLog.UCLcoType == CollectionType.user.value,
).count()
published = TravelRecord.query.filter(
TravelRecord.isdelete == false(),
TravelRecord.AuthorID == usid).count()
user = User.query.filter_by_(USid=usid).first()
follow_status = True if common_user(
) and UserCollectionLog.query.filter(
UserCollectionLog.isdelete
== false(), UserCollectionLog.UCLcollector == getattr(
request, 'user').id, UserCollectionLog.UCLcollection == usid,
UserCollectionLog.UCLcoType
== CollectionType.user.value).first() else False
try:
usminilevel = MiniUserGrade(user.USminiLevel).zh_value
except Exception:
usminilevel = None
return (followed, fens, published, getattr(user, 'USname', None),
getattr(user, 'USheader', None), usminilevel, follow_status)
def get(self):
"""商品详情"""
args = request.args.to_dict()
gpid, ggid, gg = args.get('gpid'), args.get('ggid'), None
if not gpid and not ggid:
raise ParamsError('gpid | ggid 至少需要其一')
if ggid:
gg = GuessGroup.query.filter(GuessGroup.isdelete == False, GuessGroup.GGid == ggid,
# GuessGroup.GGendtime >= datetime.datetime.now()
).first_('该拼团已结束')
gpid = gg.GPid
agree_status = GroupGoodsProduct.GPstatus == ApplyStatus.agree.value
filter_args = [GroupGoodsProduct.isdelete == False, GroupGoodsProduct.GPid == gpid]
if common_user() or is_tourist():
filter_args.append(agree_status)
try:
if gg and gg.GGstatus == GuessGroupStatus.completed.value and agree_status in filter_args:
filter_args.remove(agree_status)
gp = GroupGoodsProduct.query.filter(*filter_args).first_()
product = self._fill_gp(gp, gg)
except Exception as e :
current_app.logger.error('The error is {}'.format(e))
raise StatusError("该拼团活动已结束")
return Success('获取成功', data=product)
def list(self):
"""列出所有场景"""
now = datetime.now()
form = SceneListForm().valid_data()
kw = form.kw.data
query = ProductScene.query.filter(ProductScene.isdelete == False)
if kw:
query = query.filter(ProductScene.PSname.contains(kw))
scenes = query.order_by(ProductScene.PSsort, ProductScene.createtime).all()
res = list()
for scene in scenes:
if scene.PStimelimited:
if scene.PSstarttime < now < scene.PSendtime:
countdown = scene.PSendtime - now
hours = str(countdown.days * 24 + (countdown.seconds // 3600))
minutes = str((countdown.seconds % 3600) // 60)
seconds = str((countdown.seconds % 3600) % 60)
scene.fill('countdown', "{}:{}:{}".format('0' + hours if len(hours) == 1 else hours,
'0' + minutes if len(minutes) == 1 else minutes,
'0' + seconds if len(seconds) == 1 else seconds))
else:
if is_tourist() or common_user():
continue
res.append(scene)
return Success(data=res)
def create_room(self):
if not common_user():
raise AuthorityError
user = get_current_user()
data = parameter_required()
roomid = self.get_room(data, user)
return Success(data=roomid)
def add_toilet(self):
"""添加厕所"""
if common_user():
creator = User.query.filter_by_(
USid=getattr(request, 'user').id).first_('请重新登录')
creator_id = creator.USid
creator_type = ApplyFrom.user.value
elif is_admin():
creator = Admin.query.filter_by_(
ADid=getattr(request, 'user').id).first_('请重新登录')
creator_id = creator.ADid
creator_type = ApplyFrom.platform.value
else:
raise TokenError('请重新登录')
data = parameter_required({
'latitude': '纬度',
'longitude': '经度',
'toimage': '图片'
})
latitude, longitude = data.get('latitude'), data.get('longitude')
latitude, longitude = self.cplay.check_lat_and_long(
latitude, longitude)
if common_user() and latitude and longitude:
self.BaseController.get_user_location(latitude, longitude,
creator_id)
exist = Toilet.query.filter(Toilet.isdelete == false(),
Toilet.longitude == longitude,
Toilet.latitude == latitude).first()
if exist:
raise ParamsError('该位置的厕所已被上传过')
with db.auto_commit():
toilet = Toilet.create({
'TOid': str(uuid.uuid1()),
'creatorID': creator_id,
'creatorType': creator_type,
'longitude': longitude,
'latitude': latitude,
'TOimage': data.get('toimage'),
'TOstatus': ApprovalAction.submit.value
})
db.session.add(toilet)
super(CScenicSpot, self).create_approval('totoilet', creator_id,
toilet.TOid, creator_type)
return Success('上传成功', data={'toid': toilet.TOid})
def list(self):
"""魔盒/商品列表"""
args = request.args.to_dict()
now = datetime.now()
option = args.get('option')
mbastatus = args.get('mbastatus')
starttime, endtime = (args.get('starttime', '2019-01-01')
or '2019-01-01',
args.get('endtime', '2100-01-01')
or '2100-01-01')
if is_admin() or is_supplizer():
return self._back_box_product_list(mbastatus, starttime, endtime)
if str(option) == 'my':
my_box = []
if common_user():
my_box = self._filter_my_box().all_with_page()
list(map(lambda x: self._fill_single_box(x), my_box))
return Success(data=my_box)
my_box = []
if common_user():
my_box = self._filter_my_box().distinct().limit(2).all()
list(map(lambda x: self._fill_single_box(x), my_box))
box_product = MagicBoxApply.query.filter(
MagicBoxApply.isdelete == False,
MagicBoxApply.MBAday == now.date(),
MagicBoxApply.MBAstatus == ApplyStatus.agree.value).order_by(
MagicBoxApply.createtime.desc()).all_with_page()
for box in box_product:
box.fields = ['MBAid', 'MBAday', 'MBAstatus']
product = Products.query.filter(
Products.PRid == box.PRid, Products.isdelete == False).first()
if not product:
continue
mbssku_list = MagicBoxApplySku.query.filter_by_(
MBAid=box.MBAid).all()
mbssku_price = [mbs.LowestPrice for mbs in mbssku_list]
box.fill('prtitle', product.PRtitle)
box.fill('prmainpic', product['PRmainpic'])
box.fill('mbadeposit', min(mbssku_price))
res = {'mybox': my_box, 'box_product': box_product}
return Success(data=res)
def get(self):
"""商品详情"""
args = parameter_required(('ipid', ))
ipid = args.get('ipid')
filter_args = [
IntegralProduct.isdelete == False, IntegralProduct.IPid == ipid
]
if common_user() or is_tourist():
filter_args.append(
IntegralProduct.IPstatus == ApplyStatus.agree.value)
ip = IntegralProduct.query.filter(*filter_args).first_("没有找到该商品")
product = self._fill_ip(ip)
return Success('获取成功', data=product)
def verify_have_paid(gp, gg=None):
"""检验该团/商品 是否已付过押金"""
if not common_user():
return
usid = request.user.id
om_list = []
order_main = None
if gg:
order_main = OrderMain.query.join(
GuessRecord, GuessRecord.OMid == OrderMain.OMid
).filter(GuessRecord.USid == usid, GuessRecord.isdelete == False,
GuessRecord.GRstatus == GuessRecordStatus.valid.value,
GuessRecord.GGid == gg.GGid,
OrderMain.isdelete == False,
OrderMain.OMinRefund == False,
OrderMain.OMfrom == OrderFrom.guess_group.value,
OrderMain.USid == usid,
OrderMain.OMstatus.notin_((OrderMainStatus.cancle.value,
OrderMainStatus.wait_pay.value))
).first()
current_app.logger.info('have ggid return paid om is {}'.format(order_main))
if not gg or not order_main:
order_mains = OrderMain.query.outerjoin(OrderPart,
OrderPart.OMid == OrderMain.OMid
).filter(OrderMain.isdelete == False,
OrderMain.OMinRefund == False,
OrderMain.OMstatus == OrderMainStatus.wait_send.value,
OrderMain.USid == usid,
OrderMain.OMfrom == OrderFrom.guess_group.value,
OrderPart.isdelete == False,
OrderPart.PRid == gp.GPid
).all()
for om in order_mains:
gr = GuessRecord.query.outerjoin(GuessGroup,
GuessGroup.GGid == GuessRecord.GGid
).filter(GuessRecord.isdelete == False,
GuessRecord.GRstatus == GuessRecordStatus.valid.value,
GuessRecord.OMid == om.OMid,
GuessGroup.isdelete == False,
GuessGroup.GGstatus != GuessGroupStatus.failed.value
).first()
if not gr:
om_list.append(om)
current_app.logger.info('get paid order main {} ; id : {}'.format(len(order_mains),
[i.OMid for i in order_mains]))
order_main = om_list[0] if len(om_list) > 0 else None
current_app.logger.info('filter paid om count: {}'.format(len(om_list)))
current_app.logger.info('return paid om is {}'.format(order_main))
return order_main
def get_ticket(self):
"""门票详情"""
args = request.args.to_dict()
tiid = args.get('tiid')
tsoid = args.get('tsoid')
secret_usid = args.get('secret_usid')
if not (tiid or tsoid):
raise ParamsError
ticketorder = None
if tsoid:
if not common_user():
raise TokenError
ticketorder = TicketsOrder.query.filter(TicketsOrder.isdelete == false(),
TicketsOrder.USid == getattr(request, 'user').id,
TicketsOrder.TSOid == tsoid).first()
tiid = ticketorder.TIid if ticketorder else tiid
if secret_usid:
try:
superid = super(CTicket, self)._base_decode(secret_usid)
current_app.logger.info('secret_usid --> superid {}'.format(superid))
if common_user() and superid != getattr(request, 'user').id:
with db.auto_commit():
uin = UserInvitation.create({
'UINid': str(uuid.uuid1()),
'USInviter': superid,
'USInvited': getattr(request, 'user').id,
'UINapi': request.path
})
current_app.logger.info('已创建邀请记录')
db.session.add(uin)
except Exception as e:
current_app.logger.info('secret_usid 记录失败 error = {}'.format(e))
ticket = Ticket.query.filter(Ticket.isdelete == false(), Ticket.TIid == tiid).first_('未找到该门票信息')
self._fill_ticket(ticket, ticketorder=ticketorder)
return Success(data=ticket)
def toilet_list(self):
"""厕所列表"""
args = request.args.to_dict()
toilet_query = Toilet.query.filter(Toilet.isdelete == false())
if is_admin():
tostatus = args.get('tostatus')
try:
ApprovalAction(tostatus)
except Exception as e:
# current_app.logger.error('TOstatus error is {}'.format(e))
tostatus = None
if tostatus:
toilet_query = toilet_query.filter(Toilet.TOstatus == tostatus)
toilets = toilet_query.order_by(
Toilet.createtime.desc()).all_with_page()
for toilet in toilets:
toilet.hide('creatorID', 'creatorType')
toilet.fill('tostatus_zh',
ApprovalAction(toilet.TOstatus).zh_value)
else:
parameter_required(
{
'latitude': '请允许授权位置信息，以便为您展示附近的厕所',
'longitude': '请允许授权位置信息，以便为您展示附近的厕所'
},
datafrom=args)
latitude, longitude = args.get('latitude'), args.get('longitude')
if latitude == 'null':
raise ParamsError('请允许授权位置信息，以便为您展示附近的厕所')
latitude, longitude = self.cplay.check_lat_and_long(
latitude, longitude)
if common_user() and latitude and longitude:
self.BaseController.get_user_location(
latitude, longitude,
getattr(request, 'user').id)
scale = args.get('scale', 14)
variable = self.scale_dict.get(int(float(scale)))
toilets = toilet_query.filter(
Toilet.TOstatus == ApprovalAction.agree.value,
Toilet.latitude <= float(latitude) + variable,
Toilet.latitude >= float(latitude) - variable,
Toilet.longitude <= float(longitude) + variable,
Toilet.longitude >= float(longitude) - variable,
).all()
[toilet.hide('creatorID', 'creatorType') for toilet in toilets]
return Success(data=toilets)
def _fill_single_group(self, gg):
gg.hide('USid')
gg.fill('ggstatus_en', GuessGroupStatus(getattr(gg, 'GGstatus', 0)).name)
gg.fill('ggstatus_zh', GuessGroupStatus(getattr(gg, 'GGstatus', 0)).zh_value)
headers, numbers = self._fill_number_and_headers(gg)
gg.fill('headers', headers)
gg.fill('numbers', numbers)
if common_user():
gr = GuessRecord.query.filter_by_(GGid=gg.GGid, USid=request.user.id,
GRstatus=GuessRecordStatus.valid.value).first()
if gr:
type = '我参与的'
if gg.USid == request.user.id:
type = '我发起的'
gg.fill('type', type)
if gg.GGstatus == GuessGroupStatus.failed.value:
gg.fill('type', '拼团失败')
def _filter_not_joined_group():
filter_args = []
if common_user(): # 只筛选自己没参加过的团
usid = request.user.id
all_gr = db.session.query(GuessRecord.GGid, func.group_concat(GuessRecord.USid)
).filter(GuessRecord.isdelete == False,
GuessRecord.GRstatus == GuessRecordStatus.valid.value
).group_by(GuessRecord.GGid).all()
ggid_list = [gr[0] for gr in all_gr if usid not in gr[1]]
filter_args.append(GuessGroup.GGid.in_(ggid_list))
all_group = GuessGroup.query.filter(GuessGroup.isdelete == False,
GuessGroup.GGendtime >= datetime.datetime.now(),
GuessGroup.GGstatus.in_((GuessGroupStatus.pending.value,
GuessGroupStatus.waiting.value)),
* filter_args
).order_by(func.field(GuessGroup.GGstatus, 0, 10, 20, -10),
GuessGroup.createtime.desc())
return all_group
def _list_ticketorders(self):
import copy
if not common_user():
raise TokenError
tos = TicketsOrder.query.filter(TicketsOrder.isdelete == false(),
TicketsOrder.USid == getattr(request, 'user').id
).order_by(TicketsOrder.createtime.desc()).all_with_page()
res = []
for to in tos:
ticket = Ticket.query.filter(Ticket.isdelete == false(), Ticket.TIid == to.TIid).first()
ticket = copy.deepcopy(ticket)
if not ticket:
current_app.logger.error('未找到ticket, tiid: {}'.format(to.TIid))
continue
self._fill_ticket(ticket, to)
ticket.fields = ['TIid', 'TIname', 'TIimg', 'TIstartTime', 'TIendTime', 'TIstatus', 'tsoid', 'tsocode',
'tsostatus', 'tsostatus_zh', 'interrupt', 'tistatus_zh', 'ticategory', 'tsoqrcode']
ticket.fill('short_str', '{}.{}抢票开启 | {}'.format(ticket.TIstartTime.month,
ticket.TIstartTime.day, ticket.TIabbreviation))
res.append(ticket)
del ticket
return Success(data=res)
def read(self):
data = parameter_required(('pmid', ))
if not common_user():
raise AuthorityError
user = get_current_user()
with db.auto_commit():
upm = UserPlatfromMessage.query.filter_by(PMid=data.get('pmid'),
USid=user.USid,
isdelete=False).first()
upml = UserPlatfromMessageLog.create({
'UPMLid': str(uuid.uuid1()),
'UPMid': upm.UPMid,
'USid': user.USid
})
if upm.UPMstatus != UserPlanetMessageStatus.read.value:
upm.UPMstatus = UserPlanetMessageStatus.read.value
db.session.add(upml)
db.session.add(upm)
# usersids = self.get_usersid()
# self.push_platform_message(usid=user.USid, usersid=usersids.get(user.USid))
return Success()
def list_product(self):
"""获取活动商品"""
data = parameter_required(('tlaid', ))
tlaid = data.get('tlaid')
tlastatus = data.get('tlastatus')
prtitle = data.get('prtitle', '')
filter_args = {
TimeLimitedProduct.isdelete == False,
}
if common_user():
filter_args.add(
TimeLimitedProduct.TLAstatus == ApplyStatus.agree.value)
current_app.logger.info('本次是普通用户进行查询')
elif is_supplizer():
current_app.logger.info('本次是供应商进行查询')
filter_args.add(TimeLimitedProduct.SUid == request.user.id)
else:
current_app.logger.info('本次是管理员进行查询')
if tlaid:
filter_args.add(TimeLimitedProduct.TLAid == data.get('tlaid'))
if tlastatus:
filter_args.add(
TimeLimitedProduct.TLAstatus == data.get('tlastatus'))
if prtitle:
filter_args.add(Products.PRtitle.ilike('%{}%'.format(prtitle)))
filter_args.add(
TimeLimitedProduct.TLAstatus >= ApplyStatus.shelves.value)
tlp_list = TimeLimitedProduct.query.join(
Products, Products.PRid == TimeLimitedProduct.PRid).filter(
*filter_args).order_by(
TimeLimitedProduct.createtime.desc()).all()
product_list = list()
# tlaid = tlp.TLAid
if common_user():
tla = TimeLimitedActivity.query.filter(
TimeLimitedActivity.isdelete == False,
TimeLimitedActivity.TLAid == tlaid,
TimeLimitedActivity.TLAstatus.in_([
TimeLimitedStatus.waiting.value,
TimeLimitedStatus.starting.value
])).first_('活动已下架')
else:
tla = TimeLimitedActivity.query.filter(
TimeLimitedActivity.isdelete == False,
TimeLimitedActivity.TLAid == tlaid,
).first_('没有此活动')
for tlp in tlp_list:
current_app.logger.info(tlp)
product = self._fill_tlp(tlp, tla)
if product:
product_list.append(product)
# 筛选后重新分页
page = int(data.get('page_num', 1)) or 1
count = int(data.get('page_size', 15)) or 15
total_count = len(product_list)
if page < 1:
page = 1
total_page = math.ceil(total_count / int(count)) or 1
start = (page - 1) * count
if start > total_count:
start = 0
if total_count / (page * count) < 0:
ad_return_list = product_list[start:]
else:
ad_return_list = product_list[start:(page * count)]
request.page_all = total_page
request.mount = total_count
# tlakwargs = dict(tlaname=tla.TlAname)
self._fill_tla(tla)
return Success(data=ad_return_list).get_body(tla=tla)
def _fill_travelrecord(trecord):
"""填充时光记录详情"""
if trecord.TRtype == TravelRecordType.essay.value: # 随笔
trecord.fields = ['TRid', 'TRlocation', 'TRtype', 'TRstatus']
content = json.loads(trecord.TRcontent)
trecord.fill('text', content.get('text', '...'))
trecord.fill('image', content.get('image'))
trecord.fill('video', content.get('video'))
if content.get('image'):
showtype = 'image'
elif content.get('video'):
showtype = 'video'
else:
showtype = 'text'
trecord.fill('showtype', showtype)
elif trecord.TRtype == TravelRecordType.travels.value: # 游记
trecord.fields = [
'TRid', 'TRlocation', 'TRtitle', 'TRtype', 'TRcontent',
'TRstatus'
]
img_path = PyQuery(trecord.TRcontent)('img').attr('src')
trecord.fill(
'picture',
(img_path if str(img_path).startswith('http') else API_HOST +
img_path if img_path else None))
text_content = PyQuery(trecord.TRcontent)('p').eq(0).text()
text_content = '{}...'.format(
text_content) if text_content else None
trecord.fill('text', text_content)
else: # 攻略
trecord.fields = [
'TRid', 'TRlocation', 'TRbudget', 'TRproducts', 'TRtype',
'TRcontent', 'TRstatus'
]
trecord.fill('trtitle', '{}游玩攻略'.format(trecord.TRlocation))
trproducts_str = None
if trecord.TRproducts:
trecord.TRproducts = json.loads(trecord.TRproducts)
trproducts_str = '、'.join(
map(lambda x: str(x), trecord.TRproducts))
trecord.fill('trproducts_str', trproducts_str)
if trecord.TRbudget:
trecord.fill('trbudget_str',
'¥{}'.format(round(float(trecord.TRbudget), 2)))
img_path = PyQuery(trecord.TRcontent)('img').attr('src')
trecord.fill(
'picture',
(img_path if str(img_path).startswith('http') else API_HOST +
img_path if img_path else None))
text_content = PyQuery(trecord.TRcontent)('p').eq(0).text()
text_content = '{}...'.format(
text_content) if text_content else None
trecord.fill('text', text_content)
trecord.fill(
'travelrecordtype_zh', TravelRecordStatus.auditing.zh_value
if trecord.TRstatus == TravelRecordStatus.auditing.value else
TravelRecordType(trecord.TRtype).zh_value)
trecord.fill('trstatus_zh',
TravelRecordStatus(trecord.TRstatus).zh_value)
author = User.query.filter_by_(USid=trecord.AuthorID).first()
author_info = None if not author else {
'usname': author.USname,
'usid': author.USid,
'usheader': author.USheader,
'usminilevel': MiniUserGrade(author.USminiLevel).zh_value
}
trecord.fill('author', author_info)
is_own = True if common_user() and getattr(
request, 'user').id == trecord.AuthorID else False
trecord.fill('is_own', is_own)
followed = True if common_user() and UserCollectionLog.query.filter(
UserCollectionLog.UCLcoType == CollectionType.user.value,
UserCollectionLog.isdelete
== false(), UserCollectionLog.UCLcollector == getattr(
request, 'user').id, UserCollectionLog.UCLcollection
== trecord.AuthorID).first() else False
trecord.fill('followed', followed)
def get(self):
"""商品/盒子详情"""
args = request.args.to_dict()
mbaid, mbjid, mbj = args.get('mbaid'), args.get('mbjid'), None
if not mbaid and not mbjid:
raise ParamsError(' mbaid / mbjid 至少需要其一')
if mbjid:
mbj = MagicBoxJoin.query.filter(
MagicBoxJoin.MBJid == mbjid,
MagicBoxJoin.isdelete == False).first_('该礼盒活动已结束')
mbaid = mbj.MBAid
agree_status = MagicBoxApply.MBAstatus == ApplyStatus.agree.value
filter_args = [
MagicBoxApply.isdelete == False, MagicBoxApply.MBAid == mbaid
]
if common_user() or is_tourist():
filter_args.append(agree_status)
try:
if mbj and mbj.MBJstatus == MagicBoxJoinStatus.completed.value and agree_status in filter_args:
filter_args.remove(agree_status)
mba = MagicBoxApply.query.filter(*filter_args).first_('该礼盒商品已下架')
product = self._fill_mba(mba)
except Exception as e:
current_app.logger.error('The error is {}'.format(e))
raise StatusError('该礼盒商品已下架')
product.fill(
'rules',
db.session.query(Activity.ACdesc).filter_by_(
ACtype=ActivityType.magic_box.value).scalar())
currentprice = records = have_paid = trade = lowest = None
if mbj:
# 有mbj 的情况下，重新显示 可购 原价 当前价 最低价
currentprice = mbj.MBJcurrentPrice
product.fill('PRprice', mbj.MBJprice)
product.fill('mbjid', mbj.MBJid)
product.fill('mbjstatus', mbj.MBJstatus)
product.fill('mbjstatus_en',
MagicBoxJoinStatus(mbj.MBJstatus).name)
product.fill('mbjstatus_zh',
MagicBoxJoinStatus(mbj.MBJstatus).zh_value)
product.fill('mbadeposit', mbj.LowestPrice) # 押金 (最低价)
product.fill('purchaseprice', mbj.HighestPrice) # 可购价
product.fill('selectedsku', mbj.MBSid) # 已选的sku
spreadprice = None
records = MagicBoxOpen.query.filter_by_(MBJid=mbj.MBJid).order_by(
MagicBoxOpen.createtime.asc()).all()
if common_user():
if ActivityDeposit.query.filter(
ActivityDeposit.isdelete == False,
ActivityDeposit.ACtype == ActivityType.magic_box.value,
ActivityDeposit.ACDstatus ==
ActivityDepositStatus.valid.value,
ActivityDeposit.ACDcontentId == mbaid,
ActivityDeposit.ACDid == mbj.ACDid,
ActivityDeposit.USid == request.user.id).first():
have_paid = True
spreadprice = float(currentprice) - float(mbj.LowestPrice)
lowest = True if spreadprice <= 0 else False
trade = True if currentprice <= mbj.HighestPrice else False
spreadprice = 0 if spreadprice <= 0 else round(spreadprice, 2)
product.fill('spreadprice', spreadprice) # 需要补的差价
gearlevel = {'1': 'A', '2': 'B', '3': 'C'}
for mbjr in records:
mbjr.fields = ['MBJid', 'createtime', 'USheader']
action = MagicBoxOpenAction(mbjr.MBOaction).zh_value
record_str = '{}帮拆礼盒{}, {}{}元, 当前{}元'.format(
mbjr.USname, gearlevel.get(str(mbjr.MBOgear)), action,
mbjr.MBOresult, mbjr.MBOprice)
if mbjr.MBOresult == 0:
if mbjr.MBOaction == MagicBoxOpenAction.increase.value:
record_str = '{}帮拆礼盒{}，已是最高价，增加了0元，当前{}元'.format(
mbjr.USname, gearlevel.get(str(mbjr.MBOgear)),
mbjr.MBOprice)
else:
record_str = '{}帮拆礼盒{}，已是最低价，减少了0元，当前{}元'.format(
mbjr.USname, gearlevel.get(str(mbjr.MBOgear)),
mbjr.MBOprice)
mbjr.fill('record_str', record_str)
product.fill('currentprice', currentprice)
product.fill('records', records)
product.fill('topaydeposit', bool(not have_paid)) # 是否已付押金
product.fill('trade', bool(trade)) # 是否可以购买
product.fill('lowest', bool(lowest)) # 是否已达最大优惠
return Success(data=product)
def list(self):
form = BrandsListForm().valid_data()
pbstatus = dict(form.pbstatus.choices).get(form.pbstatus.data)
free = dict(form.free.choices).get(form.free.data)
# time_order = dict(form.time_order.choices).get(form.time_order.data)
itid = form.itid.data
itid = itid.split('|') if itid else []
kw = form.kw.data
brand_query = ProductBrand.query.filter_(
ProductBrand.isdelete == False,
ProductBrand.PBstatus == pbstatus
)
if itid:
brand_query = brand_query.join(
BrandWithItems, ProductBrand.PBid == BrandWithItems.PBid
).filter(
BrandWithItems.isdelete == False,
BrandWithItems.ITid.in_(itid)
)
if is_supplizer():
current_app.logger.info('供应商查看品牌列表..')
brand_query = brand_query.filter(
ProductBrand.SUid == request.user.id
)
if free is True:
brand_query = brand_query.filter(
ProductBrand.SUid.is_(None)
)
elif free is False:
brand_query = brand_query.filter(
ProductBrand.SUid.isnot(None)
)
if kw:
brand_query = brand_query.filter(
ProductBrand.PBname.contains(kw)
)
if common_user():
brand_query = brand_query.filter(ProductBrand.PBid.notin_(self.hide_pbid))
brands = brand_query.order_by(ProductBrand.PBsort.asc(), ProductBrand.createtime.desc()).all_with_page()
for brand in brands:
brand.fill('PBstatus_en', ProductBrandStatus(brand.PBstatus).name)
brand.fill('PBstatus_zh', ProductBrandStatus(brand.PBstatus).zh_value)
brand.add('createtime')
# 标签
print(brand.PBid)
pb_items = Items.query.filter_by().join(BrandWithItems, Items.ITid == BrandWithItems.ITid).filter_(
BrandWithItems.PBid == brand.PBid,
BrandWithItems.isdelete == False,
).all()
brand.fill('items', pb_items)
if is_admin() or brand.SUid:
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == brand.SUid
).first()
if not supplizer:
with db.auto_commit():
brand.SUid = None
db.session.add(brand)
continue
supplizer.fields = ['SUloginPhone', 'SUlinkPhone', 'SUname', 'SUlinkman', 'SUheader']
brand.fill('supplizer', supplizer)
self._fill_brand(brand, recommend_pr=True, coupon=True)
return Success(data=brands)
def travelrecord_list(self):
"""时光记录（个人中心）列表"""
args = request.args.to_dict()
usid, date, area, trtype = args.get('usid'), args.get(
'date'), args.get('area'), args.get('trtype')
option = args.get('option')
if usid:
ucl_list = [usid]
counts = self._my_home_page_count(usid)
top = self._init_top_dict(counts)
elif common_user():
ucl_list = db.session.query(
UserCollectionLog.UCLcollection).filter(
UserCollectionLog.UCLcoType == CollectionType.user.value,
UserCollectionLog.isdelete == false(),
UserCollectionLog.UCLcollector == getattr(
request, 'user').id).all()
ucl_list = [ucl[0] for ucl in ucl_list]
counts = self._my_home_page_count(getattr(request, 'user').id)
top = self._init_top_dict(counts)
elif is_admin():
ucl_list = top = None
else:
# return Success(data={'top': {'followed': 0, 'fens': 0, 'published': 0,
# 'usname': None, 'usheader': None, 'usminilevel': None, 'concerned': False},
# 'travelrecord': []})
raise TokenError('请重新登录')
base_filter = [TravelRecord.isdelete == false()]
if not (common_user() and option == 'my') and not is_admin():
base_filter.append(TravelRecord.AuthorID.in_(ucl_list))
base_filter.append(
TravelRecord.TRstatus == TravelRecordStatus.published.value)
trecords_query = TravelRecord.query.filter(*base_filter)
if date:
if not re.match(r'^\d{4}-\d{2}$', date):
raise ParamsError('查询日期格式错误')
year, month = str(date).split('-')
trecords_query = trecords_query.filter(
extract('month', TravelRecord.createtime) == month,
extract('year', TravelRecord.createtime) == year)
if trtype or str(trtype) == '0':
if not re.match(r'^[012]$', str(trtype)):
raise ParamsError('trtype 参数错误')
trecords_query = trecords_query.filter(
TravelRecord.TRtype == trtype)
if area:
scenicspots = db.session.query(ScenicSpot.SSPname).filter(
ScenicSpot.isdelete == false(),
ScenicSpot.SSParea.ilike('%{}%'.format(area))).all()
ssname = [ss[0] for ss in scenicspots]
trecords_query = trecords_query.filter(
or_(*map(
lambda x: TravelRecord.TRlocation.ilike('%{}%'.format(x)),
ssname)))
if common_user() and option == 'my':
trecords_query = trecords_query.filter(
TravelRecord.AuthorID == getattr(request, 'user').id)
trecords = trecords_query.order_by(
TravelRecord.createtime.desc()).all_with_page()
[self._fill_travelrecord(x) for x in trecords]
return Success(data={'top': top, 'travelrecord': trecords})
def _fill_brand(self, brand, **kwargs):
product_num, product_fields, = kwargs.get('product_num', 3), kwargs.get('product_fields', list())
new_product = kwargs.get('new_product', False)
banner_show = kwargs.get('banner_show', False)
recommend_pr = kwargs.get('recommend_pr', False)
coupon = kwargs.get('coupon', False)
if not product_fields:
product_fields = self.prfields[:]
if coupon:
user = None
if common_user():
user = get_current_user()
brand_coupon = self._get_brand_coupon(brand.SUid, user)
if brand_coupon:
from planet.control.CCoupon import CCoupon
ccoupon = CCoupon()
usid = user.USid if user else None
ccoupon._coupon(brand_coupon, usid=usid, fill_con=False)
product_num -= 1
brand.fill('coupon', brand_coupon)
# 推荐商品
if recommend_pr:
brand_recommend_product = self._recommend_pb_product(brand.PBid).all()[:product_num]
pr_supplement_id = list()
if brand_recommend_product:
for product in brand_recommend_product:
product.fields = product_fields
pr_supplement_id.append(product.PRid)
supplement_num = product_num - len(brand_recommend_product)
if supplement_num:
supplement_product = Products.query.filter(
Products.isdelete == false(), Products.PBid == brand.PBid).order_by(
Products.createtime.desc(), Products.PRid.notin_(pr_supplement_id)).all()
brand_recommend_product.extend(supplement_product[:supplement_num])
if brand_recommend_product:
brand.fill('recommend', brand_recommend_product)
# 新品推荐
if new_product:
brand_new_prodct = Products.query.filter(
Products.isdelete == false(), Products.PBid == brand.PBid).order_by(Products.createtime.desc()).all()
brand_new_prodct = brand_new_prodct[:self.br_new]
if brand_new_prodct:
for product in brand_new_prodct: product.fields = product_fields
brand.fill('new', brand_new_prodct)
# todo 填充动态
# brand.fill('BrandTweets', list())
# 填充banner
if banner_show:
bb_list = BrandBanner.query.filter(
BrandBanner.PBid == brand.PBid, BrandBanner.isdelete == false()).order_by(
BrandBanner.BBsort.asc(), BrandBanner.createtime.desc()).all()
bbs = self._fill_bb(bb_list)
if bbs:
brand.fill('brandbanner', bbs)
def list(self):
"""列出标签"""
form = ItemListForm().valid_data()
ittype = form.ittype.data
psid = form.psid.data
kw = form.kw.data
recommend = form.recommend.data
recommend = True if str(recommend) == '1' else None
# 如果查询商品对应的标签, 则可以传场景的id
items_query = Items.query.filter_(Items.isdelete == False, Items.ITtype == ittype,
Items.ITrecommend == recommend, Items.ITauthority != ItemAuthrity.other.value,
Items.ITposition != ItemPostion.other.value,
)
if psid:
items_query = items_query.outerjoin(SceneItem, SceneItem.ITid == Items.ITid
).filter_(SceneItem.isdelete == False,
SceneItem.PSid == psid,
)
scene_items = [sit.ITid for sit in
SceneItem.query.filter(SceneItem.PSid == psid, SceneItem.isdelete == False,
ProductScene.isdelete == False).all()]
prscene_count = Products.query.outerjoin(ProductItems, ProductItems.PRid == Products.PRid
).filter(Products.isdelete == False,
Products.PRfeatured == True,
Products.PRstatus == ProductStatus.usual.value,
ProductItems.isdelete == False,
ProductItems.ITid.in_(list(set(scene_items)))
).count()
if not prscene_count:
items_query = items_query.filter(Items.ITid != 'planet_featured') # 如果该场景下没有精选商品，不显示“大行星精选”标签
if is_supplizer():
# 供应商下不显示被限时场景关联着的标签
time_limit_itids = [it.ITid for it in
Items.query.join(SceneItem, SceneItem.ITid == Items.ITid
).join(ProductScene, ProductScene.PSid == SceneItem.PSid
).filter(SceneItem.isdelete == False,
ProductScene.isdelete == False,
Items.isdelete == False,
ProductScene.PStimelimited == True).all()]
items_query = items_query.filter(Items.ITauthority == ItemAuthrity.no_limit.value,
Items.ITposition.in_([ItemPostion.scene.value,
ItemPostion.news_bind.value,
ItemPostion.index.value]
),
Items.ITid.notin_(time_limit_itids),
Items.ITid != 'planet_featured'
)
if is_admin():
items_query = items_query.filter(Items.ITid != 'planet_featured')
if kw:
items_query = items_query.filter(
Items.ITname.contains(kw)
)
items_query = items_query.order_by(Items.ITsort.asc(), Items.createtime.desc())
# 普通用户默认获取已经自选过的圈子标签
if str(ittype) == str(ItemType.news.value):
uid = request.user.id if common_user() else None
items = self._filter_new_items(uid=uid, option=form.option.data)
return Success(data=items)
items = items_query.all()
for item in items:
item.fill('ITtype_zh', ItemType(item.ITtype).zh_value)
if item.ITtype == ItemType.product.value:
pr_scene = ProductScene.query.outerjoin(SceneItem, SceneItem.PSid == ProductScene.PSid
).filter_(SceneItem.isdelete == False,
SceneItem.ITid == item.ITid,
ProductScene.isdelete == False).all()
if (is_supplizer() or is_admin()) and pr_scene:
psname_list = str([ps.PSname for ps in pr_scene])
psname_list = re.sub(r'[\[\]\'\,]+', '', psname_list)
item.ITname = getattr(item, 'ITname', '') + ' / ' + str(psname_list) # 后台要显示标签所属场景
item.fill('prscene', pr_scene)
return Success('获取成功', data=items)
def _fill_gp(self, gp, gg=None):
product = Products.query.filter(Products.PRid == gp.PRid, Products.isdelete == False).first_('商品已下架')
product.fields = ['PRid', 'PRtitle', 'PRprice', 'PRlinePrice', 'PRsalesValue', 'PRstatus', 'PRmainpic',
'PRattribute', 'PRdesc', 'PRdescription']
if isinstance(product.PRattribute, str):
product.PRattribute = json.loads(product.PRattribute)
if isinstance(getattr(product, 'PRremarks', None) or '{}', str):
product.PRremarks = json.loads(getattr(product, 'PRremarks', None) or '{}')
pb = ProductBrand.query.filter_by(PBid=product.PBid, isdelete=False).first()
pb.fields = ['PBname', 'PBid']
images = ProductImage.query.filter(
ProductImage.PRid == product.PRid, ProductImage.isdelete == False).order_by(
ProductImage.PIsort).all()
[img.hide('PRid') for img in images]
product.fill('images', images)
product.fill('brand', pb)
gps_list = GroupGoodsSku.query.filter_by(GPid=gp.GPid, isdelete=False).all()
gpsku_price = []
skus = []
sku_value_item = []
for gps in gps_list:
gpsku_price.append(round(float(gps.SKUPrice), 2))
sku = ProductSku.query.filter_by(SKUid=gps.SKUid, isdelete=False).first()
if not sku:
current_app.logger.info('该sku已删除 skuid = {0}'.format(gps.SKUid))
continue
sku.hide('SKUstock', 'SkudevideRate', 'PRid')
sku.fill('skuprice', gps.SKUPrice)
sku.fill('gsstock', gps.GSstock)
sku.fill('gsid', gps.GSid)
if isinstance(sku.SKUattriteDetail, str):
sku.SKUattriteDetail = json.loads(sku.SKUattriteDetail)
sku_value_item.append(sku.SKUattriteDetail)
skus.append(sku)
if not skus:
current_app.logger.info('该申请的商品没有sku prid = {0}'.format(product.PRid))
return
product.fill('skus', skus)
sku_value_item_reverse = []
for index, name in enumerate(product.PRattribute):
value = list(set([attribute[index] for attribute in sku_value_item]))
value = sorted(value)
temp = {
'name': name,
'value': value
}
sku_value_item_reverse.append(temp)
product.fill('skuvalue', sku_value_item_reverse)
product.fill('gpstatus_zh', ApplyStatus(gp.GPstatus).zh_value)
product.fill('gpstatus_en', ApplyStatus(gp.GPstatus).name)
product.fill('gpstatus', gp.GPstatus)
product.fill('gpdeposit', max(gpsku_price)) # 显示的押金
product.fill('gprejectreason', gp.GPrejectReason)
product.fill('gpid', gp.GPid)
product.fill('gpday', gp.GPday)
product.fill('gpfreight', gp.GPfreight) # 运费目前默认为0
# if not gg:
# gg_query = GuessGroup.query.filter(GuessGroup.isdelete == False,
# GuessGroup.GPid == gp.GPid,
# GuessGroup.GGendtime >= datetime.datetime.now(),
# GuessGroup.GGstatus == GuessGroupStatus.pending.value)
# if common_user():
# gg_query = gg_query.outerjoin(GuessRecord, GuessRecord.GGid == GuessGroup.GGid
# ).filter(GuessRecord.isdelete == False,
# GuessRecord.USid == request.user.id,
# GuessRecord.GRstatus == GuessRecordStatus.valid.value)
# gg = gg_query.first()
if common_user() or is_tourist():
headers, numbers = self._fill_number_and_headers(gg)
status = getattr(gg, 'GGstatus', None)
ggstatus_zh = GuessGroupStatus(status).zh_value if isinstance(status, int) else None
tradeprice = None
if gg and status == GuessGroupStatus.completed.value:
tradeprice = db.session.query(OrderMain.OMtrueMount).outerjoin(
GuessRecord, GuessRecord.OMid == OrderMain.OMid
).filter(OrderMain.isdelete == False, GuessRecord.isdelete == False, GuessRecord.GGid == gg.GGid,
OrderMain.USid == request.user.id, GuessRecord.GRstatus == GuessRecordStatus.valid.value,
).scalar() if common_user() else None
ggstatus_zh = '本期正确结果: {}'.format(gg.GGcorrectNum) if common_user() else ggstatus_zh
guess_group = {'ggid': getattr(gg, 'GGid', None),
'ggstatus': status,
'ggstatus_en': GuessGroupStatus(status).name if isinstance(status, int) else None,
'ggstatus_zh': ggstatus_zh,
'headers': headers,
'numbers': numbers,
'tradeprice': tradeprice,
'rules': db.session.query(Activity.ACdesc
).filter_by_(ACtype=ActivityType.guess_group.value).scalar()
}
product.fill('guess_group', guess_group)
have_paid = self.verify_have_paid(gp, gg)
usid = request.user.id if common_user() else None
joined = self._already_joined(gg, usid)
if gg and gg.GGstatus != GuessGroupStatus.pending.value:
have_paid = True
joined = True
product.fill('topaydeposit', bool(not have_paid))
product.fill('joined', bool(joined))
return product
