def get_one_by_productid(self):
logger.info(request.detail)
args = request.args.to_dict()
prid = args.get('productid')
usid = request.user.id
if not prid:
raise PARAMS_MISS()
product = self.sproduct.get_product_by_productid(prid)
if not product:
raise NOT_FOUND(u"无此商品")
# 是管理员或客服则显示全部信息
if is_admin() or is_customerservice():
product.fields = product.all
print '是管理员或客服'
else:
# 如果是游客, 或者是未购买开店大礼包的普通用户
if is_tourist() or is_ordirnaryuser():
print '是游客或者普通用户'
product = self.trans_product_for_fans(product)
else: # 合伙人(即已购买开店大礼包的用户)
print '合伙人'
product = self.trans_product_for_shopkeeper(product)
product = self.fill_product_nums(product)
# 填充一些都需要的信息
self.fill_product_alreadylike(product, usid)
self.fill_images(product)
self.fill_prtarget(product)
self.fill_product_sku_key(product)
self.fill_product_sku_value(product)
self.sproduct.update_view_num(product.PRid)
data = import_status('get_product_success', 'OK')
data['data'] = product
return data
def get_all(self):
"""活动所有热文"""
if is_tourist():
raise TOKEN_ERROR(u'未登录')
args = request.args.to_dict()
logger.debug("get hotmessage args is %s", args)
lasting = args.get('lasting', 'true')
htfilter = 1 if is_partner() else 0
if is_admin():
htfilter = [0, 1]
try:
hot_list = self.s_hotmessage.get_hotmsg_list_by_filter(htfilter)
if str(lasting) == 'true':
hot_list = filter(
lambda hot: hot.HMstarttime < get_db_time_str() < hot.
HMendtime, hot_list)
for hotmsg in hot_list:
hotmsg.HMstarttime = get_web_time_str(hotmsg.HMstarttime)
hotmsg.HMendtime = get_web_time_str(hotmsg.HMendtime)
data = import_status("get_hotmessage_list_success", "OK")
data['data'] = hot_list
return data
except:
logger.exception("get hotmessage error")
raise SYSTEM_ERROR(u'服务器繁忙')
def get_accountinfo(self):
if is_tourist():
return AUTHORITY_ERROR(u"未登录")
usid = request.user.id
user = self.suser.get_user_by_user_id(usid)
logger.debug("get info success, this user is %s", user.USname)
default_address = self.suesraddress.get_default_address_by_usid(usid)
if not default_address:
first_address = self.suesraddress.get_first_no_default_address(
usid)
address = default_address or first_address
if address:
logger.info("get user address success")
location = self.suesraddress.get_addressinfo_by_areaid(
address.areaid)
logger.info("get address detail success")
for area, city, provice in location:
locationname = getattr(provice, "name", '') + getattr(
city, "name", '') + getattr(area, "name", '')
else:
locationname = ''
# print ''.join([x[1] for x in area])
bankcard = self.sbankcard.get_bankcard_by_usid(usid)
response = import_status("get_accountinfo_success", "OK")
response['data'] = {
"user": user.hide('USid'),
# "address": '%s%s' %(locationname, address.UAtext),
"address": '%s%s' % (locationname, getattr(address, "UAtext", '')),
"bankcard": getattr(bankcard, "BCnumber", '')
}
return response
def del_address(self):
if is_tourist():
return TOKEN_ERROR(u"未登录, 或token错误")
data = request.json
logger.info("this is del address data %s", data)
parameter_required("UAid")
try:
logger.debug("del address")
del_address = self.suesraddress.delete_address(data.get("UAid"))
if not del_address:
return SYSTEM_ERROR
exist_default = self.suesraddress.get_default_address_by_usid(
request.user.id)
if not exist_default:
no_default_address = self.suesraddress.get_first_no_default_address(
request.user.id)
if no_default_address:
self.suesraddress.change_default_address_status(
no_default_address.UAid, {'UAdefault': True})
response = import_status("delete_useraddress_success", "OK")
response['data'] = {"uaid": data.get("UAid")}
return response
except:
logger.exception("del address error")
return SYSTEM_ERROR
def get_one_or_default_address(self):
if is_tourist():
raise TOKEN_ERROR(u'未登录')
uaid = request.args.to_dict().get('uaid')
usid = request.user.id
logger.debug("get uaid is %s", uaid)
if uaid is not None:
uafilter = {'UAid': uaid}
else:
uafilter = {'USid': usid, 'UAdefault': True, 'UAisdelete': False}
default_address = self.suesraddress.get_one_or_default_address(
uafilter)
if not default_address:
any_address = self.suesraddress.get_first_no_default_address(usid)
if not any_address:
raise NOT_FOUND(u'该用户未设置地址信息')
address = default_address or any_address
if address:
logger.info("get address success, now to fill detail")
addressinfoes = self.suesraddress.get_addressinfo_by_areaid(
address.areaid)
for addressinfo in addressinfoes:
address.addressinfo = addressinfo
address.add("addressinfo")
response = import_status("messages_get_item_ok", "OK")
response['data'] = address
return response
def update_shoppingcart(self):
"""购物车添加或者修改"""
if is_tourist():
return TOKEN_ERROR # token无效或者未登录的用户
data = request.json
scid = data.get('scid') # 如果是scid则是修改
pskid = data.get('pskid')
scnums = data.get('num')
update_nums = data.get('update_num')
if not scnums and not update_nums:
raise PARAMS_MISS()
if not pskid:
raise PARAMS_MISS()
productsku = self.sproductskukey.get_psk_by_pskid(pskid)
if not productsku:
raise NOT_FOUND(u'sku不存在')
usid = request.user.id
cart = self.sshoppingcart.get_shoppingcar_by_usidandpskid(usid, pskid)
# 如果是已经存在的购物车
if cart:
scid = cart.SCid
if update_nums:
scnums = cart.SCnums + update_nums
elif scnums:
scnums = scnums
if scnums < 1:
# 删除
return self.delete_shoppingcart(scid)
self.sshoppingcart.update_shoppingcart(cart, scnums)
# 创建
else:
if update_nums:
scnums = update_nums
elif scnums:
scnums = scnums
if scnums < 1:
return self.delete_shoppingcart(scid)
psk = self.sproductskukey.get_psk_by_pskid(pskid)
if not psk:
raise SYSTEM_ERROR('不存在的商品')
prid = psk.PRid
cartdict = {
'USid': usid,
'PSKid': pskid,
'SCnums': scnums,
'PRid': prid
}
if scid:
self.sshoppingcart.update_shoppingcat_by_scid(scid, cartdict)
else:
scid = str(uuid.uuid4())
cartdict['SCid'] = scid
dict_add_models('ShoppingCart', cartdict)
data = import_status('update_cart_success', 'OK')
data['data'] = {
'scid': scid
}
return data
def share_activity(self):
if is_tourist():
raise TOKEN_ERROR(u'未登录')
data = request.json
logger.debug("share qrcode data is %s", data)
# data_url = data.get("dataurl")
data_url = self.get_share_url(data.get("dataurl"))
try:
logger.info("get user info")
user = self.suser.get_user_by_user_id(request.user.id)
if not user:
raise SYSTEM_ERROR(u'找不到该用户')
save_path = LinuxRoot + LinuxImgs + "/qrcode/" + user.openid + '.png' if platform.system(
) == "Linux" else WindowsRoot + "qrcode/" + user.openid + '.png'
make_qrcode(user.USheader, data_url, save_path)
response = import_status("make_qrcode_success", "OK")
response[
"qrcodeurl"] = QRCODEHOSTNAME + '/' + LinuxImgs + '/qrcode/' + user.openid + '.png'
response[
"components"] = QRCODEHOSTNAME + '/' + LinuxImgs + '/components.png'
logger.debug('response url is %s', response["qrcodeurl"])
url = data_url.split('#')[-1]
from WeiDian.common.get_url_params import GetUrlParams
parse_dict = GetUrlParams.url_params_to_dict(url)
if 'baid' in parse_dict or 'prid' in parse_dict:
# 分享时更改转发数
paramstype = bool(not 'baid' in parse_dict)
filter_parameter = {
'AClinkvalue':
parse_dict['prid'] if paramstype else parse_dict['baid'],
'ACSkipType':
2 if paramstype else 1,
'ACisdelete':
False
}
act_list = self.sactivity.get_acid_by_filterid(
filter_parameter)
for act in act_list:
if act.ACforwardFakenum != 0:
self.sactivity.update_forward_fakenum(act.ACid)
else:
self.sactivity.add_model(
'ActivityFoward', **{
'AFid': str(uuid.uuid1()),
'USid': request.user.id,
'ACid': act.ACid
})
if is_partner():
self.do_shoppingtask_or_forwardtask(1)
return response
except:
logger.exception("make qrcode error")
return SYSTEM_ERROR(u'服务器繁忙')
def fill_like_num(self, activity):
"""添加点赞相关字段"""
if not is_tourist():
from WeiDian.service.SActivityLike import SActivityLike
alreadylike = SActivityLike().is_like(request.user.id,
activity.ACid)
activity.alreadylike = True if alreadylike else False
activity.likenum = activity.AClikeFakeNum or activity.AClikenum
activity.add('likenum', 'alreadylike')
return activity
def get_one(self):
"""通过acid获取活动及活动下的评论
"""
if is_tourist():
return AUTHORITY_ERROR(u"未登录或token错误")
args = request.args.to_dict()
logger.info("get one act args is %s", args)
parameter_required('acid')
acid = args.get('acid') # 活动id
try:
activity = self.sactivity.get_activity_by_acid(acid)
logger.debug("get one act access")
if not activity:
raise SYSTEM_ERROR(u'数据错误，无此内容')
self.sactivity.update_view_num(activity.ACid)
self.fill_detail(activity)
self.fill_like_num(activity)
self.fill_type(activity)
if activity.ACSkipType == 0:
self.fill_comment_two(activity)
activity.fill('none_skip', 'skip_type')
activity.fill('无跳转类型', 'zh_skip_type')
elif activity.ACSkipType == 1:
baid = activity.AClinkvalue
activity.fill('bigactivity', 'skip_type')
activity.fill('专题', 'zh_skip_type')
bigactivity = self.sbigactivity.get_one_big_act(baid)
if not bigactivity:
# raise NOT_FOUND()
pass
else:
bigactivity_type = bigactivity.BAtype
big_activity_content = {'type': bigactivity_type}
big_activity_content.setdefault('baid', bigactivity.BAid)
# 图片类型专题
if bigactivity_type == 0:
big_activity_content.setdefault(
'baimage', bigactivity.BAlongimg) # 返回字段不修改
big_activity_content.setdefault(
'baid', bigactivity.BAid)
activity.fill(big_activity_content, 'bigactivity')
elif activity.ACSkipType == 2:
self.fill_soldnum(activity)
self.fill_product(activity)
activity.fill('product', 'skip_type')
activity.fill('商品', 'zh_skip_type')
activity.ACstarttime = get_web_time_str(activity.ACstarttime)
activity.ACendtime = get_web_time_str(activity.ACendtime)
data = import_status("get_activity_info_success", "OK")
data["data"] = activity
return data
except:
logger.exception("get one act error")
return SYSTEM_ERROR(u"服务器繁忙")
def delete_one(self):
"""删除购物车"""
if is_tourist():
return TOKEN_ERROR
data = request.json
if not data:
return PARAMS_MISS
scid = data.get('scid')
if not scid:
return PARAMS_MISS
return self.delete_shoppingcart(scid)
def get_shopingcart_all(self):
"""获取当前用户的购物车"""
if is_tourist():
return TOKEN_ERROR # token失效或者未携带token
carts_list = self.sshoppingcart.get_shoppingcart_by_usid(request.user.id)
map(self.fill_sku, carts_list)
map(self.fill_product, carts_list)
data = import_status('get_cart_success', "OK")
data['data'] = {"cart": carts_list}
data['total'] = self.total_price(carts_list)
data['name'] = PLATFORM_NAME
data['postfee'] = PLATFORM_POSTFEE
return data
def get_hand_out_reward(self):
"""获取平台发放在页面中的优惠券"""
if is_tourist():
raise TOKEN_ERROR(u'未登录')
horewards = self.sraward.get_all_hand_out()
for horeward in horewards:
reward = self.sraward.get_raward_by_id(horeward.RAid)
reward_detail = self.fill_reward_detail(reward)
horeward.fill(reward_detail, 'reward_detail')
data = import_status("messages_get_item_ok", "OK")
data['data'] = horewards
return data
def batch_delete_prlike(self):
if is_tourist():
return TOKEN_ERROR(u'未登录')
data = request.json
plid_list = data.get("plid").split(
',') if data and 'plid' in data else None
logger.info("batch del prlike data is %s", data)
print plid_list
try:
self.sproductlike.batch_delete_prlike(plid_list)
response = import_status('delete_activity_success', 'OK')
response['data'] = {"plidlist": plid_list}
return response
except:
logger.exception("batch del prlike error")
return SYSTEM_ERROR
def get_user_task(self):
if is_tourist():
raise AUTHORITY_ERROR(u"未登录")
task_list = self.stask.get_user_task_by_userid(request.user.id)
if not task_list:
return SYSTEM_ERROR(u'当前没有任务')
# task_list = self.fill_task_detail(task) for task in task_list
task_detail_list, task_list = task_list, []
for task in task_detail_list:
task_detail = self.fill_task_detail(task)
if task_detail:
task_list.append(task_detail)
if not task_list:
return SYSTEM_ERROR(u'当前没有任务')
task_level = self.stask.get_task_level_by_tlid(task_list[0].TLid)
if not task_level:
raise SYSTEM_ERROR(u'任务正在更新，请稍后查看')
logger.debug('get task list %s', dict(task_level))
# from WeiDian.common.divide import Partner
# pa = Partner()
# role = pa.cf.get(task_level, 'role')
# cn = pa.cf.get(task_level, 'access')
# map(self.fill_reward, task_list)
is_complate = not bool(
len([task.TUstatus for task in task_list if task.TUstatus == 0]))
# logger.debug(len(is_complate))
# logger.debug(request.user.id)
# logger.debug(len(task_list))
response = import_status("get_task_success", "OK")
if is_complate:
# 更新任务状态为已失效，发放奖励。并且添加新的任务内容
self.stask.update_user_tasks(request.user.id, {"TUstatus": 4})
self.add_user_task_raward(request.user.id, task_level.TLid)
if task_level.TAlevel < 3:
self.add_user_task(request.user.id, task_level.TAlevel)
response['RAward'] = self.fill_reward(task_level)
response['data'] = task_list
response['TArole'] = task_level.TArole
response[
'TAcomplateNotifications'] = task_level.TAcomplateNotifications
response['is_complate'] = is_complate
return response
def add_comment(self):
"""添加评论数据"""
if is_tourist():
return AUTHORITY_ERROR(u'未登录')
data = parameter_required(u'ACtext')
acid = data.get('acid')
acoid = data.get('acoid')
usid = request.user.id
actext = data.get('ACtext')
# 添加评论
if acid:
activity = self.sactivity.get_activity_by_acid(acid)
if not activity:
raise NOT_FOUND(u'推文不存在')
model_data = {
'ACOid': str(uuid.uuid4()),
'ACid': acid,
'USid': usid,
'ACtext': actext,
'ACOcreatetime': datetime.strftime(datetime.now(),
format_for_db)
}
# 如果是添加回复
elif acoid:
if not is_admin():
raise TOKEN_ERROR(u'请使用管理员回复')
comment = self.sactivitycomment.get_comment_by_acoid(acoid)
if not comment:
raise NOT_FOUND(u'不存在的评论')
acid = comment.ACid
model_data = {
'ACOid': str(uuid.uuid4()),
'ACid': acid,
'ACOparentid': acoid,
'USid': request.user.id,
'ACtext': actext,
'ACOcreatetime': datetime.strftime(datetime.now(),
format_for_db)
}
else:
raise PARAMS_MISS(u'请指定回复类型')
self.sactivity.add_model('ActivityComment', **model_data)
data = import_status('add_activity_comment_success', 'OK')
data['data'] = {'acoid': model_data['ACOid']}
return data
def get_like_list(self):
"""获取用户的收藏列表"""
if is_tourist():
return TOKEN_ERROR(u'未登录')
args = request.args.to_dict()
logger.debug("get like list args is %s", args)
parameter_required("page_size", "page_num")
page_num = args.get("page_num")
page_size = args.get("page_size")
page_num = 1 if not page_num else int(page_num)
page_size = 5 if not page_size else int(page_size)
try:
productlike_list = self.sproductlike.get_productlike_list_by_usid(
request.user.id, page_num, page_size)
if not productlike_list:
raise NOT_FOUND(u'用户无收藏信息')
logger.info("get product like list success")
map(self.fill_productinfo, productlike_list)
# 获取转发数
from WeiDian.service.SActivity import SActivity
from WeiDian.service.SActivityFoward import SActivityFoward
total_forward = 0
for prlike in productlike_list:
forward_act = SActivity().get_acid_by_filterid({
'AClinkvalue':
prlike.PRid,
'ACSkipType':
2,
})
for act in forward_act:
forward_num = SActivityFoward().get_fowardnum_by_acid(
act.ACid)
total_forward = total_forward + forward_num
prlike.forwardnum = total_forward
prlike.add("forwardnum")
prlikecount = self.sproductlike.get_prlike_count_by_usid(
request.user.id)
data = import_status("get_product_like_success", "OK")
data["count"] = prlikecount
data["data"] = productlike_list
return data
except Exception as e:
logger.exception("get product like error")
raise SYSTEM_ERROR(u'收藏信息不存在')
def get_reward_packet_detail(self):
"""获取单个集合详情"""
if is_tourist():
raise TOKEN_ERROR(u"未登录")
args = request.args.to_dict()
rptid = args.get('rptid')
logger.debug("get reward packet detail args is %s", args)
reward_packet = self.sraward.get_reward_packet_detail(rptid)
for reward_one in reward_packet:
raid = reward_one.RAid
reward = self.sraward.get_raward_by_id(raid)
reward_detail = self.fill_reward_detail(reward)
reward_one.fill(reward_detail, 'reward_detail')
packet_contact = self.sraward.get_is_where_packet(raid)
if packet_contact:
packet_info = self.sraward.get_reward_in_packet_info(packet_contact.RPTid)
reward.fill(packet_info.RPTname, 'rptname')
data = import_status("messages_get_item_ok", "OK")
data['data'] = reward_packet
return data
def get_image_by_aitype(self):
if is_tourist():
raise AUTHORITY_ERROR(u"未登录")
aitype = request.args.to_dict().get("aitype", "")
logger.debug('get aitype %s, and type of aitype %s', aitype,
type(aitype))
if re.search(r'\[', aitype):
aitype = json.loads(aitype)
adimage_list = [
self.get_image_list(aitype_item) for aitype_item in aitype
]
else:
adimage_list = self.get_image_list(aitype)
res = import_status('get_adimage_success', 'OK')
if adimage_list:
res['data'] = adimage_list
return res
res['message'] = u'尚未添加图片'
return res
def user_receive_reward(self):
"""用户自己领取页面内的优惠券"""
if is_tourist():
raise TOKEN_ERROR(u'未登录')
data = request.json
parameter_required('raid')
logger.debug("user recevive data is", data)
usid = request.user.id
raid = data.get('raid')
# 判断发放的优惠券是否还有领取数量
hang_out = self.sraward.is_hand_out({'RAid': raid})
if hang_out:
if hang_out.RTcount <= 0:
raise NOT_FOUND(u'该优惠券已领取完毕')
else:
self.sraward.update_is_hand_out({'RAid': hang_out.RAid}, {'RTcount': hang_out.RTcount - 1})
# 判断用户是否已持有
is_hold = self.sraward.is_user_hold_reward({'USid': usid, 'RAid': raid})
if is_hold:
logger.info("The user already has this type of reward ")
reward_info = self.sraward.get_raward_by_id(raid)
urid = is_hold.URid
if is_hold.RAnumber < reward_info.RAmaxholdnum:
self.sraward.update_user_reward({'RAid': raid}, {'RAnumber': is_hold.RAnumber + 1})
else:
raise PARAMS_REDUNDANCE(u'已拥有该券最大可持有数量')
else:
logger.info("New reward to user")
urid = str(uuid.uuid1())
self.sraward.add_model('UserRaward', **{
'URid': urid,
'USid': usid,
'RAid': raid,
})
data = import_status("receive_reward_success", "OK")
data['data'] = {'urid': urid
}
return data
def get_levelrules(self):
if is_tourist():
return AUTHORITY_ERROR(u"未登录")
try:
lr_list = self.slevelrules.get_rule_list()
logger.debug("get level rules")
map(lambda x: setattr(x, 'LRtext', re.sub('\s', '', x.LRtext)),
lr_list)
user = self.suser.get_user_by_user_id(request.user.id)
if user.USlevel == 0:
user.level = 'ordinary'
if user.USlevel > 0:
user.level = 'partner'
user.add('level').hide('USid', 'USname', 'USheader')
data = import_status("get_levelrules_success", "OK")
data['data'] = lr_list
data['userlevel'] = user.level
return data
except:
logger.exception("get level rules error")
return SYSTEM_ERROR
def get_image(self):
if is_tourist():
return AUTHORITY_ERROR(u"未登录")
args = request.args.to_dict()
lasting = args.get('lasting', 'true')
logger.debug("get image args is %s", args)
try:
logger.info("get my image list")
adimage_list = self.sadimage.get_myimage()
if lasting == 'true':
now_time = datetime.strftime(datetime.now(), format_for_db)
adimage_list = filter(
lambda adimage: adimage.AIstarttime < now_time < adimage.
AIendtime, adimage_list)
for adimage in adimage_list:
adimage.hide('AIurl')
data = import_status("get_adimage_success", "OK")
data['data'] = adimage_list
return data
except:
logger.exception("get ad_image by aiid error")
return SYSTEM_ERROR(u"无底部图片")
def do_task(self):
if is_tourist():
raise AUTHORITY_ERROR(u"未登录")
parameter_required(*self.do_task_params)
data = request.json
logger.debug("get data %s", data)
user_task = self.stask.get_user_task_by_id(data.get("TUid"))
logger.info('get user task %s', user_task)
if not user_task:
raise SYSTEM_ERROR(u"服务器繁忙")
task = self.stask.get_task_by_taid(user_task.TAid)
logger.info('get task : %s', dict(task))
if str(task.TAtype) == '0':
logger.debug('start update task')
# self.add_user_task_raward(request.user.id, task.TLid)
update_result = self.stask.update_user_task(
user_task.TUid, {
"TUstatus": 1,
"TUnumber": 1
})
logger.debug('get update result %s', update_result)
else:
# todo 其他类型任务执行
pass
# todo_task = self.stask.get_todo_user_task_by_user_id(request.user.id)
# is_complate = False
# if not todo_task:
# is_complate = True
# # 更新任务状态为已失效，发放奖励。并且添加新的任务内容
# self.stask.update_user_tasks(request.user.id, {"TUstatus": 4})
# if task.TAlevel < 3:
# self.add_user_task(request.user.id, task.TAlevel)
# response = import_status("do_task_success", 'OK')
# response['data'] = {
# "is_complate": is_complate
# }
return import_status("do_task_success", 'OK')
def add_like(self):
"""添加(删除)喜欢(收藏)"""
if is_tourist():
return TOKEN_ERROR()
json_data = parameter_required('prid')
prid = json_data.get('prid')
# 该用户是否已经收藏了此商品
already_like = self.sproductlike.get_productlike_by_usidprid(
request.user.id, prid)
if not already_like:
pl_dict = dict(plid=str(uuid.uuid4()),
usid=request.user.id,
prid=prid)
dict_add_models('ProductLike', pl_dict)
self.sproduct.update_like_num(prid)
data = import_status('add_productlike_success', 'OK')
else:
# 删除
self.sproductlike.del_productlike_usidprid(request.user.id, prid)
self.sproduct.update_like_num(prid, -1)
data = import_status('cancel_product_like_success', 'OK')
plid = already_like.PLid if already_like else pl_dict['plid']
data['data'] = {'plid': plid}
return data
def get_one_reward(self):
"""获取单张优惠券详情"""
if is_tourist():
raise TOKEN_ERROR(u'未登录')
# parameter_required('raid')
args = request.args.to_dict()
raid = args.get('raid')
urid = args.get('urid')
logger.debug("get reward info is %s", args)
if urid:
# 是赠送者原表里的
is_presenter_own_hold = self.sraward.is_user_hold_reward({'URid': urid})
# 在赠送者转赠表中，送出去过，已退回，可以继续转赠
is_presenter_gift_hold = self.sraward.is_user_hold_reward_in_gift(
{'RFid': urid, 'RFstatus': 1})
if is_presenter_own_hold:
raid = is_presenter_own_hold.RAid
reward = self.sraward.get_raward_by_id(raid)
reward_detail = self.fill_reward_detail(reward)
is_presenter_own_hold.fill(reward_detail, 'reward_detail')
elif is_presenter_gift_hold:
raid = is_presenter_gift_hold.RAid
gift = self.fill_transfer_detail(is_presenter_gift_hold)
gift_detail = self.sraward.get_raward_by_id(raid)
gift_detail = self.fill_reward_detail(gift_detail)
# 检验转赠券在各情况下的有效性
gift_detail.valid = gift_detail.valid and gift.transfer_valid
gift.fill(gift_detail, 'reward_detail')
gift.RFcreatetime = get_web_time_str(gift.RFcreatetime)
gift.RFendtime = get_web_time_str(gift.RFendtime)
gift_dict = {
'urid': gift.RFid,
'usid': gift.USid,
'raid': gift.RAid,
'ranumber': gift.RAnumber,
'urcreatetime': gift.RFcreatetime,
'reendtime': gift.RFendtime,
'rffrom': gift.RFfrom,
'rfstatus': gift.RFstatus,
'urusetime': gift.RFusetime,
'remarks': gift.remarks,
'tag': gift.tag,
'usheader': gift.usheader,
'reward_detail': gift.reward_detail
}
else:
raise NOT_FOUND(u'无此转赠优惠券信息')
reward_detail = is_presenter_own_hold or gift_dict
else:
reward_info = self.sraward.get_raward_by_id(raid)
if not reward_info:
raise NOT_FOUND(u'无此券信息')
reward_detail = self.fill_reward_detail(reward_info)
presenter = self.suser.get_user_by_user_id(request.user.id)
data = import_status("messages_get_item_ok", "OK")
data['usname'] = presenter.USname
data['usheader'] = presenter.USheader
data['data'] = reward_detail
return data
def give_reward_to_others(self):
"""转赠优惠券（暂时用不到）"""
if is_tourist():
raise TOKEN_ERROR(u'未登录')
data = request.json
usid = data.get('usid')
urid = data.get('urid')
# 在自己的普通券表中拥有
is_own_hold = self.sraward.is_user_hold_reward({'USid': request.user.id, 'URid': urid})
# 送出去过，但是已退回，可以继续转赠
is_own_gift_hold = self.sraward.is_user_hold_reward_in_gift({'RFfrom': request.user.id, 'RFid': urid, 'RFstatus': 1})
if is_own_hold:
raid = is_own_hold.RAid
elif is_own_gift_hold:
raid = is_own_gift_hold.RAid
else:
raise NOT_FOUND(u'用户无此优惠券')
reward_info = self.sraward.get_raward_by_id(raid)
if reward_info.RAtransfer == False:
raise SYSTEM_ERROR(u'该券不允许转赠')
return_time = reward_info.RAtransfereffectivetime # 转赠有效时间，退回时间
# 已经赠送了该券给接收者，接收者还没用，且未到退回时间
is_recivice_gift_hold = self.sraward.is_user_hold_reward_in_gift({'RAid': raid, 'USid': usid, 'RFstatus': 0, 'RFfrom': request.user.id})
if is_recivice_gift_hold:
raise SYSTEM_ERROR(u'您已赠送过该券给用户')
# 接收者已经拥有其他人送的该券, 不影响, 忽略
# is_recivice_hold_from_other = self.sraward.is_user_hold_reward({'USid': usid, 'RAid': raid})
# 接收者原来已经拥有此券了
is_recivice_hold = self.sraward.is_user_hold_reward({'RAid': raid})
if is_own_gift_hold:
up_reward_info = self.sraward.update_reward_transfer_info({'RFfrom': request.user.id, 'RFid': urid, 'RFstatus': 1}, {'USid':usid, 'RFstatus': 0})
if not up_reward_info:
raise SYSTEM_ERROR(u'再次转送失败')
if is_own_hold and is_recivice_hold:
if is_own_hold.RAnumber > 0 and is_recivice_hold.RAnumber < reward_info.RAmaxholdnum:
logger.info("The user already has this type of reward ")
update_reward = self.sraward.update_user_reward({'URid': is_own_hold.URid}, {'RAnumber': is_own_hold.RAnumber - 1})
# self.sraward.update_user_reward({'RAid': raid}, {'RAnumber': is_recivice_hold.RAnumber + 1})
rfid = str(uuid.uuid1())
self.sraward.add_model('RewardTransfer', **{
'RFid': rfid,
'USid': usid,
'RAid': raid,
'URFrom': request.user.id,
'RAnumber': 1,
'RFendtime': (datetime.now() + timedelta(hours=int(return_time))).strftime(format_for_db),
'RFstatus': 0
})
if not update_reward:
raise PARAMS_ERROR(u'更新参数错误')
else:
raise NOT_FOUND(u'您已没有可赠送数量或赠送用户已拥有该券最大可持有数')
elif is_own_hold and not is_recivice_hold:
if is_own_hold.RAnumber > 0:
logger.info("New reward to user")
rfid = str(uuid.uuid1())
self.sraward.add_model('RewardTransfer', **{
'RFid': rfid,
'USid': usid,
'RAid': raid,
'URFrom': request.user.id,
'RAnumber': 1,
'RFendtime': (datetime.now() + timedelta(hours=int(return_time))).strftime(format_for_db),
'RFstatus': 0
})
else:
raise NOT_FOUND(u'您已没有可赠送的数量')
else:
raise NOT_FOUND(u'您已没有可赠送的数量')
data = import_status("give_to_others_success", "OK")
data['data'] = {'urid': urid}
return data
def get_user_reward(self):
"""获取用户（可转赠）优惠券"""
if is_tourist():
raise TOKEN_ERROR(u'未登录')
args = request.args.to_dict()
logger.debug("get reward args is %s", args)
allow_transfer = args.get('transfer')
reward_info = self.sraward.get_reward_by_usid(request.user.id)
from WeiDian.models.model import RewardTransfer
gift_reward_info = self.sraward.get_gifts_by_usfrom_or_usid(
(RewardTransfer.USid == request.user.id, RewardTransfer.RFfrom == request.user.id))
reward_list = []
for reward in reward_info:
reward_detail = self.sraward.get_raward_by_id(reward.RAid)
reward_detail = self.fill_reward_detail(reward_detail)
reward.fill(reward_detail, 'reward_detail')
reward = dict(reward)
lower_reward = {}
for i, j in reward.items():
lower_reward[i.lower()] = j
lower_reward['urcreatetime'] = get_web_time_str(lower_reward.get('urcreatetime'))
reward_list.append(lower_reward)
for gift in gift_reward_info:
gift = self.fill_transfer_detail(gift)
gift_detail = self.sraward.get_raward_by_id(gift.RAid)
gift_detail = self.fill_reward_detail(gift_detail)
# 检验转赠券在各情况下的有效性
gift_detail.valid = gift_detail.valid and gift.transfer_valid
gift.fill(gift_detail, 'reward_detail')
gift.RFcreatetime = get_web_time_str(gift.RFcreatetime)
gift.RFendtime = get_web_time_str(gift.RFendtime)
gift_dict = {
'urid': gift.RFid,
'usid': gift.USid,
'raid': gift.RAid,
'ranumber': gift.RAnumber,
'urcreatetime': gift.RFcreatetime,
'reendtime': gift.RFendtime,
'rffrom': gift.RFfrom,
'rfstatus': gift.RFstatus,
'urusetime': gift.RFusetime,
'remarks': gift.remarks,
'tag': gift.tag,
'usheader': gift.usheader,
'reward_detail': gift.reward_detail
}
reward_list.append(gift_dict)
# reward_info = filter(lambda r: r.get('reward_detail')['RAtype'] in [0, 2], reward_list)
reward_info = filter(lambda k: k.get('ranumber') != 0, reward_list)
if str(allow_transfer) == 'true':
reward_info = filter(lambda r: r.get('reward_detail')['valid'] == True, reward_info)
reward_info = filter(lambda r: r.get('reward_detail')['RAtransfer'] == True, reward_info)
data = import_status('messages_get_item_ok', "OK")
data['data'] = reward_info
return data
def get_user_pay_reward(self):
"""查看用户支付时的优惠券"""
if is_tourist():
raise TOKEN_ERROR(u'未登录')
data = request.json
logger.debug("get pay reward data is %s", data)
skus = data.get('sku')
# parameter_required('sku')
from WeiDian.service.SProductSkuKey import SProductSkuKey
if skus:
total_price = 0
for sku in skus:
price = SProductSkuKey().get_true_price(sku.get('pskid')) * int(sku.get('num'))
total_price = total_price + price
reward_info = self.sraward.get_reward_by_usid(request.user.id)
from WeiDian.models.model import RewardTransfer
gift_reward_info = self.sraward.get_gifts_by_usfrom_or_usid((RewardTransfer.USid==request.user.id, RewardTransfer.RFfrom==request.user.id))
try:
reward_list = []
for reward in reward_info:
if reward:
reward_detail = self.sraward.get_raward_by_id(reward.RAid)
reward_detail = self.fill_reward_detail(reward_detail, total_price)
reward.fill(reward_detail, 'reward_detail')
reward = dict(reward)
lower_reward = {}
for i, j in reward.items():
lower_reward[i.lower()] = j
lower_reward['urcreatetime'] = get_web_time_str(lower_reward.get('urcreatetime'))
reward_list.append(lower_reward)
for gift in gift_reward_info:
if gift not in ['', [], {}, None]:
gift = self.fill_transfer_detail(gift)
gift_detail = self.sraward.get_raward_by_id(gift.RAid)
gift_detail = self.fill_reward_detail(gift_detail, total_price)
# 检验转赠券在各情况下的有效性
gift_detail.valid = gift_detail.valid and gift.transfer_valid
gift.fill(gift_detail, 'reward_detail')
gift.RFcreatetime = get_web_time_str(gift.RFcreatetime)
gift.RFendtime = get_web_time_str(gift.RFendtime)
gift_dict = {
'urid': gift.RFid,
'usid': gift.USid,
'raid': gift.RAid,
'ranumber': gift.RAnumber,
'urcreatetime': gift.RFcreatetime,
'reendtime': gift.RFendtime,
'rffrom': gift.RFfrom,
'rfstatus': gift.RFstatus,
'urusetime': gift.RFusetime,
'remarks': gift.remarks,
'tag': gift.tag,
'usheader': gift.usheader,
'reward_detail': gift.reward_detail
}
reward_list.append(gift_dict)
if reward_list not in [None, [], {}]:
reward_info = filter(lambda r: r.get('reward_detail')['RAtype'] in [0, 2], reward_list)
reward_info = filter(lambda k: k.get('ranumber') != 0, reward_info)
data = import_status('messages_get_item_ok', "OK")
data['data'] = reward_info
return data
except Exception as e:
logger.exception("get user reward error")
raise SYSTEM_ERROR(u'获取数据错误')
def get_info_top(self):
"""个人中心需要的数据"""
try:
if is_tourist():
return AUTHORITY_ERROR(u"未登录")
data = dict()
my_info = request.user
level = my_info.level
uslevel = userlevel.get(str(level), '普通用户')
level = 'partner' if level > 0 else 'ordinary'
my_info.fill(level, 'level')
my_info.fill(uslevel, 'uslevel')
data.setdefault('user', my_info)
usid = my_info.id
print(my_info.USname).encode('utf8')
print(my_info.USid).encode('utf8')
logger.debug("get my info by usid")
show = 0
# 正在进行中的指定等级的合伙人活动
partner_match = self.spartnermatch.get_lasting_partner_match(
level=my_info.USlevel)
# 如果是合伙人, 且活动进行中
if is_partner() and partner_match:
show = 1
data.setdefault('match_type', partner_match.PSIMtype)
# 成功超过vip数量
psimid = partner_match.PSIMid
my_achev = self.spartnermatch.get_partner_match_mount_by_usidpsmid(
usid, psimid)
my_achev_value = my_achev.sellorinvitemount if my_achev else 0 # 我的销售总额(人数)
gt_my_sell_count = self.spartnermatch.get_partner_match_mount_gt_value(
psimid, my_achev_value) # 营业额(人数)比我多的
partner_num = self.suser.get_partner_count_in_current_level(
request.user.USlevel) # 该等级vip总数
lt_my_sell_count = partner_num - gt_my_sell_count # 比我销售(人数)少的
partner_num = partner_num or 1
percents = int(float(lt_my_sell_count) / partner_num *
100) # 超过的同等级的百分比
my_info.fill(percents, 'overpercents') # 超过%的vip
data.setdefault('myranking', percents)
# 未完成还需多少升级
try:
partner_match.PSIMrule = match_rule = json.loads(
partner_match.PSIMrule)
achev_level_value = {
k: int(v) - my_achev_value
for k, v in match_rule.items()
if int(v) > my_achev_value
}
#
if achev_level_value: # 是否有下一级
next_level = sorted(achev_level_value.keys())[0]
# 当前等级(未用到)
current_level = int(next_level) - 1
to_next = achev_level_value[next_level]
my_info.fill(to_next, 'next')
data.setdefault('next', to_next)
else:
my_info.fill(0, 'next')
current_level = sorted(achev_level_value.keys())[-1]
except ValueError as e:
print('保级错误')
my_info.fill('0', 'next')
# pass
# 保级差别
response = import_status("get_my_info_success", "OK")
data.setdefault('show', show)
response["data"] = data
return response
except Exception as e:
logger.exception("get myinfo error")
raise SYSTEM_ERROR()
def get_all(self):
"""获取条件下的所有活动
"""
if is_tourist():
return AUTHORITY_ERROR(u"未登录")
args = request.args.to_dict()
logger.info("this is get all activity args %s", args)
parameter_required(u'tnid')
tnid = args.get('tnid') # 导航id
suid = args.get('suid') # 管理员id
lasting = args.get('lasting', 'true') # 是否正在进行的活动
acid = args.get("acid")
if not acid:
acid = None
start = int(args.get('start', 0)) # 起始位置
count = int(args.get('count', 5)) # 取出条数
page = (args.get('page'))
# 过滤跳转类型
skiptype = args.get('skiptype')
if skiptype is None:
settings = Partner()
skiptype = settings.get_item('skip', 'skip_type') # 配置文件中的过滤条件(默认)
if skiptype == 'all':
skiptype = None
# 分页
if not page:
page = int(math.floor(start / count) + 1)
if not (tnid or suid):
raise PARAMS_MISS(u"参数缺失")
try:
topnav = self.stopnav.get_topnav_by_tnid(tnid)
if not topnav:
raise NOT_FOUND(u'无此tnid')
if topnav.TNtype == 2 and str(tnid) != '1': # '1'为每日十荐页tnid
skiptype = 0
print(skiptype)
now_time = None
if str(lasting) == 'true':
now_time = datetime.strftime(datetime.now(), format_for_db)
activity_list = self.sactivity.get_activity_by_topnavid(
tnid, page, count, skiptype, acid, suid, now_time)
logger.info("get activity_list success")
# if suid:
# activity_list = self.sactivity.get_activity_by_suid(suid, page, count)
# if not activity_list:
# raise SYSTEM_ERROR(u'数据库错误')
for activity in activity_list:
self.sactivity.update_view_num(activity.ACid)
self.fill_detail(activity)
self.fill_like_num(activity)
self.fill_type(activity)
activity.fill(activity.AClinkvalue, 'aclinkvalue')
if activity.ACSkipType == 0:
self.fill_comment_two(activity)
activity.fill('none_skip', 'skip_type')
activity.fill('无跳转类型', 'zh_skip_type')
elif activity.ACSkipType == 1:
baid = activity.AClinkvalue
activity.fill('bigactivity', 'skip_type')
activity.fill('专题', 'zh_skip_type')
bigactivity = self.sbigactivity.get_one_big_act(baid)
if not bigactivity:
# raise NOT_FOUND()
pass
else:
bigactivity_type = bigactivity.BAtype
big_activity_content = {'type': bigactivity_type}
big_activity_content.setdefault(
'baid', bigactivity.BAid)
# 图片类型专题
if bigactivity_type == 0:
big_activity_content.setdefault(
'baimage', bigactivity.BAlongimg) # 返回字段不修改
big_activity_content.setdefault(
'baid', bigactivity.BAid)
activity.fill(big_activity_content, 'bigactivity')
elif activity.ACSkipType == 2:
self.fill_soldnum(activity)
self.fill_product(activity)
activity.fill('product', 'skip_type')
activity.fill('商品', 'zh_skip_type')
activity.ACstarttime = get_web_time_str(activity.ACstarttime)
activity.ACendtime = get_web_time_str(activity.ACendtime)
data = import_status("get_activity_list_success", "OK")
data["count"] = request.all_count
data["page_count"] = request.page_count
data["data"] = activity_list
return data
except Exception as e:
logger.exception("get activity error")
generic_log(e)
return e
def like_or_cancel(self):
if is_tourist():
raise AUTHORITY_ERROR(u"未登录")
print(request.user.USname.encode('utf8'))
json_data = request.json
logger.debug("act like data is %s", json_data)
parameter_required('acid')
acid = json_data.get('acid')
usid = request.user.id
already_like = self.salike.is_like(usid, acid)
activity = self.sactivity.get_activity_by_acid(acid)
if not already_like:
logger.info("this is not already_like to add activitylike")
al_dict = {
'ALid': str(uuid.uuid4()),
'USid': request.user.id,
'ACid': acid
}
self.salike.add_model('ActivityLike', **al_dict)
self.salike.add_like_by_acid(acid)
data = import_status('add_activity_like_success', 'OK')
# data = import_status('add_productlike_success', 'OK')
if activity.ACSkipType == 2 and activity.AClinkvalue:
logger.info("this is add productlike")
pl_dict = {
'PLid': str(uuid.uuid4()),
'USid': request.user.id,
'PRid': activity.AClinkvalue
}
self.sproductlike.add_model('ProductLike', **pl_dict)
self.sproduct.update_like_num(activity.AClinkvalue)
data = import_status('add_ac_pr_like_success', 'OK')
# elif not already_like:
# al_dict = dict(
# alid=str(uuid.uuid4()),
# usid=request.user.id,
# acid=acid
# )
# dict_add_models('ActivityLike', al_dict)
# self.salike.add_like_by_acid(acid)
# data = import_status('add_activity_like_success', 'OK')
# # data = import_status('add_productlike_success', 'OK')
# elif already_like and not activity.PRid:
# self.salike.del_like(request.user.id, acid)
# self.salike.cancel_like_by_acid(acid)
# data = import_status('cancel_activity_like_success', 'OK')
else:
logger.info("this is already like activity to cancel like")
self.salike.del_like(usid, acid)
product_like = self.sproductlike.get_product_is_like_by_prid(
usid, activity.AClinkvalue)
logger.info("this is already like product to cancel like")
if product_like:
self.sproductlike.del_productlike_usidprid(
usid, activity.AClinkvalue)
self.salike.cancel_like_by_acid(acid)
self.sproduct.update_like_num(activity.AClinkvalue, -1)
data = import_status('cancel_activity_like_success', 'OK')
alid = already_like.ALid if already_like else al_dict['ALid']
data['data'] = {'alid': alid}
return data
