def post(self, token):
form = self.form()
if form.validate_on_submit():
try:
service = self.password_reset_service_factory()
service.reset_password(
token, form.email.data, form.password.data
)
except TokenError as e:
flash(e.reason, 'danger')
return redirect(url_for('auth.forgot_password'))
except StopValidation as e:
form.populate_errors(e.reasons)
form.token.data = token
return render_template("auth/reset_password.html", form=form)
except Exception:
logger.exception("Error when resetting password")
flash(_('Error when resetting password'))
return redirect(url_for('auth.forgot_password'))
finally:
try:
db.session.commit()
except Exception:
logger.exception(
"Error while finalizing database when resetting password" # noqa
)
db.session.rollback()
flash(_("Your password has been updated."), "success")
return redirect(url_for("auth.login"))
form.token.data = token
return render_template("auth/reset_password.html", form=form)
def post(self):
form = self.form()
if form.validate_on_submit():
registration_info = UserRegistrationInfo(
username=form.username.data,
password=form.password.data,
group=4,
email=form.email.data,
language=form.language.data
)
service = self.registration_service_factory()
try:
service.register(registration_info)
except StopValidation as e:
form.populate_errors(e.reasons)
return render_template("auth/register.html", form=form)
except PersistenceError:
logger.exception("Database error while persisting user")
flash(
_(
"Could not process registration due"
"to an unrecoverable error"
), "danger"
)
return render_template("auth/register.html", form=form)
current_app.pluggy.hook.flaskpet_event_user_registered(
username=registration_info.username
)
return redirect_or_next(url_for('forum.index'))
return render_template("auth/register.html", form=form)
def post(self):
page = request.args.get("page", 1, type=int)
sort_by = request.args.get("sort_by", "reg_date")
order_by = request.args.get("order_by", "asc")
if order_by == "asc":
order_func = asc
else:
order_func = desc
if sort_by == "reg_date":
sort_obj = User.id
elif sort_by == "post_count":
sort_obj = User.post_count
else:
sort_obj = User.username
form = self.form()
if form.validate():
users = form.get_results().paginate(
page, flaskpet_config["USERS_PER_PAGE"], False
)
return render_template(
"forum/memberlist.html", users=users, search_form=form
)
users = User.query.order_by(order_func(sort_obj)).paginate(
page, flaskpet_config["USERS_PER_PAGE"], False
)
return render_template(
"forum/memberlist.html", users=users, search_form=form
)
def post(self):
form = self.form()
if form.validate_on_submit():
result = form.get_results()
return render_template(
"forum/search_result.html", form=form, result=result
)
return render_template("forum/search_form.html", form=form)
def get(self, user_id):
user = User.query.filter_by(id=user_id).first_or_404()
form = self.form(user)
member_group = db.and_(*[
db.not_(getattr(Group, p))
for p in ['admin', 'mod', 'super_mod', 'banned', 'guest']
])
filt = db.or_(Group.id.in_(g.id for g in current_user.groups),
member_group)
if Permission(IsAtleastSuperModerator, identity=current_user):
filt = db.or_(filt, Group.mod)
if Permission(IsAdmin, identity=current_user):
filt = db.or_(filt, Group.admin, Group.super_mod)
if Permission(CanBanUser, identity=current_user):
filt = db.or_(filt, Group.banned)
group_query = Group.query.filter(filt)
form.primary_group.query = group_query
form.secondary_groups.query = group_query
return render_template('management/user_form.html',
form=form,
title=_('Edit User'))
def get(self, post_id):
post = Post.query.filter_by(id=post_id).first_or_404()
form = self.form(obj=post)
return render_template(
"forum/new_post.html", topic=post.topic, form=form, edit_mode=True
)
def get(self):
categories = Category.get_all(user=real(current_user))
# Fetch a few stats about the forum
user_count = User.query.count()
topic_count = Topic.query.count()
post_count = Post.query.count()
newest_user = User.query.order_by(User.id.desc()).first()
# Check if we use redis or not
if not current_app.config["REDIS_ENABLED"]:
online_users = User.query.filter(User.lastseen >= time_diff()
).count()
# Because we do not have server side sessions,
# we cannot check if there are online guests
online_guests = None
else:
online_users = len(get_online_users())
online_guests = len(get_online_users(guest=True))
return render_template(
"forum/index.html",
categories=categories,
user_count=user_count,
topic_count=topic_count,
post_count=post_count,
newest_user=newest_user,
online_users=online_users,
online_guests=online_guests
)
def post(self):
form = self.form()
if form.validate_on_submit():
token = form.token.data
activator = self.account_activator_factory()
try:
activator.activate_account(token)
except TokenError as e:
form.populate_errors([('token', e.reason)])
except ValidationError as e:
flash(e.reason, 'danger')
return redirect(url_for('forum.index'))
else:
try:
db.session.commit()
except Exception: # noqa
logger.exception("Database error while activating account")
db.session.rollback()
flash(
_(
"Could not activate account due to an unrecoverable error" # noqa
), "danger"
)
return redirect(url_for('auth.request_activation_token'))
flash(
_("Your account has been activated and you can now login."),
"success"
)
return redirect(url_for("forum.index"))
return render_template("auth/account_activation.html", form=form)
def get(self):
page = request.args.get("page", 1, type=int)
reports = Report.query.\
order_by(Report.id.asc()).\
paginate(page, flaskpet_config['USERS_PER_PAGE'], False)
return render_template("management/reports.html", reports=reports)
def get(self, forum_id, slug=None):
forum_instance, forumsread = Forum.get_forum(
forum_id=forum_id, user=real(current_user)
)
if forum_instance.external:
return redirect(forum_instance.external)
# remove the current forum from the select field (move).
available_forums = Forum.query.order_by(Forum.position).all()
available_forums.remove(forum_instance)
page = request.args.get("page", 1, type=int)
topics = Forum.get_topics(
forum_id=forum_instance.id,
user=real(current_user),
page=page,
per_page=flaskpet_config["TOPICS_PER_PAGE"]
)
return render_template(
"forum/edit_forum.html",
forum=forum_instance,
topics=topics,
available_forums=available_forums,
forumsread=forumsread,
)
def post(self):
page = request.args.get('page', 1, type=int)
form = self.form()
if form.validate():
users = form.get_results().\
paginate(page, flaskpet_config['USERS_PER_PAGE'], False)
return render_template('management/users.html',
users=users,
search_form=form)
users = User.query.order_by(User.id.asc()).paginate(
page, flaskpet_config['USERS_PER_PAGE'], False)
return render_template('management/users.html',
users=users,
search_form=form)
def get(self):
if current_app.config["REDIS_ENABLED"]:
online_users = get_online_users()
else:
online_users = User.query.filter(User.lastseen >= time_diff()).all()
return render_template(
"forum/online_users.html", online_users=online_users
)
def post(self, post_id):
form = self.form()
if form.validate_on_submit():
post = Post.query.filter_by(id=post_id).first_or_404()
form.save(real(current_user), post)
flash(_("Thanks for reporting."), "success")
return render_template("forum/report_post.html", form=form)
def get(self, category_id, slug=None):
category, forums = Category.get_forums(
category_id=category_id, user=real(current_user)
)
return render_template(
"forum/category.html", forums=forums, category=category
)
def get(self, category_id):
category = Category.query.filter_by(id=category_id).first_or_404()
form = self.form(obj=category)
return render_template('management/category_form.html',
form=form,
title=_('Edit Category'))
def get(self):
page = request.args.get("page", 1, type=int)
groups = Group.query.\
order_by(Group.id.asc()).\
paginate(page, flaskpet_config['USERS_PER_PAGE'], False)
return render_template("management/groups.html", groups=groups)
def post(self, forum_id, slug=None):
forum_instance = Forum.query.filter_by(id=forum_id).first_or_404()
form = self.form()
if form.validate_on_submit():
topic = form.save(real(current_user), forum_instance)
return redirect(url_for("forum.view_topic", topic_id=topic.id))
return render_template(
"forum/new_topic.html", forum=forum_instance, form=form
)
def post(self):
form = AddGroupForm()
if form.validate_on_submit():
form.save()
flash(_('Group added.'), 'success')
return redirect(url_for('management.groups'))
return render_template('management/group_form.html',
form=form,
title=_('Add Group'))
def post(self):
form = self.form()
if form.validate_on_submit():
form.save()
flash(_('User added.'), 'success')
return redirect(url_for('management.users'))
return render_template('management/user_form.html',
form=form,
title=_('Add User'))
def get(self, topic_id, slug=None, post_id=None):
topic = Topic.query.filter_by(id=topic_id).first_or_404()
form = self.form()
if post_id is not None:
post = Post.query.filter_by(id=post_id).first_or_404()
form.content.data = format_quote(post.username, post.content)
return render_template(
"forum/new_post.html", topic=topic, form=form
)
def post(self):
form = self.form()
if form.validate_on_submit():
form.save()
flash(_('Category added.'), 'success')
return redirect(url_for('management.forums'))
return render_template('management/category_form.html',
form=form,
title=_('Add Category'))
def post(self):
page = request.args.get('page', 1, type=int)
search_form = self.form()
users = User.query.filter(Group.banned == True,
Group.id == User.primary_group_id).paginate(
page, flaskpet_config['USERS_PER_PAGE'],
False)
if search_form.validate():
users = search_form.get_results().\
paginate(page, flaskpet_config['USERS_PER_PAGE'], False)
return render_template('management/banned_users.html',
users=users,
search_form=search_form)
return render_template('management/banned_users.html',
users=users,
search_form=search_form)
def get(self, category_id=None):
form = self.form()
form.groups.data = Group.query.order_by(Group.id.asc()).all()
if category_id:
category = Category.query.filter_by(id=category_id).first()
form.category.data = category
return render_template('management/forum_form.html',
form=form,
title=_('Add Forum'))
def post(self, topic_id, slug=None, post_id=None):
topic = Topic.query.filter_by(id=topic_id).first_or_404()
form = self.form()
# check if topic exists
if post_id is not None:
post = Post.query.filter_by(id=post_id).first_or_404()
if form.validate_on_submit():
post = form.save(real(current_user), topic)
return redirect(url_for("forum.view_post", post_id=post.id))
return render_template("forum/new_post.html", topic=topic, form=form)
def post(self, category_id):
category = Category.query.filter_by(id=category_id).first_or_404()
form = self.form(obj=category)
if form.validate_on_submit():
form.populate_obj(category)
flash(_('Category updated.'), 'success')
category.save()
return render_template('management/category_form.html',
form=form,
title=_('Edit Category'))
def post(self, post_id):
post = Post.query.filter_by(id=post_id).first_or_404()
form = self.form(obj=post)
if form.validate_on_submit():
form.populate_obj(post)
post.date_modified = time_utcnow()
post.modified_by = real(current_user).username
post.save()
return redirect(url_for("forum.view_post", post_id=post.id))
return render_template(
"forum/new_post.html", topic=post.topic, form=form, edit_mode=True
)
def get(self, forum_id):
forum = Forum.query.filter_by(id=forum_id).first_or_404()
form = self.form(forum)
if forum.moderators:
form.moderators.data = ','.join(
[user.username for user in forum.moderators])
else:
form.moderators.data = None
return render_template('management/forum_form.html',
form=form,
title=_('Edit Forum'))
def post(self):
form = self.form()
if form.validate_on_submit():
auth_manager = self.authentication_manager_factory()
try:
user = auth_manager.authenticate(
identifier=form.login.data, secret=form.password.data
)
login_user(user, remember=form.remember_me.data)
return redirect_or_next(url_for("forum.index"))
except StopAuthentication as e:
flash(e.reason, "danger")
except Exception:
flash(_("Unrecoverable error while handling login"))
return render_template("auth/login.html", form=form)
def get(self, slug=None, plugin=None):
form, old_settings, plugin_obj, active_nav = \
self._determine_active_settings(slug, plugin)
# get all groups and plugins - used to build the navigation
all_groups = SettingsGroup.query.all()
all_plugins = PluginRegistry.query.filter(
db.and_(PluginRegistry.values != None,
PluginRegistry.enabled == True)).all()
form = populate_settings_form(form, old_settings)
return render_template("management/settings.html",
form=form,
all_groups=all_groups,
all_plugins=all_plugins,
active_nav=active_nav)
def post(self, category_id=None):
form = self.form()
if form.validate_on_submit():
form.save()
flash(_('Forum added.'), 'success')
return redirect(url_for('management.forums'))
else:
form.groups.data = Group.query.order_by(Group.id.asc()).all()
if category_id:
category = Category.query.filter_by(id=category_id).first()
form.category.data = category
return render_template('management/forum_form.html',
form=form,
title=_('Add Forum'))
