def upload_file(request):
try:
file = request.FILES.get('file')
name = file.name
name_re = re.compile('(.png|.jpg)$', flags=re.IGNORECASE)
img_type = name_re.search(name).group()
if img_type:
img = bytes()
for chunk in file.chunks():
img += chunk
riven_data = riven_property_ocr(img)
return restful.ok(data=riven_data)
else:
return restful.parameters_error('请上传正确的格式的图片，只接受PNG与JPG图片。')
except:
return restful.server_error('图片识别失败')
def get(self): # 对应ajax，此处仅用get
email = request.args.get('email')
# 验证邮箱地址是否合法
pattern = re.compile(r'^[0-9a-zA-Z_]{5,19}@[0-9a-zA-Z]{1,13}\.')
# 使用re库的match方法校验传入的邮箱参数是否合理,是否与表达式匹配
if re.match(pattern, email) is not None:
# if pattern.match(email):
# 发送验证码邮件
captcha = email_captcha.generate_code(4)
msg = Message("cms验证码邮件",
recipients=[email],
body="您的验证码是：%s" % captcha)
try:
mail.send(msg)
except:
return restful.server_error()
# 存储验证码到Redis，以及设置验证码过期时间
cache_redis.captcha_set(email, captcha)
return restful.success()
else:
return restful.bad_request_error("邮箱地址错误")
def ubanners():
form = AddBannerForm(request.form)
if form.validate():
name = form.name.data
image_url = form.image_url.data
link_url = form.link_url.data
priority = form.priority.data
id = form.id.data
banner = BannerModel.query.get(id)
if banner:
banner.name = name
banner.image_url = image_url
banner.link_url = link_url
banner.priority = priority
db.session.commit()
return restful.success('轮播图信息修改成功！')
else:
return restful.server_error('没有这个轮播图')
else:
return restful.params_error(form.get_error())
def email_captcha():
# /email_capthca/[email protected]
email = request.args.get('email')
if not email:
return restful.params_error('请传递邮箱参数！')
# source.extend(["0","1","2","3","4","5","6","7","8","9"])
source = list(string.ascii_letters)
source.extend(map(lambda x: str(x), range(0, 10)))
captcha = "".join(random.sample(source, 6))
# 给这个邮箱发送邮件
message = Message('智慧菜谱邮箱验证码',
recipients=[email],
body='您的验证码是：%s' % captcha)
try:
mail.send(message)
except:
return restful.server_error()
zlcache.set(email, captcha)
return restful.success()
def add_rank(request):
form = AddRankForm(request.POST)
if form.is_valid():
nickname = request.POST.get('nickname')
game_name = request.POST.get('game_name')
duration = request.POST.get('duration')
duration = time_format.split_time(duration)
platform = request.POST.get('platform')
# if platform.isdigit():
# platform = int(platform) # 这么写太low了
platform = int(platform) if platform.isdigit() else 0
try:
Rank.objects.create(nickname=nickname,
game_name=game_name,
duration=duration,
platform=platform)
return restful.ok()
except:
return restful.server_error(message='添加排行失败，服务器内部错误')
else:
return restful.params_error(message=form.get_errors())
def email_captcha():
email = request.args.get('email')
validate_res = validate_email(email)
if not validate_res['flag']:
return restful.params_error(message=validate_res['message'])
source = list(string.ascii_lowercase) + list(string.digits)
captcha = "".join(random.sample(source, 6))
try:
send_email()
my_redis.set(email,
subject='CMS系统修改邮箱验证码',
template='email/change_email',
captcha=captcha,
user=current_user,
ex=300)
print('生成的验证码', captcha)
except Exception:
return restful.server_error()
return restful.success(message="邮件发送成功请注意查收！")
def login_view(request):
form = LoginForm(request.POST)
if form.is_valid():
telephone = form.cleaned_data.get('telephone')
password = form.cleaned_data.get('password')
remember = form.cleaned_data.get('remember')
user = authenticate(request,telephone=telephone,password=password)
if user:
if user.is_active:
login(request, user)
if remember:
request.session.set_expiry(None)
else:
request.session.set_expiry(0)
return restful.ok()
else:
return restful.unauth(message="您的账号已被冻结")
else:
return restful.params_error(message="您的手机号或密码错误")
else:
errors = form.get_errors()
return restful.server_error(message=errors)
def delete_(self):
chat_id = self.request_data.get('chat_id')
if not chat_id:
self.result = params_error()
return
chat_obj = self.check_chat(chat_id)
if not chat_obj:
return
if not self.user_obj:
return
# 判断当前聊天是否属于该用户
if chat_obj.user_id != self.user_id:
self.result = unauth_error('用户无权限')
return
db.session.delete(chat_obj)
if not self.commit():
self.result = server_error('删除异常')
self.result = success()
def index(request):
if request.method == 'GET':
if request.user.is_authenticated:
return render(request, 'riven/riven_mygoods.html')
else:
return redirect(reverse('rivenmarket:index'))
else:
if request.user.is_authenticated:
try:
wfuser = request.user
rivens = Riven.objects.filter(seller_id=wfuser.uid,
is_sell__in=[
SellState.IS_SELL.value,
SellState.IS_AUDIT.value
]).order_by('-pub_time')
riven_serializer = RivenSerializer(rivens, many=True)
return restful.ok(data=riven_serializer.data)
except:
return restful.server_error('加载失败')
else:
return restful.authority_error('请先登录')
def email_captcha():
email = request.args.get("email")
if not email:
return restful.param_error(message="请传递参数")
source = list(string.ascii_letters)
source.extend([str(i) for i in range(10)])
captcha = "".join(random.sample(source, 6))
# 缓存验证码
cache.set(email, captcha)
msg = Message("flask测试验证码", recipients=[email])
msg.body = 'captcha: %s' % captcha
try:
th = Thread(target=send_email.send_email_async, args=[msg])
# mail.send(msg)
th.start()
th.join()
except:
return restful.server_error("服务器开小差了")
return restful.success()
def get_(self):
""" 获取群组信息 """
user_obj = self.check_user()
if not user_obj:
return
# 若群组ID存在，则只取出该群组信息
group_id = self.request_data.get('group_id')
print('..........group_id', group_id)
if group_id:
print(group_id)
group_obj = self.check_group(group_id)
if not group_obj:
return
self.result = success(data=group_obj.to_json())
return
# 如果用户为站长，则返回所有群组信息
if user_obj.type == 0:
group_query = self.filter_all(Group, '群组信息获取异常')
# 否则先从群组成员表，获取包含自己的群组ID，通过群组ID获取所在的群组
else:
group_user = self.query_(GroupsToUser, {'user_id': self.user_id},
'群组成员获取异常')
group_ids = [group.group_id for group in group_user]
try:
group_query = Group.query.filter(Group.id.in_(group_ids))
except Exception as e:
current_app.logger(e)
self.result = server_error(message='群组信息查询异常')
return
# 分页
#group_obj = group_query.paginate(page=page, per_page=page_size, error_out=False)
# 对象转换成列表
group_list = [group.to_json() for group in group_query]
self.result = success(data=group_list)
def upload_logo():
""" 上传头像 """
# 获取图片
print('upload..................')
file = request.files.get('file')
print('file..', file)
content_type = file.content_type
if content_type != 'image/jpeg':
return jsonify(params_error(message='文件类型不正确'))
# 生成图片名称
image_name = str(uuid.uuid1()) + '.' + file.filename.split('.')[-1]
image_path = '/static/logo/%s' % image_name
try:
with open('app' + image_path, 'wb') as f:
f.write(file.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(server_error(message='上传失败'))
ci = CutImage('app' + image_path, 'app' + image_path)
ci.cut()
return jsonify(success(data={'url': image_path}))
def upload_imges():
global rate
rate = 0
count = request.form.get('count')
album_id = request.form.get('album_id')
album = AlbumModel.query.get(album_id)
if count and album_id:
for i in range(0, int(count)):
file = request.files[str(i)]
file_name = secure_filename(
change_filename(file.filename) + uuid.uuid4().hex[:10] + '')
bucket.put_object('images/' + file_name + '.jpg',
file,
progress_callback=percentage)
image = ImagesModel(url=base_images_url + file_name + '.jpg',
album_id=album_id)
if album.author == g.front_user:
rate = 0
db.session.add(image)
db.session.commit()
return restful.success()
else:
return restful.server_error()
def send_email():
email = request.args.get('email')
if email:
strnum = list(string.ascii_letters)
num = map(lambda x:str(x),range(10))
strnum.extend(num)
captche = "".join(random.sample(strnum,6))
try:
send_mail.delay('Python论坛邮箱验证码', [email], '您的验证码是：%s' % captche)
redis.set(email, captche, 120)
return restful.success('邮件发送成功！')
except Exception as e:
return restful.server_error(str(e))
# message = Message('后台邮箱验证码',body='你的验证码是：'+captche,recipients=[email])
# try:
# mail.send(message)
# redis.set(email,captche,120)
# return restful.success('邮件发送成功！')
# except Exception as e:
# return restful.server_error(str(e))
# pass
else:
return restful.params_error('请输入邮箱地址！')
def send_captcha():
email = request.args.get('email')
ret = re.match(r'^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$',
email)
user = UserModel.query.filter_by(email=email).first()
if user:
return restful.params_error(message='邮箱已经存在')
if ret:
E = list(string.ascii_letters)
E.extend(map(lambda x: str(x), range(0, 10)))
cap = ''.join(random.sample(E, 4))
text = f'您的验证码是：\n {cap} \n打死也别告诉别人哦~~\n有效期为5分钟'
print(email, cap, text)
try:
send_mail.delay([email], '注册验证码', text)
except:
return restful.server_error()
cache.set(email, cap, ex=300)
return restful.success()
else:
return restful.params_error("邮箱格式错误！")
def sendmail_captcha():
email = request.args.get('email')
if not email:
return restful.params_error('请传递邮箱参数！')
captcha = list(string.ascii_letters)
# 获得a-zA-Z的字符串 列表
captcha_num = map(lambda x: str(x), range(0, 10))
# 获得0-9的数字 的列表
captcha.extend(captcha_num)
# 列表的一个方法，使得列表之间能够继承
# print("".join(captcha))
# 结合完毕，剩下就是随机打印出6个不同的字符串和数字了
result_captcha = random.sample(captcha, 6)
result_captcha = "".join(result_captcha)
print(result_captcha)
message = Message("bbs论坛验证码", recipients=[email],
body="关于您更改默认邮箱，我们向您发送了一条邮箱验证码，邮箱验证码为%s ，如果不是本人操作，请自觉忽略" % result_captcha)
try:
send_mail.delay('知了论坛邮箱验证码', recipients=[email], body='你的验证码是：%s' % captcha)
except:
return restful.server_error()
zlcache.set(email, captcha) # 添加验证码缓存
return restful.success()
def write_self_msg(request):
msg = request.POST.get('msg')
riven_id = request.POST.get('riven_id')
gfw = DFAFilter()
path = paths.get_path(f'sensitive_words.txt')
gfw.parse(path)
msg = gfw.filter(msg)
wfuser = request.user
if wfuser.is_authenticated:
if wfuser.game_name is not None:
try:
RivenMsg.objects.create(content=msg,
view_state=True,
riven_id=riven_id,
writer=wfuser)
return restful.ok('留言成功')
except:
return restful.server_error('发表留言失败，请稍后再试。')
else:
return restful.authority_error('需要通过审核游戏ID后才能留言。')
else:
return restful.authority_error('请登录后留言')
def check_group(self, group_id):
""" 检查群组是否存在 """
# 获取用户信息
user_obj = self.check_user()
if not user_obj:
return
# 判断用户是否在群组中
group_user = self.check_group_user(self.user_id, group_id)
if not group_user and user_obj.type != 0:
self.result = unauth_error(message='权限异常')
return
try:
group_obj = Group.query.get(group_id)
except Exception as e:
current_app.logger.error(e)
self.result = server_error(message='群组查询异常')
return
if not group_obj:
self.result = unauth_error(message='群组不存在')
return
return group_obj
def post(self):
form = ClassScheduleForm(request.form)
if form.validate():
startDate = form.startDate.data
studentID = form.studentID.data
password = form.password.data
# classCaptcha = form.classCaptcha.data
print(startDate, studentID, password)
# 爬取内容
spider = ZhengfangSpider(studentNum=studentID, password=password)
spider.login()
page_content = spider.getClassSchedule()
# 解析并存储
collection = mongo.db.flask
user_tel = g.front_user.telephone
# 构造html解析器
parser = etree.HTMLParser(encoding='utf-8')
html = etree.HTML(page_content, parser=parser)
# 获取课程信息所在td标签
tds = html.xpath("//tr[position()>2]/td[@align='Center']//text()")
if len(tds) == 0:
# raise ValueError('get classSchedule fail')
return restful.server_error(message='爬取或解析课表过程出错')
# 取出列表中无用杂项
for i in range(0, tds.count('\xa0')):
tds.remove('\xa0')
# print(tds)
def saveLessons(times, name):
'''saveLessons
获取课程信息，并将其存入mongoDB数据库
:param times: [list] 课程时间列表，包含一节课的周次、每周周几、一天第几节
e.g. ('week1', 'day1', 1)
:param name: [str] 课程名称，e.g. 机器人视觉@南B309
:return: result [boolean] True: 保存成功， False: 保存失败
'''
for time in times:
# time : e.g. ('week1', 'day1', 1)
weekClass = collection.find_one({'user_tel': user_tel, 'week': time[0]})
if not weekClass:
# 该周信息尚未登记
new_weekClass = {
'user_tel': user_tel,
'week': time[0],
'day1': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'day2': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'day3': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'day4': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'day5': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'day6': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'day7': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
}
new_weekClass[time[1]][time[2] - 1] = name
try:
collection.insert_one(new_weekClass).inserted_id
except:
print('save fail when {}, with the document does not exist before'.format(str(time)))
return False
else:
day = weekClass[time[1]]
day[time[2] - 1] = name
try:
collection.update_one({
'user_tel': user_tel,
'week': time[0],
},
{'$set': {time[1]: day}}
)
except:
print('save fail when {}, with the document exist before'.format(str(time)))
return False
return True
# 存放课表信息
index = 0
while index < len(tds):
singleLesson = Lesson(name=tds[index], type=tds[index + 1], time=tds[index + 2], teacher=tds[index + 3], address=tds[index + 4])
# print(singleLesson)
if saveLessons(singleLesson.getTime(), singleLesson.getName() + '@' + singleLesson.getAddress()):
index += 5
else:
print('save fail in loop')
return restful.server_error(message='存入数据库时发生错误')
def saveWeekCalibration():
# 存放开学第一周是本年度第几周
firstWeek = collection.find_one({
'user_tel': user_tel,
'type': 'weekCalibration'
})
if not firstWeek:
# 尚未记录
new_firstWeek = {
'user_tel': user_tel,
'type': 'weekCalibration',
'firstWeek': startDate
}
try:
collection.insert_one(new_firstWeek).inserted_id
except:
print('save fail with firstweek, with the document does not exist before')
return False
else:
try:
a = collection.update_one({
'user_tel': user_tel,
'type': 'weekCalibration',
},
{'$set': {'firstWeek': startDate}}
)
except:
print('save fail with firstweek, with the document exist before')
return False
return True
# 标定第一周
if not saveWeekCalibration():
return restful.server_error(message='第一周标定失败')
return restful.success()
else:
return restful.params_error(message=form.get_error())
def index(request):
if request.method == 'GET':
return render(request, 'riven/riven_market.html')
else:
try:
count = int(ONE_PAGE_RIVEN_COUNT) # 一次性加载count数量的紫卡
# [0:count]切片操作,选取从索引为0到索引为count的紫卡信息
rivens = Riven.objects.filter(is_sell=Riven.IS_SELL)
rivens = rivens.order_by('-pub_time')[0:count]
rivens_serializer = RivenSerializer(
rivens, many=True) # 序列化,其中many=True表示rivenes有很多数据需要序列化
all_name = Riven.objects.values(
'riven_name').distinct() # 获取所有不重复的紫卡名
all_name = list(all_name) # 不重复紫卡名列表
name_set = set()
for item in all_name:
name_set.add(item['riven_name'])
all_name = list(name_set)
if request.user.is_authenticated:
wfuser = request.user
my_rivens = Riven.objects.filter(seller=wfuser) # 查找我的紫卡
# 我的紫卡id列表
my_rivens_list = []
for riven in my_rivens:
my_rivens_list.append({'id': riven.id})
my_collector_rivens = wfuser.collector_wfuser.all() # 查找我的收藏
# 我的收藏id列表
my_collector_list = []
for my_collector_riven in my_collector_rivens:
my_collector_list.append({
'riven': my_collector_riven.id,
'collector': wfuser.uid,
})
data = {
'all_name': all_name,
'rivens': rivens_serializer.data,
'collections': my_collector_list,
'my_rivens': my_rivens_list,
}
return restful.ok(data=data)
else:
data = {
'all_name': all_name,
'rivens': rivens_serializer.data,
'collections': [],
'my_rivens': [],
}
return restful.ok(data=data)
except Exception:
print(Exception)
return restful.server_error('服务器未知错误')
def riven_new_list(request):
# 通过p参数,来指定获取第几页的数据,并且p参数是通过查询字符串的方式传过来的/rivenmarket/searchRivenView/?p=1,
# 如果没有传递p参数,默认为1
try:
page = int(request.GET.get('p', 1))
count = int(ONE_PAGE_RIVEN_COUNT)
start = (page - 1) * count
end = start + count
riven_name = request.GET.get('riven_name')
riven_mode = request.GET.get('riven_mode')
if riven_name != '':
if riven_mode == '时间':
# [0:count]切片操作,选取从索引为0到索引为count的紫卡信息
rivens = Riven.objects.filter(
riven_name=riven_name,
is_sell=True).order_by('-pub_time')[start:end]
elif riven_mode == '热度':
rivens = Riven.objects.annotate(riven_count=Count('collector'))
rivens = rivens.filter(
riven_name=riven_name,
is_sell=True).order_by('-riven_count')[start:end]
elif riven_mode == '价格':
rivens = Riven.objects.filter(
riven_name=riven_name,
is_sell=True).order_by('price')[start:end]
else:
rivens = {}
else:
if riven_mode == '时间':
# [0:count]切片操作,选取从索引为0到索引为count的紫卡信息
rivens = Riven.objects.filter(
is_sell=True).order_by('-pub_time')[start:end]
elif riven_mode == '热度':
rivens = Riven.objects.annotate(riven_count=Count('collector'))
rivens = rivens.filter(
is_sell=True).order_by('-riven_count')[start:end]
elif riven_mode == '价格':
rivens = Riven.objects.filter(
is_sell=True).order_by('price')[start:end]
else:
rivens = {}
# 序列化,其中many=True表示rivenes有很多数据需要序列化
rivens_serializer = RivenSerializer(rivens, many=True)
if request.user.is_authenticated:
wfuser = request.user
my_rivens = Riven.objects.filter(seller=wfuser)
my_rivens_list = []
for riven in my_rivens:
my_rivens_list.append({'id': riven.id})
my_collector_rivens = wfuser.collector_wfuser.all()
my_collector_list = []
for my_collector_riven in my_collector_rivens:
my_collector_list.append({
'riven': my_collector_riven.id,
'collector': wfuser.uid,
})
data = {
'rivens': rivens_serializer.data,
'collections': my_collector_list,
'my_rivens': my_rivens_list,
}
return restful.ok(data=data)
else:
data = {
'rivens': rivens_serializer.data,
'collections': [],
'my_rivens': [],
}
return restful.ok(data=data)
except:
return restful.server_error('服务器查询失败，请稍后再试')
def login():
"""
用户登录
用户名、 密码
:return:
"""
#index_url = url_for('.index', _external=True)
#if session.get('id'):
# return redirect(index_url)
#if request.method == 'GET':
# return render_template('login.html')
# 获取用户传输数据
request_data = request.json
username = request_data.get('username')
password = request_data.get('password')
if not all([username, password]):
#return render_template('login.html', message='缺少必要参数')
return jsonify(params_error(message='缺少必要参数'))
# 获取用户登录IP
user_ip = request.remote_addr
try:
access_nums = redis_store.get('access_num_%s' % user_ip)
except Exception as e:
current_app.logger.error(e)
else:
if access_nums and int(access_nums) >= 5:
#return render_template('login.html', message='错误次数过多，请稍后重试')
return jsonify(unauth_error(message='错误次数过多，请稍后重试'))
# 从数据库查询用户对象
try:
user_obj = User.query.filter_by(username=username).first()
except Exception as e:
current_app.logger.error(e)
#return render_template('login.html', message='获取用户信息失败')
return jsonify(server_error(message='获取用户信息失败'))
# 取出用户密码与数据库密码对比
if not user_obj or not user_obj.check_password(password):
# 如果用户不存在或者用户密码不正确，返回错误消息，并记录错误次数
try:
# redis的incr可以对字符串类型数据进行加1操作，如果数据开始不存在，则默认设置为1
redis_store.incr('access_num_%s' % user_ip)
redis_store.expire('access_num_%s' % user_ip, 600) # 数据保存600秒
except Exception as e:
current_app.logger.error(e)
#return render_template('login.html', message='用户名或密码错误')
return jsonify(unauth_error(message='用户名或密码错误'))
# 登录成功
session['username'] = username
session['nickname'] = user_obj.nickname
session['id'] = user_obj.id
# 更改用户在线状态
user_obj.state = 1
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
#return render_template('login.html', message='登录异常')
return jsonify(server_error('登录异常'))
#return redirect(index_url)
return jsonify(success(data=user_obj.to_dict(), message='用户登录成功'))
def upload_file(request):
try:
file = request.FILES.get('file')
name = file.name
name_re = re.compile('(.png|.jpg)$', flags=re.IGNORECASE)
if name_re.search(name):
wfuser = request.user
user_game, judge = WfUserGame.objects.get_or_create(wfuser=wfuser)
if judge:
img_name = f'{wfuser.username}+{wfuser.uid}{name_re.search(name).group()}'
if os.path.exists(paths.get_path(
f'media/wfusers/{wfuser.uid}')) is False:
os.makedirs(paths.get_path(f'media/wfusers/{wfuser.uid}'))
with open(
paths.get_path(
f'media/wfusers/{wfuser.uid}/{img_name}'),
'wb') as imgfp:
for chunk in file.chunks():
imgfp.write(chunk)
user_game.first_img = f'/media/wfusers/{wfuser.uid}/{img_name}'
user_game.game_status = WfUserGame.AUDIT_STATUS
user_game.save()
add_img_thread = threading.Thread(target=add_wfuser_gamename,
args=(wfuser, user_game))
add_img_thread.start()
return restful.ok('后台以开始审核，请注意查看状态。')
else:
img_dict = user_game.other_imgs
if img_dict:
num = len(img_dict) + 1
img_name = f'{wfuser.username}+{wfuser.uid}_{num}{name_re.search(name).group()}'
if os.path.exists(
paths.get_path(
f'media/wfusers/{wfuser.uid}')) is False:
os.makedirs(
paths.get_path(f'media/wfusers/{wfuser.uid}'))
with open(
paths.get_path(
f'media/wfusers/{wfuser.uid}/{img_name}'),
'wb') as imgfp:
for chunk in file.chunks():
imgfp.write(chunk)
img_dict[
f'{num}'] = f'/media/wfusers/{wfuser.uid}/{img_name}'
user_game.game_status = WfUserGame.MANUAL_STATUS
user_game.save()
wfuser.game_name = None
wfuser.save()
return restful.ok('后台已开始审核，请注意查看状态。')
else:
img_name = f'{wfuser.username}+{wfuser.uid}_1{name_re.search(name).group()}'
if os.path.exists(
paths.get_path(
f'media/wfusers/{wfuser.uid}')) is False:
os.makedirs(
paths.get_path(f'media/wfusers/{wfuser.uid}'))
with open(
paths.get_path(
f'media/wfusers/{wfuser.uid}/{img_name}'),
'wb') as imgfp:
for chunk in file.chunks():
imgfp.write(chunk)
img_dict['1'] = f'/media/wfusers/{wfuser.uid}/{img_name}'
user_game.game_status = WfUserGame.MANUAL_STATUS
user_game.save()
wfuser.game_name = None
wfuser.save()
return restful.ok('后台已开始审核，请注意查看状态。')
else:
return restful.parameters_error('请上传正确的格式的图片，后台只接受PNG与JPG图片。')
except:
return restful.server_error('服务器处理请求失败，请稍后再试。')
def post(self, request):
try:
logout(request)
return restful.ok(message='注销成功。')
except:
return restful.server_error('注销失败，请稍后再试。')
def internal_server_error(e):
if request.accept_mimetypes.accept_json and \
not request.accept_mimetypes.accept_html:
return restful.server_error()
return render_template('errors/front_500.html'), 500
