def add_bankcard(self):
if not hasattr(request, 'user'):
return TOKEN_ERROR(u"未登录, 或token错误")
data = request.json
logger.info("this add bankcard info %s", data)
parameter_required('BCusername', 'BCnumber', 'BCbankname', 'BCaddress')
banknumber = str(data.get('BCnumber')).strip()
self._verify_cardnum(banknumber, error='raise')
usid = request.user.id
try:
bankcard = self.sbankcard.update_bankcard_by_usid(
usid, {'BCisdelete': True})
logger.debug("bankcard count is %s", bankcard)
bcid = str(uuid.uuid1())
self.sbankcard.add_model(
"BankCard", **{
"BCid": bcid,
"USid": usid,
"BCusername": data.get("BCusername"),
"BCnumber": banknumber,
"BCbankname": data.get("BCbankname"),
"BCaddress": data.get("BCaddress")
})
response = import_status("add_bank_card_success", "OK")
response['data'] = {"BCid": bcid}
return response
except:
logger.exception("add bankcard error")
return SYSTEM_ERROR
def update_address(self):
if not hasattr(request, 'user'):
return TOKEN_ERROR(u"未登录, 或token错误")
args = request.args.to_dict()
logger.debug("this is address args %s", args)
data = request.json
logger.debug("this is address data %s", data)
uaid = args.get('uaid')
uadefault = data.get("UAdefault")
try:
exist_default = self.suesraddress.get_default_address_by_usid(
request.user.id)
parameter_required("uaid", "areaid", "UAname", "UAphone", "UAtext",
"UAdefault")
if uadefault == True and exist_default:
self.suesraddress.change_default_address_status(
exist_default.UAid, {'UAdefault': False})
update_address = self.suesraddress.update_address(
uaid, {
"areaid": data.get("areaid"),
"UAname": data.get("UAname"),
"UAphone": data.get("UAphone"),
"UAtext": data.get("UAtext"),
"UAdefault": uadefault
})
logger.info("update address succress ")
if not update_address:
raise SYSTEM_ERROR(u'数据更新错误')
response = import_status("update_useraddress_success", "OK")
response['data'] = {"uaid": args["uaid"]}
return response
except:
logger.exception("update address error")
return SYSTEM_ERROR
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
def add_complain(self):
if not hasattr(request, 'user'):
return TOKEN_ERROR # 未登录, 或token错误
parameter_required("OIid", "COtype")
data = request.json
try:
complain = self.scomplain.get_complain_by_oiid(data.get("OIid"))
logger.debug("get complain by oiid %s", complain)
if complain:
return import_status("complain_repeat_error", "WD_ERROR",
"error_complain_exit")
coid = str(uuid.uuid1())
cotype_list = [str(i) for i in data.get("COtype", [])]
self.scomplain.add_model(
"Complain", **{
"COid": coid,
"COcontent": data.get("COcontent"),
"COtype": ",".join(cotype_list),
"OIid": data.get("OIid"),
"USid": request.user.id,
"COtreatstatus": 1,
})
response = import_status("complain_success", "OK")
response['data'] = {"COid": coid}
return response
except:
logger.exception("add complain error")
return SYSTEM_ERROR
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 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'用户名或密码错误')
def add_useraddress(self):
if not hasattr(request, 'user'):
return TOKEN_ERROR(u"未登录, 或token错误")
parameter_required("areaid", "UAname", "UAphone", "UAtext")
data = request.json
logger.info("this is useraddress data %s", data)
try:
uaid = str(uuid.uuid1())
logger.debug("get default address by usid")
exist_default = self.suesraddress.get_default_address_by_usid(
request.user.id)
uadefault = True if not exist_default else data.get("UAdefault")
if str(uadefault) not in ['True', 'False']:
raise PARAMS_ERROR(u'uadefault参数不合法')
if uadefault is True and exist_default:
self.suesraddress.change_default_address_status(
exist_default.UAid, {'UAdefault': False})
self.suesraddress.add_model(
"UserAddress", **{
"UAid": uaid,
"USid": request.user.id,
"UAname": data.get("UAname"),
"UAphone": data.get("UAphone"),
"UAtext": data.get("UAtext"),
"areaid": data.get("areaid"),
"UAdefault": uadefault
})
response = import_status("add_address_success", "OK")
response['data'] = {"UAid": uaid}
return response
except:
logger.exception("add user address error")
return SYSTEM_ERROR
def update_recommend_by_reid(self):
if not is_admin():
raise AUTHORITY_ERROR(u'当前非管理员权限') # 权限不足
args = request.args.to_dict()
logger.debug("update args is %s", args)
data = request.json
parameter_required(u'reid')
logger.debug("update data is %s", data)
reid = args.get('reid')
recommend = {
'REstarttime': get_db_time_str(data.get('restarttime')),
'REendtime': get_db_time_str(data.get('reendtime')),
'REfakeviewnum': data.get('reviewnum'),
'RElikefakenum': data.get('relikenum'),
'SUid': data.get('suid')
# 'REisdelete': data.get('reisdelete')
}
recommend = {k: v for k, v in recommend.items() if v is not None}
res = self.srecommend.update_recommend_by_reid(reid, recommend)
if not res:
raise SYSTEM_ERROR(u"信息修改错误")
prid_list = data.get('prid_list')
if prid_list:
for item in prid_list:
prid = item.get('prid')
prisdelete = item.get('prisdelete')
rpsort = item.get('rpsort')
refilter = {'REid': reid, 'PRid': prid}
already_exist_product = self.srecommend.get_exist_reproduct_by_filter(
refilter)
if not already_exist_product:
add_model(
'RecommendProduct', **{
'REid': reid,
'PRid': prid,
'RPid': str(uuid.uuid4()),
'RPsort': rpsort
})
else:
if prisdelete is True:
self.srecommend.del_reproduct_by_filter(refilter)
elif rpsort:
repr_changed = self.srecommend.get_exist_reproduct_by_filter(
{'RPsort': rpsort})
if repr_changed:
self.srecommend.update_exist_reproduct_by_filter(
{'RPid': repr_changed.RPid},
{'RPsort': already_exist_product.RPsort})
self.srecommend.update_exist_reproduct_by_filter(
refilter, {
'REid': reid,
'PRid': prid,
'RPsort': rpsort
})
response_update_recommend = import_status('update_recommend_success',
'OK')
response_update_recommend['data'] = {'reid': reid}
return response_update_recommend
def del_task(self):
if not is_admin():
raise AUTHORITY_ERROR(u'权限不足')
data = request.json
parameter_required("TAid")
logger.debug('get del task data, %s', data)
update_result = self.stask.update_task(data.get("TAid"),
{"TAstatus": 4})
if not update_result:
raise SYSTEM_ERROR(u'数据库异常')
return import_status("delete_success", "OK")
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 add_one(self):
"""添加推荐"""
# 此处无需添加图片, 关联商品id即可
if not is_admin():
return AUTHORITY_ERROR(u'当前非管理员权限')
data = request.json
logger.debug("data is %s", data)
parameter_required('PRid_list')
now_time = datetime.strftime(datetime.now(), format_for_web_second)
restarttime = get_db_time_str(data.get('REstarttime',
now_time)) # 上线时间, 默认当前时间
restarttime_str_to_time = datetime.strptime(restarttime, format_for_db)
days_later = datetime.strftime(
restarttime_str_to_time + timedelta(days=7), format_for_web_second)
reendtime = get_db_time_str(data.get('REendtime',
days_later)) # 推荐下线时间, 默认7天以后
relikefakenum = data.get('RElikenum', 0) # 喜欢数
refakeviewnum = data.get('REviewnum', 0) # 浏览数
prid_list = data.get('PRid_list')
if not prid_list:
raise PARAMS_MISS(u'缺失PRid_list')
reid = str(uuid.uuid4())
try:
re_info = {
# 'REid': reid,
# 'SUid': request.user.id,
'RElikefakenum': relikefakenum,
'REfakeviewnum': refakeviewnum,
'REstarttime': restarttime,
'REendtime': reendtime,
}
update_info = self.srecommend.update_recommend_by_reid
except Exception as e:
logger.debug("add Recommend error")
raise SYSTEM_ERROR(u'添加Recommend错误')
try:
for item in prid_list:
add_model(
'RecommendProduct', **{
'REid': reid,
'PRid': item.get('PRid'),
'RPid': str(uuid.uuid4()),
'RPsort': item.get('RPsort')
})
except Exception as e:
logger.debug("add recommondproduct list error")
raise SYSTEM_ERROR(u'添加每日推荐商品RecommendProduct内容出错')
response_make_recommend = import_status('add_recommend_success', 'OK')
response_make_recommend['data'] = {
'reid': reid,
}
return response_make_recommend
def del_task_level(self):
if not is_admin():
raise AUTHORITY_ERROR(u'权限不足')
data = request.json
parameter_required("tlid")
logger.debug('get del task level data, %s', data)
tasklevel = self.stask.get_task_level_by_tlid(data.get("tlid"))
if not tasklevel:
return SYSTEM_ERROR(u'该任务等级不存在或已删除')
self.stask.update_task_by_tlid(tasklevel.TLid, {"TAstatus": 4})
self.stask.update_task_level(data.get("tlid"), {"TLisdelete": True})
return import_status("delete_success", "OK")
def add_or_update_task_level(self):
if not is_admin():
raise AUTHORITY_ERROR(u"权限不足")
parameter_required(*self.add_task_level)
data = request.json
logger.debug('get request data : %s', data)
reward_list = data.get("reward")
try:
tasklevel = self.stask.get_tasklevel_by_level(
int(data.get("TAlevel")))
if not tasklevel:
tlid = str(uuid.uuid1())
self.stask.add_model(
"TaskLevel", **{
"TLid":
tlid,
"TAlevel":
data.get("TAlevel"),
"TArole":
data.get("TArole"),
"TAcomplateNotifications":
data.get("TAcomplateNotifications"),
"TLisdelete":
0
})
for reward in reward_list:
self.add_task_raward(tlid, reward)
else:
update_result = self.stask.update_task_level(
tasklevel.TLid, {
"TAlevel":
data.get("TAlevel", 0),
"TArole":
data.get("TArole"),
"TAcomplateNotifications":
data.get("TAcomplateNotifications")
})
if not update_result:
return import_status("update_data_error", "WEIDIAN_ERROR",
"error_update_data")
self.sraward.delte_task_raward_by_tlid(tasklevel.TLid)
for reward in reward_list:
self.add_task_raward(tasklevel.TLid, reward)
return import_status('add_task_success', 'OK')
except:
logger.exception('add or update task level error')
return SYSTEM_ERROR(u"服务器繁忙")
def get_area_by_citynum(self):
args = request.args.to_dict()
logger.info("get area args is %s", args)
parameter_required('cityid')
city_id = args['cityid']
try:
logger.debug("get arealist by cityid")
area_list = self.suesraddress.get_arealist_by_cityid(city_id)
# map(lambda x: x.hide('_id'), area_list)
res = import_status("get_area_list_success", "OK")
res["data"] = area_list
return res
except:
logger.exception("get area list error")
return SYSTEM_ERROR
def set_share_params(self):
if not is_admin():
raise TOKEN_ERROR(u'请使用管理员登录')
data = request.json
title = data.get('title')
# title = title.encode("utf8") if isinstance(title, unicode) else title
content = data.get('content')
img = data.get('img')
parameter_required('title', 'content', 'img')
Partner().set_item('share', 'title', title)
Partner().set_item('share', 'content', content)
Partner().set_item('share', 'img', img)
response = import_status('set_success', 'OK')
return response
def like_or_cancel(self):
if not is_partner():
return AUTHORITY_ERROR
print '是合伙人'
json_data = parameter_required('reid')
reid = json_data.get('reid')
already_like = self.srecommendlike.get_recommend_like_by_usidreid(request.user.id, reid)
# recommend = self.srecommend.get_recommend_by_reid(reid)
if not already_like:
rl_dict = dict(
rlid=str(uuid.uuid4()),
usid=request.user.id,
reid=reid
)
dict_add_models('RecommendLike', rl_dict)
rlid = already_like.RLid if already_like else rl_dict['rlid']
self.srecommend.add_like_num(reid) # 数量更改
data = import_status('add_recommend_like_success', 'OK')
data['data'] = {'rlid': rlid}
return data
else:
# 删除点赞
self.srecommendlike.del_like(request.user.id, reid)
self.srecommend.del_like_num(reid)
response_make_like = import_status('cancel_recommend_like_success', 'OK')
response_make_like['data'] = {'reid': reid}
return response_make_like
def get_city_by_provincenum(self):
args = request.args.to_dict()
logger.info("get city list args is %s", args)
parameter_required("provinceid")
province_id = args["provinceid"]
try:
logger.debug("get citylist by province_id")
city_list = self.suesraddress.get_citylist_by_provinceid(
province_id)
# map(lambda x: x.hide('_id'), city_list)
res = import_status("get_city_list_success", "OK")
res["data"] = city_list
return res
except:
logger.exception("get city list error")
return SYSTEM_ERROR
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 del_bankcard(self):
if not hasattr(request, 'user'):
return TOKEN_ERROR(u"未登录, 或token错误")
data = request.json
logger.info("this is del bankcard data %s", data)
parameter_required("BCid")
try:
logger.debug("del bankcard")
del_bankcard = self.sbankcard.del_bankcard(data.get("BCid"),
request.user.id)
if not del_bankcard:
return SYSTEM_ERROR
response = import_status("delete_bankcard_success", "OK")
response['data'] = {"bcid": data.get("BCid")}
return response
except:
logger.exception("del address error")
return SYSTEM_ERROR
def add_one(self):
"""添加活动热文, 需要管理员登录"""
if not is_admin():
return AUTHORITY_ERROR # 权限不足
data = request.json
logger.debug("add hotmessage data is ", data)
parameter_required('HMtext', 'HMsort', 'HMSkipType')
now_time = datetime.strftime(datetime.now(), format_for_db)
HMstarttime = get_db_time_str(data.get('HMstarttime',
now_time)) # 热文开始时间
hmstarttime_str_to_time = datetime.strptime(HMstarttime, format_for_db)
# 7天以后
seven_days_later = datetime.strftime(
hmstarttime_str_to_time + timedelta(days=7), format_for_db)
HMendtime = get_db_time_str(data.get(
'HMendtime', seven_days_later)) # 热文结束时间, 默认7天以后
# if not self.sproduct.get_product_by_prid(prid):
# return SYSTEM_ERROR
HMSkipType = data.get('HMSkipType')
if str(HMSkipType) not in self.hotmessage_type:
raise SYSTEM_ERROR(u'HMSkipType参数错误')
HMdisplaytype = data.get("HMdisplaytype")
if str(HMdisplaytype) not in self.hotmessage_display_type:
raise SYSTEM_ERROR(u'HMdisplaytype参数错误')
try:
HMid = str(uuid.uuid1())
self.s_hotmessage.add_model(
'HotMessage', **{
'HMid': HMid,
'HMtext': data.get('HMtext'),
'HMstarttime': HMstarttime,
'HMendtime': HMendtime,
'HMsort': data.get('HMsort'),
'HMSkipType': HMSkipType,
"HMcontent": data.get("HMcontent"),
"HMdisplaytype": HMdisplaytype
})
response_make_hotmesasge = import_status('add_hotmessage_success',
'OK')
response_make_hotmesasge['data'] = {'HMid': HMid}
return response_make_hotmesasge
except:
logger.exception("create hotmessage error")
return SYSTEM_ERROR(u'服务器繁忙')
def update_status(self):
# if not is_admin():
# raise TOKEN_ERROR
parameter_required('coid', 'cotreatstatus')
data = request.json
logger.debug('get update complain status %s', data)
complain = self.scomplain.get_complain_by_coid(data.get("coid"))
if not complain:
raise PARAMS_MISS('params coid is not right')
if not re.match(r'^[0-2]$', str(data.get("cotreatstatus"))):
raise PARAMS_MISS('params cotreatstatus is not right')
cotreatstatus = int(data.get("cotreatstatus"))
if cotreatstatus <= complain.COtreatstatus:
raise PARAMS_MISS('params cotreatstatus is not right')
update_result = self.scomplain.update_complain(
data.get("coid"), {"COtreatstatus": cotreatstatus})
if not update_result:
raise SYSTEM_ERROR(u"服务器繁忙")
return import_status('update_complain_success', "OK")
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'添加管理员信息错误')
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 update_bankcard(self):
if not hasattr(request, 'user'):
return TOKEN_ERROR(u"未登录, 或token错误")
args = request.args.to_dict()
logger.info("this is update bankcard args %s", args)
data = request.json
logger.info("this is update bankcard data %s", data)
try:
parameter_required("bcid", "BCusername", "BCnumber", "BCbankname",
"BCaddress")
update_bankcard = self.sbankcard.update_bankcard(
args["bcid"], data)
logger.debug("update bankcard accress")
if not update_bankcard:
return SYSTEM_ERROR
response = import_status("update_bankcard_success", "OK")
response["data"] = {"bcid": args["bcid"]}
return response
except:
logger.exception("update bankcard error")
return SYSTEM_ERROR
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
def set_show_type(self):
if not is_admin():
raise TOKEN_ERROR(u'请使用管理员登录')
data = parameter_required('skip_type')
try:
skip_type = str(data.get('skip_type'))
if skip_type not in ['0', '1', '2']:
raise TypeError()
except TypeError as e:
raise PARAMS_ERROR(u'参数skip_type错误')
Partner().set_item('skip', 'skip_type', skip_type)
response = import_status('set_success', 'OK')
return response
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
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
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_task(self):
if not is_admin():
raise AUTHORITY_ERROR(u"权限不足")
data = request.json
logger.info("add task body %s", data)
parameter_required(*self.add_task_params)
task = {k: data.get(k) for k in self.add_task_params}
logger.debug('get tatype is %s and type of tatype is %s',
task.get("TAtype"), type(task.get("TAtype")))
tatype = int(task.get("TAtype"))
if tatype == 0 and "TAurl" not in data:
raise PARAMS_ERROR(u"参数TAurl缺失")
task['TAstartTime'] = get_db_time_str(data.get("TAstartTime"))
if data.get("TAendTime"):
task['TAendTime'] = get_db_time_str(data.get("TAendTime"))
if data.get("TAduration"):
task['TAduration'] = data.get("TAduration")
task['TAstatus'] = data.get("TAstatus", 0)
task['TAmessage'] = data.get("TAmessage")
task['TAurl'] = data.get("TAurl", 1)
task['TAtype'] = tatype
logger.debug('add task : task is %s', task)
try:
if data.get("TAid"):
update_result = self.stask.update_task(data.get("TAid"), task)
if not update_result:
raise SYSTEM_ERROR(u"数据库异常")
task["TAid"] = data.get("TAid")
else:
task['TAid'] = str(uuid.uuid1())
self.stask.add_model("Task", **task)
# self.add_or_update_task_raward(task['TAid'], task['RAid'], task.get("RAnumber", 1))
except:
logger.exception("add task error")
return SYSTEM_ERROR(u'服务器繁忙')
return import_status("add_task_success", "OK")
