def new_repo_hook_token(repo, username=None):
""" Re-generate a hook token for the present project.
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for('view_settings', username=username, repo=repo)
return flask.redirect(flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403, 'You are not allowed to change the settings for this project')
form = pagure.forms.ConfirmationForm()
if not form.validate_on_submit():
flask.abort(400, 'Invalid request')
try:
repo.hook_token = pagure.lib.login.id_generator(40)
SESSION.commit()
flask.flash('New hook token generated')
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Could not generate a new token for this project', 'error')
def update_project(repo, username=None):
""" Update the description of a project.
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for(
'view_settings', username=username, repo=repo.name)
return flask.redirect(
flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to change the settings for this project')
form = pagure.forms.ProjectFormSimplified()
if form.validate_on_submit():
try:
repo.description = form.description.data
repo.avatar_email = form.avatar_email.data.strip()
repo.url = form.url.data.strip()
SESSION.add(repo)
SESSION.commit()
flask.flash('Project updated')
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
def set_default_email():
""" Set the default email address of the user.
"""
if admin_session_timedout():
return flask.redirect(flask.url_for("auth_login", next=flask.request.url))
user = pagure.lib.search_user(SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, "User not found")
form = pagure.forms.UserEmailForm()
if form.validate_on_submit():
email = form.email.data
useremails = [mail.email for mail in user.emails]
if email not in useremails:
flask.flash("You do not have the email: %s, nothing to set" % email, "error")
return flask.redirect(flask.url_for(".user_settings"))
user.default_email = email
try:
SESSION.commit()
flask.flash("Default email set to: %s" % email)
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash("Default email could not be set", "error")
return flask.redirect(flask.url_for(".user_settings"))
def add_user_email():
""" Add a new email for the logged in user.
"""
if admin_session_timedout():
return flask.redirect(flask.url_for("auth_login", next=flask.request.url))
user = pagure.lib.search_user(SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, "User not found")
form = pagure.forms.UserEmailForm()
if form.validate_on_submit():
email = form.email.data
useremails = [mail.email for mail in user.emails]
if email in useremails:
flask.flash("The email: %s is already associated to you" % email, "error")
return flask.redirect(flask.url_for(".user_settings"))
try:
pagure.lib.add_user_pending_email(SESSION, user, email)
SESSION.commit()
flask.flash("Email pending validation")
return flask.redirect(flask.url_for(".user_settings"))
except pagure.exceptions.PagureException, err:
flask.flash(str(err), "error")
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash("Email could not be added", "error")
def delete_repo(repo, username=None):
""" Delete the present project.
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for('view_settings', username=username, repo=repo)
return flask.redirect(flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403, 'You are not allowed to change the settings for this project')
try:
for issue in repo.issues:
for comment in issue.comments:
SESSION.delete(comment)
SESSION.commit()
SESSION.delete(issue)
SESSION.delete(repo)
SESSION.commit()
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Could not delete the project', 'error')
def user_settings():
""" Update the user settings.
"""
if admin_session_timedout():
return flask.redirect(flask.url_for("auth_login", next=flask.request.url))
user = pagure.lib.search_user(SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, "User not found")
form = pagure.forms.UserSettingsForm()
if form.validate_on_submit():
ssh_key = form.ssh_key.data
try:
message = "Nothing to update"
if user.public_ssh_key != ssh_key:
pagure.lib.update_user_ssh(
SESSION, user=user, ssh_key=ssh_key, keydir=APP.config.get("GITOLITE_KEYDIR", None)
)
SESSION.commit()
message = "Public ssh key updated"
flask.flash(message)
return flask.redirect(flask.url_for("view_user", username=user.user))
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), "error")
def set_default_email():
""" Set the default email address of the user.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.UserEmailForm()
if form.validate_on_submit():
email = form.email.data
useremails = [mail.email for mail in user.emails]
if email not in useremails:
flask.flash(
'You do not have the email: %s, nothing to set' % email,
'error')
return flask.redirect(flask.url_for('.user_settings'))
user.default_email = email
try:
SESSION.commit()
flask.flash('Default email set to: %s' % email)
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Default email could not be set', 'error')
return flask.redirect(flask.url_for('.user_settings'))
def delete_repo(repo, username=None):
""" Delete the present project.
"""
if not pagure.APP.config.get('ENABLE_DEL_PROJECTS', True):
flask.abort(404)
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for(
'view_settings', username=username, repo=repo)
return flask.redirect(
flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to change the settings for this project')
try:
for issue in repo.issues:
for comment in issue.comments:
SESSION.delete(comment)
SESSION.commit()
SESSION.delete(issue)
SESSION.delete(repo)
SESSION.commit()
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Could not delete the project', 'error')
def user_settings():
""" Update the user settings.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.UserSettingsForm()
if form.validate_on_submit():
ssh_key = form.ssh_key.data
try:
message = pagure.lib.update_user_ssh(
SESSION,
user=user,
ssh_key=ssh_key,
)
if message != 'Nothing to update':
generate_gitolite_key(user.user, ssh_key)
generate_authorized_key_file()
SESSION.commit()
flask.flash(message)
return flask.redirect(
flask.url_for('view_user', username=user.user))
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
def change_ref_head(repo, username=None):
""" Change HEAD reference
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for(
'view_settings', username=username, repo=repo)
return flask.redirect(
flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to change the settings for this project')
repopath = pagure.get_repo_path(repo)
repo_obj = pygit2.Repository(repopath)
branches = repo_obj.listall_branches()
form = pagure.forms.DefaultBranchForm(branches=branches)
if form.validate_on_submit():
branchname = form.branches.data
try:
reference = repo_obj.lookup_reference('refs/heads/%s'%branchname).resolve()
repo_obj.set_head(reference.name)
flask.flash('Default branch updated to %s'%branchname)
except Exception as err: # pragma: no cover
APP.logger.exception(err)
return flask.redirect(flask.url_for(
'view_settings', username=username, repo=repo.name))
def user_settings():
""" Update the user settings.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.UserSettingsForm()
if form.validate_on_submit():
ssh_key = form.ssh_key.data
try:
message = 'Nothing to update'
if user.public_ssh_key != ssh_key:
pagure.lib.update_user_ssh(
SESSION,
user=user,
ssh_key=ssh_key,
keydir=APP.config.get('GITOLITE_KEYDIR', None),
)
SESSION.commit()
message = 'Public ssh key updated'
flask.flash(message)
return flask.redirect(
flask.url_for('view_user', username=user.user))
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
def revoke_api_user_token(token_id):
""" Revoke a user token (ie: not project specific).
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for('.user_settings')
return flask.redirect(flask.url_for('auth_login', next=url))
token = pagure.lib.get_api_token(SESSION, token_id)
if not token \
or token.user.username != flask.g.fas_user.username:
flask.abort(404, 'Token not found')
form = pagure.forms.ConfirmationForm()
if form.validate_on_submit():
try:
if token.expiration >= datetime.datetime.utcnow():
token.expiration = datetime.datetime.utcnow()
SESSION.add(token)
SESSION.commit()
flask.flash('Token revoked')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
_log.exception(err)
flask.flash('Token could not be revoked, please contact an admin',
'error')
return flask.redirect(flask.url_for('.user_settings'))
def new_repo_hook_token(repo, username=None):
""" Re-generate a hook token for the present project.
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for(
'view_settings', username=username, repo=repo)
return flask.redirect(
flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to change the settings for this project')
form = pagure.forms.ConfirmationForm()
if not form.validate_on_submit():
flask.abort(400, 'Invalid request')
try:
repo.hook_token = pagure.lib.login.id_generator(40)
SESSION.commit()
flask.flash('New hook token generated')
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Could not generate a new token for this project', 'error')
def add_user_email():
""" Add a new email for the logged in user.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(
SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.UserEmailForm(
emails=[mail.email for mail in user.emails])
if form.validate_on_submit():
email = form.email.data
try:
pagure.lib.add_user_pending_email(SESSION, user, email)
SESSION.commit()
flask.flash('Email pending validation')
return flask.redirect(flask.url_for('.user_settings'))
except pagure.exceptions.PagureException as err:
flask.flash(str(err), 'error')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Email could not be added', 'error')
return flask.render_template(
'user_emails.html',
user=user,
form=form,
)
def user_settings():
""" Update the user settings.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(
SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.UserSettingsForm()
if form.validate_on_submit():
ssh_key = form.ssh_key.data
try:
message = pagure.lib.update_user_ssh(
SESSION,
user=user,
ssh_key=ssh_key,
)
if message != 'Nothing to update':
generate_gitolite_key(user.user, ssh_key)
generate_authorized_key_file()
SESSION.commit()
flask.flash(message)
return flask.redirect(
flask.url_for('view_user', username=user.user))
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
def regenerate_git(repo, username=None):
""" Regenerate the specified git repo with the content in the project.
"""
if admin_session_timedout():
flask.flash("Action canceled, try it again", "error")
url = flask.url_for("view_settings", username=username, repo=repo)
return flask.redirect(flask.url_for("auth_login", next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, "Project not found")
if not is_repo_admin(repo):
flask.abort(403, "You are not allowed to regenerate the git repos")
regenerate = flask.request.form.get("regenerate")
if not regenerate or regenerate.lower() not in ["tickets", "requests"]:
flask.abort(400, "You can only regenerate tickest or requests repos")
form = pagure.forms.ConfirmationForm()
if form.validate_on_submit():
if regenerate.lower() == "requests":
for request in repo.requests:
pagure.lib.git.update_git(request, repo=repo, repofolder=APP.config["REQUESTS_FOLDER"])
flask.flash("Requests git repo updated")
elif regenerate.lower() == "tickets":
for ticket in repo.issues:
# Do not store private issues in the git
if ticket.private:
continue
pagure.lib.git.update_git(ticket, repo=repo, repofolder=APP.config["TICKETS_FOLDER"])
flask.flash("Tickets git repo updated")
return flask.redirect(flask.url_for(".view_settings", repo=repo.name, username=username))
def reconfirm_email():
""" Re-send the email address of the user.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(
SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.UserEmailForm()
if form.validate_on_submit():
email = form.email.data
try:
pagure.lib.resend_pending_email(SESSION, user, email)
SESSION.commit()
flask.flash('Confirmation email re-sent')
except pagure.exceptions.PagureException as err:
flask.flash(str(err), 'error')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Confirmation email could not be re-sent', 'error')
return flask.redirect(flask.url_for('.user_settings'))
def add_user_email():
""" Add a new email for the logged in user.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.UserEmailForm(
emails=[mail.email for mail in user.emails])
if form.validate_on_submit():
email = form.email.data
try:
pagure.lib.add_user_pending_email(SESSION, user, email)
SESSION.commit()
flask.flash('Email pending validation')
return flask.redirect(flask.url_for('.user_settings'))
except pagure.exceptions.PagureException as err:
flask.flash(str(err), 'error')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Email could not be added', 'error')
return flask.render_template(
'user_emails.html',
user=user,
form=form,
)
def new_repo_hook_token(repo, username=None):
""" Re-generate a hook token for the present project.
"""
if not pagure.APP.config.get("WEBHOOK", False):
flask.abort(404)
if admin_session_timedout():
flask.flash("Action canceled, try it again", "error")
url = flask.url_for("view_settings", username=username, repo=repo)
return flask.redirect(flask.url_for("auth_login", next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, "Project not found")
if not is_repo_admin(repo):
flask.abort(403, "You are not allowed to change the settings for this project")
form = pagure.forms.ConfirmationForm()
if not form.validate_on_submit():
flask.abort(400, "Invalid request")
try:
repo.hook_token = pagure.lib.login.id_generator(40)
SESSION.commit()
flask.flash("New hook token generated")
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash("Could not generate a new token for this project", "error")
return flask.redirect(flask.url_for("view_settings", repo=repo.name, username=username))
def add_token(repo, username=None):
""" Add a token to a specified project.
"""
if admin_session_timedout():
if flask.request.method == "POST":
flask.flash("Action canceled, try it again", "error")
return flask.redirect(flask.url_for("auth_login", next=flask.request.url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, "Project not found")
if not is_repo_admin(repo):
flask.abort(403, "You are not allowed to change the settings for this project")
acls = pagure.lib.get_acls(SESSION)
form = pagure.forms.NewTokenForm(acls=acls)
if form.validate_on_submit():
try:
msg = pagure.lib.add_token_to_user(SESSION, repo, acls=form.acls.data, username=flask.g.fas_user.username)
SESSION.commit()
flask.flash(msg)
return flask.redirect(flask.url_for(".view_settings", repo=repo.name, username=username))
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash("User could not be added", "error")
return flask.render_template("add_token.html", form=form, acls=acls, username=username, repo=repo)
def revoke_api_token(repo, token_id, username=None):
""" Revokie a token to a specified project.
"""
if admin_session_timedout():
flask.flash("Action canceled, try it again", "error")
url = flask.url_for("view_settings", username=username, repo=repo)
return flask.redirect(flask.url_for("auth_login", next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, "Project not found")
if not is_repo_admin(repo):
flask.abort(403, "You are not allowed to change the settings for this project")
token = pagure.lib.get_api_token(SESSION, token_id)
if not token or token.project.fullname != repo.fullname or token.user.username != flask.g.fas_user.username:
flask.abort(404, "Token not found")
form = pagure.forms.ConfirmationForm()
if form.validate_on_submit():
try:
token.expiration = datetime.datetime.utcnow()
SESSION.commit()
flask.flash("Token revoked")
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash("Token could not be revoked, please contact an admin", "error")
return flask.redirect(flask.url_for(".view_settings", repo=repo.name, username=username))
def change_ref_head(repo, username=None):
""" Change HEAD reference
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for('view_settings', username=username, repo=repo)
return flask.redirect(flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403, 'You are not allowed to change the settings for this project')
repopath = pagure.get_repo_path(repo)
repo_obj = pygit2.Repository(repopath)
branches = repo_obj.listall_branches()
form = pagure.forms.DefaultBranchForm(branches=branches)
if form.validate_on_submit():
branchname = form.branches.data
try:
reference = repo_obj.lookup_reference('refs/heads/%s' %
branchname).resolve()
repo_obj.set_head(reference.name)
flask.flash('Default branch updated to %s' % branchname)
except Exception as err: # pragma: no cover
APP.logger.exception(err)
return flask.redirect(
flask.url_for('view_settings', username=username, repo=repo.name))
def reconfirm_email():
""" Re-send the email address of the user.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.UserEmailForm()
if form.validate_on_submit():
email = form.email.data
try:
pagure.lib.resend_pending_email(SESSION, user, email)
SESSION.commit()
flask.flash('Confirmation email re-sent')
except pagure.exceptions.PagureException as err:
flask.flash(str(err), 'error')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Confirmation email could not be re-sent', 'error')
return flask.redirect(flask.url_for('.user_settings'))
def view_settings(repo, username=None):
""" Presents the settings of the project.
"""
if admin_session_timedout():
if flask.request.method == 'POST':
flask.flash('Action canceled, try it again', 'error')
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
repo_admin = is_repo_admin(repo)
if not repo_admin:
flask.abort(
403,
'You are not allowed to change the settings for this project')
reponame = pagure.get_repo_path(repo)
repo_obj = pygit2.Repository(reponame)
plugins = pagure.ui.plugins.get_plugin_names(
APP.config.get('DISABLED_PLUGINS'))
tags = pagure.lib.get_tags_of_project(SESSION, repo)
form = pagure.forms.ConfirmationForm()
tag_form = pagure.forms.AddIssueTagForm()
branches = repo_obj.listall_branches()
branches_form = pagure.forms.DefaultBranchForm(branches=branches)
if form.validate_on_submit():
settings = {}
for key in flask.request.form:
if key == 'csrf_token':
continue
settings[key] = flask.request.form[key]
try:
message = pagure.lib.update_project_settings(
SESSION,
repo=repo,
settings=settings,
user=flask.g.fas_user.username,
)
SESSION.commit()
flask.flash(message)
return flask.redirect(flask.url_for(
'view_repo', username=username, repo=repo.name))
except pagure.exceptions.PagureException as msg:
SESSION.rollback()
flask.flash(msg, 'error')
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
def view_settings(repo, username=None):
""" Presents the settings of the project.
"""
if admin_session_timedout():
if flask.request.method == 'POST':
flask.flash('Action canceled, try it again', 'error')
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
repo_admin = is_repo_admin(repo)
if not repo_admin:
flask.abort(
403,
'You are not allowed to change the settings for this project')
reponame = pagure.get_repo_path(repo)
repo_obj = pygit2.Repository(reponame)
plugins = pagure.ui.plugins.get_plugin_names(
APP.config.get('DISABLED_PLUGINS'))
tags = pagure.lib.get_tags_of_project(SESSION, repo)
form = pagure.forms.ConfirmationForm()
tag_form = pagure.forms.AddIssueTagForm()
branches = repo_obj.listall_branches()
branches_form = pagure.forms.DefaultBranchForm(branches=branches)
if form.validate_on_submit():
settings = {}
for key in flask.request.form:
if key == 'csrf_token':
continue
settings[key] = flask.request.form[key]
try:
message = pagure.lib.update_project_settings(
SESSION,
repo=repo,
settings=settings,
user=flask.g.fas_user.username,
)
SESSION.commit()
flask.flash(message)
return flask.redirect(flask.url_for(
'view_repo', username=username, repo=repo.name))
except pagure.exceptions.PagureException as msg:
SESSION.rollback()
flask.flash(msg, 'error')
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
def decorated_function(*args, **kwargs):
""" Decorated function, actually does the work. """
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
elif not is_admin():
flask.flash('Access restricted', 'error')
return flask.redirect(flask.url_for('.index'))
return function(*args, **kwargs)
def decorated_function(*args, **kwargs):
""" Decorated function, actually does the work. """
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
elif not is_admin():
flask.flash('Access restricted', 'error')
return flask.redirect(flask.url_for('.index'))
return function(*args, **kwargs)
def delete_repo(repo, username=None):
""" Delete the present project.
"""
if not pagure.APP.config.get('ENABLE_DEL_PROJECTS', True):
flask.abort(404)
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for(
'view_settings', username=username, repo=repo)
return flask.redirect(
flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to change the settings for this project')
try:
for issue in repo.issues:
for comment in issue.comments:
SESSION.delete(comment)
SESSION.commit()
SESSION.delete(issue)
SESSION.delete(repo)
SESSION.commit()
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Could not delete the project', 'error')
repopath = os.path.join(APP.config['GIT_FOLDER'], repo.path)
if repo.is_fork:
repopath = os.path.join(APP.config['FORK_FOLDER'], repo.path)
docpath = os.path.join(APP.config['DOCS_FOLDER'], repo.path)
ticketpath = os.path.join(APP.config['TICKETS_FOLDER'], repo.path)
requestpath = os.path.join(APP.config['REQUESTS_FOLDER'], repo.path)
try:
shutil.rmtree(repopath)
shutil.rmtree(docpath)
shutil.rmtree(ticketpath)
shutil.rmtree(requestpath)
except (OSError, IOError) as err:
APP.logger.exception(err)
flask.flash(
'Could not delete all the repos from the system', 'error')
return flask.redirect(
flask.url_for('view_user', username=flask.g.fas_user.username))
def add_group_project(repo, username=None):
""" Add the specified group from the project.
"""
if not pagure.APP.config.get('ENABLE_USER_MNGT', True):
flask.abort(404)
if admin_session_timedout():
if flask.request.method == 'POST':
flask.flash('Action canceled, try it again', 'error')
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to add groups to this project')
form = pagure.forms.AddGroupForm()
if form.validate_on_submit():
try:
msg = pagure.lib.add_group_to_project(
SESSION, repo,
new_group=form.group.data,
user=flask.g.fas_user.username,
)
SESSION.commit()
pagure.lib.git.generate_gitolite_acls()
flask.flash(msg)
return flask.redirect(
flask.url_for(
'.view_settings', repo=repo.name, username=username)
)
except pagure.exceptions.PagureException as msg:
SESSION.rollback()
flask.flash(msg, 'error')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Group could not be added', 'error')
return flask.render_template(
'add_group_project.html',
form=form,
username=username,
repo=repo,
)
def add_group_project(repo, username=None):
""" Add the specified group from the project.
"""
if not pagure.APP.config.get('ENABLE_USER_MNGT', True):
flask.abort(404)
if admin_session_timedout():
if flask.request.method == 'POST':
flask.flash('Action canceled, try it again', 'error')
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to add groups to this project')
form = pagure.forms.AddGroupForm()
if form.validate_on_submit():
try:
msg = pagure.lib.add_group_to_project(
SESSION, repo,
new_group=form.group.data,
user=flask.g.fas_user.username,
)
SESSION.commit()
pagure.lib.git.generate_gitolite_acls()
flask.flash(msg)
return flask.redirect(
flask.url_for(
'.view_settings', repo=repo.name, username=username)
)
except pagure.exceptions.PagureException as msg:
SESSION.rollback()
flask.flash(msg, 'error')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Group could not be added', 'error')
return flask.render_template(
'add_group_project.html',
form=form,
username=username,
repo=repo,
)
def delete_repo(repo, username=None):
""" Delete the present project.
"""
if not pagure.APP.config.get('ENABLE_DEL_PROJECTS', True):
flask.abort(404)
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for('view_settings', username=username, repo=repo)
return flask.redirect(flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403, 'You are not allowed to change the settings for this project')
try:
for issue in repo.issues:
for comment in issue.comments:
SESSION.delete(comment)
SESSION.commit()
SESSION.delete(issue)
SESSION.delete(repo)
SESSION.commit()
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Could not delete the project', 'error')
repopath = os.path.join(APP.config['GIT_FOLDER'], repo.path)
if repo.is_fork:
repopath = os.path.join(APP.config['FORK_FOLDER'], repo.path)
docpath = os.path.join(APP.config['DOCS_FOLDER'], repo.path)
ticketpath = os.path.join(APP.config['TICKETS_FOLDER'], repo.path)
requestpath = os.path.join(APP.config['REQUESTS_FOLDER'], repo.path)
try:
shutil.rmtree(repopath)
shutil.rmtree(docpath)
shutil.rmtree(ticketpath)
shutil.rmtree(requestpath)
except (OSError, IOError) as err:
APP.logger.exception(err)
flask.flash('Could not delete all the repos from the system', 'error')
return flask.redirect(
flask.url_for('view_user', username=flask.g.fas_user.username))
def remove_user(repo, userid, username=None):
""" Remove the specified user from the project.
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for(
'view_settings', username=username, repo=repo)
return flask.redirect(
flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to change the users for this project')
form = pagure.forms.ConfirmationForm()
if form.validate_on_submit():
userids = [str(user.id) for user in repo.users]
if str(userid) not in userids:
flask.flash(
'User does not have commit or cannot loose it right', 'error')
return flask.redirect(
flask.url_for(
'.view_settings', repo=repo.name, username=username)
)
for user in repo.users:
if str(user.id) == str(userid):
repo.users.remove(user)
break
try:
SESSION.commit()
pagure.lib.git.generate_gitolite_acls()
flask.flash('User removed')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('User could not be removed', 'error')
return flask.redirect(
flask.url_for('.view_settings', repo=repo.name, username=username)
)
def add_token(repo, username=None):
""" Add a token to a specified project.
"""
if admin_session_timedout():
if flask.request.method == 'POST':
flask.flash('Action canceled, try it again', 'error')
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to change the settings for this project')
acls = pagure.lib.get_acls(SESSION)
form = pagure.forms.NewTokenForm(acls=acls)
if form.validate_on_submit():
try:
msg = pagure.lib.add_token_to_user(
SESSION,
repo,
acls=form.acls.data,
username=flask.g.fas_user.username,
)
SESSION.commit()
flask.flash(msg)
return flask.redirect(
flask.url_for(
'.view_settings', repo=repo.name, username=username)
)
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('User could not be added', 'error')
return flask.render_template(
'add_token.html',
form=form,
acls=acls,
username=username,
repo=repo,
)
def remove_user(repo, userid, username=None):
""" Remove the specified user from the project.
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for(
'view_settings', username=username, repo=repo)
return flask.redirect(
flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to change the users for this project')
form = pagure.forms.ConfirmationForm()
if form.validate_on_submit():
userids = [str(user.id) for user in repo.users]
if str(userid) not in userids:
flask.flash(
'User does not have commit or cannot loose it right', 'error')
return flask.redirect(
flask.url_for(
'.view_settings', repo=repo.name, username=username)
)
for user in repo.users:
if str(user.id) == str(userid):
repo.users.remove(user)
break
try:
SESSION.commit()
pagure.lib.git.generate_gitolite_acls()
flask.flash('User removed')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('User could not be removed', 'error')
return flask.redirect(
flask.url_for('.view_settings', repo=repo.name, username=username)
)
def remove_user_email():
""" Remove the specified email from the logged in user.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(
SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
if len(user.emails) == 1:
flask.flash(
'You must always have at least one email', 'error')
return flask.redirect(
flask.url_for('.user_settings')
)
form = pagure.forms.UserEmailForm()
if form.validate_on_submit():
email = form.email.data
useremails = [mail.email for mail in user.emails]
if email not in useremails:
flask.flash(
'You do not have the email: %s, nothing to remove' % email,
'error')
return flask.redirect(
flask.url_for('.user_settings')
)
for mail in user.emails:
if mail.email == email:
user.emails.remove(mail)
break
try:
SESSION.commit()
flask.flash('Email removed')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Email could not be removed', 'error')
return flask.redirect(flask.url_for('.user_settings'))
def remove_user_email():
""" Remove the specified email from the logged in user.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(
SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
if len(user.emails) == 1:
flask.flash(
'You must always have at least one email', 'error')
return flask.redirect(
flask.url_for('.user_settings')
)
form = pagure.forms.UserEmailForm()
if form.validate_on_submit():
email = form.email.data
useremails = [mail.email for mail in user.emails]
if email not in useremails:
flask.flash(
'You do not have the email: %s, nothing to remove' % email,
'error')
return flask.redirect(
flask.url_for('.user_settings')
)
for mail in user.emails:
if mail.email == email:
user.emails.remove(mail)
break
try:
SESSION.commit()
flask.flash('Email removed')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash('Email could not be removed', 'error')
return flask.redirect(flask.url_for('.user_settings'))
def revoke_api_token(repo, token_id, username=None):
""" Revokie a token to a specified project.
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for(
'view_settings', username=username, repo=repo)
return flask.redirect(
flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403,
'You are not allowed to change the settings for this project')
token = pagure.lib.get_api_token(SESSION, token_id)
if not token \
or token.project.fullname != repo.fullname \
or token.user.username != flask.g.fas_user.username:
flask.abort(404, 'Token not found')
form = pagure.forms.ConfirmationForm()
if form.validate_on_submit():
try:
token.expiration = datetime.datetime.utcnow()
SESSION.commit()
flask.flash('Token revoked')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash(
'Token could not be revoked, please contact an admin',
'error')
return flask.redirect(
flask.url_for(
'.view_settings', repo=repo.name, username=username)
)
def regenerate_git(repo, username=None):
""" Regenerate the specified git repo with the content in the project.
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for(
'view_settings', username=username, repo=repo)
return flask.redirect(
flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(403, 'You are not allowed to regenerate the git repos')
regenerate = flask.request.form.get('regenerate')
if not regenerate or regenerate.lower() not in ['tickets', 'requests']:
flask.abort(400, 'You can only regenerate tickest or requests repos')
form = pagure.forms.ConfirmationForm()
if form.validate_on_submit():
if regenerate.lower() == 'requests':
for request in repo.requests:
pagure.lib.git.update_git(
request, repo=repo,
repofolder=APP.config['REQUESTS_FOLDER'])
flask.flash('Requests git repo updated')
elif regenerate.lower() == 'tickets':
for ticket in repo.issues:
# Do not store private issues in the git
if ticket.private:
continue
pagure.lib.git.update_git(
ticket, repo=repo,
repofolder=APP.config['TICKETS_FOLDER'])
flask.flash('Tickets git repo updated')
return flask.redirect(
flask.url_for('.view_settings', repo=repo.name, username=username)
)
def regenerate_git(repo, username=None):
""" Regenerate the specified git repo with the content in the project.
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for(
'view_settings', username=username, repo=repo)
return flask.redirect(
flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(403, 'You are not allowed to regenerate the git repos')
regenerate = flask.request.form.get('regenerate')
if not regenerate or regenerate.lower() not in ['tickets', 'requests']:
flask.abort(400, 'You can only regenerate tickest or requests repos')
form = pagure.forms.ConfirmationForm()
if form.validate_on_submit():
if regenerate.lower() == 'requests':
for request in repo.requests:
pagure.lib.git.update_git(
request, repo=repo,
repofolder=APP.config['REQUESTS_FOLDER'])
flask.flash('Requests git repo updated')
elif regenerate.lower() == 'tickets':
for ticket in repo.issues:
# Do not store private issues in the git
if ticket.private:
continue
pagure.lib.git.update_git(
ticket, repo=repo,
repofolder=APP.config['TICKETS_FOLDER'])
flask.flash('Tickets git repo updated')
return flask.redirect(
flask.url_for('.view_settings', repo=repo.name, username=username)
)
def add_api_user_token():
""" Create an user token (not project specific).
"""
if admin_session_timedout():
if flask.request.method == 'POST':
flask.flash('Action canceled, try it again', 'error')
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
# Ensure the user is in the DB at least
user = _get_user(username=flask.g.fas_user.username)
acls = pagure.lib.get_acls(SESSION,
restrict=APP.config.get('CROSS_PROJECT_ACLS'))
form = pagure.forms.NewTokenForm(acls=acls)
if form.validate_on_submit():
try:
msg = pagure.lib.add_token_to_user(
SESSION,
project=None,
description=form.description.data.strip() or None,
acls=form.acls.data,
username=user.username,
)
SESSION.commit()
flask.flash(msg)
return flask.redirect(flask.url_for('.user_settings'))
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
_log.exception(err)
flask.flash('API key could not be added', 'error')
# When form is displayed after an empty submission, show an error.
if form.errors.get('acls'):
flask.flash('You must select at least one permission.', 'error')
return flask.render_template(
'add_token.html',
select='settings',
form=form,
acls=acls,
)
def user_settings():
""" Update the user settings.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(
SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.UserSettingsForm()
if form.validate_on_submit():
ssh_key = form.ssh_key.data
try:
message = 'Nothing to update'
if user.public_ssh_key != ssh_key:
pagure.lib.update_user_ssh(
SESSION,
user=user,
ssh_key=ssh_key,
keydir=APP.config.get('GITOLITE_KEYDIR', None),
)
SESSION.commit()
message = 'Public ssh key updated'
flask.flash(message)
return flask.redirect(
flask.url_for('.user_settings'))
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
elif flask.request.method == 'GET':
form.ssh_key.data = user.public_ssh_key
return flask.render_template(
'user_settings.html',
user=user,
form=form,
)
def confirm_email(token):
""" Confirm a new email.
"""
if admin_session_timedout():
return flask.redirect(flask.url_for("auth_login", next=flask.request.url))
email = pagure.lib.search_pending_email(SESSION, token=token)
if not email:
flask.flash("No email associated with this token.", "error")
else:
try:
pagure.lib.add_email_to_user(SESSION, email.user, email.email)
SESSION.delete(email)
SESSION.commit()
flask.flash("Email validated")
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
flask.flash(
"Could not set the account as active in the db, " "please report this error to an admin", "error"
)
APP.logger.exception(err)
def update_project(repo, username=None):
""" Update the description of a project.
"""
if admin_session_timedout():
flask.flash('Action canceled, try it again', 'error')
url = flask.url_for('view_settings', username=username, repo=repo)
return flask.redirect(flask.url_for('auth_login', next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, 'Project not found')
if not is_repo_admin(repo):
flask.abort(
403, 'You are not allowed to change the settings for this project')
form = pagure.forms.ProjectFormSimplified()
if form.validate_on_submit():
try:
repo.description = form.description.data
repo.avatar_email = form.avatar_email.data.strip()
repo.url = form.url.data.strip()
pagure.lib.update_tags(
SESSION,
repo,
tags=[t.strip() for t in form.tags.data.split(',')],
username=flask.g.fas_user.username,
ticketfolder=None,
)
SESSION.add(repo)
SESSION.commit()
flask.flash('Project updated')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(
flask.url_for('view_settings', username=username, repo=repo.name))
def update_user_settings():
""" Update the user's settings set in the settings page.
"""
if admin_session_timedout():
if flask.request.method == 'POST':
flask.flash('Action canceled, try it again', 'error')
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(
SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.ConfirmationForm()
if form.validate_on_submit():
settings = {}
for key in flask.request.form:
if key == 'csrf_token':
continue
settings[key] = flask.request.form[key]
try:
message = pagure.lib.update_user_settings(
SESSION,
settings=settings,
user=flask.g.fas_user.username,
)
SESSION.commit()
flask.flash(message)
except pagure.exceptions.PagureException as msg:
SESSION.rollback()
flask.flash(msg, 'error')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(flask.url_for('user_settings'))
def update_user_settings():
""" Update the user's settings set in the settings page.
"""
if admin_session_timedout():
if flask.request.method == 'POST':
flask.flash('Action canceled, try it again', 'error')
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = pagure.lib.search_user(
SESSION, username=flask.g.fas_user.username)
if not user:
flask.abort(404, 'User not found')
form = pagure.forms.ConfirmationForm()
if form.validate_on_submit():
settings = {}
for key in flask.request.form:
if key == 'csrf_token':
continue
settings[key] = flask.request.form[key]
try:
message = pagure.lib.update_user_settings(
SESSION,
settings=settings,
user=flask.g.fas_user.username,
)
SESSION.commit()
flask.flash(message)
except pagure.exceptions.PagureException as msg:
SESSION.rollback()
flask.flash(msg, 'error')
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(flask.url_for('user_settings'))
def confirm_email(token):
""" Confirm a new email.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
email = pagure.lib.search_pending_email(SESSION, token=token)
if not email:
flask.flash('No email associated with this token.', 'error')
else:
try:
pagure.lib.add_email_to_user(SESSION, email.user, email.email)
SESSION.delete(email)
SESSION.commit()
flask.flash('Email validated')
except SQLAlchemyError, err: # pragma: no cover
SESSION.rollback()
flask.flash(
'Could not set the account as active in the db, '
'please report this error to an admin', 'error')
APP.logger.exception(err)
def update_project(repo, username=None):
""" Update the description of a project.
"""
if admin_session_timedout():
flask.flash("Action canceled, try it again", "error")
url = flask.url_for("view_settings", username=username, repo=repo)
return flask.redirect(flask.url_for("auth_login", next=url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, "Project not found")
if not is_repo_admin(repo):
flask.abort(403, "You are not allowed to change the settings for this project")
form = pagure.forms.ProjectFormSimplified()
if form.validate_on_submit():
try:
repo.description = form.description.data
repo.avatar_email = form.avatar_email.data.strip()
repo.url = form.url.data.strip()
pagure.lib.update_tags(
SESSION,
repo,
tags=[t.strip() for t in form.tags.data.split(",")],
username=flask.g.fas_user.username,
ticketfolder=None,
)
SESSION.add(repo)
SESSION.commit()
flask.flash("Project updated")
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), "error")
return flask.redirect(flask.url_for("view_settings", username=username, repo=repo.name))
def add_user(repo, username=None):
""" Add the specified user from the project.
"""
if not pagure.APP.config.get("ENABLE_USER_MNGT", True):
flask.abort(404)
if admin_session_timedout():
if flask.request.method == "POST":
flask.flash("Action canceled, try it again", "error")
return flask.redirect(flask.url_for("auth_login", next=flask.request.url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, "Project not found")
if not is_repo_admin(repo):
flask.abort(403, "You are not allowed to add users to this project")
form = pagure.forms.AddUserForm()
if form.validate_on_submit():
try:
msg = pagure.lib.add_user_to_project(SESSION, repo, new_user=form.user.data, user=flask.g.fas_user.username)
SESSION.commit()
pagure.lib.git.generate_gitolite_acls()
flask.flash(msg)
return flask.redirect(flask.url_for(".view_settings", repo=repo.name, username=username))
except pagure.exceptions.PagureException as msg:
SESSION.rollback()
flask.flash(msg, "error")
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
APP.logger.exception(err)
flask.flash("User could not be added", "error")
return flask.render_template("add_user.html", form=form, username=username, repo=repo)
def user_settings():
""" Update the user settings.
"""
if admin_session_timedout():
return flask.redirect(
flask.url_for('auth_login', next=flask.request.url))
user = _get_user(username=flask.g.fas_user.username)
form = pagure.forms.UserSettingsForm()
if form.validate_on_submit() and APP.config.get('LOCAL_SSH_KEY', True):
ssh_key = form.ssh_key.data
try:
message = 'Nothing to update'
if user.public_ssh_key != ssh_key:
pagure.lib.update_user_ssh(
SESSION,
user=user,
ssh_key=ssh_key,
keydir=APP.config.get('GITOLITE_KEYDIR', None),
)
SESSION.commit()
message = 'Public ssh key updated'
flask.flash(message)
return flask.redirect(flask.url_for('.user_settings'))
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
elif flask.request.method == 'GET':
form.ssh_key.data = user.public_ssh_key
return flask.render_template(
'user_settings.html',
user=user,
form=form,
)
def view_settings(repo, username=None):
""" Presents the settings of the project.
"""
if admin_session_timedout():
if flask.request.method == "POST":
flask.flash("Action canceled, try it again", "error")
return flask.redirect(flask.url_for("auth_login", next=flask.request.url))
repo = pagure.lib.get_project(SESSION, repo, user=username)
if not repo:
flask.abort(404, "Project not found")
repo_admin = is_repo_admin(repo)
if not repo_admin:
flask.abort(403, "You are not allowed to change the settings for this project")
reponame = pagure.get_repo_path(repo)
repo_obj = pygit2.Repository(reponame)
plugins = pagure.ui.plugins.get_plugin_names(APP.config.get("DISABLED_PLUGINS"))
tags = pagure.lib.get_tags_of_project(SESSION, repo)
form = pagure.forms.ConfirmationForm()
tag_form = pagure.forms.AddIssueTagForm()
branches = repo_obj.listall_branches()
branches_form = pagure.forms.DefaultBranchForm(branches=branches)
if form.validate_on_submit():
settings = {}
for key in flask.request.form:
if key == "csrf_token":
continue
settings[key] = flask.request.form[key]
try:
message = pagure.lib.update_project_settings(
SESSION, repo=repo, settings=settings, user=flask.g.fas_user.username
)
SESSION.commit()
flask.flash(message)
return flask.redirect(flask.url_for("view_repo", username=username, repo=repo.name))
except pagure.exceptions.PagureException as msg:
SESSION.rollback()
flask.flash(msg, "error")
except SQLAlchemyError as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), "error")
if not repo_obj.is_empty and not repo_obj.head_is_unborn:
branchname = repo_obj.head.shorthand
else:
branchname = None
return flask.render_template(
"settings.html",
select="settings",
username=username,
repo=repo,
form=form,
tag_form=tag_form,
branches_form=branches_form,
tags=tags,
plugins=plugins,
repo_admin=repo_admin,
branchname=branchname,
)