def user_reconfirm():
"""
When user can't receive the confirm email,app can resend the email through this view.
"""
if current_user.confirmed:
return render_template('auth/user_confirm.html', confirmed=True)
else:
token = current_user.generate_token()
send_mail(to=current_user.email, subject="Confirm Your Account", template='auth/email/confirm',
token=token, user=current_user)
flash("Register successful.Pleas log in.And a confirm message has been sent to your email.")
return redirect(request.args.get('next') or url_for('auth.login'))
def user_signup():
form = SignupForm()
if form.validate_on_submit():
password = form.password.data
user = User(email=form.email.data, username=form.name.data, password_hash=generate_password_hash(password))
db.session.add(user)
db.session.commit()
token = user.generate_token()
send_mail(to=user.email, subject="Confirm Your Account", template='auth/email/confirm', token=token, user=user)
flash("Register successful.Pleas log in.And a confirm message has been sent to your email.")
user.member_since = datetime.utcnow()
return redirect(request.args.get('next') or url_for('auth.login'))
return render_template("auth/user_signup.html", form=form)
def password_reset_request():
if not current_user.is_anonymous:
flash("Reset password is for user who forgot the password.")
return redirect(url_for("web.index"))
# EmailForm is only used for validation, not in rendering
form = PasswordResetRequestForm()
if form.validate_on_submit():
email = form.email.data.lower()
user = User.query.filter_by(email=email).first()
if user:
token = user.generate_reset_token()
send_mail(user.email,
"重置密码",
"email/reset_password",
user=user,
token=token)
flash("密码重置邮件已发送到{}，注意查收".format(user.email))
return redirect(url_for("auth.login"))
else:
flash("邮件地址无效")
return render_template("auth/forget_password_request.html", form=form)
def forget_password():
form = Forget_passwordForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if send_mail(form.email.data,
'用户密码找回',
'forget_password_email.html',
user=user,
token=get_token(user)):
return
flash('找回密码的邮件已经发送到' + form.email.data + ',请及时查收！', 'info')
return render_template('forget_password.html', form=form)
def register():
form = RegisterForm()
if form.validate_on_submit():
u = User(username=form.username.data,
password=form.password.data,
email=form.email.data)
# 将数据写入数据库
db.session.add(u)
db.session.commit()
#生成用于验证激活状态的token
token = u.make_active_token()
#调用邮箱发送激活邮件
send_mail(u.email,
'账户激活',
'email/active',
username=u.username,
token=token)
#来一个提示信息 跳转到首页
flash('邮件已发送 请读取邮件并激活')
return render_template('main/index.html')
return render_template('user/register.html', form=form)
def export_reports(user_id):
try:
user = User.query.get(user_id)
reports_query = Report.query.order_by(Report.timestamp.desc())
_set_task_progress(0)
data = []
i = 0
total_posts = reports_query.count()
for report in reports_query.all():
data.append({
'employee_id':
report.employee.id,
'employee_name':
report.employee.name,
'report_observation':
report.observations,
'report_timestamp':
report.timestamp.strftime('%d/%m/%Y %H:%M'),
'report_checkin':
'Prezent' if report.check_in else 'Absent',
})
time.sleep(1)
i += 1
_set_task_progress(100 * i // total_posts)
send_mail('[Progresso Nel Edilizia] Rapoartele tale',
recipients=app.config['ADMINS'],
text_body=render_template('email/export_posts.txt',
user=user,
what='rapoartele'),
html_body=render_template('email/export_posts.html',
user=user,
what='rapoartele'),
attachments=[('posts.json', 'application/json',
json.dumps({'posts': data}, indent=4))],
sync=True)
except:
app.logger.error('Unhandled exception', exc_info=sys.exc_info())
_set_task_progress(100)
def register():
form = RegisterationForm()
if form.validate_on_submit():
user = User()
user.username = form.username.data
user.password = form.password.data
user.email = form.email.data
user.role = Role.query.filter_by(name='普通会员').first()
db.session.add(user)
flash('用户%s注册成功' % (user.username), category='success')
# 提交数据库之后才能赋予新用户 id 值,而确认令牌需要用到 id ,所以不能延后提交。
db.session.commit()
token = user.generate_confirmation_token()
send_mail(to=[user.email],
subject='请激活你的任务管理平台帐号',
filename='confirm',
user=user,
token=token)
flash('平台验证消息已经发送到你的邮箱, 请确认后登录', category='success')
return redirect(url_for('auth.login'))
return render_template('register.html', form=form)
def reset_password():
form1 = EUForm()
global authcode
authcode = random_string(length=6)
if form1.validate_on_submit():
global Uname
username = form1.username.data
Uname = username
user = User.query.filter(
or_(User.username == username, User.email == username)).first()
# print(user.email)
if user:
send_mail([user.email],
'验证码邮件',
'email/authcode',
username=user.username,
authcode=authcode)
flash('验证码邮件已发送,注意查收')
return redirect(url_for('users.reset_password2'))
else:
flash('请输入正确的用户名或邮箱')
return render_template('users/reset_password.html', form1=form1)
def register():
form = RegisterForm()
if form.validate_on_submit():
# 根据提交的数据创建用户对象
u = User(username=form.username.data,
password=form.password.data,
email=form.email.data)
# 保存到数据库中
db.session.add(u)
# 手动提交，此时需要用到用户id
db.session.commit()
# 发送激活邮件
token = u.generate_activate_token()
send_mail('账户激活',
form.email.data,
'activate.html',
username=form.username.data,
token=token)
# 发送提示
flash('注册成功，请点击邮件链接以完成激活')
return redirect(url_for('main.index'))
return render_template('user/register.html', form=form)
def register():
form = RegisterForm()
if form.validate_on_submit():
# 创建User模型
u = User(username=form.username.data,
password=form.password.data,
email=form.email.data)
# 保存到数据库
db.session.add(u)
# 此时用户还没有添加到数据库中，因此没有id，无法生成token
# 在这里需要手动提交，也就是立即将数据写入到数据库中
db.session.commit()
# 发送账户激活邮件
token = u.generate_activate_token()
send_mail(form.email.data,
'账户激活',
'email/activate',
token=token,
username=u.username)
flash('注册成功，激活邮件已发送至注册邮箱，请点击完成激活')
return redirect(url_for('main.index'))
return render_template('user/register.html', form=form)
def reset_password1():
form = Reset_pwd1()
if form.validate_on_submit():
global authcode
authcode = random_string(length=6)
user = User.query.filter(
or_(User.username == form.username.data,
User.email == form.username.data)).first()
if user:
global uname
uname = user.username
send_mail([user.email],
'验证码',
'users/mail_auth',
username=user.username,
authcode=authcode)
flash('验证码已经发送')
return redirect(url_for('users.reset_password2', ))
else:
flash('没有此用户！')
return render_template('users/reset_pwd1.html', form=form)
def register():
form = RegisterForm()
if form.validate_on_submit():
# 创建对象
u = User(username=form.username.data,
password=form.password.data,
email=form.email.data)
# 写入数据库
db.session.add(u)
# 因为下面产生token时需要用到用户id，此时还没有用户id
db.session.commit()
# 生成token
token = u.generate_activate_token()
# 发送激活邮件
send_mail(form.email.data,
'账户激活',
'email/account_activate',
token=token,
username=form.username.data)
flash('激活邮件已发送，请点击链接完成用户激活')
return redirect(url_for('main.index'))
return render_template('user/register.html', form=form)
def register():
form = Register()
if form.validate_on_submit():
# 实例化user
u = User(username=form.username.data,
password=form.password.data,
email=form.email.data)
db.session.add(u)
db.session.commit()
# 生成token
token = u.generate_token()
# 发送邮件
send_mail('邮件激活',
form.email.data,
'activate',
username=form.username.data,
token=token)
# 提示注册
flash('注册成功,去激活')
# 跳转登陆页面
return redirect(url_for('user.login'))
return render_template('user/register.html', form=form)
def register():
form = RegisterForm()
if form.validate_on_submit():
# 创建用户对象
u = User()
try:
u.username = form.username.data
u.password = form.password.data
u.email = form.email.data
except Exception as e:
flash('用户名或邮箱不可用')
return redirect(url_for('user.register'))
# 保存到数据库
db.session.add(u)
# 手动提交，因为生成token时需要使用用户id
db.session.commit()
# 生成包含有效信息的token
token = u.generate_activate_token()
# 发送激活邮件
send_mail('账户激活', form.email.data, 'email/activate.html', token=token)
flash('注册成功，请点击邮件中的链接以完成激活')
return redirect(url_for('main.index'))
return render_template('user/register.html', form=form)
def register():
form = RegisterForm()
if form.validate_on_submit():
# 根据form的数据，生成用户对象
u = User(username=form.username.data,
email=form.email.data,
password=form.password.data)
# 保存对象。
db.session.add(u)
# 增强代码强壮性，手动提交一次。
db.session.commit()
# 发送激活邮件。
token = u.generate_activate_token()
send_mail('用户激活',
form.email.data,
'user/activate',
username=form.username.data,
token=token)
# 提示用户注册成功
# 跳转
flash('注册成功')
return redirect(url_for('user.login'))
return render_template('user/register.html', form=form)
def register():
from app.models import Role
form = Register()
if form.validate_on_submit():
user = User()
user.name = form.name.data
user.password = form.password.data
user.email = form.email.data
if user.email == current_app.config['MAIL_USERNAME']:
user.role = Role.query.filter_by(permissions=0xff).first()
else:
user.role = Role.query.filter_by(default=True).first()
db.session.add(user)
db.session.commit()
user.generate_api()
token = user.generate_token()
html = render_template('email/register.html',
token=token,
name=user.name)
send_mail('博客注册验证', current_app.config['MAIL_USERNAME'],
[form.email.data], None, html)
return redirect(url_for('main.index'))
return render_template('auth/register.html', form=form)
def change_email():
form = EmailForm()
if form.validate_on_submit():
if current_user.email == form.old_email.data:
current_user.confirmed = False
db.session.add(current_user)
db.session.commit()
token = current_user.generate_activate_token()
send_mail(current_user.email,
'账号重置',
'email/account_activate',
token=token,
username=current_user.username)
current_user.email = form.new_email.data
# current_user.confirmed = True
# db.session.add(current_user)
flash('邮箱发送成功')
return redirect(url_for('main.index'))
else:
flash('原始邮箱不存在')
return redirect(url_for('user.change_email.html'))
return render_template('user/change_email.html', form=form)
def export_posts(user_id):
try:
# read user posts from database
user = User.query.get(user_id)
_set_task_progress(0)
data = []
i = 0
total_posts = user.posts.count()
for post in user.posts.order_by(Post.timestamp.asc()):
data.append({'body': post.body, 'timestamp': post.timestamp.isoformat() + 'Z'})
# in production environment, time.sleep is not used.
time.sleep(5)
i += 1
_set_task_progress(100 * i // total_posts)
# send email with data to user
send_mail('[Microblog] Your blog posts', sender=app.config['ADMINS'][0], recipients=[user.email],
text_body=render_template('email/export_posts.txt', user=user),
html_body=render_template('email/export_posts.html', user=user),
attachments=[('posts.json', 'application/json', json.dumps({'posts':data}, indent=4))], sync=True)
except:
# handle unexpected errors
_set_task_progress(100)
app.logger.error('Unhandled exception', exc_info=sys.exc_info())
def login():
form = LoginForm()
if current_user.is_authenticated:
return redirect_tag(current_user.tag)
elif form.validate_on_submit():
user_id = form.userid.data
user_passwd = form.password.data
remember = form.remember.data
tag = form.tag.data
if tag == 'student':
user = Student.query.filter_by(idcard=user_id).first()
elif tag == 'teacher':
user = Teacher.query.filter_by(idcard=user_id).first()
else:
user = Admin.query.filter_by(idcard=user_id).first()
if not user:
flash("登录密码错误，请重新输入")
elif user.verify_password(password=user_passwd):
if user.tag == 'student':
if user.confirmed:
flash("登录成功")
login_user(user, remember=remember)
return redirect_tag(tag)
else:
token = id2Token(user.idcard)
send_mail(user.email,
'账户激活',
'email/active',
username=user.name,
token=token)
flash("您的账号还未激活，请查看邮件进行激活")
else:
flash("登录成功")
login_user(user, remember=remember)
return redirect_tag(tag)
return render_template('login.html', form=form)
def register():
form = RegisterForm()
if form.validate_on_submit():
# 根据表单数据创建用户对象
u = User(username=form.username.data,
password=form.password.data,
email=form.email.data)
# 将对象保存到数据库
db.session.add(u)
# 此时数据还没有保存到数据库中，没有id字段值，下面生成token时需要使用id
# 因此等请求结束再提交时来不及的，故需要手动提交
db.session.commit()
# 发送用户的激活邮件
# 生成用户激活的token
token = u.generate_activate_token()
send_mail(form.email.data,
'账户激活',
'email/activate',
username=form.username.data,
token=token)
# 给出flash提示消息
flash('邮件已发送，请点击链接完成用户激活')
return redirect(url_for('main.index'))
return render_template('user/register.html', form=form)
def test_sending_email(self):
"""Tests the sending of emails"""
send_mail('test_email', '*****@*****.**',
['*****@*****.**'],
'This is a test mail', '<h1>This</h1><p> is a test mail</p>')
def send_mail_async(mail_to, subject, template, **kwargs):
send_mail(mail_to, subject, template, **kwargs)
def send():
send_mail('*****@*****.**', '账户激活', 'email/activate', username='******')
return '邮件已发送'
def post(self):
args = parser.parse_args()
email = args.get('email')
password = args.get('password')
role = args.get('role')
if email is None:
return raise_error(400, "Email is missing")
if password is None:
return raise_error(400, "Password is missing")
if role is None:
return raise_error(400, "role is missing")
# validate input data
if valid_email(email) is None:
return raise_error(400, "Invalid email format")
if valid_password(password) is None:
return raise_error(
400, "Invalid password. Should be at least 5 "
"characters long and include a number and a special "
"character")
if valid_role(role) is None:
return raise_error(400, "Invalid role")
user = User.query.filter_by(email=email).first()
if user is not None:
return raise_error(400, "User already exists")
user = User(email=email, role=role)
user.set_password(password)
try:
db.session.add(user)
send_mail(
to_emails=email,
subject='Account Creation - One Acre',
template='register',
content='You have successfully created an account on One-Acre')
db.session.commit()
except:
raise
# Create our JWTs
access_token = create_access_token(identity=email)
refresh_token = create_refresh_token(identity=email)
# Store the tokens in our store with a status of not currently revoked.
add_token_to_database(access_token,
current_app.config['JWT_IDENTITY_CLAIM'])
add_token_to_database(refresh_token,
current_app.config['JWT_IDENTITY_CLAIM'])
data = {}
data['access_token'] = access_token
data['refresh_token'] = refresh_token
data['user'] = user.serialize
response = {"status": 201, "data": [data]}
return response, 201
def send():
send_mail('*****@*****.**',
'关于密码',
'email/activate',
username='******')
return 'send mail'
def user(username):
user = User.query.filter_by(username=username).first_or_404()
cancelform = CancelForm(prefix="a")
editform = EditForm(request.form, prefix="b")
if cancelform.submit.data and cancelform.validate():
order = user.orders.filter_by(
order_name=cancelform.confirm.data).first_or_404()
order.order_flag = "cancelled"
db.session.add(order)
db.session.commit()
send_mail(
f"{cancelform.confirm.data} cancelled",
current_user.email,
["*****@*****.**"],
f"{cancelform.confirm.data} has been cancelled",
)
if editform.submit2.data and editform.validate():
file = request.files.get(editform.profileimg.name)
print(file)
if file:
filename = secure_filename(file.filename)
file_extensions = [".jpg", ".jpeg", ".png"]
good = False
for file_extension in file_extensions:
if filename.endswith(file_extension):
good = True
if good:
file.save(app.config["UPLOAD_FOLDER"] + filename)
user.profile_img = "/static/profile_imgs/" + filename
db.session.add(user)
db.session.commit()
else:
flash("Not an image!")
if editform.name.data:
user_exists = User.query.filter_by(
username=editform.name.data).first()
if not user_exists:
user.username = editform.name.data
db.session.add(user)
db.session.commit()
return redirect(f"/account/{user.username}")
else:
flash("Username exists!")
else:
print("no!")
ordered = user.orders.filter_by(order_flag="open")
cancels = user.orders.filter_by(order_flag="cancelled")
completed = user.orders.filter_by(order_flag="completed")
if current_user.email in [
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
]:
return render_template(
"user.html",
user=user,
opens=ordered,
cancels=cancels,
completed=completed,
cancel_form=cancelform,
edit_form=editform,
isAdmin=True,
)
else:
return render_template(
"user.html",
user=user,
opens=ordered,
cancels=cancels,
completed=completed,
cancel_form=cancelform,
edit_form=editform,
isAdmin=False,
)
def resend_confirmation():
token = current_user.generate_token()
send_mail(current_user.email, 'Confirm Your Account', \
'auth/email/confirm', user=current_user, token=token)
flash('A new confirmation mail has been resent to your email.')
return redirect(url_for('main.index'))
