def get(self):
args = reset_parser.parse_args()
phone = args.get('phone')
imageCode = args.get('imageCode').replace('\n', '').replace('\r', '')
current_app.logger.info(imageCode)
print(imageCode, '----', type(imageCode))
code = session.get('imageCode')
print(code, '----', type(code))
if code and imageCode.lower() == code.lower():
print(111)
user = User.query.filter(User.phone == phone).first()
if user:
result, smscode = send_message(phone)
current_app.logger.info(result)
if result['statusCode'] == '000000':
# current_app.logger.info(result)
cache.set(phone, smscode, timeout=1000)
return jsonify(code=200, msg='发送成功')
else:
current_app.logger.error(result)
return jsonify(code=400, msg='发送失败')
else:
return jsonify(code=400, msg='用户名不存在')
else:
return jsonify(code=400, msg='验证码有误')
def my_before_request():
'''用户权限验证'''
# 查询网站底部信息，先从缓存中取，无则在数据库中查找，并更新缓存
g.bottom_info = cache.get('bottom_info')
if not g.bottom_info:
try:
bottom_info = BottomInfoModel.query.filter().first()
g.bottom_info = bottom_info
cache.set('bottom_info', bottom_info,
timeout=60 * 60 * 24) # 更新缓存，1天
except:
g.bottom_info = None
# 尝试获取用户id
uid = session.get('uid')
try:
user = UserModel.query.get(uid)
g.user = user # 使用g对象存储用户，这样哪个页面都能用了
except:
# 查询数据库出错
g.user = user = None
# 未登录，不能访问
if request.path in required_login_path and not user:
return redirect(url_for('user.login'))
# 已登录，不能访问
if request.path in login_not_path and user:
return redirect(url_for('main.index'))
# 不是管理员不能访问
if re.search(r'^/admin.*', request.path):
if not user or user.is_admin != 1: # 未登录或普通用户
return abort(404) # 抛出404错误，避免被发现后台管理路径
def post(self):
args = lr_parser.parse_args()
mobile = args.get('mobile')
code = args.get('code')
cache_code = cache.get(mobile)
print('code:', code)
print('cache_code:', cache_code)
if cache_code and code == cache_code:
# 数据库中查找是否存在此mobile
user = User.query.filter(User.phone == mobile).first()
# 列表中是否存在用户
if not user:
# 注册处理
user = User()
user.phone = mobile
s = ''
for i in range(13):
ran = random.randint(0, 9)
s += str(ran)
user.username = '******' + s
db.session.add(user)
db.session.commit()
#
# 登录处理，记录登录状态：session，cookie，cache（redis）
cache.set(mobile + "_", 1)
return marshal(user, user_fields) # 输出的内容
else:
return {'errmsg': '验证码错误', 'status': 400}
def send_email_code():
'''发送动态验证码'''
form = SendEmailCodeForm()
if request.method == 'POST' and form.validate_on_submit():
# 接收邮箱号
email = form.email.data
# 判断缓存是否有值，有：表单重复提交
if cache.get(email) == 1:
# 重复提交表单处理
return render_template('user/send_email_code.html',
form=form,
is_send_mail=1)
# 生成随机动态验证码，保存到session
email_code = str(random.randint(1000, 999999)) # 4~6位验证码，转为str发送邮件
# 保存到session，邮箱也要保存到session
session['email_code'] = email_code
session['email'] = email
# 发送动态验证码
send_mail_code(email=email, email_code=email_code)
is_send_mail = 1 # 标记动态验证码发送成功，用来返回给前端
# 防止重复提交：设置一唯一个标志，放入缓存
cache.set(email, 1, timeout=10)
return render_template('user/send_email_code.html',
form=form,
is_send_mail=is_send_mail)
return render_template('user/send_email_code.html', form=form)
def post(self):
args = lr_parser.parse_args()
mobile = args.get('mobile')
code = args.get('code')
cache_code = cache.get(mobile)
if cache_code and code == cache_code:
# if code == '1234':
# 数据库中查找是否存在此mobile用户
user = User.query.filter(User.phone == mobile).first()
if not user: # 无用户
# 注册处理
user = User()
user.phone = mobile
s = ''
for i in range(10):
ran = random.randint(0, 9)
s += str(ran)
user.username = '******' + s
db.session.add(user)
db.session.commit()
# 登录处理 记录登录状态：session(一个用户一个session)，cookie，cache(redis所有用户用一个大池子)，token
token = str(uuid.uuid4()).replace('-', '') + str(
random.randint(100, 999))
# print('token:', token)
# 存储用户的登录信息
cache.set(token, mobile)
return marshal(user, user_fields) # 用装饰器则上下需返回一样格式的内容
# return {'status': 200, 'msg': '用户登录成功', 'token': token}
else:
return {'errmsg': '验证码错误', 'status': 400}
def post(self):
args = lr_parser.parse_args()
mobile = args.get('mobile')
code = args.get('code')
cache_code = cache.get(mobile)
print('code:', code)
print('cache_code:', cache_code)
if cache_code and code == cache_code:
# 数据库中查找是否存在此mobile
user = User.query.filter(User.phone == mobile).first()
# 列表中是否存在用户
if not user:
# 注册处理
user = User()
user.phone = mobile
s = ''
for i in range(13):
ran = random.randint(0, 9)
s += str(ran)
user.username = '******' + s
db.session.add(user)
db.session.commit()
#
# 登录处理，记录登录状态：session，cookie，cache（redis），token，JWT
# 说明用户是登录成功的 dfjkdj-hdfjhsd34-sdjf83748-3847fnmm
token = str(uuid.uuid4()).replace('-', '') + str(
random.randint(100, 999))
print('token:', token)
# 存储用户的登录信息
cache.set(token, mobile)
return {'status': 200, 'msg': '用户登录成功', 'token': token}
else:
return {'errmsg': '验证码错误', 'status': 400}
def post(self):
args = lor_parser.parse_args()
phone = args.get('phone')
code = args.get('code')
print(type(code), phone)
cache_code = cache.get(phone)
print(cache_code, type(cache_code))
if cache_code and code == str(cache_code):
user = User.query.filter(User.phone == phone).first()
if not user:
user = User()
user.phone = phone
now_time = datetime.now().strftime('%Y%m%d%H%M%S')
user.username = '******' + now_time
db.session.add(user)
db.session.commit()
token = str(uuid.uuid4())
print(token, '--------')
cache.set(token, phone)
return jsonify(code=200, msg='登录成功', token=token)
else:
return jsonify(code=400, msg='验证码错误')
def post(self):
args = password_login_parser.parse_args()
phone = args.get('phone')
password = args.get('password')
user = User.query.filter(User.phone == phone).first()
if check_password_hash(user.password, password):
token = str(uuid.uuid4())
cache.set(token, phone)
return jsonify(code=200, msg='登录成功', token=token)
else:
return jsonify(code=400, msg='登录失败')
def post(self):
args = sms_parser.parse_args()
phone = args.get('phone')
result, code = send_message(phone)
current_app.logger.info(result)
if result['statusCode'] == '000000':
cache.set(phone, code, timeout=1000)
return jsonify(code=200, msg='发送成功')
else:
current_app.logger.error(result)
return jsonify(code=400, msg='发送失败')
def send_msg():
'''发送短信验证码'''
phone = request.args.get('phone')
print(phone, '************************************')
ret, code = sms_send(phone)
cache.set(phone, code, timeout=180) # 验证码缓存到redis,（key，value， timeout）
# cache.set_many([(key, value), (key, value), ...]) # 缓存多个
# cache.get(key) # 获取, cache.get_many(key, key2, ...)
# cache.delete(key) # 删除, cache.delete_many(key, key2, ...)
# cache.clear() # 清空
return jsonify(code=200, msg='短信发送成功')
def message_board():
'''留言板'''
form = MessageBoradForm()
# get请求
try:
p = int(request.args.get('page', 1)) # 页码要为整形
except:
p = 1
# 查询数据，分页，按id降序
try:
message_list = MessageBoardModel.query.order_by(
-MessageBoardModel.id).paginate(page=p, per_page=20)
except:
return render_template('main/message_board.html', form=form)
# post请求
# 是否登录
if request.method == 'POST' and not g.user:
return render_template('main/message_board.html',
form=form,
message_list=message_list,
msg='请先登录')
# 表单验证
if request.method == 'POST' and form.validate_on_submit():
# 接收数据
content = form.content.data
# 查看缓存判断是否重复提交
if cache.get(str(g.user.id) + content + request.path) == 1:
return redirect(url_for('main.message_board'))
# 创建对象
item = MessageBoardModel()
item.content = content
item.user_id = g.user.id
# 提交数据库
try:
db.session.add(item)
db.session.commit()
# 缓存，10秒内不能重复提交，唯一标识key：用户id+内容+请求路径
cache.set(str(g.user.id) + content + request.path, 1, timeout=10)
return redirect(url_for('main.message_board'))
except:
return render_template('main/message_board.html',
form=form,
message_list=message_list,
msg='提交失败')
# get请求
return render_template('main/message_board.html',
form=form,
message_list=message_list)
def post(self):
args = password_login_parser.parse_args()
mobile = args.get('mobile')
password = args.get('password')
# 判断用户
user = User.query.filter(User.phone == mobile).first()
if user:
if check_password_hash(user.password, password):
# 说明用户是登录成功的
cache.set(mobile + '_', 1)
return {'status': 200, 'msg': '用户登录成功'}
return {'status': 400, 'msg': '账户名或者密码有误！'}
def post(self):
args = sms_parser.parse_args()
mobile = args.get('mobile')
ret, code = send_duanxin(mobile)
# 验证是否发送成功
if ret is not None:
if ret["code"] == 200:
# cache.set(key,value,timeout=second)
cache.set(mobile, code, timeout=1800)
return jsonify(code=200, msg='短信发送成功！')
else:
print("ERROR: ret.code=%s,msg=%s" % (ret['code'], ret['msg']))
return jsonify(code=400, msg='短信发送失败！')
def email_captcha():
email = request.args.get('email')
if not email:
return 'empty address', 400
captcha = ''.join(map(str, np.random.randint(0, 10, 6)))
if cache.get(email):
return 'request too frequently'
msg = Message('百团通注册验证码', recipients=[email], body='您的验证码是：%s' % captcha)
try:
mail.send(msg)
except smtplib.SMTPException:
return 'sending failed', 500
cache.set(email, captcha)
return 'success', 200
def sendmess(mobile):
r = str(int(random.random() * 10000 // 1))
text = "您的验证码是：%s。请不要把验证码泄露给其他人。" % r
ret = smssend.send_sms(text, mobile)
ret = eval(ret.decode('utf-8'))
# print(ret)
if ret is not None:
if ret["code"] == 2:
# 使用缓存 过期时间为180s
cache.set(mobile, str(r), timeout=18000)
return jsonify(code=2, msg='短信发送成功')
else:
# cache.set(mobile, str(r), timeout=18000)
return jsonify(code=0, msg='短信未发送成功')
def del_cache_():
"""
cache缓存值
:return:
"""
cache.set('name', 'xiaoming', timeout=30)
cache.set('person', {'name': 'aaa', 'age': 20})
x = cache.get('name')
print(x)
cache.set_many([('name1', 'hhh'), ('name2', 'jjj')])
print(cache.get_many("name1", "name2"))
print(cache.delete("name"))
print(cache.delete_many("name1", "name2"))
print(cache.get('person'))
return 'ok'
def post(self):
args = password_login_parser.parse_args()
mobile = args.get('mobile')
password = args.get('password')
# 判断用户
user = User.query.filter(User.phone == mobile).first()
if user:
if check_password_hash(user.password, password):
# 说明用户登录成功
token = str(uuid.uuid4()).replace('-', '') + str(
random.randint(100, 999))
# print(token)
# 存储用户的登录信息
cache.set(token, mobile)
return {'status': 200, 'msg': '用户登录成功', 'token': token}
return {'status': 400, 'msg': '账户名或者密码有误！'}
def get_pic():
# 造图片
im, s = validate_picture(4)
print('=====>s:', s)
# 将图片转成二进制的形式
buffer = BytesIO()
im.save(buffer, 'jpeg')
buf_bytes = buffer.getvalue()
# 构建response对象
response = make_response(buf_bytes)
response.headers['Content-Type'] = 'image/jpg'
# 保存s
# session['pic_code'] = s
cache.set('code_abc', s, timeout=120)
print('---------->', s)
return response
def send_message():
mobile = request.args.get('phone')
import random
r = str(int(random.random() * 10000 // 1))
text = "您的验证码是：%s。请不要把验证码泄露给其他人。" % r
ret = send_sms(text, mobile)
ret = eval(ret.decode('utf-8'))
print(ret)
if ret is not None:
if ret["code"] == 2:
# 使用缓存 过期时间为180s
# cache.set(key,value,timeout=s)
cache.set(mobile, str(r), timeout=180)
# session[ mobile ] = str(r)
return jsonify(code=2, msg='短信发送成功')
else:
return jsonify(code=0, msg='提交失败')
def get_img():
'''返回一个图形验证码'''
# 调用生成图片验证码的函数
code, yzm_img = yzm()
# 验证码保存到redis
cache.set('code', code, timeout=180)
# 创建一个缓冲区
buffer = io.BytesIO()
# 将图片保存到缓冲区
yzm_img.save(buffer, 'jpeg')
# 获取缓冲区里的二进制图片
b_img = buffer.getvalue()
# 二进制图片交给响应，响应头要改为图片类型
res = make_response(b_img)
res.headers['Content-Type'] = 'image/jpg'
return res
def bp_user_login():
data = request.get_json()
if not data and data is None:
return Tools.generate_cors_response({'code': 200, 'msg': '缺少必要参数'})
if not data.get('username'):
return Tools.generate_cors_response({'code': 200, 'msg': '请输入用户名'})
if not data.get('phone'):
return Tools.generate_cors_response({'code': 200, 'msg': '请输入手机号码'})
if not data.get('password'):
return Tools.generate_cors_response({'code': 200, 'msg': '请输入密码'})
user = User.query.filter(User.phone == data.get('phone')).first()
if user and user.username == data.get('username') and check_password_hash(
user.password, data.get('password')):
token = str(uuid.uuid4()).replace('-', '') + str(
random.randint(100, 999))
cache.set(token, data.get('phone'), timeout=6000)
return Tools.generate_cors_response({
'code': 200,
'msg': '登录成功',
'token': token
})
return Tools.generate_cors_response({'code': 200, 'msg': '登录失败'})
def send_request():
# 获取phone
phone = request.args.get('phone')
url = 'https://api.netease.im/sms/sendcode.action' # 网易云信接口
headers = {}
headers['Content-Type'] = 'application/x-www-form-urlencoded;charset=utf-8'
AppSecret = 'ee8d51d1061e'
Nonce = '74093849032804'
CurTime = str(time.time())
headers['AppKey'] = 'cc735ffe22684cc4dab2dc943540777c'
headers['Nonce'] = Nonce
headers['CurTime'] = CurTime
s = AppSecret + Nonce + CurTime
headers['CheckSum'] = hashlib.sha1(s.encode('utf-8')).hexdigest().lower()
res = requests.post(url, data={'mobile': phone}, headers=headers)
print(res.text, type(res.text))
json_obj = json.loads(res.text) # 字典
cache.set(phone, json_obj.obj)
# print(res.content)
if json_obj.code == 200:
return {'msg': 'success'}
else:
return {'msg': 'fail'}
def get(self):
args = reset_parser.parse_args()
mobile = args.get('mobile')
imageCode = args.get('imageCode')
code = session.get('code')
if code and imageCode.lower() == code.lower():
# 判断手机号码
user = User.query.filter(User.phone == mobile).first()
if user:
# 发送手机验证码
ret, smscode = send_duanxin(mobile)
if ret is not None:
if ret["code"] == 200:
# cache.set(key,value,timeout=second)
cache.set(mobile, smscode, timeout=180)
return jsonify(status=200, msg='短信发送成功！')
else:
print("ERROR: ret.code=%s,msg=%s" %
(ret['code'], ret['msg']))
return jsonify(status=400, msg='短信发送失败！')
else:
return {'status': 400, 'msg': '此用户未注册，请注册'}
else:
return {'status': 400, 'msg': '验证码输入有误或者超时'}
def index():
'''首页'''
# 先从缓存中获取数据，没有则到数据库查找，并更新缓存
index_brief_introduction = cache.get('index_brief_introduction')
scenic_spots_list = cache.get('scenic_spots_list')
image_list = cache.get('image_list')
# 查询首页简介数据
if not index_brief_introduction:
try:
index_brief_introduction = IndexBriefIntroductionModel.query.filter(
).first()
cache.set('index_brief_introduction',
index_brief_introduction,
timeout=60 * 60) # 1小时
except:
index_brief_introduction = None
# 查询景点数据
if not scenic_spots_list:
try:
scenic_spots_list = ScenicSpotsModel.query.order_by(
-ScenicSpotsModel.num).limit(4).all()
cache.set('scenic_spots_list', scenic_spots_list,
timeout=60) # 60秒
except:
scenic_spots_list = None
# 轮播图
if not image_list:
try:
image_list = BannerModel.query.filter().all()
cache.set('image_list', image_list, timeout=60 * 60 * 24 * 7) # 7天
except:
image_list = None
return render_template('main/index.html',
index_brief_introduction=index_brief_introduction,
scenic_spots_list=scenic_spots_list,
image_list=image_list)
def add_scenic_spot():
'''添加景点'''
cache.delete('scenic_spots_list') # 删除缓存
form = AddScenicSpotForm()
is_succeed = 0 # 标志:添加成功为1，否则为0
# 有sid则为编辑景点
sid = request.args.get('sid')
if sid:
# 编辑景点表单验证
form = EditScenicSpotForm()
# 查询id对应景点
item = ScenicSpotsModel.query.get(sid)
if item and request.method == 'POST' and form.validate_on_submit():
# 接收数据
name = form.name.data
content = form.content.data
opening_hours = form.opening_hours.data
rates = form.rates.data
image = form.image.data
images = request.files.getlist('images') # 图集
# 判断是否重复提交
if cache.get(name) == 1:
return redirect(url_for('admin.admin_index'))
# 判断是否上传有封面图
if image:
# 判断上传封面图片大小，限制大小：5M
size = image.read(5 * 1024 * 1024 + 1) # 限制最大读取字节大小，防止读取全部
if len(size) > 5 * 1024 * 1024:
return render_template('admin/add_scenic_spot.html',
form=form,
image_msg='大小不能超过5M',
is_succeed=is_succeed,
item=item)
# 将二进制图片保存到本地
image_filename = str(uuid.uuid4()) + '.jpg' # 文件名
image_path = os.path.join(settings.SCENIC_SPOT_DIR,
image_filename)
with open(image_path, 'wb') as f:
f.write(size)
item.image = '/images/scenic_spot/' + image_filename
# 更新数据库
item.name = name
item.content = content
item.opening_hours = opening_hours if opening_hours else '24小时开放'
item.rates = rates if rates else '免费' # 三元表达式
item.create_time = datetime.datetime.now().strftime(
'%Y-%m-%d') # 更新时间
db.session.commit()
# 判断是否上传有图集
if images[0].filename != '':
# 图集处理
for img in images:
# 图片后缀名验证
if '.' not in img.filename or img.filename != '' and img.filename.rsplit(
'.')[1] not in ('png', 'jpg', 'gif', 'jpeg'):
return render_template(
'admin/add_scenic_spot.html',
form=form,
images_msg='只支持png,jpg,gif,jpeg格式的图片',
is_succeed=is_succeed,
item=item)
# 图片限制大小：15M
size = img.read(15 * 1024 * 1024 + 10) # 读取15M加10字节
if len(size) > 15 * 1024 * 1024:
return render_template('admin/add_scenic_spot.html',
form=form,
images_too_big='最大只支持15M的图片',
is_succeed=is_succeed,
item=item)
# 创建文件名，景点id_uuid.jpg
img_filename = str(item.id) + '_' + str(
uuid.uuid4()) + '.jpg'
# 创建文件路径
img_path = os.path.join(settings.SCENIC_SPOT_IMAGES_DIR,
img_filename)
# 图片保存到本地，二进制写入
with open(img_path, 'wb') as f:
f.write(size)
# 保存图片到数据库
try:
img_item = ScenicSpotsImagesModel()
img_item.image = '/images/scenic_spot_images/' + img_filename
img_item.scenic_spots_id = item.id
db.session.add(img_item)
db.session.commit()
except:
return render_template('admin/add_scenic_spot.html',
form=form,
is_succeed=is_succeed,
msg='添加失败！',
item=item)
# 防止重复提交，设置唯一标识，放入缓存
cache.set(name, 1, timeout=10)
return render_template('admin/add_scenic_spot.html',
form=form,
item=item,
is_succeed=1)
# get请求(编辑)
return render_template('admin/add_scenic_spot.html',
form=form,
item=item)
# post请求+表单验证
if request.method == 'POST' and form.validate_on_submit():
# 接收数据
name = form.name.data
content = form.content.data
opening_hours = form.opening_hours.data
rates = form.rates.data
image = form.image.data
images = request.files.getlist('images') # 图集
# 判断是否重复提交
if cache.get(name) == 1:
return redirect(url_for('admin.admin_index'))
# 判断上传封面图片大小，限制大小：5M
size = image.read(5 * 1024 * 1024 + 1) # 限制最大读取字节大小，防止读取全部
if len(size) > 5 * 1024 * 1024:
return render_template('admin/add_scenic_spot.html',
form=form,
image_msg='大小不能超过5M',
is_succeed=is_succeed)
# 将二进制图片保存到本地
image_filename = str(uuid.uuid4()) + '.jpg' # 文件名
image_path = os.path.join(settings.SCENIC_SPOT_DIR, image_filename)
with open(image_path, 'wb') as f:
f.write(size)
# 查询数据库是否有相同的景点名称，有则更新
try:
item = ScenicSpotsModel.query.filter(
ScenicSpotsModel.name == name).first()
if item:
item.name = name
item.content = content
item.opening_hours = opening_hours if opening_hours else '24小时开放'
item.rates = rates if rates else '免费' # 三元表达式
item.image = '/images/scenic_spot/' + image_filename
item.create_time = datetime.datetime.now().strftime(
'%Y-%m-%d') # 更新时间
db.session.commit()
# 判断是否上传有图集
if images[0].filename != '':
# 图集处理
for img in images:
# 图片后缀名验证
if '.' not in img.filename or img.filename != '' and img.filename.rsplit(
'.')[1] not in ('png', 'jpg', 'gif', 'jpeg'):
return render_template(
'admin/add_scenic_spot.html',
form=form,
images_msg='只支持png,jpg,gif,jpeg格式的图片',
is_succeed=is_succeed)
# 图片限制大小：15M
size = img.read(15 * 1024 * 1024 + 1)
if len(size) > 15 * 1024 * 1024:
return render_template(
'admin/add_scenic_spot.html',
form=form,
images_too_big='最大只支持15M的图片',
is_succeed=is_succeed)
# 创建文件名，景点id_uuid.jpg
img_filename = str(item.id) + '_' + str(
uuid.uuid4()) + '.jpg'
# 创建文件路径
img_path = os.path.join(
settings.SCENIC_SPOT_IMAGES_DIR, img_filename)
# 图片保存到本地，二进制写入
with open(img_path, 'wb') as f:
f.write(size)
# 保存图片到数据库
try:
img_item = ScenicSpotsImagesModel()
img_item.image = '/images/scenic_spot_images/' + img_filename
img_item.scenic_spots_id = item.id
db.session.add(img_item)
db.session.commit()
except:
return render_template(
'admin/add_scenic_spot.html',
form=form,
is_succeed=is_succeed,
msg='添加失败！')
# 防止重复提交，设置唯一标识，放入缓存
cache.set(name, 1, timeout=10)
return render_template('admin/add_scenic_spot.html',
form=form,
is_succeed=1)
except:
return render_template('admin/add_scenic_spot.html',
form=form,
is_succeed=is_succeed,
msg='添加失败！')
# 保存到数据库
item = ScenicSpotsModel()
item.name = name
item.content = content
item.opening_hours = opening_hours if opening_hours else '24小时开放'
item.rates = rates if rates else '免费' # 三元表达式
item.image = '/images/scenic_spot/' + image_filename
try:
db.session.add(item)
db.session.commit()
# 判断是否上传有图集
if images[0].filename != '':
# 图集处理
for img in images:
# 图片后缀名验证
if '.' not in img.filename or img.filename != '' and img.filename.rsplit(
'.')[1] not in ('png', 'jpg', 'gif', 'jpeg'):
return render_template(
'admin/add_scenic_spot.html',
form=form,
images_msg='只支持png,jpg,gif,jpeg格式的图片',
is_succeed=is_succeed)
# 图片限制大小：15M
size = img.read(15 * 1024 * 1024 + 1)
if len(size) > 15 * 1024 * 1024:
return render_template('admin/add_scenic_spot.html',
form=form,
images_too_big='最大只支持15M的图片',
is_succeed=is_succeed)
# 创建文件名，景点id_uuid.jpg
img_filename = str(item.id) + '_' + str(
uuid.uuid4()) + '.jpg'
# 创建文件路径
img_path = os.path.join(settings.SCENIC_SPOT_IMAGES_DIR,
img_filename)
# 图片保存到本地，二进制写入
with open(img_path, 'wb') as f:
f.write(size)
# 保存图片到数据库
try:
img_item = ScenicSpotsImagesModel()
img_item.image = '/images/scenic_spot_images/' + img_filename
img_item.scenic_spots_id = item.id
db.session.add(img_item)
db.session.commit()
except:
return render_template('admin/add_scenic_spot.html',
form=form,
is_succeed=is_succeed,
msg='添加失败！')
# 防止重复提交，设置唯一标识，放入缓存
cache.set(name, 1, timeout=10)
return render_template('admin/add_scenic_spot.html',
form=form,
is_succeed=1)
except:
return render_template('admin/add_scenic_spot.html',
form=form,
is_succeed=is_succeed,
msg='添加失败！')
# get请求
return render_template('admin/add_scenic_spot.html', form=form)
def add_info():
'''发布公告'''
form = AddInfoForm()
is_succeed = 0 # 标志:添加成功为1，否则为0
# get请求如果带有info_id，则为编辑公告
# 编辑公告
info_id = request.args.get('info_id')
if info_id:
# 查询id对应公告
try:
item = InfoModel.query.get(info_id)
if request.method == 'POST' and form.validate_on_submit() and item:
title = form.title.data
# 判断是否重复提交
if cache.get(title) == 1:
return redirect(url_for('admin.admin_index'))
item.title = title
item.content = form.content.data
item.create_time = datetime.datetime.now().strftime(
'%Y-%m-%d') # 更新时间
db.session.commit()
# 防止重复提交，设置唯一标识，放入缓存
cache.set(title, 1, timeout=10)
return render_template('admin/add_info.html',
form=form,
is_succeed=1)
return render_template('admin/add_info.html',
form=form,
is_succeed=is_succeed,
item=item)
except:
# 查询出错则转为添加公告
return render_template('admin/add_info.html',
form=form,
is_succeed=is_succeed)
# 发布或更新公告
if request.method == 'POST' and form.validate_on_submit():
# 接收数据
title = form.title.data
content = form.content.data
# 判断是否重复提交
if cache.get(title) == 1:
return redirect(url_for('admin.admin_index'))
# 查询数据库是否有相同的公告名称，有则更新公告
try:
item = InfoModel.query.filter(InfoModel.title == title).first()
if item:
item.title = title
item.content = content
item.create_time = datetime.datetime.now().strftime(
'%Y-%m-%d') # 更新时间
db.session.commit()
# 防止重复提交，设置唯一标识，放入缓存
cache.set(title, 1, timeout=10)
return render_template('admin/add_info.html',
form=form,
is_succeed=1)
except:
return render_template('admin/add_info.html',
form=form,
is_succeed=is_succeed,
msg='发布失败！')
# 发布公告
item = InfoModel()
item.title = title
item.content = content
try:
db.session.add(item)
db.session.commit()
# 防止重复提交，设置唯一标识，放入缓存
cache.set(title, 1, timeout=10)
return render_template('admin/add_info.html',
form=form,
is_succeed=1)
except:
return render_template('admin/add_info',
form=form,
is_succeed=is_succeed,
msg='发布失败！')
# 普通get请求(添加公告)
return render_template('admin/add_info.html',
form=form,
is_succeed=is_succeed)
def test_register2(self, client):
cache.set('*****@*****.**', '123')
print(cache.get('*****@*****.**'))
rv = register(client, 'lzh', r'heihei', r'*****@*****.**', '123')
assert rv.data == b'user established'
def test_register6(self, client):
cache.set('*****@*****.**', '123')
rv = register(client, 'tbw', r'jojo', r'*****@*****.**', '123')
assert rv.data == b'user established'
def test_register7(self, client):
cache.set('*****@*****.**', '123')
rv = register(client, '王蓝绅', r'jojojo', r'*****@*****.**', '123')
assert rv.data == b'user established'
def register():
'''用户注册'''
# 实例化一个表单验证对象
form = UserRegisterForm()
# 1表示已发送邮件，注册成功后才返回给前端
is_send_register_mail = 1
if request.method == 'POST':
# 表单验证
if form.validate_on_submit():
# 验证通过，接收数据，可使用以下两种方式
email = request.form.get('email') # POST:form，GET:args
password = form.password.data
code = form.code.data
# 判断是否重复提交表单
if cache.get(email) == 1:
return render_template('user/register.html',
form=form,
flag=is_send_register_mail)
# 如果用户已注册，且已激活，first()得到一个对象，不加得到查询集
# 方法一，取下标
# user = UserModel.query.filter(UserModel.email == email)
# user = user[0]
# 方法二，first()
user = UserModel.query.filter(UserModel.email == email).first()
# 如果用户存在
if user:
# 用户存在且已激活
if user.is_activate == 1:
return render_template('user/register.html',
form=form,
msg='邮箱已被注册')
elif user.is_delete == 1:
# 恶意账户被管理员逻辑删除
return render_template('user/register.html',
form=form,
msg='该用户不能注册')
elif user.is_delete == 0:
# 用户存在但未激活，未销号，只更新用户密码，然后重新发送激活邮件
user.password = generate_password_hash(
password, salt_length=9) # 密码加密
try:
db.session.commit()
except:
# 提交数据库出错
return render_template('user/register.html',
form=form,
msg='注册失败')
# 发邮件（异步）
send_mail(email)
# 防止重复提交，设置一唯一个标志，放入缓存
cache.set(email, 1, timeout=10)
return render_template('user/register.html',
form=form,
flag=is_send_register_mail)
# 用户不存在，注册新用户
user = UserModel()
user.email = email
user.password = generate_password_hash(password,
salt_length=9) # 密码加密
try:
db.session.add(user)
db.session.commit()
except:
return render_template('user/register.html',
form=form,
msg='注册失败')
# 发邮件（异步）
send_mail(email)
# 防止重复提交，设置一个唯一标志，放入缓存
cache.set(email, 1, timeout=10)
return render_template('user/register.html',
form=form,
flag=is_send_register_mail)
# 表单验证未通过
return render_template('user/register.html', form=form)
# get请求
return render_template('user/register.html', form=form)
