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 update_hot(self):
"""修改热文"""
if not is_admin():
return AUTHORITY_ERROR # 权限不足
data = request.json
if 'hmid' not in data.keys():
return PARAMS_MISS
logger.debug("update hotmessage data is %s", data)
hmid = data.get('hmid')
# HMSkipType = data.get('hmskiptype')
# HMdisplaytype = data.get("hmdisplaytype")
# if str(HMdisplaytype) not in self.hotmessage_display_type:
# raise SYSTEM_ERROR(u'HMdisplaytype参数错误')
hot = {
"HMid": data.get("hmid"),
"HMtext": data.get("hmtext"),
# "HMcontent": data.get("hmcontent"),
"HMstarttime": get_db_time_str(data.get("hmstarttime")),
"HMsort": data.get("hmsort"),
# "HMSkipType": HMSkipType
# "HMdisplaytype": HMdisplaytype
}
hot = {k: v for k, v in hot.items() if v not in self.empty}
if data.get("hmendtime"):
hot["HMendtime"] = get_db_time_str(data.get("hmendtime"))
if data.get('HMisdelete'):
hot['HMisdelete'] = True
from WeiDian.models.model import HotMessage
filter_change = {HotMessage.HMid == hmid}
hostmessage_change = self.s_hotmessage.get_hotmessage_by_filter(
filter_change)
if not hostmessage_change:
raise SYSTEM_ERROR(u'热文不存在')
# for key in self.hostmessage_update_key:
# if data.get(str(key).lower()):
# hot[key] = data.get(str(key))
if data.get("hmsort"):
filter_changed = {HotMessage.HMsort == data.get("hmsort")}
hostmessage_changeed = self.s_hotmessage.get_hotmessage_by_filter(
filter_changed)
if hostmessage_changeed:
self.s_hotmessage.update_hot_by_hmid(
hostmessage_changeed.HMid,
{"HMsort": hostmessage_change.HMsort})
update_info = self.s_hotmessage.update_hot_by_hmid(hmid, hot)
if not update_info:
return SYSTEM_ERROR(u'热文不存在')
response_update_hotmessage = import_status('update_hotmessage_success',
'OK')
response_update_hotmessage['data'] = {'hmid': hmid}
return response_update_hotmessage
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 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 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 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_complain_by_usid(self):
"""后台管理查看投诉记录"""
if not hasattr(request, 'user'):
raise TOKEN_ERROR() # 未登录, 或token错误
args = request.args.to_dict()
logger.debug("get complain args is %s", args)
page_size = args.get('page_size')
page_size = 10 if not page_size else int(page_size)
page_num = args.get('page_num')
page_num = 1 if not page_num else int(page_num)
try:
complain_list = self.scomplain.admin_get_all_complain(
page_size, page_num)
complain_list_length = self.scomplain.admin_get_complain_count()
from WeiDian.config.enums import complain_type
data = import_status("get_complain_success", "OK")
for complain in complain_list:
colist = str(complain.COtype).split(",")
logger.debug('get colist %s', colist)
complaintype = "，".join([complain_type.get(i) for i in colist])
logger.debug('convert complain type %s', complaintype)
complain.COtype = complaintype
user_info = self.suser.get_user_by_user_id(complain.USid)
complain.fill(user_info.USname, 'usname')
complain.COcreatetime = get_web_time_str(complain.COcreatetime)
data['data'] = complain_list
data['count'] = complain_list_length
logger.debug("get complain by usid %s", complain_list)
return data
except:
logger.exception("get complain by usid error")
raise SYSTEM_ERROR(u'获取数据错误')
def add_one(self):
"""添加一个轮播图, 需要管理员的登录状态"""
if not hasattr(request, 'user'):
return TOKEN_ERROR # 未登录, 或token错误
if not is_admin():
return AUTHORITY_ERROR # 权限不足
data = request.json
now_time = datetime.strftime(datetime.now(), format_for_db)
rbstarttime = data.get('rbstarttime', now_time) # 轮播 开始时间
rbstarttime_str_to_time = datetime.strptime(rbstarttime, format_for_db)
one_days_later = datetime.strftime(
rbstarttime_str_to_time + timedelta(days=1), format_for_db)
rbentime = data.get('rbendtime', one_days_later) # 轮播结束时间, 默认1天以后
rbid = str(uuid.uuid1())
rbimage = data.get('rbimage')
rbsort = data.get('rbsort')
prid = data.get('prid')
if not rbimage or not prid:
return PARAMS_MISS
if not self.sproduct.get_product_by_prid(prid):
return SYSTEM_ERROR("缺少对应的商品id")
add_model(
'RecommendBanner', **{
'RBid': rbid,
'RBimage': rbimage,
'RRid': prid,
'RBstarttime': rbstarttime,
'RBendtime': rbentime,
'RBsort': rbsort
})
response_make_banner = import_status('add_recommendbanner_success',
'OK')
response_make_banner['data'] = {'rbid': rbid}
return response_make_banner
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 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 fill_productinfo(self, prlike):
prid = prlike.PRid
prlike.productinfo = self.sproduct.get_product_by_prid(prid)
if not prlike.productinfo:
raise SYSTEM_ERROR(u'无此收藏商品')
prlike.productinfo.fields = ['PRmainpic', 'PRsalestatus']
prlike.add('productinfo')
return prlike
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 _verify_cardnum(self, num, error='ignore'):
"""获取所属行"""
bank_url = 'https://ccdcapi.alipay.com/validateAndCacheCardInfo.json?cardNo={}&cardBinCheck=true'
url = bank_url.format(num)
response = requests.get(url).json()
bank = response.get('bank')
if not bank and error != 'ignore':
raise SYSTEM_ERROR(u'卡号无效')
return bank
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 add_image(self):
if not is_admin():
return AUTHORITY_ERROR(u"权限不足")
# parameter_required(*self.add_image_params)
data = request.json
adimage_list_web = data.get("adimage", [])
if not adimage_list_web:
raise PARAMS_MISS('adimage')
for adimage_web in adimage_list_web:
aitype = int(adimage_web.get("aitype"))
if not adimage_web.get("aiimage") or not (0 <= aitype < 15):
continue
adimage = {
'AIimage': adimage_web.get("aiimage"),
'AItype': adimage_web.get("aitype"),
'AIsize': adimage_web.get("aisize"),
'ACid': adimage_web.get("acid"),
}
adimage_list = self.sadimage.get_image_by_aitype(aitype)
if aitype != 10:
if adimage_list:
update_result = self.sadimage.update_image(
adimage_list[0].AIid, adimage)
if not update_result:
raise SYSTEM_ERROR(u"数据更新异常")
else:
adimage['AIid'] = str(uuid.uuid1())
self.sadimage.add_model("AdImage", **adimage)
else:
if len(adimage_list) == 3:
adimage['AIcreatetime'] = get_db_time_str()
update_result = self.sadimage.update_image(
adimage_list[1].AIid, adimage)
if not update_result:
raise SYSTEM_ERROR(u"数据更新异常")
else:
adimage['AIid'] = str(uuid.uuid1())
self.sadimage.add_model("AdImage", **adimage)
return import_status('save_photo_success', 'OK')
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 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 get_all_task_level(self):
if not is_admin():
raise AUTHORITY_ERROR(u"未登录")
try:
task_level_list = self.stask.get_task_level_all()
map(self.fill_reward, task_level_list)
response = import_status('get_task_success', 'OK')
response['data'] = task_level_list
except:
logger.exception('get all task level error')
raise SYSTEM_ERROR(u"服务器繁忙")
return response
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')
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 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 get_exist_tags(self):
if not is_admin():
raise AUTHORITY_ERROR(u'非管理员权限')
args = request.args.to_dict()
logger.debug("get tags args is %s", args)
try:
tags_list = self.stags.get_exist_tags()
logger.info("try to get tags")
response = import_status("messages_get_item_ok", "OK")
response['data'] = {"tags_list": tags_list}
return response
except Exception as e:
logger.exception("get exist tags error")
raise SYSTEM_ERROR(u"数据错误")
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 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")
def update_searchfield(self):
if not hasattr(request, 'user'):
return TOKEN_ERROR # 未登录, 或token错误
if not is_admin():
return AUTHORITY_ERROR # 权限不足
data = request.json
if not 'sfid' in data.keys():
return PARAMS_MISS
sfid = data.pop('sfid')
res = self.s_searchfield.update_searchfield(sfid, **data)
if not res:
return SYSTEM_ERROR('字段不存在')
response_update_searchfield = import_status('update_searchfield_success', 'OK')
response_update_searchfield['data'] = {'sfid': sfid}
return response_update_searchfield
def del_one(self):
if not hasattr(request, 'user'):
return TOKEN_ERROR # 未登录, 或token错误
if not is_admin():
return AUTHORITY_ERROR # 权限不足
data = request.json
rbid = data.get('rbid')
if not rbid:
return PARAMS_MISS
if not self.srecommendbanner.del_banner(rbid):
return SYSTEM_ERROR("轮播图不存在")
response_make_banner = import_status('del_recommendbanner_success',
'OK')
response_make_banner['data'] = {'rbid': rbid}
return response_make_banner
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 verify_inforcode(self):
if not hasattr(request, 'user'):
return TOKEN_ERROR(u"未登录, 或token错误")
data = request.json
user = self.suser.get_user_by_user_id(request.user.id)
codeinfo = self.smycenter.get_inforcode_by_usphone(user.USphone)
if not codeinfo:
return SYSTEM_ERROR(u"用户验证信息错误")
iccode = data.get("ICcode")
verifystatus = True if iccode == codeinfo.ICcode else False
verifymessage = u"验证码正确" if verifystatus is True else u"验证码错误"
response = import_status("verify_inforcode_access", "OK")
response["data"] = {
"verifystatus": verifystatus,
"verifymessage": verifymessage
}
return response
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')
