def refresh_daily_tasks(cls, user_id):
_tasks = []
for task in Task.get_daily_tasks():
tmp = dict(user_id=user_id,
task_id=task.task_id,
task_type=task.task_type,
action=task.action)
# 每日签到任务自动完成
if task.action == DAILY_SIGNIN:
tmp['task_status'] = FINISHED
tmp['finish_num'] = 1
_tasks.append(tmp)
with MYDB.atomic():
# 删除旧的每日任务
cls.delete().where(UserTask.user_id == user_id,
UserTask.task_type == 2).execute()
# 增加新的每日任务
if _tasks:
UserTask.insert_many(_tasks).execute()
# 修改任务刷新时间
UserCredit.update(task_at=datetime.datetime.now()).where(
UserCredit.user_id == user_id).execute()
key = USER_TASK_KEY % (user_id)
Redis.delete(key)
def add_product2user(self, user_id, num, action=None, extra={}):
if self.product_type == EMPTY: # 空
return const.ORDER_FINISHED
elif self.product_type == GEM: # 游票
uc = UserCredit.get_or_create_user_credit(user_id)
uc.add_gem(num, action)
return const.ORDER_FINISHED
elif self.product_type == GOLD: # 游米
uc = UserCredit.get_or_create_user_credit(user_id)
uc.add_gold(num, action)
return const.ORDER_FINISHED
elif self.product_type == GIFT: # 礼物
up = UserProduct.get_or_create_user_product(
user_id, self.product_id, extra.get("is_money", False))
up.add_product(num)
return const.ORDER_FINISHED
elif self.product_type in [
WHOLE_TRAFFIC, MOBILE_TRAFFIC, UNICOM_TRAFFIC, TELECOM_TRAFFIC
]:
ret = Marketing.draw_resource(extra['migu_id'], extra['phone'],
extra['campaign_id'], 6, num)
status = const.ORDER_IN_HAND if ret == True else const.ORDER_FAILED
return status
elif self.product_type == PHYSICAL_OBJECT: # 实物物品, 比如：手机
return const.ORDER_IN_HAND
elif self.product_type == GIFT_BAG: # 礼包, 比如：途牛券、游戏礼包
return const.ORDER_FINISHED
elif self.product_type == PHONE_FEE: # 全网话费
ret = Marketing.draw_resource(extra['migu_id'], extra['phone'],
extra['campaign_id'], 4, num)
status = const.ORDER_NEED_DRAW if ret == True else const.ORDER_IN_HAND
return status
return None
def refresh_daily_free_gifts(cls, user_id):
from wanx.models.gift import Gift
with MYDB.atomic():
for gift in Gift.get_free_gifts():
up = cls.get_or_create_user_product(user_id, gift.product_id)
up.gift_free = gift.credit_value
up.save()
# 修改免费刷新时间
UserCredit.update(gift_at=datetime.datetime.now()).where(
UserCredit.user_id == user_id).execute()
key = USER_PRODUCT_KEY % (user_id)
Redis.delete(key)
def get_user(uid):
"""获取用户详细信息 (GET)
:uri: /users/<string:uid>
:returns: object
"""
user = User.get_one(uid)
if not user:
return error.UserNotExist
user_lives = Xlive.get_user_lives(uid)
live_ids = [ul['event_id'] for ul in user_lives]
user_info = user.format()
user_info.update({'live_id': live_ids[0] if live_ids else ''})
# 如果是登录用户自己返回货币信息
if request.authed_user and str(request.authed_user._id) == uid:
uc = UserCredit.get_or_create_user_credit(user_id=uid)
uproducts = UserProduct.get_user_products(str(uid))
gift_num = sum([up.num for up in uproducts])
user_info.update({
'gem': uc.gem,
'gold': uc.gold,
'gift_num': gift_num
})
return user_info
def user_credit():
"""获取用户经济信息 (GET&LOGIN)
:uri: /credit/user
:return: {'gem': int, 'gold': int, 'gift_num': int}
"""
user = request.authed_user
uc = UserCredit.get_or_create_user_credit(user_id=str(user._id))
uproducts = UserProduct.get_user_products(str(user._id))
gift_num = sum([up.num for up in uproducts])
return {'gem': uc.gem, 'gold': uc.gold, 'gift_num': gift_num}
def create_and_init_user_tasks(cls, user_id):
# 删除任务已被移除的用户任务
cls.delete_removed_tasks(user_id)
uc = UserCredit.get_or_create_user_credit(user_id)
# 刷新每日任务
if uc.task_at.date() < datetime.date.today():
UserTask.refresh_daily_tasks(user_id)
# 如果没有活动任务创建活动任务
# if not UserTask.get_activity_tasks(user_id):
# 检查并更新活动任务
UserTask.init_tasks(user_id, ACTIVITY_TASK)
# 检查并更新新手任务
UserTask.init_tasks(user_id, NOVICE_TASK)
# 检查并更新游戏任务
UserTask.init_tasks(user_id, GAME_TASK)
def add_barrage_color(event_id):
"""发送彩色弹幕(POST)
:uri: /store/<int:event_id>/add_barrage_color
:参数:
text 弹幕内容
colorid 颜色id
:return: {}
"""
user = request.authed_user
text = request.values.get('text', None)
cid = request.values.get('colorid', None)
if not text or not cid:
return error.InvalidArguments
color = BarrageColor.get_color(int(cid))
if not color:
return error.StoreError('该颜色的弹幕不存在')
uc = UserCredit.get_or_create_user_credit(user_id=str(user._id))
if color.credit_type == const.SALE_GEM and uc.gem < color.credit_value:
return error.StoreError('游票不足，颜料还在调制中！')
elif color.credit_type == const.SALE_GOLD and uc.gold < color.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 color.credit_type == const.SALE_GEM:
uc.reduce_gem(color.credit_value, const.BARRAGE)
elif color.credit_type == const.SALE_GOLD:
uc.reduce_gold(color.credit_value, const.BARRAGE)
data = dict(event_id=event_id,
nickname=user.nickname or user.name,
text=spam.Spam.replace_words(text),
color=color.format()['desc'])
from wanx.platforms.xlive import Xlive
Xlive.send_live_msg(data, 'danmu')
return {}
def all_gifts():
"""获取所有可赠送礼物 (GET)
:uri: /gifts/all_gifts
:return: {'gifts': list, 'available_num': list}
"""
user = request.authed_user
if user:
# 刷新每日免费礼物
uc = UserCredit.get_or_create_user_credit(str(user._id))
if uc.gift_at.date() < datetime.date.today():
UserProduct.refresh_daily_free_gifts(str(user._id))
gifts = []
#
video_type = int(request.values.get('video_type', '0'))
#
for gf in Gift.get_onsale_gifts():
tmp = gf.format()
# 每日免费礼物显示剩余数量
if gf.credit_type == const.DAILY_FREE:
if user:
up = UserProduct.get_or_create_user_product(
str(user._id), gf.product_id)
tmp['free_num'] = up.gift_free
else:
tmp['free_num'] = 0
if gf.credit_type == const.MONEY:
if not video_type:
continue
if video_type == 2:
continue
# 单位分
tmp['credit_value'] = tmp['credit_value'] / 100.0
gifts.append(tmp)
available_num = _gift_num()
return {'gifts': gifts, 'available_num': available_num}
def send_to_user(self, from_user, to_user, num, gift_from, from_id,
**kwargs):
if num < 1:
return error.InvalidArguments
uc = from_user_uc = UserCredit.get_or_create_user_credit(from_user)
product = Product.get_product(self.product_id)
if self.credit_type == const.SALE_GOLD:
total_gold = self.credit_value * num
if uc.gold < total_gold:
return error.GiftError('你的游米不足，做任务可获取游米')
with MYDB.atomic():
uc.reduce_gold(total_gold, const.GIFT)
product.add_product2user(to_user, num, const.GIFT)
UserGiftLog.create(user_id=to_user,
from_user=from_user,
product_id=self.product_id,
credit_type=self.credit_type,
credit_value=self.credit_value,
num=num,
gold_price=self.gold_price * num,
gift_from=gift_from,
from_id=from_id,
send_success=1)
elif self.credit_type == const.SALE_GEM:
total_gem = self.credit_value * num
if uc.gem < total_gem:
return error.GiftError('你的游票不足')
with MYDB.atomic():
uc.reduce_gem(total_gem, const.GIFT)
product.add_product2user(to_user, num, const.GIFT)
UserGiftLog.create(user_id=to_user,
from_user=from_user,
product_id=self.product_id,
credit_type=self.credit_type,
credit_value=self.credit_value,
num=num,
gold_price=self.gold_price * num,
gift_from=gift_from,
from_id=from_id,
send_success=1)
elif self.credit_type == const.DAILY_FREE:
from_up = UserProduct.get_or_create_user_product(
from_user, self.product_id)
if from_up.gift_free < num:
return error.GiftError('对不起，您今天的免费礼物已用完')
with MYDB.atomic():
from_up.gift_free -= num
from_up.save()
product.add_product2user(to_user, num, const.GIFT)
UserGiftLog.create(user_id=to_user,
from_user=from_user,
product_id=self.product_id,
credit_type=self.credit_type,
credit_value=self.credit_value,
num=num,
gold_price=self.gold_price * num,
gift_from=gift_from,
from_id=from_id,
send_success=1)
elif self.credit_type == const.MONEY:
# 请求支付
with MYDB.atomic():
# uc.reduce_gem(total_gem, const.GIFT)
#
send_success = kwargs.get("send_success", 0)
if not send_success:
UserGiftLog.create(
user_id=to_user,
from_user=from_user,
product_id=self.product_id,
credit_type=self.credit_type,
credit_value=self.credit_value,
num=num,
gold_price=self.gold_price * num,
gift_from=gift_from,
from_id=from_id,
gift_id=self.gift_id,
send_success=0,
transaction_id=kwargs.get("transactionId"))
else:
total_money = self.gold_price * num
from_user_uc.add_cost_money(total_money)
to_user_uc = UserCredit.get_or_create_user_credit(to_user)
to_user_uc.add_get_money(total_money)
# 状态为1
log = UserGiftLog.get_by_transaction_id(
kwargs.get("transactionId"))
if not log:
return error.GiftError('未发现支付记录')
log.send_success = 1
log.save()
# redis 更新
UserGiftLog.update_redis_gift(log)
product.add_product2user(to_user,
num,
const.GIFT,
extra={"is_money": True})
return True
def gifts_exchange():
user = request.authed_user
requ_type = request.values.get('requ_type')
value = PayForGift.get_all_value() # 现已兑换的总金额
cfg = GiftExchangeCfg.get_gift_config()
total_exchange_value = cfg.total_exchange_value # 兑换上限
break_rate = cfg.break_rate # 折损率
exchange_thresthold = cfg.exchange_thresthold # 兑换下限
gift_value = UserProduct.get_total_money(user) # 当前用户礼物价值
_gift_value = float(gift_value) / float(100)
# gift_value = UserCredit.get_or_create_user_credit(user._id).current_money # 当前用户礼物价值
_value = _gift_value * float(break_rate)
exchange_value = int(_value) + 1 if _value > int(_value) else int(
_value) # 折损后的价值
current_exchange_value = int(total_exchange_value) - int(
value) # 当前还可兑换的金额
# 营销数据入库经分
data_dict = dict(cmd="exchange_huafei",
deviceid=request.values.get('device', ''),
mobile=user.phone,
source=request.values.get('source', 'activity'),
activityid="0",
activityname=u"兑换话费活动")
if requ_type == 'get_judge':
certify_status = UserCertify.get_certify_status(user._id)
is_anchor_wlist = AnchorWlist.is_anchor_wlist(user._id) # 是否是签约主播
if is_anchor_wlist:
return {'exchange_status': 1, 'exchange_msg': '签约主播无法兑换'}
user_certify = True if certify_status == 3 else False
if not user_certify:
return {
'exchange_status': 2,
'exchange_msg': '只有实名认证的用户才可以兑换哦，快去认证吧'
}
is_exchange_time = GiftExchangeCfg.is_exchange_time() # 是否在兑换时间内
if not is_exchange_time:
return {
'exchange_status': 3,
'exchange_msg': '当前时间不在礼物兑换期内，请在兑换期内进行礼物兑换'
}
if int(exchange_value) >= int(current_exchange_value): # 超过总额度
return {
'exchange_status': 4,
'exchange_msg': '本月额度已经被全部兑换完啦，下个月请早了'
}
is_exchange = PayForGift.is_exchange(user) # 兑换次数
if is_exchange:
return {
'exchange_status': 5,
'exchange_msg': '每个月只能兑换一次哦，您本月已经兑换过啦'
}
if int(exchange_value) < int(exchange_thresthold): # 不满足兑换门槛
return {'exchange_status': 6, 'exchange_msg': '您的礼物还不够提现哦'}
data_dict["opt"] = "1:{0}:{1}".format(gift_value, exchange_value)
Marketing.jf_report(data_dict)
return {
'exchange_status':
0,
'exchange_msg':
'您有价值{0}元的礼物，可以兑换{1}元话费，话费将发放到您登录的手机号码内，兑换完成后付费礼物全部清零'.format(
_gift_value, exchange_value)
}
elif requ_type == 'pay_exchange':
is_anchor_wlist = AnchorWlist.is_anchor_wlist(user._id) # 是否是签约主播
if is_anchor_wlist:
return error.StoreError
certify_status = UserCertify.get_certify_status(user._id)
user_certify = True if certify_status == 3 else False
if not user_certify:
return error.StoreError
is_exchange_time = GiftExchangeCfg.is_exchange_time()
if not is_exchange_time:
return error.StoreError
if int(exchange_value) >= int(current_exchange_value):
return error.StoreError
is_exchange = PayForGift.is_exchange(user)
if is_exchange:
return error.StoreError
if int(exchange_value) < int(exchange_thresthold):
return error.StoreError
lock_key = 'lock:exchange_fee:%s' % (str(user._id))
with util.Lockit(Redis, lock_key) as locked:
if locked:
return error.StoreError('兑换太频繁')
try:
uc = UserCredit.get_or_create_user_credit(user._id)
uc.reduce_money(gift_value)
UserProduct.clear_gifts_num(user, True)
PayForGift.create_log(user, const.SUCCESS, _gift_value,
exchange_value, const.GIFT_EXCHANGE)
data_dict["opt"] = "1:{0}:{1}".format(gift_value,
exchange_value)
Marketing.jf_report(data_dict)
return {
'exchange_status':
0,
'exchange_msg':
'兑换成功，{0}元的话费将在30个工作日内发到您登录的咪咕游玩手机账户'.format(
exchange_value)
}
except:
PayForGift.create_log(user, const.FAIL, _gift_value,
exchange_value, const.GIFT_EXCHANGE)
return {'exchange_status': 7, 'exchange_msg': '兑换失败，请稍后再试哦'}
elif requ_type == 'gold_exchange':
lock_key = 'lock:exchange_gold:%s' % (str(user._id))
with util.Lockit(Redis, lock_key) as locked:
if locked:
return error.StoreError('兑换太频繁')
try:
total_gold_value = UserProduct.get_total_gold(user)
uc = UserCredit.get_or_create_user_credit(user._id)
uc.add_gold(total_gold_value, const.GIFT_EXCHANGE)
UserProduct.clear_gifts_num(user, False)
data_dict["opt"] = "1:{0}:{1}".format(gift_value,
exchange_value)
Marketing.jf_report(data_dict)
return {
'exchange_status': 0,
'exchange_msg': '您已兑换成功，请去游米账户中进行查询'
}
except:
data_dict["opt"] = "0:0:0"
Marketing.jf_report(data_dict)
return {'exchange_status': 7, 'exchange_msg': '兑换失败，请稍后再试哦'}
else:
return {'exchange_status': 7, 'exchange_msg': '兑换失败，请稍后再试哦'}
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()}