def __init__(self):
from WeiDian.service.SRaward import SRaward
self.sraward = SRaward()
from WeiDian.service.SUser import SUser
self.suser = SUser()
from WeiDian.service.SSuperUser import SSuperUser
self.ssuperuser = SSuperUser()
from WeiDian.control.Cuser import CUser
self.cuser = CUser()
def __init__(self):
from WeiDian.service.SActivityComment import SActivityComment
self.sactivitycomment = SActivityComment()
from WeiDian.service.SActivity import SActivity
self.sactivity = SActivity()
from WeiDian.service.SUser import SUser
self.suser = SUser()
from WeiDian.service.SSuperUser import SSuperUser
self.ssuperuser = SSuperUser()
def __init__(self):
from WeiDian.service.SActivity import SActivity
self.sactivity = SActivity()
from WeiDian.service.SActivityComment import SActivityComment
self.sacomment = SActivityComment()
from WeiDian.service.SActivityLike import SActivityLike
self.salike = SActivityLike()
from WeiDian.service.SSuperUser import SSuperUser
self.ssuperuser = SSuperUser()
from WeiDian.service.SActivityMedia import SActivityMedia
self.smedia = SActivityMedia()
from WeiDian.service.SActivityTag import SActivityTag
self.stags = SActivityTag()
from WeiDian.service.SActivityFoward import SActivityFoward
self.foward = SActivityFoward()
from WeiDian.service.SProduct import SProduct
self.sproduct = SProduct()
from WeiDian.service.SUser import SUser
self.suser = SUser()
from WeiDian.service.SBigActivity import SBigActivity
self.sbigactivity = SBigActivity()
from WeiDian.service.STopNav import STopNav
self.stopnav = STopNav()
from WeiDian.service.STask import STask
self.stask = STask()
self.empty = ['', None, [], {}]
def __init__(self):
from WeiDian.service.SProduct import SProduct
self.sproduct = SProduct()
from WeiDian.service.SProductSkuValue import SProductSkuValue
self.sproductskuvalue = SProductSkuValue()
from WeiDian.service.SProductImage import SProductImage
self.sproductimage = SProductImage()
from WeiDian.service.SProductSkuKey import SProductSkuKey
self.sproductskukey = SProductSkuKey()
from WeiDian.service.SActivity import SActivity
self.sactivity = SActivity()
from WeiDian.service.SProductLike import SProductLike
self.sproductlike = SProductLike()
from WeiDian.control.Cuser import CUser
self.cuser = CUser()
from WeiDian.service.SBigActivity import SBigActivity
self.sbigactivity = SBigActivity()
from WeiDian.service.STopNav import STopNav
self.stopnav = STopNav()
from WeiDian.service.SOrder import SOrder
self.sorder = SOrder()
from WeiDian.service.SSuperUser import SSuperUser
self.ssuperuser = SSuperUser()
self.empty = ['', [], {}, None]
# 后续修改
self.partner = Partner()
self.update_sku_params = [
'PRid', "PSVid", 'PSKproductnum', 'PSKalias', 'PSKprice',
'PSKpostfee', 'PSKactiviyid', 'PSKproperkey', "PSisdelete"
]
self.update_product_params = [
'PRmainpic', 'PRdetail', 'PRimporturl', 'PRishot', 'PRtitle',
'PRname', 'Maketlias', 'PRalias', 'PRprice', 'PReditstate',
'PRsalesvolume', 'PRoldprice', 'PRchannelname', 'PRvipprice',
'PRlogisticsfee', 'PRchannelid', 'SUid', 'PRstock', 'PRsalestatus',
'PRishhare', 'PRtarget', 'PRviewnum', 'PRfakeviewnum',
'PRfakelikenum', 'PRsalefakenum', 'PRbaid'
]
class CActivityComment(BaseActivityCommentControl):
def __init__(self):
from WeiDian.service.SActivityComment import SActivityComment
self.sactivitycomment = SActivityComment()
from WeiDian.service.SActivity import SActivity
self.sactivity = SActivity()
from WeiDian.service.SUser import SUser
self.suser = SUser()
from WeiDian.service.SSuperUser import SSuperUser
self.ssuperuser = SSuperUser()
@verify_token_decorator
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
@verify_token_decorator
def del_comment_admin(self):
if not is_admin():
raise AUTHORITY_ERROR(u'当前非管理员')
data = request.json
acoid = data.get('acoid')
logger.debug('del comment data is %s', data)
up_info = self.sactivitycomment.delete_comment_by_acoid(acoid)
if not up_info:
raise NOT_FOUND(u'要删除的数据不存在')
data = import_status("delete_success", "OK")
data['acoid'] = acoid
return data
def get_comment_list(self):
"""获取评论列表"""
try:
args = request.args.to_dict()
acid = args.get('acid')
if not acid:
raise PARAMS_MISS(u'必要的参数缺失: acid;')
reply = True if args.get('reply') else False
page = int(args.get('page', 1)) # 页码
# start = int(args.get('start', 0)) # 起始位置
count = int(args.get('count', 15)) # 取出条数
# if not start:
# start = (page -1) * count
comment_list = self.sactivitycomment.get_comment_by_activity_id(
acid, page, count, reply)
# end = start + count
# len_comment_list = len(comment_list)
# if end > len_comment_list:
# end = len_comment_list
# comment_list = comment_list[start: end]
map(self.fill_user, comment_list)
map(self.fill_comment_apply_for, comment_list)
data = import_status('get_acvity_comment_list_success', 'OK')
data['data'] = comment_list
return data
except Exception as e:
generic_log(e)
raise e
def get_comment_with_apply(self):
"""获取推文的评论列表(评论回复嵌套)"""
try:
args = request.args.to_dict()
acid = args.get('acid')
if not acid:
raise PARAMS_MISS(u'必要的参数缺失: acid;')
page = int(args.get('page', 1)) # 页码
count = int(args.get('count', 15)) # 取出条数
comment_list = self.sactivitycomment.get_comment_by_activity_id(
acid, page, count)
for comment in comment_list:
self.fill_user(comment)
comment.ACOcreatetime = get_web_time_str(comment.ACOcreatetime)
replys = self.sactivitycomment.get_apply_by_acoid(
comment.ACOid)
if replys:
for reply in replys:
comment.fill(replys, 'reply')
reply.hide('USid')
# 改: 所有的回复都是管理员回复
admin_user = self.ssuperuser.get_one_super_by_suid(
reply.USid)
if admin_user:
user = admin_user
admin_user.fill(0, 'robot')
user.hide('SUid')
else:
user = {'name': u'运营人员', 'robot': 1}
reply.ACOcreatetime = get_web_time_str(
reply.ACOcreatetime)
reply.fill(user, 'user')
data = import_status('get_acvity_comment_list_success', 'OK')
data['data'] = comment_list
data["count"] = request.all_count
data["page_count"] = request.page_count
return data
except Exception as e:
generic_log(e)
raise e
def __init__(self):
self.ssuperuser = SSuperUser()
self.empty = ['', None, [], {}]
class CSuperUser():
def __init__(self):
self.ssuperuser = SSuperUser()
self.empty = ['', None, [], {}]
def login(self):
"""超级用户登录"""
json_data = request.json
suname = json_data.get('suname').encode('utf8')
supassword = json_data.get('supassword')
logger.debug("super user login data is %s", json_data)
# if not suname or not supassword:
# return PARAMS_MISS
parameter_required('suname', 'supassword')
try:
suuser = self.ssuperuser.verify_super(suname, supassword)
# if not suuser:
# return SYSTEM_ERROR
if suuser.SUlevel == 0:
level = 'customerservice'
if suuser.SUlevel == 1:
level = 'ordinaryadmin'
if suuser.SUlevel == 2:
level = 'superadmin'
token = usid_to_token(suuser.SUid, 'SuperUser')
token_data = {
'token': token,
'level': level,
'head': suuser.SUheader
}
data = import_status('generic_token_success', 'OK')
data['data'] = token_data
return data
except:
logger.exception('super user login in error')
raise SYSTEM_ERROR(u'用户名或密码错误')
@verify_token_decorator
def add_admin_by_superadmin(self):
"""超级管理员添加普通管理"""
if not is_superadmin():
raise AUTHORITY_ERROR(u'当前非超管权限')
data = request.json
logger.debug("add admin data is %s", data)
parameter_required('suname', 'password', 'suheader')
suid = str(uuid.uuid1())
password = data.get('password')
if len(password) < 4:
raise PARAMS_ERROR(u'密码长度低于4位')
zh_pattern = re.compile(u'[\u4e00-\u9fa5]+')
match = zh_pattern.search(password)
if match:
raise PARAMS_ERROR(u'密码包含中文字符')
suname = data.get('suname')
sulevel = data.get('sulevel')
sulevel = 1 if not sulevel else int(sulevel)
if sulevel not in [0, 1]:
raise PARAMS_ERROR(u'sulevel参数错误')
sufilter = {'SUisdelete': False, 'SUname': suname}
suexist = self.ssuperuser.get_existuser_by_name(sufilter)
if suexist:
raise SYSTEM_ERROR(u'用户名已存在')
try:
self.ssuperuser.add_model(
'SuperUser', **{
'SUid': suid,
'SUname': suname,
'SUpassword': generate_password_hash(password),
'SUheader': data.get('suheader'),
'SUlevel': sulevel,
})
response = import_status("add_admin_success", "OK")
response["data"] = {'suid': suid}
return response
except Exception as e:
logger.exception("add admin error")
raise SYSTEM_ERROR(u'添加管理员信息错误')
@verify_token_decorator
def get_all_admin_by_filter(self):
"""获取所有管理员"""
if not is_admin():
raise AUTHORITY_ERROR(u'当前非管理员账户')
args = request.args.to_dict()
logger.debug("get admin args is %s", args)
parameter_required('sutype')
sutype = args.get('sutype')
if not sutype:
sutype = 'normal'
if str(sutype) not in ['all', 'normal', 'freeze']:
raise PARAMS_ERROR('sutype error')
if str(sutype) == 'normal':
sufilter = {'SUisdelete': False, 'SUidfreeze': False}
elif str(sutype) == 'freeze':
sufilter = {'SUisdelete': False, 'SUidfreeze': True}
else:
sufilter = {'SUisdelete': False}
logger.debug("query sutype is %s", sutype)
suser_list = self.ssuperuser.get_all_super_by_sufilter(sufilter)
for suser in suser_list:
suser.fill(suser.SUlevel, 'sulevel')
suser.fill(suser.SUid, 'suid')
if suser.SUlevel == 0:
suser.level = 'customerservice'
if suser.SUlevel == 1:
suser.level = 'ordinaryadmin'
if suser.SUlevel == 2:
suser.level = 'superadmin'
suser.fill(suser.level, 'levelmeaning')
if suser.SUidfreeze is True:
suser.sustatus = 'freeze'
else:
suser.sustatus = 'normal'
suser.fill(suser.sustatus, 'sustatus')
response = import_status("messages_get_item_ok", "OK")
response['data'] = suser_list
return response
@verify_token_decorator
def superadmin_to_update_others(self):
if not is_superadmin():
raise AUTHORITY_ERROR(u'当前非超管权限')
data = request.json
logger.debug("update admin data is %s", data)
parameter_required('suid')
suid = data.get('suid')
password = data.get('password')
sulevel = data.get("sulevel")
sulevel = 1 if not sulevel else int(sulevel)
if sulevel not in [0, 1]:
raise PARAMS_ERROR(u'sulevel参数错误')
change_suser = self.ssuperuser.get_one_super_by_suid(suid)
if not change_suser:
raise NOT_FOUND(u'要修改的信息不存在')
upinfo = {
"SUid": suid,
"SUname": data.get("suname"),
"SUheader": data.get("suheader"),
"SUlevel": sulevel,
"SUidfreeze": data.get("suisfreeze"),
"SUisdelete": data.get("suisdelete")
}
upinfo = {k: v for k, v in upinfo.items() if v not in self.empty}
if password:
if len(password) < 4:
raise PARAMS_ERROR(u'密码长度低于4位')
zh_pattern = re.compile(u'[\u4e00-\u9fa5]+')
match = zh_pattern.search(password)
if match:
raise PARAMS_ERROR(u'密码包含中文字符')
pwdhashed = generate_password_hash(password)
upinfo["SUpassword"] = pwdhashed
changed = self.ssuperuser.update_info(suid, upinfo)
if not changed:
raise SYSTEM_ERROR(u"修改信息不存在")
response = import_status("update_superinfo_success", "OK")
response['data'] = {'suid': suid}
return response
@verify_token_decorator
def update_suerinfo(self):
"""管理员修改自身账户信息"""
if not is_admin():
raise AUTHORITY_ERROR(u'当前非管理员账户')
data = request.json
suid = request.user.SUid
old_suname = request.user.SUname
new_suname = data.get('suname')
if new_suname:
new_suname = new_suname.encode('utf8')
old_password = data.get('oldpassword')
new_password = data.get('newpassword')
avatar = data.get('head')
logger.debug("update info is %s", data)
# parameter_required('suname', 'head')
if old_password and new_password:
suuser = self.ssuperuser.verify_super(old_suname, old_password)
if not suuser:
raise PARAMS_ERROR(u'原密码错误')
password = generate_password_hash(new_password)
info = {
'SUname': new_suname,
'SUpassword': password,
'SUheader': avatar
}
info = {k: v for k, v in info.items() if v not in self.empty}
update_info = self.ssuperuser.update_info(suid, info)
if not update_info:
raise SYSTEM_ERROR()
else:
info = {'SUname': new_suname, 'SUheader': avatar}
info = {k: v for k, v in info.items() if v not in self.empty}
update_info = self.ssuperuser.update_info(suid, info)
if not update_info:
raise SYSTEM_ERROR(u"修改信息错误")
response = import_status("update_superinfo_success", "OK")
response['data'] = {'suid': suid}
return response
def __init__(self):
self.srecommend = SRecommend()
self.sproduct = SProduct()
self.ssuperuser = SSuperUser()
self.srecommendlike = SRecommendLike()
class CProduct(BaseProductControl):
def __init__(self):
from WeiDian.service.SProduct import SProduct
self.sproduct = SProduct()
from WeiDian.service.SProductSkuValue import SProductSkuValue
self.sproductskuvalue = SProductSkuValue()
from WeiDian.service.SProductImage import SProductImage
self.sproductimage = SProductImage()
from WeiDian.service.SProductSkuKey import SProductSkuKey
self.sproductskukey = SProductSkuKey()
from WeiDian.service.SActivity import SActivity
self.sactivity = SActivity()
from WeiDian.service.SProductLike import SProductLike
self.sproductlike = SProductLike()
from WeiDian.control.Cuser import CUser
self.cuser = CUser()
from WeiDian.service.SBigActivity import SBigActivity
self.sbigactivity = SBigActivity()
from WeiDian.service.STopNav import STopNav
self.stopnav = STopNav()
from WeiDian.service.SOrder import SOrder
self.sorder = SOrder()
from WeiDian.service.SSuperUser import SSuperUser
self.ssuperuser = SSuperUser()
self.empty = ['', [], {}, None]
# 后续修改
self.partner = Partner()
self.update_sku_params = [
'PRid', "PSVid", 'PSKproductnum', 'PSKalias', 'PSKprice',
'PSKpostfee', 'PSKactiviyid', 'PSKproperkey', "PSisdelete"
]
self.update_product_params = [
'PRmainpic', 'PRdetail', 'PRimporturl', 'PRishot', 'PRtitle',
'PRname', 'Maketlias', 'PRalias', 'PRprice', 'PReditstate',
'PRsalesvolume', 'PRoldprice', 'PRchannelname', 'PRvipprice',
'PRlogisticsfee', 'PRchannelid', 'SUid', 'PRstock', 'PRsalestatus',
'PRishhare', 'PRtarget', 'PRviewnum', 'PRfakeviewnum',
'PRfakelikenum', 'PRsalefakenum', 'PRbaid'
]
@verify_token_decorator
def add_product_list(self):
if not hasattr(request, 'user'):
return TOKEN_ERROR # 未登录, 或token错误
if not is_admin():
return AUTHORITY_ERROR # 权限不足
json_data = request.json
product_list = json_data.get('products')
logger.debug('get product list %s', product_list)
product_list = self.fix_product_list(product_list)
list_add_models('Product', product_list)
data = import_status('add_product_list_success', 'OK')
data['data'] = {'prid': self.prid_list}
return data
# 删除商品
@verify_token_decorator
def delete_product(self):
if not is_admin():
return AUTHORITY_ERROR(u'权限不足')
data = parameter_required('productid')
logger.debug('get delete_product data %s', data)
product = self.sproduct.get_product_by_productid(data.get('productid'))
if not product:
return import_status('no_product', 'OK')
update_result = self.sproduct.update_product_by_productid(
data.get('productid'), {
"PRisdelete": True,
'PRmodifytime': get_db_time_str()
})
if not update_result:
raise SYSTEM_ERROR(u'服务器繁忙')
return import_status('delete_product_success', 'OK')
# 上下架商品
@verify_token_decorator
def shelves_product(self):
"""状态改成0 上架 1下架"""
if not is_admin():
return AUTHORITY_ERROR(u'权限不足')
data = parameter_required('productid')
prstatus = data.get("prstatus", 1)
logger.debug('get prestatus. %s', prstatus)
logger.debug('get productid. %s', data.get('productid'))
if not re.match(r'^[0-2]$', str(prstatus)):
raise PARAMS_MISS(u'prstatus, 参数异常')
prstatus = int(prstatus)
prstatus = 0 if int(prstatus) else 1
product = self.sproduct.get_product_by_productid(data.get('productid'))
logger.debug('get product %s', product)
if not product and prstatus != 1:
return import_status('no_product', 'OK')
update_result = self.sproduct.update_product_by_productid(
data.get('productid'), {
"PRstatus": prstatus,
'PRmodifytime': get_db_time_str()
})
if not update_result:
raise SYSTEM_ERROR(u'服务器繁忙')
return import_status('update_product_success', 'OK')
# 更新sku
@verify_token_decorator
def update_sku(self):
if not is_admin():
return AUTHORITY_ERROR(u'权限不足')
data = parameter_required('psskuid', 'productid')
logger.debug('get update_sku data %s', data)
pskpropervalue = data.get('pskpropervalue')
skukey = {}
product = self.sproduct.get_product_by_productid(data.get('productid'))
if not product:
return import_status('no_product', 'OK')
for key in self.update_sku_params:
if not data.get(key.lower()) and data.get(key.lower()) != 0:
continue
skukey[key] = data.get(key.lower())
if skukey.get("PSKproperkey"):
skukey['_PSKproperkey'] = json.dumps(skukey.pop('PSKproperkey'))
productsku = self.sproductskukey.get_psk_by_psskuid(
data.get("psskuid"), product.PRid)
if not productsku:
psv = self.sproductskuvalue.get_skvalue_by_prid(product.PRid)
skukey['PSKid'] = str(uuid.uuid1())
skukey['PRid'] = product.PRid
skukey['PSVid'] = psv.PSVid
skukey['PSskuid'] = data.get("psskuid")
self.sproductskukey.add_model("ProductSkuKey", **skukey)
else:
update_result = self.sproductskukey.update_product_sku(
data.get("psskuid"), product.PRid, skukey)
if not update_result:
raise SYSTEM_ERROR(u'服务器繁忙')
if pskpropervalue and product:
update_result = self.sproductskuvalue.update_skuvalue(
product.PRid, {"_PSVpropervalue": json.dumps(pskpropervalue)})
if not update_result:
raise SYSTEM_ERROR(u'服务器繁忙')
return import_status('update_product_sku_success', 'OK')
# 更新商品
@verify_token_decorator
def update_product(self):
if not is_admin():
raise AUTHORITY_ERROR(u'权限不足')
data = parameter_required('productid')
logger.debug('get update_product data %s', data)
productid = data.get('productid')
product = self.sproduct.get_product_by_productid(productid)
if not product:
return import_status('no_product', 'OK')
product = {}
for key in self.update_product_params:
if not data.get(key.lower()) and data.get(key.lower()) != 0:
continue
product[key] = data.get(key.lower())
product['PRmodifytime'] = get_db_time_str()
update_result = self.sproduct.update_product_by_productid(
productid, product)
if not update_result:
raise SYSTEM_ERROR(u'服务器繁忙')
return import_status('update_product_success', 'OK')
# 更新商品
@verify_token_decorator
def update_product_image(self):
if not is_admin():
raise AUTHORITY_ERROR(u'权限不足')
data = parameter_required('productid', 'images')
logger.debug('get update_product_image data %s', data)
product = self.sproduct.get_product_by_productid(data.get("productid"))
if not product:
raise PARAMS_MISS(u"商品不存在或已删除")
# for image in data.get("images"):
# primage = self.sproductimage.get_images_by_prid_pisort(product.PRid, image.get('pisort', 0))
# if primage:
# update_result = self.sproductimage.update_image(
# primage.PIid, {"PIurl": image.get("piurl"), "PIexist": image.get("piexist", 1)})
# if not update_result:
# logger.error('update product image error, sort is %s', image.get("pisort", 0))
# raise SYSTEM_ERROR(u"数据库异常")
# else:
# self.sproductimage.add_model("ProductImage", **{
# "PIid": str(uuid.uuid1()),
# "PRid": product.PRid,
# "PIurl": image.get("piurl"),
# "PIsort": image.get("pisort", 0),
# "PIexist": image.get("piexist", 1),
# })
self.sproductimage.update_image_by_prid(product.PRid, {"PIexist": 0})
for image in data.get('images'):
self.sproductimage.add_model(
"ProductImage", **{
"PIid": str(uuid.uuid1()),
"PRid": product.PRid,
"PIurl": image.get("piurl"),
"PIsort": image.get("pisort", 0),
"PIexist": image.get("piexist", 1),
})
return import_status('update_product_image_success', 'OK')
@verify_token_decorator
def get_product_pools(self):
"""后台获取商品池列表内容"""
if not is_admin():
raise AUTHORITY_ERROR(u'请使用管理员账号重新登录')
args = request.args.to_dict()
logger.debug("Get Commodity Pools data is %s", args)
page, count = self.cuser.get_pagesize_pagenum(args)
time_start = args.get('time_start')
if time_start:
time_start = get_db_time_str(time_start)
time_end = args.get('time_end')
if time_end:
time_end = get_db_time_str(time_end)
status = args.get('status')
kw = args.get('kw')
if kw not in self.empty:
kw = kw.encode('utf8')
isdelete = args.get('isdelete', 0) # 0 or 1
if str(isdelete) == '0':
isdelete = False
elif str(isdelete) == '1':
isdelete = True
else:
isdelete = None
product_list = self.sproduct.get_product_filter(
kw, time_start, time_end, isdelete, status, page, count)
for product in product_list:
self.sproduct.update_view_num(product.PRid)
self.fill_prbaid(product)
self.fill_prtarget(product)
if product.PRcreatetime:
prcreatetime = get_web_time_str(product.PRcreatetime)
product.fill(prcreatetime, 'prcreatetime')
if product.SUmodifyid:
isclaim = True
canclaim = True if product.SUmodifyid == request.user.id else False
caneditact = True if product.SUmodifyid == request.user.id else False
else:
isclaim = False
canclaim = True
caneditact = False
product.fill(product.SUmodifyid or '', "claimid")
product.fill(isclaim, "isclaim")
product.fill(canclaim, "canclaim")
product.fill(caneditact, "caneditact")
isbig = False
if product.PRtarget:
isbig = True if product.PRtarget[0] == '101' else False
product.fill(isbig, 'isbig')
pv = product.PRviewnum
product.fill(pv, 'pv')
salesvolume = product.PRsalesvolume
transform = 0 if pv == 0 else salesvolume / float(pv)
ortransform = "%.2f%%" % (transform * 100)
product.fill(ortransform, 'ortransform')
refund_list = self.sorder.get_refund_product()
redfund_num = 0
if refund_list:
for refund in refund_list:
refund_product = self.sorder.get_orderproductinfo_by_opiid(
refund.OPIid)
if refund_product:
redfund_num = redfund_num + refund_product.OPIproductnum
refundrate_f = 0 if salesvolume == 0 else redfund_num / float(
salesvolume)
refundrate = "%.2f%%" % (refundrate_f * 100)
product.fill(refundrate, 'refundrate')
product.fill(product.prbaid, 'prbaid')
product.fill(product.PRstatus, 'prstatus')
activitystatus = 0
acid = None
ac_list = self.sactivity.get_acid_by_filterid({
'AClinkvalue':
product.PRid,
'ACSkipType':
2,
'ACisdelete':
False
})
if ac_list not in self.empty:
for act in ac_list:
temp_num = -1 if act.ACeditstatus is None else act.ACeditstatus
activitystatus = temp_num + 1
acid = act.ACid
zh_activitystatus = activity_edit_status.get(str(activitystatus))
product.fill(activitystatus, 'activitystatus')
product.fill(zh_activitystatus, 'zh_activitystatus')
product.fill(acid, 'acid')
data = import_status('get_product_list_success', 'OK')
data['data'] = product_list
data["count"] = request.all_count
data["page_count"] = request.page_count
return data
@verify_token_decorator
def update_sku_price(self):
"""更新sku里的售价/进价/利润"""
if not is_admin():
raise AUTHORITY_ERROR(u'请使用管理员账号重新登录')
data = request.json
pskid = data.get('pskid')
parameter_required('pskid')
logger.debug("update sku price data is %s", data)
sku_info = self.sproductskukey.get_psk_by_pskid(pskid)
if not sku_info:
raise NOT_FOUND(u'没有找到相应的sku')
price_dict = {
"PSKprice": data.get('pskprice'),
"PSKprofict": data.get('pskprofict'),
"PSKpurchase": data.get('pskpurchase')
}
price_dict = {
k: v
for k, v in price_dict.items() if v not in self.empty
}
if price_dict not in self.empty:
up_info = self.sproductskukey.update_sku_price_by_filter(
{'PSKid': pskid}, price_dict)
if not up_info:
raise SYSTEM_ERROR(u'更新数据错误')
# 操作日志
operation_dict = {
"PSKprice": u'更新售价',
"PSKprofict": u'更新利润',
"PSKpurchase": u'更新进货价'
}
if price_dict not in self.empty:
for i in price_dict.keys():
self.__make_product_recording(sku_info.PRid, sku_info.PSskuid,
operation_dict[i])
response = import_status("update_success", "OK")
response['data'] = {'pskid': pskid}
return response
@verify_token_decorator
def shelf_product_and_claim_act(self):
"""商品上下架/删除商品/推文认领"""
if not is_admin():
raise AUTHORITY_ERROR(u'请使用管理员账号重新登录')
data = request.json
logger.debug("shelf product and claim act data is %s", data)
prid = data.get('prid')
parameter_required('prid')
shelf = data.get('shelf') # 0 下架 1 上架
claim = data.get('claim') # 0 取消认领 1 认领推文
prdel = data.get('prdel') # 1 删除
modifyid = None
if shelf not in self.empty and claim not in self.empty:
raise PARAMS_MISS(u'参数错误，只能进行一项操作')
pr_info = self.sproduct.get_product_by_prid(prid)
if not pr_info:
raise NOT_FOUND(u'无该商品信息')
if pr_info.PRisdelete == True:
raise NOT_FOUND(u'数据错误，该商品已被删除')
if shelf not in self.empty:
if not re.match(r'^[0-1]$', str(shelf)):
raise PARAMS_MISS(u'shelf, 参数异常')
if pr_info.PRstatus == int(shelf):
raise SYSTEM_ERROR(u'已完成上/下架操作')
upinfo = self.sproduct.update_product_info_by_filter(
{'PRid': prid}, {
'PRmodifytime': get_db_time_str(),
'PRstatus': int(shelf)
})
if not upinfo:
raise SYSTEM_ERROR(u'更新数据错误')
# 操作日志
shelf_operation = u'上架商品' if str(shelf) == '1' else u'下架商品'
self.__make_product_recording(prid, prid, shelf_operation)
if claim not in self.empty:
if not re.match(r'^[0-1]$', str(claim)):
raise PARAMS_MISS(u'claim, 参数异常')
if pr_info.SUmodifyid:
if pr_info.SUmodifyid != request.user.id:
raise SYSTEM_ERROR(u'该推文已被其他运营认领')
else:
if str(claim) == '1':
raise SYSTEM_ERROR(u'您已完成认领')
else:
if str(claim) == '0':
raise SYSTEM_ERROR(u'您没有认领该商品的关联推文，不能进行解除操作')
modifyid = request.user.id if str(claim) == '1' else None
upinfo = self.sproduct.update_product_info_by_filter(
{'PRid': prid}, {
'PRmodifytime': get_db_time_str(),
'SUmodifyid': modifyid
})
if not upinfo:
raise SYSTEM_ERROR(u'更新数据错误')
# 操作日志
operation = u'认领推文' if str(claim) == '1' else u'解除推文认领'
self.__make_product_recording(prid, prid, operation)
if prdel not in self.empty:
if str(prdel) == '1':
update_result = self.sproduct.update_product_info_by_filter(
{'PRid': prid}, {
"PRisdelete": True,
'PRmodifytime': get_db_time_str()
})
if not update_result:
raise SYSTEM_ERROR(u'删除数据错误')
# 操作日志
self.__make_product_recording(prid, prid, u'删除商品')
response = import_status("update_success", "OK")
response['data'] = {'prid': prid, 'claimid': modifyid or ''}
return response
@verify_token_decorator
def get_product_operation_record(self):
"""获取商品操作记录"""
if not is_admin():
raise AUTHORITY_ERROR(u'请使用管理员账号重新登录')
args = request.args.to_dict()
prid = args.get('prid')
page_num, page_size = self.cuser.get_pagesize_pagenum(args)
record_list = self.sproduct.get_product_operation_record(
page_num, page_size, prid)
if record_list:
for record in record_list:
portarget = record.PRid if not record.PORtarget else record.PORtarget
record.PORcreatetime = get_web_time_str(record.PORcreatetime)
suser = self.ssuperuser.get_one_super_by_suid(record.SUid)
suname = suser.SUname if suser else ''
record.fill(suname, 'suname')
record.fill(portarget, 'portarget')
response = import_status("messages_get_item_ok", "OK")
response['data'] = record_list
response['page_count'] = request.page_count
response['count'] = request.all_count
return response
@verify_token_decorator
def update_product_relate_prtarget(self):
"""商品池修改商品与模块的关联"""
if not is_admin():
raise AUTHORITY_ERROR(u'请使用管理员账号重新登录')
data = request.json
logger.debug("update product relate prtarget data is %s", data)
prid = data.get('prid')
prtargets = data.get('prtarget')
if prtargets:
if len(prtargets) > 3:
raise SYSTEM_ERROR(u'每个商品最多只能关联三个模块')
ptid = str(uuid.uuid1())
if '101' in prtargets:
del_info = self.sproduct.del_product_target_by_filter(
{"PRid": prid})
logger.debug(
"del prtarget relation success before add operation, del count: %s",
del_info)
self.sproduct.add_model(
"ProductTarget", **{
'PTid': ptid,
'PRid': prid,
'PRtarget': '101'
})
# 操作记录
self.__make_product_recording(prid, prid, u'更改为大礼包商品')
else:
topnav_list = self.stopnav.get_all_tnid()
tnid_list = []
[tnid_list.append(topnav.TNid) for topnav in topnav_list]
with self.sproduct.auto_commit() as session:
model_beans = []
for targetid in prtargets:
if str(targetid) not in tnid_list:
raise PARAMS_MISS(u'prtarget参数错误，未找到要关联的模块')
prtarget_dict = dict(PTid=str(uuid.uuid4()),
PRid=prid,
PRtarget=targetid)
prtarget_info = ProductTarget.create(prtarget_dict)
model_beans.append(prtarget_info)
# 操作记录
self.__make_product_recording(prid, targetid,
u'更改模块关联')
session.query(ProductTarget).filter(
ProductTarget.PRid == prid).delete()
session.add_all(model_beans)
elif prtargets == []:
# 操作记录
try:
target_info = self.sproduct.get_product_target_by_prid(prid)
if target_info:
for tgid in target_info:
self.__make_product_recording(prid, tgid.PRtarget,
u'解除模块关联')
except Exception as e:
logger.exception("not found prtargetid ,error is %s", e)
self.__make_product_recording(prid, prid, u'解除模块关联')
del_info = self.sproduct.del_product_target_by_filter(
{"PRid": prid})
logger.debug("del prtarget relation success this is none list: %s",
del_info)
response = import_status("update_success", "OK")
response['data'] = {'prid': prid}
return response
@verify_token_decorator
def get_product_relate_bigactivity(self):
"""商品池获取商品与专题的关联详情"""
if not is_admin():
raise AUTHORITY_ERROR(u'请使用管理员账号重新登录')
prid = request.args.to_dict().get('prid')
parameter_required('prid')
logger.debug("get product relate bigactivity PRID is %s", prid)
prbaids = self.sproduct.get_product_baid_by_prid(prid)
list_baid = []
suid = ''
suname = u'批量导入'
updatetime = ''
for prbaid in prbaids:
record_info = self.sproduct.get_singel_record_by_filter({
'PRid':
prid,
'PORtarget':
prbaid.BAid
})
if record_info:
suid = record_info.SUid
suser_info = self.ssuperuser.get_one_super_by_suid(suid)
suname = suser_info.SUname if suser_info else ''
updatetime = get_web_time_str(record_info.PORcreatetime)
dict_baid = {
'pbid': prbaid.PBid,
'baid': prbaid.BAid,
'claimid': suid,
'clainname': suname,
'updatetime': updatetime
}
list_baid.append(dict_baid)
response = import_status("messages_get_item_ok", "OK")
response['data'] = list_baid
return response
@verify_token_decorator
def update_product_relate_bigactivity(self):
"""商品池修改商品与专题的关联"""
if not is_admin():
raise AUTHORITY_ERROR(u'请使用管理员账号重新登录')
data = request.json
logger.debug("update product relate bigactivity data is %s", data)
pbid = data.get('pbid')
baid = data.get('baid')
prid = data.get('prid')
option = data.get('option')
if not re.match(r'^[0-2]$', str(option)):
raise PARAMS_MISS(u'option 参数异常')
if baid == '':
raise PARAMS_MISS(u'baid 参数异常')
elif baid not in self.empty:
bigact = self.sbigactivity.get_one_big_act(baid)
if not bigact:
raise NOT_FOUND(u'输入的关联专题不存在')
if prid == '':
raise PARAMS_MISS(u'prid 参数异常')
elif prid not in self.empty:
product = self.sproduct.get_product_by_prid(prid)
if not product:
raise NOT_FOUND(u'商品信息不存在')
if str(option) == '0': # 0 删除
parameter_required('pbid')
# 操作记录
pbinfo = self.sproduct.get_single_productbigactivity_by_filter(
{'PBid': pbid})
if pbinfo:
self.__make_product_recording(pbinfo.PRid, pbinfo.BAid,
u'解除专题关联')
del_info = self.sproduct.del_productbigactivity_by_filter(
{'PBid': pbid})
if not del_info:
raise NOT_FOUND(u'错误，未找到要删除的关联专题')
elif str(option) == '1': # 1 添加
parameter_required('prid', 'baid')
prbaid_list = self.sproduct.get_product_baid_by_prid(prid)
if prbaid_list:
logger.debug("exist prbaid count is %s", len(prbaid_list))
if len(prbaid_list) >= 3:
raise SYSTEM_ERROR(u'每个商品最多只能关联三个专题')
for prbaid in prbaid_list:
if baid == prbaid.BAid:
raise SYSTEM_ERROR(u'已与此专题进行过关联')
pbid = str(uuid.uuid1())
self.sproduct.add_model(
'ProductBigActivity', **{
'PBid': pbid,
'PRid': prid,
'BAid': baid
})
# 操作记录
self.__make_product_recording(prid, baid, u'添加专题关联')
elif str(option) == '2': # 2 修改
parameter_required('pbid', 'baid')
pbact = self.sproduct.update_productbigactivity_by_filter(
{'PBid': pbid}, {'BAid': baid})
if not pbact:
raise NOT_FOUND(u'修改失败')
# 操作记录
pbinfo = self.sproduct.get_single_productbigactivity_by_filter(
{'PBid': pbid})
if pbinfo:
self.__make_product_recording(pbinfo.PRid, baid, u'修改专题关联')
response = import_status("update_success", "OK")
response['data'] = {'pbid': pbid}
return response
def get_product_list(self):
args = request.args.to_dict()
logger.debug("get product list args is %s", args)
page = args.get('page_num') # 页码
count = args.get('page_size') # 取出条数
page = 1 if page in self.empty else int(page)
count = 15 if count in self.empty else int(count)
time_start = None
time_end = None
kw = args.get('kw')
if kw not in ['', None]:
kw = kw.encode('utf8')
else:
kw = None
status = args.get('status')
status = 1 if status in self.empty else int(status)
try:
isdelete = int(args.get('isdelete')) # 0 or 1
isdelete = False if isdelete else True
except Exception as e:
isdelete = None
product_list = self.sproduct.get_product_filter(
kw, time_start, time_end, isdelete, status, page, count)
for product in product_list:
self.sproduct.update_view_num(product.PRid)
data = import_status('get_product_list_success', 'OK')
data['data'] = product_list
data["count"] = request.all_count
data["page_count"] = request.page_count
return data
@verify_token_decorator
def get_product_one(self):
logger.info(request.detail)
args = request.args.to_dict()
prid = args.get('prid')
if is_tourist():
usid = None
else:
usid = request.user.id
if not prid:
raise PARAMS_MISS()
product = self.sproduct.get_product_by_prid(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_prbaid(product)
self.fill_product_sku_key(product)
self.fill_product_sku_value(product)
self.sproduct.update_view_num(prid)
data = import_status('get_product_success', 'OK')
data['data'] = product
return data
@verify_token_decorator
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 __make_product_recording(self, prid, portarget, poraction):
"""创建商品操作记录"""
self.sproduct.add_model(
'ProductOperationRecord', **{
'PORid': str(uuid.uuid1()),
'PRid': prid,
'PORcreatetime': get_db_time_str(),
'SUid': request.user.id,
'PORtarget': portarget,
'PORaction': poraction
})
def fill_user(self, comment):
"""给对象添加一个用户字段"""
if comment.ACOrobot:
user = {'usname': comment.ACOrobot, 'robot': 1}
else:
usid = comment.USid
from WeiDian.service.SUser import SUser
from WeiDian.service.SSuperUser import SSuperUser
if comment.ACOparentid:
user = SSuperUser().get_one_super_by_suid(usid)
if user:
user.fill(0, 'robot')
user.hide('SUid')
else:
user = SUser().get_user_by_user_id(usid) # 对象的用户
if user:
user.fill(0, 'robot')
user.hide('USid')
user.hide('USphone')
comment.user = user # 对象的用户
comment.add('user').hide('USid')
return comment
class CRaward():
def __init__(self):
from WeiDian.service.SRaward import SRaward
self.sraward = SRaward()
from WeiDian.service.SUser import SUser
self.suser = SUser()
from WeiDian.service.SSuperUser import SSuperUser
self.ssuperuser = SSuperUser()
from WeiDian.control.Cuser import CUser
self.cuser = CUser()
@verify_token_decorator
def create_reward(self):
"""创建优惠券"""
if not is_admin():
raise AUTHORITY_ERROR(u'当前账号权限不足')
data = request.json
logger.debug("create reward data is %s", data)
raid = str(uuid.uuid1())
ratype = data.get('ratype')
rptid = data.get('rptid')
if not re.match(r'^[0-4]$', str(ratype)):
raise PARAMS_ERROR(u'ratype, 参数异常')
now_time = get_db_time_str()
nowtime_str_to_time = datetime.strptime(now_time, format_for_db)
days_later = datetime.strftime(nowtime_str_to_time + timedelta(days=30), format_for_web_second)
reendtime = get_db_time_str(data.get('raendtime', days_later))
ratransfer = data.get('ratransfer', False)
reward_dict = {
'RAid': raid,
'RAtype': ratype,
'RAmaxusenum': data.get('ramaxusenum', 1),
'RAmaxholdnum': data.get('ramaxholdnum', 1),
'RAendtime': reendtime,
'RAname': data.get('raname'),
'RAtransfer': ratransfer,
'SUid': request.user.id
}
if re.match(r'^[0-2]$', str(ratype)):
if str(ratype) == '0':
parameter_required('rafilter', 'raamount', 'ratype', 'raname')
logger.info('This reward type 0 is created')
reward_dict['RAfilter'] = data.get('rafilter')
reward_dict['RAamount'] = data.get('raamount')
elif str(ratype) == '1':
parameter_required('raratio', 'ratype', 'raname')
logger.info('This reward type 1 is created')
reward_dict['RAratio'] = data.get('raratio')
else:
parameter_required('raamount', 'ratype', 'raname')
logger.info('This reward type 2 is created')
reward_dict['RAfilter'] = 0
reward_dict['RAamount'] = data.get('raamount')
if ratransfer == True:
reward_dict['RAtransfereffectivetime'] = data.get('ratransfereffectivetime', 24)
self.sraward.add_model('Raward', **reward_dict)
if rptid:
self.sraward.add_model('RewardPacketContact', **{
'RPCid': str(uuid.uuid1()),
'RAid': raid,
'RPTid': rptid
})
data = import_status("create_reward_success", "OK")
data['data'] = {'raid': raid}
return data
@verify_token_decorator
def update_reward(self):
"""更换优惠券集合或删除"""
if not is_admin():
raise AUTHORITY_ERROR(u'非管理员权限')
data = request.json
logger.debug("update or del reward id is %s", data)
raid = data.get('raid')
raisdelete = data.get('raisdelete')
rptid = data.get('rptid')
if raisdelete:
upinfo = self.sraward.update_reward({'RAid': raid}, {'RAisdelete': raisdelete})
if not upinfo:
raise NOT_FOUND(u'删除失败')
elif rptid is not None:
self.sraward.del_packet_reward(raid)
if rptid:
self.sraward.add_model('RewardPacketContact', **{
'RPCid': str(uuid.uuid1()),
'RAid': raid,
'RPTid': rptid
})
data = import_status("update_success", "OK")
data['data'] = {'raid': raid}
return data
@verify_token_decorator
def admin_giving_reward(self):
"""后台赠送用户优惠券"""
if not is_admin():
raise AUTHORITY_ERROR(u'非管理员权限')
data = request.json
logger.debug("admin giving reward data is %s", data)
parameter_required('raid', 'usid')
usid = data.get('usid')
raid = data.get('raid')
ranumber = int(data.get('ranumber', 1)) # 该优惠券分发数量
is_hold = self.sraward.is_user_hold_reward({'USid': usid, 'RAid': raid})
if is_hold:
urid = is_hold.URid
logger.info("The user already has this type of reward ")
update_info = self.sraward.update_user_reward({'URid': is_hold.URid}, {'RAnumber': is_hold.RAnumber + ranumber})
if not update_info:
raise SYSTEM_ERROR(u'更新数据错误')
else:
logger.info("New reward to user")
urid = str(uuid.uuid1())
self.sraward.add_model('UserRaward', **{
'URid': urid,
'USid': usid,
'RAid': raid,
'RAnumber': ranumber
})
logger.info("now to write distribution the record")
self.sraward.add_model('RewardGrantRecord', **{
'RGRid': str(uuid.uuid1()),
'SUid': request.user.id,
'USid': usid,
'RAid': raid,
'RAnumber': ranumber
})
data = import_status("hand_out_reward_success", "OK")
data['data'] = {'urid': urid}
return data
@verify_token_decorator
def get_grant_record(self):
"""获取运营发放记录"""
if not is_admin():
raise AUTHORITY_ERROR(u'非管理员权限')
args = request.args.to_dict()
logger.debug('get grant record args : %s', args)
pagenum, pagesize = self.cuser.get_pagesize_pagenum(args)
record_list, count = self.sraward.get_grant_record(pagenum, pagesize)
for record in record_list:
if record:
user = self.suser.get_user_by_user_id(record.USid)
usname = user.USname
suser = self.ssuperuser.get_one_super_by_suid(record.SUid)
susername = suser.SUname
reward_info = self.sraward.get_raward_by_id(record.RAid)
reward_info = self.fill_reward_detail(reward_info)
record_str = '运营 {0} 发放给 {1} {2}优惠券 {3}张'.format(susername.encode('utf8'), usname.encode('utf8'), reward_info.rewardstr, record.RAnumber)
record.fill(reward_info.rewardstr, 'rewardname')
record.fill(usname, 'usname')
record.fill(susername, 'susername')
record.fill(record_str, 'record_str')
record.RGRcreatetime = get_web_time_str(record.RGRcreatetime)
response = import_status('messages_get_item_ok', 'OK')
response['data'] = record_list
response['count'] = count
return response
@verify_token_decorator
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
@verify_token_decorator
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
@verify_token_decorator
def hand_out_reward(self):
"""平台发放在页面内的优惠券"""
if not is_admin():
raise AUTHORITY_ERROR(u'非管理员权限')
data = request.json
logger.debug("hand out data is %s", data)
raid = data.get('raid')
rtid = str(uuid.uuid1())
is_hand_out = self.sraward.is_hand_out({'RAid': raid})
if is_hand_out:
raise PARAMS_REDUNDANCE(u'该优惠券已在页面发放')
else:
self.sraward.add_model('RewardToUser', **{
'RTid': rtid,
'RAid': raid,
'RTcount': data.get('rtcount', 10)
})
data = import_status("hand_out_reward_success", "OK")
data['data'] = {'rtid': rtid}
return data
@verify_token_decorator
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
@verify_token_decorator
def get_transfer_reward(self):
"""接收者领取优惠券"""
if is_tourist():
raise TOKEN_ERROR(u'未登录')
data = request.json
logger.debug('get transfer data is %s', data)
urid = data.get('urid')
usid = data.get('usid')
presenter = self.suser.get_user_by_user_id(usid)
if not presenter:
raise NOT_FOUND(u'无此赠送用户')
is_self_reward = self.sraward.is_user_hold_reward({'USid': request.user.id, 'URid': urid})
is_self_gift_reward = self.sraward.is_user_hold_reward_in_gift({'RFfrom': request.user.id, 'RFid': urid})
if is_self_reward or is_self_gift_reward:
raise SYSTEM_ERROR(u'不能领取自己转赠的优惠券')
# 在赠送者的普通券表中有
is_own_hold = self.sraward.is_user_hold_reward({'USid': usid, 'URid': urid})
# 赠送者送出去过，但是已退回，可以继续转赠
is_own_gift_hold = self.sraward.is_user_hold_reward_in_gift(
{'RFfrom': usid, '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 not reward_info:
raise NOT_FOUND(u'该券已失效')
elif 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': request.user.id, 'RFstatus': 0, 'RFfrom': usid})
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({'USid': request.user.id, 'RAid': raid})
if is_own_gift_hold:
up_reward_info = self.sraward.update_reward_transfer_info(
{'RFfrom': usid, 'RFid': urid, 'RFstatus': 1}, {'USid': request.user.id, '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': request.user.id,
'RAid': raid,
'URFrom': usid,
'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': request.user.id,
'RAid': raid,
'URFrom': usid,
'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
@verify_token_decorator
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
@verify_token_decorator
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
@verify_token_decorator
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'获取数据错误')
@verify_token_decorator
def create_rewardpacket(self):
"""创建优惠券集合"""
if not is_admin():
raise AUTHORITY_ERROR(u'非管理员权限')
data = request.json
logger.debug("create reward packet data is %s", data)
rptid = str(uuid.uuid1())
self.sraward.add_model('RewardPacket', **{
'RPTid': rptid,
'SUid': request.user.id,
'RPTname': data.get('name')
})
data = import_status("create_reward_packet_success", "OK")
data['data'] = {'rptid': rptid}
return data
@verify_token_decorator
def get_rewardpacket(self):
"""获取优惠券集合"""
if not is_admin():
raise AUTHORITY_ERROR(u'非管理员权限')
rewardpackets = self.sraward.get_reward_packet_list()
logger.info(('get reward packet list success'))
data = import_status("messages_get_item_ok", "OK")
data['data'] = rewardpackets
return data
@verify_token_decorator
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
@verify_token_decorator
def del_rewardpacket(self):
"""删除优惠券集合"""
if not is_admin():
raise AUTHORITY_ERROR(u'非管理员权限')
data = request.json
logger.debug("del reward packet id is %s", data)
rptid = data.get('rptid')
del_info = self.sraward.update_reward_packet({'RPTid': rptid}, {'RPTisdelete': True})
self.sraward.del_packet_contact({'RPTid': rptid})
if not del_info:
raise NOT_FOUND(u'删除失败')
data = import_status("delete_success", "OK")
data['data'] = {'rptid': rptid}
return data
def fill_reward_detail(self, raward, price=None):
reward_number = '{0}张'
reward_number_ratio = '前{0}单'
filter_str = '满{0}-{1}新衣币'
ratio_str = '佣金上涨{0}%'
amout_str = '{0}元无门槛新衣币'
price_use = False
if raward not in ['', None, [], {}]:
if re.match(r'^[0-2]$', str(raward.RAtype)):
if raward.RAtype == 0:
reward_str = filter_str.format(int(raward.RAfilter), int(raward.RAamount))
elif raward.RAtype == 1:
reward_str = ratio_str.format(int(raward.RAratio))
else:
reward_str = amout_str.format(int(raward.RAamount))
zh_ratype = REWARD_TYPE.get(str(raward.RAtype))
raward.fill(zh_ratype, 'zh_ratype')
raward.fill(reward_str, 'rewardstr')
time_valid = raward.RAcreatetime < get_db_time_str() < raward.RAendtime and not raward.RAisdelete
if price:
if raward.RAtype == 0:
price_use = price > raward.RAfilter
elif raward.RAtype == 2:
price_use = True
valid = time_valid and price_use
else:
valid = time_valid
raward.fill(valid, 'valid')
raward.RAendtime = get_web_time_str(raward.RAendtime)
raward.RAcreatetime = get_web_time_str(raward.RAcreatetime)
return raward
def fill_transfer_detail(self, raward):
from WeiDian.service.SUser import SUser
if hasattr(raward, 'RFstatus'):
reward_info = self.sraward.get_raward_by_id(raward.RAid)
# if reward_info.RAtransfer == False:
# raise SYSTEM_ERROR(u'信息错误，该券不能被赠送')
if not re.match(r'^[0-2]$', str(raward.RFstatus)):
raise SYSTEM_ERROR(u'优惠券转赠状态异常')
if raward.RFstatus == 0:
presenter = SUser().get_user_by_user_id(raward.RFfrom)
recipient = SUser().get_user_by_user_id(raward.USid)
if not presenter or not recipient:
raise NOT_FOUND(u'转赠信息不正确')
if raward.USid == request.user.id:
usheader = presenter.USheader
remarks = '由{0}赠送'.format((presenter.USname).encode('utf8'))
tag = '赠送'
transfer_valid = True
elif raward.RFfrom == request.user.id:
usheader = recipient.USheader
remarks = '已赠送给{0}'.format((recipient.USname).encode('utf8'))
tag = '赠送'
transfer_valid = False
elif raward.RFstatus == 1:
recipient = SUser().get_user_by_user_id(raward.USid)
presenter = SUser().get_user_by_user_id(raward.RFfrom)
if raward.USid == request.user.id:
usheader = presenter.USheader
remarks = '因领取后{0}小时未使用已退还给{1}'.format(reward_info.RAtransfereffectivetime, (presenter.USname).encode('utf8'))
tag = '已退回'
transfer_valid = False
elif raward.RFfrom == request.user.id:
usheader = recipient.USheader
remarks = '{0}领取后{1}小时未使用还回'.format((recipient.USname).encode('utf8'), reward_info.RAtransfereffectivetime)
tag = '已还回'
transfer_valid = True
elif raward.RFstatus == 2:
recipient = SUser().get_user_by_user_id(raward.USid)
usheader = recipient.USheader
remarks = '{0}已使用'.format(str(recipient.USname))
tag = '已使用'
transfer_valid = False
raward.fill(transfer_valid, 'transfer_valid')
raward.fill(usheader, 'usheader')
raward.fill(remarks, 'remarks')
raward.fill(tag, 'tag')
return raward
def check_holdnum_is_exceeded(self, reward):
"""检查持有的优惠券是否超出可拥有数量"""
pass