def game_poplists():
"""
获取所有游戏排行
:uri: /games/toplists
:param os: 平台
:param channels: 渠道号【可选】
:param version_code: 版本号
:return: {'toplists': <TopList> list}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
if not os or not version_code:
return error.InvalidArguments
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
toplists = list()
_ids = TopList.all_ids_by_os(os)
for b in TopList.get_list(_ids):
if b.os and b.os != os:
continue
if (b.version_code_mix and b.version_code_mix > version_code) or\
(b.version_code_max and b.version_code_max < version_code):
continue
if channels and b.channels and channels not in b.channels:
continue
if b.login == 'login' and (not uid
or not b.user_in_group(str(b.group), uid)):
continue
if b.province and not province:
continue
if b.province and province and province not in b.province:
continue
toplists.append(b.format())
return {'toplists': toplists}
def fixed_banner():
"""获取Banner信息 (GET)
:uri: /fixed_banners
:param os: 平台
:param channels: 渠道(可选)
:param version_code: 版本号
:returns: {'banners': list}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
if not os or not version_code:
return error.InvalidArguments
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
banners = list()
_ids = FixedBanner.all_banner_ids()
for b in FixedBanner.get_list(_ids):
if b.os and b.os != os:
continue
if (b.version_code_mix and b.version_code_mix > version_code) or \
(b.version_code_max and b.version_code_max < version_code):
continue
if channels and b.channels and channels not in b.channels:
continue
if b.login == 'login' and (not uid
or not b.user_in_group(str(b.group), uid)):
continue
if b.province and not province:
continue
if b.province and province and province not in b.province:
continue
banners.append(b.format())
return {'banners': banners}
def is_mobile_phone():
"""是否为移动手机号(GET)
:uri: /is_mobile_phone
:param phone: 手机号
:return: {'ret': bool}
"""
phone = request.values.get('phone', None)
return {'ret': util.is_mobile_phone(phone)}
def all_game_grids():
"""
获取游戏页所有宫格
uri: /games/grids
:param: os
:return: {'grids': list}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 1))
if not os or not version_code:
return error.InvalidArguments
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
grids = list()
_ids = GameGrid.all_ids()
for b in GameGrid.get_list(_ids):
if b.os and b.os != os:
continue
if (b.version_code_mix and b.version_code_mix > version_code) or\
(b.version_code_max and b.version_code_max < version_code):
continue
if channels and b.channels and channels not in b.channels:
continue
if b.login == 'login' and (not uid
or not b.user_in_group(str(b.group), uid)):
continue
if b.province and not province:
continue
if b.province and province and province not in b.province:
continue
grids.append(b.format())
return {'grids': grids}
def recommend_module():
"""获取游戏模块分类 (GET)
:uri: /home/recommend_module
:param os: 平台
:param channels: 渠道(可选)
:param version_code: 版本号
:returns: {'modules': list}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
modules = list()
_ids = GameRecommend.all_module_ids()
for b in GameRecommend.get_list(_ids):
if b.os and b.os != os:
continue
if (b.version_code_mix and b.version_code_mix > version_code) or \
(b.version_code_max and b.version_code_max < version_code):
continue
if channels and b.channels and channels not in b.channels:
continue
if b.login == 'login' and (not uid
or not b.user_in_group(str(b.group), uid)):
continue
if b.province and not province:
continue
if b.province and province and province not in b.province:
continue
modules.append(b.format())
return {'modules': modules}
def banner_icon():
"""获取Banner图标信息 (GET)
:uri: /banners/icon
:param os: 平台
:param channels: 渠道(可选)
:param version_code: 版本号
:returns: {'title_color': title_color, 'bottom_color': bottom_color, 'bottom_photo': bottom_photo}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
if not os or not version_code:
return error.InvalidArguments
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
title_color = list()
_ids = TitleColor.get_banner_title_color()
for t in TitleColor.get_list(_ids):
if t.os and t.os != os:
continue
if (t.version_code_mix and t.version_code_mix > version_code) or \
(t.version_code_max and t.version_code_max < version_code):
continue
if channels and t.channels and channels not in t.channels:
continue
if t.login == 'login' and (not uid
or not t.user_in_group(str(t.group), uid)):
continue
if t.province and not province:
continue
if t.province and province and province not in t.province:
continue
title_color.append(t.format())
title_color = title_color[0] if title_color else {}
bottom_color = list()
_ids = BottomColor.get_banner_bottom_color()
for b in BottomColor.get_list(_ids):
if b.os and b.os != os:
continue
if (b.version_code_mix and b.version_code_mix > version_code) or \
(b.version_code_max and b.version_code_max < version_code):
continue
if channels and b.channels and channels not in b.channels:
continue
if b.login == 'login' and (not uid
or not b.user_in_group(str(b.group), uid)):
continue
if b.province and not province:
continue
if b.province and province and province not in b.province:
continue
bottom_color.append(b.format())
bottom_color = bottom_color[0] if bottom_color else {}
bottom_photo = list()
_ids = BottomPhoto.get_banner_bottom_photo()
for b in BottomPhoto.get_list(_ids):
if b.os and b.os != os:
continue
if (b.version_code_mix and b.version_code_mix > version_code) or \
(b.version_code_max and b.version_code_max < version_code):
continue
if channels and b.channels and channels not in b.channels:
continue
if b.login == 'login' and (not uid
or not b.user_in_group(str(b.group), uid)):
continue
if b.province and not province:
continue
if b.province and province and province not in b.province:
continue
bottom_photo.append(b.format())
return {
'title_color': title_color,
'bottom_color': bottom_color,
'bottom_photo': bottom_photo
}
def user_migupay_info():
"""
用户咪咕币信息及会员信息
:return:
"""
user = request.authed_user
os = request.values.get('os', 'andriod')
channels = request.values.get('channels', None)
version_code = int(request.values.get('version_code', 1))
if not os or not version_code:
return error.InvalidArguments
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
vip_zone = None
_ids = GameGrid.all_ids()
for b in GameGrid.get_list(_ids):
if b.name != u'会员':
continue
if b.os and b.os != os:
continue
if (b.version_code_mix and b.version_code_mix > version_code) or\
(b.version_code_max and b.version_code_max < version_code):
continue
if channels and b.channels and channels not in b.channels:
continue
if b.login == 'login' and (not uid
or not b.user_in_group(str(b.group), uid)):
continue
if b.province and not province:
continue
if b.province and province and province not in b.province:
continue
vip_zone = b
break
if os == 'ios':
hide_migumoney = Config.fetch('ios_hide_migu_money', False, int)
else:
hide_migumoney = False
migu_money = {
'miguTotalCount': 0,
'miguMoneyCount': 0,
'miguMarketingCount': 0
}
# 当登录用户访问且显示咪咕币时，去一级支付中心获取用户咪咕币信息
if not hide_migumoney and user:
passid = user.partner_migu and user.partner_migu.get('passid')
if not passid:
passid = Migu.get_user_info_by_account_name(user.phone,
keyword='passID')
if passid:
user.update_model({'$set': {'partner_migu.passid': passid}})
# passid = '6484464505210'
if passid:
migu_money = MiguPay.query_balance_available_new(passid)
if isinstance(migu_money, error.ApiError):
# TODO 生产环境中需要返回错误信息
# return migu_money
migu_money = {
'miguTotalCount': 0,
'miguMoneyCount': 0,
'miguMarketingCount': 0
}
vip = {
'vip5': {
'subscribed': False,
'can_sub': True
},
'vip10': {
'subscribed': False,
'can_sub': True
}
}
if user and user.phone:
vip = MiguPay.check_user_vip_level(user.phone)
if isinstance(vip, error.ApiError):
return vip
data = {
'hide_migu_money': bool(hide_migumoney),
'migu_money': migu_money,
'vip': vip,
'vip_action': vip_zone and vip_zone.action
}
return data
def home():
"""获取首页信息 (GET)
:uri: /home
:param os: 平台
:param channels: 渠道(可选)
:param version_code: 版本号
:returns: {'banners': list, 'categories': list,
'sub_games': list, 'hot_games': list,
'hot_lives': list}
"""
user = request.authed_user
ret = dict()
# banner广告
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
no_gamefy = False # 不返回游戏风云视频及内容
if not os or not version_code:
no_gamefy = True
elif (os == 'ios' and version_code < 5920) or (os == 'android'
and version_code < 416):
no_gamefy = True
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
banners = list()
_ids = Banner.all_banner_ids()
for b in Banner.get_list(_ids):
if b.os and b.os != os:
continue
if (b.version_code_mix and b.version_code_mix > version_code) or \
(b.version_code_max and b.version_code_max < version_code):
continue
if channels and b.channels and channels not in b.channels:
continue
if b.login == 'login' and (not uid
or not b.user_in_group(str(b.group), uid)):
continue
if b.province and province and province not in b.province:
continue
banners.append(b.format())
if version_code == 0 and not banners:
_ids = Banner.all_banners_by_version()
banners = [b.format() for b in Banner.get_list(_ids)]
ret['banners'] = banners
support_cates = ['video', 'game', 'user', 'show-video']
if no_gamefy:
support_cates.pop(-1)
categories = []
cate_ids = HomeCategory.all_category_ids()
cates = HomeCategory.get_list(cate_ids)
for cate in cates:
ids = HomeCategoryConfig.category_object_ids(str(cate._id))
if not ids or cate.ctype not in support_cates:
continue
_category = cate.format()
if cate.ctype in ['video', 'show-video']:
ex_fields = [
'is_favored', 'is_liked', 'author__is_followed',
'game__subscribed'
]
if no_gamefy:
_category['objects'] = [
v.format(exclude_fields=ex_fields)
for v in Video.get_list(ids) if v.author
]
else:
_category['objects'] = [
v.format(exclude_fields=ex_fields)
for v in Video.get_list(ids)
]
elif cate.ctype == 'game':
ex_fields = ['subscribed']
_category['objects'] = [
g.format(exclude_fields=ex_fields) for g in Game.get_list(ids)
]
elif cate.ctype == 'user':
ex_fields = ['is_followed']
_category['objects'] = [
u.format(exclude_fields=ex_fields) for u in User.get_list(ids)
]
_category['objects'] = _category['objects'][:4]
categories.append(_category)
ret['categories'] = categories
# 兼容老版本
ret['hottest_of_today'] = []
# 热门直播
all_lives = Xlive.get_all_lives()
hot_lives = all_lives[:4] if len(all_lives) >= 4 else all_lives[:2]
hot_lives = hot_lives if len(hot_lives) > 1 else []
ret['hot_lives'] = [Xlive.format(l) for l in hot_lives]
# 用户已订阅游戏
sub_game_ids = []
if user:
sub_game_ids = UserSubGame.sub_game_ids(str(user._id))
tmp = []
for game_id in sub_game_ids:
ex_fields = [
'is_favored', 'is_liked', 'author__is_followed',
'game__subscribed'
]
vids = GameRecommendVideo.game_video_ids(game_id) or []
videos = [
v.format(exclude_fields=ex_fields)
for v in Video.get_list(vids)
]
# 补齐4个人气视频
if len(videos) < 4:
hot_vids = Video.game_hotvideo_ids(game_id, 1, 4)
for _vid in hot_vids:
if len(videos) == 4:
break
if _vid in vids:
continue
v = Video.get_one(_vid, check_online=True)
v and videos.append(v.format(exclude_fields=ex_fields))
if videos:
tmp.append({'game': videos[0]['game'], 'videos': videos})
else:
tmp = list()
ret['sub_games'] = tmp
# 热门游戏
gids = HotGame.hot_game_ids()
# 去掉用户已订阅游戏
gids = [gid for gid in gids if gid not in sub_game_ids]
tmp = []
for game_id in gids:
ex_fields = [
'is_favored', 'is_liked', 'author__is_followed', 'game__subscribed'
]
vids = GameRecommendVideo.game_video_ids(game_id) or []
videos = [
v.format(exclude_fields=ex_fields) for v in Video.get_list(vids)
]
# 补齐4个人气视频
if len(videos) < 4:
hot_vids = Video.game_hotvideo_ids(game_id, 1, 4)
for _vid in hot_vids:
if len(videos) == 4:
break
if _vid in vids:
continue
v = Video.get_one(_vid, check_online=True)
v and videos.append(v.format(exclude_fields=ex_fields))
if videos:
tmp.append({'game': videos[0]['game'], 'videos': videos})
ret['hot_games'] = tmp
return ret
def live_redpacket():
"""直播间红包活动(GET)
:uri: /lives/redpacket/info
:param os: 平台
:param channels: 渠道（可选）
:param version_code: 版本号
:param live_id: 直播间ID
:return: {'ret': bool}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
live_id = params.get('live_id', None)
if not os or not version_code or not live_id:
return error.InvalidArguments
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
live = Xlive.get_live(live_id)
# live = Xlive.test_lives()[0]
if not live:
return error.LiveError('直播不存在')
red_packet = None
red_packet_count = 0
# 先获取已存在的红包，以及已经参与的直播间抢红包
_ids = UserRedPacket.user_red_packets(uid)
# user_rps = []
lrp_ids = []
for urp in UserRedPacket.get_list(_ids):
# 查找用户直播间抽取红包记录
# if urp.resource_id is None:
# user_rps.append((urp.campaign_id, urp.resource_id))
lrp_ids.append(str(urp.active_id))
if not LiveRedPacket.get_one(urp.active_id):
continue
if urp.chance <= 0:
continue
if red_packet is None or red_packet.expire_at > urp.expire_at:
red_packet = urp
red_packet_count += urp.chance
red_packet = red_packet.format(
red_packet_count) if red_packet else red_packet
cdrp = None
rp_ids = LiveRedPacket.all_ids()
for rp in LiveRedPacket.get_list(rp_ids):
# 过滤非观看时长红包
if rp.mode != 2:
continue
# 过滤已参与的红包活动id
if str(rp._id) in lrp_ids:
continue
if rp.os and rp.os not in ['all', os]:
continue
if (rp.version_code_mix and rp.version_code_mix > version_code) or \
(rp.version_code_max and rp.version_code_max < version_code):
continue
if channels and rp.channels and channels not in rp.channels:
continue
if rp.login == 'login' and (not uid or
not rp.user_in_group(str(rp.group), uid)):
continue
if rp.province and not province:
continue
if rp.province and province and province not in rp.province:
continue
# 过滤主播
live_authors = [] if not rp.live_authors else rp.live_authors.split(
'\r\n')
if live_authors and live['user_id'] not in live_authors:
continue
# 过滤游戏
live_games = [] if not rp.live_games else rp.live_games.split('\r\n')
if live_games and live['game_id'] not in live_games:
continue
# 过滤关键字
key_words = [] if not rp.keyword else rp.keyword.split(u',')
if key_words and not any(map(lambda x: x in live['name'], key_words)):
continue
cdrp = rp.format()
break
return {'red_packet': red_packet, 'cdrp': cdrp}
def user_msg_home():
"""获取消息首页信息(GET|POST)
:uri: /messages/home
:param lrt: 系统消息最后阅读时间
:returns: {'msgs': list, 'sys_msgs': list, 'letters': list}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
ts = params.get('lrt', None)
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
# 默认取7天前的系统个人消息
cts = time.time()
if ts:
ts = ts_user = float(ts)
else:
ts_user = (cts - 7 * 24 * 3600)
sys_msgs = []
# 过滤系统消息（平台、渠道、版本、用户组、有效期）
for msg in SysMessage.sys_new_messages(ts, cts):
if msg.os and msg.os not in ['all', os]:
continue
if (msg.version_code_mix and msg.version_code_mix > version_code) or\
(msg.version_code_max and msg.version_code_max < version_code):
continue
if channels and msg.channels and channels not in msg.channels:
continue
if msg.login == 'login' and (
not uid or not msg.user_in_group(str(msg.group), uid)):
continue
if msg.province and not province:
continue
if msg.province and province and province not in msg.province:
continue
sys_msgs.append(msg.format())
msgs = []
letters = []
if user:
uid = str(user._id)
# 用户系统消息推送
sys_user_msg = [
msg.format() for msg in SysMessage.sys_user_messages(ts_user, uid)
]
sys_msgs.extend(sys_user_msg)
msgs = [msg.format() for msg in Message.user_new_messages(uid)]
letters = list()
_letters = Letter.new_letter_count(uid)
for _letter in _letters:
last_letter = Letter.get_one(_letter['last_id'])
temp = dict(last_letter=last_letter.format(),
count=_letter['count'])
letters.append(temp)
return {'msgs': msgs, 'sys_msgs': sys_msgs, 'letters': letters}
def popup():
"""弹窗
:uri: /popup
:param os: 平台
:param device: 设备ID
:param channels: 渠道(可选)
:return:{'popup': list}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
device = params.get('device', None)
version_code = int(params.get('version_code', 0))
if not os or not device:
return error.InvalidArguments
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
pids = Popup.popup_platform_ids(os)
list_popup = list()
for p in Popup.get_list(pids):
if p.os != os:
continue
if version_code and (p.version_code_mix and p.version_code_mix > version_code) or \
(p.version_code_max and p.version_code_max < version_code):
continue
if channels and p.channels and channels not in p.channels:
continue
if p.login == 'login' and (not uid
or not p.user_in_group(str(p.group), uid)):
continue
if p.province and not province:
continue
if p.province and province and province not in p.province:
continue
list_popup.append(p.format())
popup = list()
if list_popup:
_pids = PopupLog.get_by_device(device)
for p in list_popup:
if p['popup_id'] in _pids:
continue
plg = PopupLog.init()
plg.device = device
plg.target = ObjectId(p['popup_id'])
id = plg.create_model()
if id:
popup = p
break
return {'popup': [popup] if popup else []}
def live_task():
"""观看直播时长任务 (GET)
:uri: /lives/task
:param task_id: 直播任务ID
:param os: 平台
:param channels: 渠道（可选）
:param version_code: 版本号
:param live_id: 直播间ID
:return: {'ret': bool}
"""
user = request.authed_user
params = request.values
task_id = params.get('task_id', None)
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
live_id = request.values.get('live_id')
if not os or not version_code or not task_id or not live_id:
return error.InvalidArguments
uid = str(user._id)
phone = str(user.phone)
province = None
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
# 避免出现跨天时出现没有任务的情况
tids = WatchLiveTask.get_user_tids(uid)
task = WatchLiveTask.get_one(task_id)
if not task:
return error.TaskError(u'观看直播时长任务不存在！')
if task.os not in ['all', os]:
return error.TaskError(u'不符合任务条件！')
if (task.version_code_mix and task.version_code_mix > version_code) or \
(task.version_code_max and task.version_code_max < version_code):
return error.TaskError(u'不符合任务条件！')
if channels and task.channels and channels not in task.channels:
return error.TaskError(u'不符合任务条件！')
if task.login == 'login' and (
not uid or not task.user_in_group(str(task.group), uid)):
return error.TaskError(u'不符合任务条件！')
if task.province and not province:
return error.TaskError(u'不符合任务条件！')
if task.province and province and province not in task.province:
return error.TaskError(u'不符合任务条件！')
extra = dict(migu_id=user.partner_migu['id'],
phone=user.phone,
campaign_id=task.campaign_id)
msg = u"恭喜%(name)s获得%(gift)s"
def send_default_gift(uid, task_id, user, extra, msg):
item = WatchLiveTaskItem.get_item_by_identity(task_id, 'default')
if not item:
return {'ret': False, 'task': task.format(uid), 'item': None}
# 更新库存
item.update_left()
# 进行物品的发放
product = Product.get_product(item.product_id)
status = product.add_product2user(uid, item.product_num, const.TASK,
extra)
_msg = msg % ({'name': user.nickname or user.name, 'gift': item.title})
data = dict(message=_msg, event_id=live_id)
Xlive.send_live_msg(data, 'activity')
return {'ret': True, 'task': task.format(uid), 'item': item.format()}
lockkey = 'lock:task:%s:%s' % (uid, task_id)
with util.Lockit(Redis, lockkey) as locked:
if locked:
return error.TaskError(u'请求频率过高')
# 查看是否有抽奖机会
stat = WatchLiveTask.update_left_chance(uid, task_id)
if not stat:
return error.TaskError(u'无抽奖机会！')
# 从营销中心查询/请求抽奖机会
left_chances = Marketing.query_lottery_chance(user.partner_migu['id'],
task.campaign_id)
if isinstance(left_chances, error.ApiError):
return send_default_gift(uid, task_id, user, extra, msg)
if left_chances <= 0:
# 进行抽奖机会的兑换
ret = Marketing.execute_campaign(user.partner_migu['id'],
user.phone, [task.campaign_id])
if not ret or isinstance(ret, error.ApiError):
return send_default_gift(uid, task_id, user, extra, msg)
# 调用营销平台进行抽奖
prize = Marketing.draw_lottery(user.partner_migu['id'],
task.campaign_id)
if isinstance(prize, error.ApiError):
prize = None
if not prize:
# 如果没有抽中奖品，发放默认奖品
return send_default_gift(uid, task_id, user, extra, msg)
prize_name = None
for i in prize['extensionInfo']:
if i['key'] == 'levelName':
prize_name = i['value']
break
item = WatchLiveTaskItem.get_item_by_identity(task_id, prize_name)
# 更新库存
item.update_left()
# 生成兑奖订单
order = UserLiveOrder.create(user_id=uid,
item_id=str(item._id),
activity_id=task_id,
activity_type=0,
campaign_id=task.campaign_id,
title=item.title,
product_id=item.product_id,
product_num=item.product_num,
status=const.ORDER_FINISHED,
result=json.dumps(prize))
order.save()
# 进行物品的发放
product = Product.get_product(item.product_id)
status = product.add_product2user(uid, item.product_num, const.TASK,
extra)
_msg = msg % ({'name': user.nickname or user.name, 'gift': item.title})
data = dict(message=_msg, event_id=live_id)
Xlive.send_live_msg(data, 'activity')
return {'ret': True, 'task': task.format(uid), 'item': item.format()}
def async_msg():
"""服务器给客户端发消息接口(GET|POST)
:uri: /async/msg
:returns: {'has_new_msg': bool, 'has_new_follow': bool, 'has_new_task': bool}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
retry_seconds = 60
retry_times = 0
msgs = []
while len(msgs) <= 0 and retry_times < 10:
ts = time.time()
if user:
pubsub = MRedis.pubsub()
with gevent.Timeout(retry_seconds, False):
user_channel = User.USER_ASYNC_MSG % ({'uid': uid})
pubsub.subscribe(user_channel)
for item in pubsub.listen():
if item['type'] == 'message':
msgs.append(item['data'])
break
pubsub.unsubscribe(user_channel)
pubsub.close()
msgs = [json.loads(m) for m in msgs]
# 获取发给用户的系统消息
for sys_msg in SysMessage.sys_user_messages(ts, uid):
_msg = dict(obj_type='SysMessage',
obj_id=str(sys_msg._id),
count=1)
msgs.append(_msg)
else:
time.sleep(retry_seconds)
# 获取并过滤系统消息（平台、渠道、版本、用户组、有效期）
for msg in SysMessage.sys_new_messages(ts, time.time()):
if msg.os and msg.os not in ['all', os]:
continue
if (msg.version_code_mix and msg.version_code_mix > version_code) or \
(msg.version_code_max and msg.version_code_max < version_code):
continue
if channels and msg.channels and channels not in msg.channels:
continue
if msg.login == 'login' and (
not uid or not msg.user_in_group(str(msg.group), uid)):
continue
if msg.province and not province:
continue
if msg.province and province and province not in msg.province:
continue
_msg = dict(obj_type='SysMessage', obj_id=str(msg._id), count=1)
msgs.append(_msg)
break
retry_times += 1
has_new_msg = False
has_new_follow = False
has_new_task = False
for msg in msgs:
if msg['obj_type'] == 'FriendShip':
has_new_follow = True
elif msg['obj_type'] == 'Message':
has_new_msg = True
elif msg['obj_type'] == 'Letter':
has_new_msg = True
elif msg['obj_type'] == 'SysMessage':
has_new_msg = True
elif msg['obj_type'] == 'Task':
has_new_task = True
return {
'has_new_msg': has_new_msg,
'has_new_follow': has_new_follow,
'has_new_task': has_new_task
}
def exchange_product():
"""兑换物品接口(POST&LOGIN)
:uri: /store/exchange_product
:param store_id: 兑换活动ID
:param item_id: 兑换物品ID
:return: {'item': <Item>object, 'order': <Order>object}
"""
user = request.authed_user
store_id = request.values.get('store_id', None)
item_id = request.values.get('item_id', None)
user_ip = request.remote_addr
device = request.values.get('device', None)
if not store_id or not item_id:
return error.InvalidArguments
store = Store.get_store(store_id)
if not store or not store.online():
return error.StoreError('该兑换活动不存在或已下线')
item = StoreItem.get_store_item(store_id, item_id)
if not item:
return error.StoreError('该兑换奖品不存在')
# 库存判断
if item.left_num < 1:
return error.StoreError('该兑换奖品已卖完')
product = Product.get_product(item.product_id)
# 判断手机号
if product.product_type == MOBILE_TRAFFIC and not util.is_mobile_phone(
user.phone):
return error.StoreError('非移动手机号不能兑换此商品')
if product.product_type == UNICOM_TRAFFIC and not util.is_unicom_phone(
user.phone):
return error.StoreError('非联通手机号不能兑换此商品')
if product.product_type == TELECOM_TRAFFIC and not util.is_telecom_phone(
user.phone):
return error.StoreError('非电信手机号不能兑换此商品')
uc = UserCredit.get_or_create_user_credit(user_id=str(user._id))
if item.credit_type == const.SALE_GEM and uc.gem < item.credit_value:
return error.StoreError('你的游票不足，无法兑换此物品哦！')
elif item.credit_type == const.SALE_GOLD and uc.gold < item.credit_value:
return error.StoreError('你的游米不足，无法兑换此物品哦！')
key = 'lock:store:%s' % (str(user._id))
status = None
with util.Lockit(Redis, key) as locked:
if locked:
return error.StoreError('兑换太频繁')
extra = dict(migu_id=user.partner_migu['id'],
phone=user.phone,
campaign_id=store.resource_campaign_id)
status = product.add_product2user(str(user._id), item.product_num,
const.EXCHANGE, extra)
if status == const.ORDER_FAILED:
return error.StoreError('兑换失败')
else:
# 扣除货币
if item.credit_type == const.SALE_GEM:
uc.reduce_gem(item.credit_value, const.EXCHANGE)
elif item.credit_type == const.SALE_GOLD:
uc.reduce_gold(item.credit_value, const.EXCHANGE)
# 更新库存
item.left_num -= 1
item.use_num += 1
item.save()
# 记录订单
order = UserOrder.create(
user_id=str(user._id),
item_id=item.item_id,
store_id=item.store_id,
store_type=store.store_type,
campaign_id=store.campaign_id,
title=item.title,
product_id=item.product_id,
product_num=item.product_num,
status=status,
user_ip=request.access_route[0],
)
# 营销数据入库经分 兑换活动
data_dict = dict(cmd="exchange",
opt="1",
deviceid=request.values.get('device', ''),
mobile=user.phone,
source=request.values.get('source', 'activity'),
activityid=store_id,
activityname=store.title)
Marketing.jf_report(data_dict)
return {'item': item.format(), 'order': order.format()}
def draw_lottery():
"""抽奖接口(POST&LOGIN)
:uri: /store/draw_lottery
:param store_id: 抽奖活动ID
:return: {'item': <Item>object, 'order': <Order>object}
"""
user = request.authed_user
store_id = request.values.get('store_id', None)
trigger = request.values.get('trigger', None)
user_ip = request.remote_addr
device = request.values.get('device', None)
if not store_id:
return error.InvalidArguments
store = Store.get_store(store_id)
if not store or not store.online():
return error.StoreError('该抽奖活动不存在或已下线')
if store.pause():
return error.StoreError('该抽奖活动还未开始')
if store.yxmember:
uservip = MiguPay.check_user_vip_level(user.phone)
if isinstance(uservip, error.ApiError):
return uservip
if not (uservip['vip5']['subscribed']
or uservip['vip10']['subscribed']):
return error.MemberError('该抽奖需要游戏会员才能参加')
# 进行抽奖奖项库存判断
items = StoreItem.get_store_items(store_id)
left_num = sum(map(lambda x: x.left_num, items))
if left_num < 0:
return error.StoreError('该抽奖活动奖项已被领取完')
# 判断号码是否符合规则
info = Marketing.query_campaign(store.campaign_id)
if isinstance(info, error.ApiError):
return info
if info['mobile_phone_only'] and not util.is_mobile_phone(user.phone):
return error.StoreError('该抽奖活动只对移动手机号开放')
# 查看是否有抽奖机会
left_chances = Marketing.query_lottery_chance(user.partner_migu['id'],
store.campaign_id)
if isinstance(left_chances, error.ApiError):
return error.StoreError('获取抽奖机会失败')
if left_chances <= 0:
uc = UserCredit.get_or_create_user_credit(user_id=str(user._id))
if store.credit_type == const.SALE_GEM and uc.gem < store.credit_value:
return error.StoreError('你的游票不足，无法参与抽奖哦！')
elif store.credit_type == const.SALE_GOLD and uc.gold < store.credit_value:
return error.StoreError('你的游米不足，无法参与抽奖哦！')
key = 'lock:store:%s' % (str(user._id))
with util.Lockit(Redis, key) as locked:
if locked:
return error.StoreError('抽奖太频繁')
# 进行抽奖机会的兑换
if not trigger:
ret = Marketing.execute_campaign(user.partner_migu['id'],
user.phone,
[store.campaign_id])
else:
ret = Marketing.execute_campaign(user.partner_migu['id'],
user.phone,
[store.campaign_id],
trigger=trigger)
if not ret or isinstance(ret, error.ApiError):
return error.StoreError('兑换抽奖机会失败')
else: # 扣除货币
if store.credit_type == const.SALE_GEM:
uc.reduce_gem(store.credit_value, const.LOTTERY_REWAED)
elif store.credit_type == const.SALE_GOLD:
uc.reduce_gold(store.credit_value, const.LOTTERY_REWAED)
# 调用营销平台进行抽奖
prize = Marketing.draw_lottery(user.partner_migu['id'], store.campaign_id)
if isinstance(prize, error.ApiError):
return prize
# 营销数据入库经分 抽奖活动
data_dict = dict(cmd="lottery",
opt="1",
deviceid=request.values.get('device', ''),
mobile=user.phone,
source=request.values.get('source', 'activity'),
activityid=store_id,
activityname=store.title)
Marketing.jf_report(data_dict)
# 营销平台奖项有各种限制, 会导致用户抽不中任何物品的可能。
# 比如有A/B/C三个抽奖奖项，概率分别为20%/30%/50%，如果A物品配置为一个手机号只能中一次，
# 那当用户抽中过A之后，以后再抽奖，就会有20%(A)的几率啥也抽不中。如果B物品库存又没有了，
# 那用户就会有20%(A)+30%(B)的几率啥也抽不中。为了处理这种情况，目前默认如果抽不中就给
# 用户发一个抽奖活动配置的"default"奖项(运营后台: 营销平台奖项ID配置为'default')
if not prize:
item = StoreItem.get_item_by_identity(store.store_id, 'default')
if not item:
return {'item': None, 'order': None}
else:
# 更新库存
item.left_num -= 1
item.use_num += 1
item.save()
# 生成兑奖订单
order = UserOrder.create(
user_id=str(user._id),
item_id=item.item_id,
store_id=item.store_id,
store_type=store.store_type,
campaign_id=store.campaign_id,
title=item.title,
product_id=item.product_id,
product_num=item.product_num,
status=const.ORDER_NEED_DRAW,
result='',
user_ip=request.access_route[0],
)
extra = dict(migu_id=user.partner_migu['id'],
phone=user.phone,
campaign_id=store.resource_campaign_id)
# 进行物品的发放
product = Product.get_product(item.product_id)
status = product.add_product2user(str(user._id), item.product_num,
const.LOTTERY, extra)
# 订单状态更新
if status != order.status:
order.status = status
order.save()
return {'item': item.format(), 'order': order.format()}
# 由于营销平台看不到id, 暂时只能用奖项名称进行对应
prize_name = None
for i in prize['extensionInfo']:
if i['key'] == 'levelName':
prize_name = i['value']
break
item = StoreItem.get_item_by_identity(store.store_id, prize_name)
# 更新库存
item.left_num -= 1
item.use_num += 1
item.save()
# 无领取规则的活动营销平台会自动领取
status = const.ORDER_NEED_DRAW if info[
'is_exchange_rule'] else const.ORDER_IN_HAND
# 生成兑奖订单
order = UserOrder.create(
user_id=str(user._id),
item_id=item.item_id,
store_id=item.store_id,
store_type=store.store_type,
campaign_id=store.campaign_id,
title=item.title,
product_id=item.product_id,
product_num=item.product_num,
status=status,
result=json.dumps(prize),
user_ip=request.access_route[0],
)
product = Product.get_product(item.product_id)
if product.product_type != PHYSICAL_OBJECT: # 非实物物品直接去营销平台进行奖励兑换
# 有领取规则的抽奖活动的非实物物品自动领取, 无领取规则的活动营销平台会自动领取
if info['is_exchange_rule']:
# 获取用户可兑换奖励信息
prizes = Marketing.query_exchengable_prizes(
user.partner_migu['id'], order.campaign_id)
if isinstance(prizes, error.ApiError):
return prizes
# 进行奖励的兑换, 目前最后一条为最近获得的奖励
for _prize in prizes[::-1]:
exchenge_ids = map(lambda x: x['id'],
_prize['exchengeResources'])
exchengeable_id = _prize['exchengableResource']['id']
if [prize['id']] == exchenge_ids:
exchenge_ids = [prize['id']]
ret = Marketing.draw_exchengable_prize(
user.partner_migu['id'], order.campaign_id,
exchenge_ids, exchengeable_id, prize['amount'])
if isinstance(ret, error.ApiError):
return ret
# 由于对方没有返回订单ID, 只能通过获取用户最近一个已兑换奖励的订单ID, 实物物品需要手动领取
ret, _ = Marketing.query_exchenged_prizes(user.partner_migu['id'],
order.campaign_id,
page=1,
pagesize=1)
if isinstance(ret, error.ApiError):
return ret
# 更新订单信息
if isinstance(ret, list) and len(ret) > 0 and 'recId' in ret[0]:
order.recid = ret[0]['recId']
order.status = const.ORDER_IN_HAND
order.save()
extra = dict(migu_id=user.partner_migu['id'],
phone=user.phone,
campaign_id=store.resource_campaign_id)
# 进行物品的发放
status = product.add_product2user(str(user._id), item.product_num,
const.LOTTERY, extra)
# 订单状态更新
if status != order.status:
order.status = status
order.save()
return {'item': item.format(), 'order': order.format()}
def grab_redpacket():
"""直播间红包争抢(POST)
:uri: /lives/redpacket/grab
:param os: 平台
:param channels: 渠道（可选）
:param version_code: 版本号
:param live_id: 直播间ID
:param source_id: 红包ID
:return: {'ret': bool}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
live_id = params.get('live_id', None)
source_id = params.get('source_id', None)
if not os or not version_code or not source_id or not live_id:
return error.InvalidArguments
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
red_packet = UserRedPacket.get_one(source_id)
if not red_packet:
return error.RedPacketError(u'红包不存在！')
activity = LiveRedPacket.get_one(red_packet.active_id)
if not activity:
return error.RedPacketError(u'直播红包活动不存在！')
# 查看是否有抽奖机会
if red_packet.chance <= 0:
return error.RedPacketError(u'已达到领取红包次数上限！')
def get_user_redpackets():
# 先获取已存在的红包，以及已经参与的直播间抢红包
_red_packet, _red_packet_count = None, 0
_ids = UserRedPacket.user_red_packets(uid)
for urp in UserRedPacket.get_list(_ids):
if not LiveRedPacket.get_one(urp.active_id):
continue
if urp.source == 0:
# 过滤掉所有直播间抽奖机会
continue
if urp.chance <= 0:
continue
if _red_packet is None or _red_packet.expire_at > urp.expire_at:
_red_packet = urp
_red_packet_count += 1
# 如果是直播间红包，返回直播间红包；如果不是，返回新红包
if red_packet.from_user == red_packet.user_id:
_red_packet = red_packet
# 如果没有新红包，返回当前红包，并标记剩余红包数为0
if not _red_packet:
_red_packet = red_packet
return _red_packet.format(_red_packet_count)
def send_default_gift(uid, task_id, user, extra):
return {
'ret': True,
'red_packet': get_user_redpackets(True),
'item': None,
'current_red_packet': red_packet.format(0, True)
}
extra = dict(migu_id=user.partner_migu['id'],
phone=user.phone,
campaign_id=red_packet.campaign_id)
item = None
key = 'lock:receive_red_packet:%s' % (uid)
with util.Lockit(Redis, key) as locked:
if locked:
return error.RedPacketError(u'领取红包失败，请稍后再试！')
# 如果是直播间红包抽奖，则需要先调用抽奖接口再获取红包物品
if not red_packet.source:
# 从营销中心查询/请求抽奖机会
left_chances = Marketing.query_lottery_chance(
user.partner_migu['id'], red_packet.campaign_id)
if isinstance(left_chances, error.ApiError):
return send_default_gift(uid, source_id, user, extra)
if left_chances <= 0:
# 进行抽奖机会的兑换
ret = Marketing.execute_campaign(user.partner_migu['id'],
user.phone,
[red_packet.campaign_id])
if not ret or isinstance(ret, error.ApiError):
return send_default_gift(uid, source_id, user, extra)
# 扣除用户抽奖次数
red_packet.take_chance()
# 调用营销平台进行抽奖
prize = Marketing.draw_lottery(user.partner_migu['id'],
red_packet.campaign_id)
if isinstance(prize, error.ApiError):
prize = None
if not prize:
# 如果没有抽中奖品，发放默认奖品
return send_default_gift(uid, source_id, user, extra)
# 先请求红包机会
extra.update({'campaign_id': activity.redpacket_id})
ret = Marketing.execute_campaign(user.partner_migu['id'],
user.phone,
[activity.redpacket_id])
if not ret or isinstance(ret, error.ApiError):
return send_default_gift(uid, source_id, user, extra)
# 抢红包
rps = Marketing.query_red_package_by_user(user.partner_migu['id'],
activity.redpacket_id)
if isinstance(rps, error.ApiError):
return send_default_gift(uid, source_id, user, extra)
if not rps:
return send_default_gift(uid, source_id, user, extra)
# 将最新的红包放到最前面
rps.sort(key=lambda x: x['createDate']['time'], reverse=True)
# 将红包放入用户可分享红包
_urp = UserRedPacket.init()
_urp.active_id = activity._id
_urp.campaign_id = activity.redpacket_id
_urp.resource_id = rps[0]['id']
_urp.chance = 1
_urp.expire_at = activity.share_expire_at
_urp.item_count = activity.share_count
_urp.user_id = uid
_urp.from_user = uid
_urp.source = 1
_urp.create_model()
red_packet = _urp
# 扣除红包领取次数
red_packet.take_chance()
# 从分享红包获取物品
prize = Marketing.grab_red_package(user.partner_migu['id'],
red_packet.campaign_id,
red_packet.resource_id)
if isinstance(prize, error.ApiError):
return {
'ret': False,
'red_packet': get_user_redpackets(),
'item': None,
'current_red_packet': red_packet.format(0, True)
}
if not prize:
# 如果没有抽中奖品，发放默认奖品
return send_default_gift(uid, source_id, user, extra)
# 发放物品
prize_name = prize.get('name')
item = LiveRedPacketItem.get_item_by_identity(activity._id, prize_name)
# 更新库存
item.update_left()
# 生成兑奖订单
order = UserLiveOrder.create(user_id=str(user._id),
item_id=str(item._id),
activity_id=str(activity._id),
activity_type=1,
campaign_id=red_packet.campaign_id,
title=item.title,
product_id=item.product_id,
product_num=item.product_num,
status=const.ORDER_FINISHED,
result=json.dumps(prize))
order.save()
# 进行物品的发放
product = Product.get_product(item.product_id)
product.add_product2user(uid, item.product_num, const.TASK, extra)
return {
'ret': True,
'red_packet': get_user_redpackets(),
'item': item and item.format(),
'current_red_packet': red_packet.format(0, item is None)
}
def query_new_redpacket():
"""
:uri: /lives/redpacket/query_new
:param os: 平台
:param channels: 渠道（可选）
:param version_code: 版本号
:param live_id: 直播间ID
:param active_id: 活动ID
:return:
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
live_id = params.get('live_id', None)
active_id = params.get('active_id', None)
if not os or not version_code or not active_id or not live_id:
return error.InvalidArguments
live = Xlive.get_live(live_id)
if not live:
return error.LiveError(u'直播不存在')
activity = LiveRedPacket.get_one(active_id)
if not activity:
return error.RedPacketError(u'直播红包活动不存在！')
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
else:
return {'red_packet': activity.format()}
live_authors = [] if not activity.live_authors else activity.live_authors.split(
'\r\n')
live_games = [] if not activity.live_games else activity.live_games.split(
'\r\n')
key_words = [] if not activity.keyword else activity.keyword.split(u',')
# 过滤主播
if live_authors and live['user_id'] not in live_authors:
return error.RedPacketError(u'不符合活动条件！')
# 过滤游戏
if live_games and live['game_id'] not in live_games:
return error.RedPacketError(u'不符合活动条件！')
# 过滤关键字
if key_words and not any(map(lambda x: x in live['name'], key_words)):
return error.RedPacketError(u'不符合活动条件！')
if activity.os not in ['all', os]:
return error.RedPacketError(u'不符合活动条件！')
if (activity.version_code_mix and activity.version_code_mix > version_code) or \
(activity.version_code_max and activity.version_code_max < version_code):
return error.RedPacketError(u'不符合活动条件！')
if channels and activity.channels and channels not in activity.channels:
return error.RedPacketError(u'不符合活动条件！')
if activity.login == 'login' and (
not uid or not activity.user_in_group(str(activity.group), uid)):
return error.RedPacketError(u'不符合活动条件！')
if activity.province and not province:
return error.RedPacketError(u'不符合活动条件！')
if activity.province and province and province not in activity.province:
return error.RedPacketError(u'不符合活动条件！')
key = 'lock:receive_red_packet:%s' % (uid)
with util.Lockit(Redis, key) as locked:
if locked:
return error.RedPacketError(u'领取红包失败，请稍后再试！')
# 查看用户是否已领取该红包
if UserRedPacket.check_live_redpacket(uid, activity._id):
return error.RedPacketError(u'用户已领取该红包！')
_urp = UserRedPacket.init()
_urp.active_id = activity._id
_urp.campaign_id = activity.campaign_id
_urp.chance = activity.chance
_urp.expire_at = activity.expire_at
_urp.user_id = uid
_urp.source = 0 # 不可被分享
_urp.create_model()
return {'red_packet': _urp.format(activity.chance)}
def game_home():
"""
获取游戏页首页内容
uri: /games/home
:param os: 平台
:param channels: 渠道(可选)
:param version_code: 版本号
:return: {'grids': list}
"""
user = request.authed_user
params = request.values
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
if not os or not version_code:
return error.InvalidArguments
uid = None
province = None
if user:
uid = str(user._id)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
def my_filter(data):
result = list()
for b in data:
if b.os and b.os != os:
continue
if (b.version_code_mix and b.version_code_mix > version_code) or\
(b.version_code_max and b.version_code_max < version_code):
continue
if channels and b.channels and channels not in b.channels:
continue
if b.login == 'login' and (not uid or
not b.user_in_group(str(b.group), uid)):
continue
if b.province and not province:
continue
if b.province and province and province not in b.province:
continue
result.append(b.format())
return result
# 游戏页宫格
_ids = GameGrid.all_ids()
grids = my_filter(GameGrid.get_list(_ids))
# 游戏页广告
_ids = GameAds.all_ad_ids()
banners = my_filter(GameAds.get_list(_ids))
# 游戏页主推游戏
_ids = GameMainstay.all_ids()
mainstays = my_filter(GameMainstay.get_list(_ids))
# 游戏页热门游戏
_ids = HotRecommendGame.hot_game_ids()
hot_games = [g.format() for g in Game.get_list(_ids)]
# 游戏页模块内容
_ids = GameModule.all_ids_by_os(os)
modules = [
i.format() for i in GameModule.get_list(_ids)
if ModuleGame.module_game_ids(str(i._id))
]
return {
'grids': grids,
'ads': banners,
'mainstays': mainstays,
'hot_games': hot_games,
'modules': modules
}
def play_live():
"""观看直播接口 (GET)
:uri: /lives/play
:param live_id: 直播ID
:param os: 平台
:param channels: 渠道（可选）
:param version_code: 版本
:return: {'ret': bool}
"""
user = request.authed_user
params = request.values
live_id = params.get('live_id', None)
os = params.get('os', None)
channels = params.get('channels', None)
version_code = int(params.get('version_code', 0))
if not os or not version_code or live_id is None:
return error.InvalidArguments
live = Xlive.get_live(live_id)
if not live:
return error.LiveError('直播不存在')
uid = None
province = None
if user:
uid = str(user._id)
UserTask.check_user_tasks(uid, PLAY_LIVE, 1)
task_ids = WatchLiveTask.get_user_tids(uid)
phone = str(user.phone)
if user.province:
province = user.province
if not user.province and util.is_mobile_phone(phone):
province = Migu.get_user_info_by_account_name(phone)
if not isinstance(province, error.ApiError):
user.update_model({'$set': {'province': province}})
else:
province = None
else:
task_ids = WatchLiveTask.get_live_tids()
task = None
for b in WatchLiveTask.get_list(task_ids):
if b.os and b.os not in ['all', os]:
continue
if (b.version_code_mix and b.version_code_mix > version_code) or \
(b.version_code_max and b.version_code_max < version_code):
continue
if channels and b.channels and channels not in b.channels:
continue
if b.login == 'login' and (not uid
or not b.user_in_group(str(b.group), uid)):
continue
if b.province and not province:
continue
if b.province and province and province not in b.province:
continue
task = b.format(uid)
break
red_packet, red_packet_count = None, 0
_ids = UserRedPacket.user_red_packets(uid)
lrp_ids = []
for urp in UserRedPacket.get_list(_ids):
lrp_ids.append(str(urp.active_id))
if not LiveRedPacket.get_one(urp.active_id):
continue
if urp.source == 0:
# 过滤掉所有直播间抽奖机会
continue
if urp.chance <= 0:
continue
if red_packet is None or red_packet.expire_at > urp.expire_at:
red_packet = urp
red_packet_count += 1
red_packet = red_packet.format(
red_packet_count) if red_packet else red_packet
cdrp = None
rp_ids = LiveRedPacket.all_ids()
for rp in LiveRedPacket.get_list(rp_ids):
# 过滤非观看时长红包
if rp.mode != 2:
continue
# 过滤已参与的红包活动id
if str(rp._id) in lrp_ids:
continue
if rp.os and rp.os not in ['all', os]:
continue
if (rp.version_code_mix and rp.version_code_mix > version_code) or \
(rp.version_code_max and rp.version_code_max < version_code):
continue
if channels and rp.channels and channels not in rp.channels:
continue
if rp.login == 'login' and (not uid or
not rp.user_in_group(str(rp.group), uid)):
continue
if rp.province and not province:
continue
if rp.province and province and province not in rp.province:
continue
# 过滤主播
live_authors = [] if not rp.live_authors else rp.live_authors.split(
'\r\n')
if live_authors and live['user_id'] not in live_authors:
continue
# 过滤游戏
live_games = [] if not rp.live_games else rp.live_games.split('\r\n')
if live_games and live['game_id'] not in live_games:
continue
# 过滤关键字
key_words = [] if not rp.keyword else rp.keyword.split(u',')
if key_words and not any(map(lambda x: x in live['name'], key_words)):
continue
cdrp = rp.format()
break
return {'ret': True, 'task': task, 'red_packet': red_packet, 'cdrp': cdrp}
