contentdb/app/blueprints/users/settings.py

473 lines
16 KiB
Python
Raw Normal View History

2023-06-19 20:32:36 +02:00
# ContentDB
# Copyright (C) 2023 rubenwardy
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
from flask import redirect, abort, render_template, request, flash, url_for
from flask_babel import gettext, get_locale, lazy_gettext
2020-12-09 20:33:31 +01:00
from flask_login import current_user, login_required, logout_user
from flask_wtf import FlaskForm
from kombu import uuid
from sqlalchemy import or_
2023-06-19 20:32:36 +02:00
from wtforms import StringField, SubmitField, BooleanField, SelectField
from wtforms.validators import Length, Optional, Email, URL
2023-06-19 20:32:36 +02:00
from app.models import User, AuditSeverity, db, UserRank, PackageAlias, EmailSubscription, UserNotificationPreferences, \
UserEmailVerification, Permission, NotificationType, UserBan
2020-12-06 16:02:02 +01:00
from app.tasks.emails import send_verify_email
from app.tasks.usertasks import update_github_user_id
2023-06-19 22:27:49 +02:00
from app.utils import nonempty_or_none, add_audit_log, random_string, rank_required, has_blocked_domains
from . import bp
def get_setting_tabs(user):
2022-01-21 23:23:24 +01:00
ret = [
{
"id": "edit_profile",
2022-01-07 23:11:12 +01:00
"title": gettext("Edit Profile"),
"url": url_for("users.profile_edit", username=user.username)
},
2020-12-09 20:50:11 +01:00
{
"id": "account",
2022-01-07 23:11:12 +01:00
"title": gettext("Account and Security"),
2020-12-09 20:50:11 +01:00
"url": url_for("users.account", username=user.username)
},
{
"id": "notifications",
2022-01-07 23:11:12 +01:00
"title": gettext("Email and Notifications"),
"url": url_for("users.email_notifications", username=user.username)
},
{
"id": "api_tokens",
2022-01-07 23:11:12 +01:00
"title": gettext("API Tokens"),
"url": url_for("api.list_tokens", username=user.username)
},
]
2023-10-31 19:40:01 +01:00
if user.check_perm(current_user, Permission.CREATE_OAUTH_CLIENT):
ret.append({
"id": "oauth_clients",
"title": gettext("OAuth2 Applications"),
"url": url_for("oauth.list_clients", username=user.username)
})
2023-06-19 22:27:49 +02:00
if current_user.rank.at_least(UserRank.MODERATOR):
2022-01-21 23:23:24 +01:00
ret.append({
"id": "modtools",
"title": gettext("Moderator Tools"),
"url": url_for("users.modtools", username=user.username)
})
return ret
class UserProfileForm(FlaskForm):
2023-06-19 22:27:49 +02:00
display_name = StringField(lazy_gettext("Display Name"), [Optional(), Length(1, 20)], filters=[lambda x: nonempty_or_none(x.strip())])
2022-01-07 22:55:33 +01:00
website_url = StringField(lazy_gettext("Website URL"), [Optional(), URL()], filters = [lambda x: x or None])
donate_url = StringField(lazy_gettext("Donation URL"), [Optional(), URL()], filters = [lambda x: x or None])
submit = SubmitField(lazy_gettext("Save"))
2023-01-03 13:17:01 +01:00
def handle_profile_edit(form: UserProfileForm, user: User, username: str):
severity = AuditSeverity.NORMAL if current_user == user else AuditSeverity.MODERATION
2023-06-19 22:27:49 +02:00
add_audit_log(severity, current_user, "Edited {}'s profile".format(user.display_name),
url_for("users.profile", username=username))
2023-01-21 20:03:43 +01:00
display_name = form.display_name.data or user.username
if user.check_perm(current_user, Permission.CHANGE_DISPLAY_NAME) and \
2023-01-21 20:03:43 +01:00
user.display_name != display_name:
if User.query.filter(User.id != user.id,
2023-01-21 20:03:43 +01:00
or_(User.username == display_name,
User.display_name.ilike(display_name))).count() > 0:
2022-01-07 22:46:16 +01:00
flash(gettext("A user already has that name"), "danger")
return None
2023-01-21 20:03:43 +01:00
alias_by_name = PackageAlias.query.filter(or_(
2023-01-21 20:03:43 +01:00
PackageAlias.author == display_name)).first()
if alias_by_name:
2022-01-07 22:46:16 +01:00
flash(gettext("A user already has that name"), "danger")
return
2023-01-21 20:03:43 +01:00
user.display_name = display_name
severity = AuditSeverity.USER if current_user == user else AuditSeverity.MODERATION
2023-06-19 22:27:49 +02:00
add_audit_log(severity, current_user, "Changed display name of {} to {}"
.format(user.username, user.display_name),
url_for("users.profile", username=username))
if user.check_perm(current_user, Permission.CHANGE_PROFILE_URLS):
2023-01-03 13:17:01 +01:00
if has_blocked_domains(form.website_url.data, current_user.username, f"{user.username}'s website_url") or \
has_blocked_domains(form.donate_url.data, current_user.username, f"{user.username}'s donate_url"):
2023-01-12 17:43:08 +01:00
flash(gettext("Linking to blocked sites is not allowed"), "danger")
2023-01-03 13:17:01 +01:00
return
user.website_url = form.website_url.data
user.donate_url = form.donate_url.data
db.session.commit()
return redirect(url_for("users.profile", username=username))
@bp.route("/users/<username>/settings/profile/", methods=["GET", "POST"])
@login_required
def profile_edit(username):
user : User = User.query.filter_by(username=username).first()
if not user:
abort(404)
if not user.can_see_edit_profile(current_user):
2024-05-01 00:13:22 +02:00
abort(403)
form = UserProfileForm(obj=user)
if form.validate_on_submit():
ret = handle_profile_edit(form, user, username)
if ret:
return ret
# Process GET or invalid POST
return render_template("users/profile_edit.html", user=user, form=form, tabs=get_setting_tabs(user), current_tab="edit_profile")
def make_settings_form():
attrs = {
2022-01-07 22:55:33 +01:00
"email": StringField(lazy_gettext("Email"), [Optional(), Email()]),
"submit": SubmitField(lazy_gettext("Save"))
}
for notificationType in NotificationType:
key = "pref_" + notificationType.to_name()
attrs[key] = BooleanField("")
attrs[key + "_digest"] = BooleanField("")
return type("SettingsForm", (FlaskForm,), attrs)
SettingsForm = make_settings_form()
def handle_email_notifications(user, prefs: UserNotificationPreferences, is_new, form):
for notificationType in NotificationType:
field_email = getattr(form, "pref_" + notificationType.to_name()).data
field_digest = getattr(form, "pref_" + notificationType.to_name() + "_digest").data or field_email
prefs.set_can_email(notificationType, field_email)
prefs.set_can_digest(notificationType, field_digest)
if is_new:
db.session.add(prefs)
if user.check_perm(current_user, Permission.CHANGE_EMAIL):
newEmail = form.email.data
if newEmail and newEmail != user.email and newEmail.strip() != "":
if EmailSubscription.query.filter_by(email=form.email.data, blacklisted=True).count() > 0:
2022-01-07 23:11:12 +01:00
flash(gettext("That email address has been unsubscribed/blacklisted, and cannot be used"), "danger")
return
2023-06-19 22:27:49 +02:00
token = random_string(32)
severity = AuditSeverity.NORMAL if current_user == user else AuditSeverity.MODERATION
msg = "Changed email of {}".format(user.display_name)
2023-06-19 22:27:49 +02:00
add_audit_log(severity, current_user, msg, url_for("users.profile", username=user.username))
ver = UserEmailVerification()
ver.user = user
ver.token = token
ver.email = newEmail
db.session.add(ver)
db.session.commit()
2022-01-22 22:23:01 +01:00
send_verify_email.delay(newEmail, token, get_locale().language)
return redirect(url_for("users.email_sent"))
db.session.commit()
return redirect(url_for("users.email_notifications", username=user.username))
@bp.route("/user/settings/email/")
@bp.route("/users/<username>/settings/email/", methods=["GET", "POST"])
@login_required
def email_notifications(username=None):
if username is None:
return redirect(url_for("users.email_notifications", username=current_user.username))
user: User = User.query.filter_by(username=username).first()
if not user:
abort(404)
if not user.check_perm(current_user, Permission.CHANGE_EMAIL):
abort(403)
is_new = False
prefs = user.notification_preferences
if prefs is None:
is_new = True
prefs = UserNotificationPreferences(user)
data = {}
types = []
for notificationType in NotificationType:
types.append(notificationType)
data["pref_" + notificationType.to_name()] = prefs.get_can_email(notificationType)
data["pref_" + notificationType.to_name() + "_digest"] = prefs.get_can_digest(notificationType)
data["email"] = user.email
form = SettingsForm(data=data)
if form.validate_on_submit():
ret = handle_email_notifications(user, prefs, is_new, form)
if ret:
return ret
return render_template("users/settings_email.html",
form=form, user=user, types=types, is_new=is_new,
2020-12-05 23:20:43 +01:00
tabs=get_setting_tabs(user), current_tab="notifications")
2020-12-09 20:33:31 +01:00
2022-01-21 23:23:24 +01:00
@bp.route("/users/<username>/settings/account/")
@login_required
def account(username):
user : User = User.query.filter_by(username=username).first()
if not user:
abort(404)
2024-05-01 00:13:22 +02:00
if not user.can_see_edit_profile(current_user):
abort(403)
2022-01-21 23:23:24 +01:00
return render_template("users/account.html", user=user, tabs=get_setting_tabs(user), current_tab="account")
2024-05-01 00:13:22 +02:00
@bp.route("/users/<username>/settings/account/disconnect-github/", methods=["POST"])
def disconnect_github(username: str):
user: User = User.query.filter_by(username=username).one_or_404()
if not user.can_see_edit_profile(current_user):
abort(403)
if user.password and user.email:
user.github_user_id = None
user.github_username = None
db.session.commit()
flash(gettext("Removed GitHub account"), "success")
else:
flash(gettext("You need to add an email address and password before you can remove your GitHub account"), "danger")
return redirect(url_for("users.account", username=username))
2022-01-21 23:23:24 +01:00
@bp.route("/users/<username>/delete/", methods=["GET", "POST"])
@rank_required(UserRank.ADMIN)
def delete(username):
user: User = User.query.filter_by(username=username).first()
if not user:
abort(404)
2023-06-19 22:27:49 +02:00
if user.rank.at_least(UserRank.MODERATOR):
2022-01-21 23:23:24 +01:00
flash(gettext("Users with moderator rank or above cannot be deleted"), "danger")
return redirect(url_for("users.account", username=username))
if request.method == "GET":
return render_template("users/delete.html", user=user, can_delete=user.can_delete())
2023-06-19 22:27:49 +02:00
if "delete" in request.form and (user.can_delete() or current_user.rank.at_least(UserRank.ADMIN)):
2022-01-21 23:23:24 +01:00
msg = "Deleted user {}".format(user.username)
flash(msg, "success")
2023-06-19 22:27:49 +02:00
add_audit_log(AuditSeverity.MODERATION, current_user, msg, None)
2022-01-21 23:23:24 +01:00
2023-06-19 22:27:49 +02:00
if current_user.rank.at_least(UserRank.ADMIN):
2022-01-21 23:23:24 +01:00
for pkg in user.packages.all():
pkg.review_thread = None
db.session.delete(pkg)
db.session.delete(user)
elif "deactivate" in request.form:
2023-04-03 21:43:26 +02:00
for reply in user.replies.all():
db.session.delete(reply)
2022-01-21 23:23:24 +01:00
for thread in user.threads.all():
db.session.delete(thread)
for token in user.tokens.all():
db.session.delete(token)
user.profile_pic = None
2022-01-21 23:23:24 +01:00
user.email = None
if user.rank != UserRank.BANNED:
user.rank = UserRank.NOT_JOINED
2022-01-21 23:23:24 +01:00
msg = "Deactivated user {}".format(user.username)
flash(msg, "success")
2023-06-19 22:27:49 +02:00
add_audit_log(AuditSeverity.MODERATION, current_user, msg, None)
2022-01-21 23:23:24 +01:00
else:
assert False
db.session.commit()
if user == current_user:
logout_user()
return redirect(url_for("homepage.home"))
class ModToolsForm(FlaskForm):
2022-01-07 22:55:33 +01:00
username = StringField(lazy_gettext("Username"), [Optional(), Length(1, 50)])
display_name = StringField(lazy_gettext("Display name"), [Optional(), Length(2, 100)])
forums_username = StringField(lazy_gettext("Forums Username"), [Optional(), Length(2, 50)])
github_username = StringField(lazy_gettext("GitHub Username"), [Optional(), Length(2, 50)])
rank = SelectField(lazy_gettext("Rank"), [Optional()], choices=UserRank.choices(), coerce=UserRank.coerce,
default=UserRank.NEW_MEMBER)
2022-01-07 22:55:33 +01:00
submit = SubmitField(lazy_gettext("Save"))
2022-01-21 23:23:24 +01:00
@bp.route("/users/<username>/modtools/", methods=["GET", "POST"])
@rank_required(UserRank.MODERATOR)
def modtools(username):
user: User = User.query.filter_by(username=username).first()
2020-12-09 20:50:11 +01:00
if not user:
abort(404)
if not user.check_perm(current_user, Permission.CHANGE_EMAIL):
2022-01-21 23:23:24 +01:00
abort(403)
2020-12-09 20:50:11 +01:00
2022-01-21 23:23:24 +01:00
form = ModToolsForm(obj=user)
if form.validate_on_submit():
severity = AuditSeverity.NORMAL if current_user == user else AuditSeverity.MODERATION
2023-06-19 22:27:49 +02:00
add_audit_log(severity, current_user, "Edited {}'s account".format(user.display_name),
url_for("users.profile", username=username))
redirect_target = url_for("users.modtools", username=username)
# Copy form fields to user_profile fields
if user.check_perm(current_user, Permission.CHANGE_USERNAMES):
if user.username != form.username.data:
for package in user.packages:
alias = PackageAlias(user.username, package.name)
package.aliases.append(alias)
db.session.add(alias)
user.username = form.username.data
user.display_name = form.display_name.data
2023-06-19 22:27:49 +02:00
user.forums_username = nonempty_or_none(form.forums_username.data)
github_username = nonempty_or_none(form.github_username.data)
if github_username is None:
user.github_username = None
user.github_user_id = None
else:
task_id = uuid()
update_github_user_id.apply_async((user.id, github_username), task_id=task_id)
redirect_target = url_for("tasks.check", id=task_id, r=redirect_target)
if user.check_perm(current_user, Permission.CHANGE_RANK):
2023-06-19 20:32:36 +02:00
new_rank = form["rank"].data
2023-06-19 22:27:49 +02:00
if current_user.rank.at_least(new_rank):
2023-06-19 20:32:36 +02:00
if new_rank != user.rank:
user.rank = form["rank"].data
2024-06-08 13:27:05 +02:00
msg = "Set rank of {} to {}".format(user.display_name, user.rank.title)
2023-06-19 22:27:49 +02:00
add_audit_log(AuditSeverity.MODERATION, current_user, msg,
url_for("users.profile", username=username))
else:
2022-01-07 22:46:16 +01:00
flash(gettext("Can't promote a user to a rank higher than yourself!"), "danger")
db.session.commit()
return redirect(redirect_target)
2022-01-21 23:23:24 +01:00
return render_template("users/modtools.html", user=user, form=form, tabs=get_setting_tabs(user), current_tab="modtools")
2020-12-09 20:50:11 +01:00
2022-01-21 23:23:24 +01:00
@bp.route("/users/<username>/modtools/set-email/", methods=["POST"])
@rank_required(UserRank.MODERATOR)
def modtools_set_email(username):
2020-12-09 20:33:31 +01:00
user: User = User.query.filter_by(username=username).first()
if not user:
abort(404)
if not user.check_perm(current_user, Permission.CHANGE_EMAIL):
2022-01-21 23:23:24 +01:00
abort(403)
2022-01-21 23:23:24 +01:00
user.email = request.form["email"]
user.is_active = False
2020-12-09 20:33:31 +01:00
2023-06-19 22:27:49 +02:00
token = random_string(32)
add_audit_log(AuditSeverity.MODERATION, current_user, f"Set email and sent a password reset on {user.username}",
url_for("users.profile", username=user.username), None)
2020-12-09 20:33:31 +01:00
2022-01-21 23:23:24 +01:00
ver = UserEmailVerification()
ver.user = user
ver.token = token
ver.email = user.email
ver.is_password_reset = True
db.session.add(ver)
db.session.commit()
2022-01-22 22:23:01 +01:00
send_verify_email.delay(user.email, token, user.locale or "en")
2020-12-09 20:33:31 +01:00
2022-01-21 23:23:24 +01:00
flash(f"Set email and sent a password reset on {user.username}", "success")
return redirect(url_for("users.modtools", username=username))
2020-12-09 20:33:31 +01:00
2022-01-21 23:23:24 +01:00
@bp.route("/users/<username>/modtools/ban/", methods=["POST"])
@rank_required(UserRank.MODERATOR)
def modtools_ban(username):
user: User = User.query.filter_by(username=username).first()
if not user:
abort(404)
2020-12-09 20:33:31 +01:00
if not user.check_perm(current_user, Permission.CHANGE_RANK):
2022-01-21 23:23:24 +01:00
abort(403)
2022-02-13 11:37:54 +01:00
message = request.form["message"]
expires_at = request.form.get("expires_at")
2022-01-21 23:23:24 +01:00
2022-02-13 11:37:54 +01:00
user.ban = UserBan()
user.ban.banned_by = current_user
user.ban.message = message
if expires_at and expires_at != "":
user.ban.expires_at = expires_at
else:
user.rank = UserRank.BANNED
2023-06-19 22:27:49 +02:00
add_audit_log(AuditSeverity.MODERATION, current_user, f"Banned {user.username}, expires {user.ban.expires_at or '-'}, message: {message}",
url_for("users.profile", username=user.username), None)
2022-01-21 23:23:24 +01:00
db.session.commit()
flash(f"Banned {user.username}", "success")
2022-02-13 11:37:54 +01:00
return redirect(url_for("users.modtools", username=username))
@bp.route("/users/<username>/modtools/unban/", methods=["POST"])
@rank_required(UserRank.MODERATOR)
def modtools_unban(username):
user: User = User.query.filter_by(username=username).first()
if not user:
abort(404)
if not user.check_perm(current_user, Permission.CHANGE_RANK):
2022-02-13 11:37:54 +01:00
abort(403)
if user.ban:
db.session.delete(user.ban)
if user.rank == UserRank.BANNED:
user.rank = UserRank.MEMBER
2023-06-19 22:27:49 +02:00
add_audit_log(AuditSeverity.MODERATION, current_user, f"Unbanned {user.username}",
url_for("users.profile", username=user.username), None)
2022-02-13 11:37:54 +01:00
db.session.commit()
flash(f"Unbanned {user.username}", "success")
return redirect(url_for("users.modtools", username=username))