feat(2fa): updates routes names and urls to better reflect actions

rhodecode/apps/login/views.py

@@ -1,554 +1,554 b''
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 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 <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import time
 import json
 import pyotp
 import qrcode
 import collections
 import datetime
 import formencode
 import formencode.htmlfill
 import logging
 import urllib.parse
 import requests
 from io import BytesIO
 from base64 import b64encode
 
 from pyramid.renderers import render
 from pyramid.response import Response
 from pyramid.httpexceptions import HTTPFound
 
 
 from rhodecode.apps._base import BaseAppView
 from rhodecode.authentication.base import authenticate, HTTP_TYPE
 from rhodecode.authentication.plugins import auth_rhodecode
 from rhodecode.events import UserRegistered, trigger
 from rhodecode.lib import helpers as h
 from rhodecode.lib import audit_logger
 from rhodecode.lib.auth import (
     AuthUser, HasPermissionAnyDecorator, CSRFRequired, LoginRequired, NotAnonymous)
 from rhodecode.lib.base import get_ip_addr
 from rhodecode.lib.exceptions import UserCreationError
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.model.db import User, UserApiKeys
 from rhodecode.model.forms import LoginForm, RegisterForm, PasswordResetForm, TOTPForm
 from rhodecode.model.meta import Session
 from rhodecode.model.auth_token import AuthTokenModel
 from rhodecode.model.settings import SettingsModel
 from rhodecode.model.user import UserModel
 from rhodecode.translation import _
 
 
 log = logging.getLogger(__name__)
 
 CaptchaData = collections.namedtuple(
     'CaptchaData', 'active, private_key, public_key')
 
 
 def store_user_in_session(session, user_identifier, remember=False):
     user = User.get_by_username_or_primary_email(user_identifier)
     auth_user = AuthUser(user.user_id)
     auth_user.set_authenticated()
     cs = auth_user.get_cookie_store()
     session['rhodecode_user'] = cs
     user.update_lastlogin()
     Session().commit()
 
     # If they want to be remembered, update the cookie
     if remember:
         _year = (datetime.datetime.now() +
                  datetime.timedelta(seconds=60 * 60 * 24 * 365))
         session._set_cookie_expires(_year)
 
     session.save()
 
     safe_cs = cs.copy()
     safe_cs['password'] = '****'
     log.info('user %s is now authenticated and stored in '
              'session, session attrs %s', user_identifier, safe_cs)
 
     # dumps session attrs back to cookie
     session._update_cookie_out()
     # we set new cookie
     headers = None
     if session.request['set_cookie']:
         # send set-cookie headers back to response to update cookie
         headers = [('Set-Cookie', session.request['cookie_out'])]
     return headers
 
 
 def get_came_from(request):
     came_from = safe_str(request.GET.get('came_from', ''))
     parsed = urllib.parse.urlparse(came_from)
 
     allowed_schemes = ['http', 'https']
     default_came_from = h.route_path('home')
     if parsed.scheme and parsed.scheme not in allowed_schemes:
         log.error('Suspicious URL scheme detected %s for url %s',
                   parsed.scheme, parsed)
         came_from = default_came_from
     elif parsed.netloc and request.host != parsed.netloc:
         log.error('Suspicious NETLOC detected %s for url %s server url '
                   'is: %s', parsed.netloc, parsed, request.host)
         came_from = default_came_from
     elif any(bad_char in came_from for bad_char in ('\r', '\n')):
         log.error('Header injection detected `%s` for url %s server url ',
                   parsed.path, parsed)
         came_from = default_came_from
 
     return came_from or default_came_from
 
 
 class LoginView(BaseAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         c.came_from = get_came_from(self.request)
         return c
 
     def _get_captcha_data(self):
         settings = SettingsModel().get_all_settings()
         private_key = settings.get('rhodecode_captcha_private_key')
         public_key = settings.get('rhodecode_captcha_public_key')
         active = bool(private_key)
         return CaptchaData(
             active=active, private_key=private_key, public_key=public_key)
 
     def validate_captcha(self, private_key):
 
         captcha_rs = self.request.POST.get('g-recaptcha-response')
         url = "https://www.google.com/recaptcha/api/siteverify"
         params = {
             'secret': private_key,
             'response': captcha_rs,
             'remoteip': get_ip_addr(self.request.environ)
         }
         verify_rs = requests.get(url, params=params, verify=True, timeout=60)
         verify_rs = verify_rs.json()
         captcha_status = verify_rs.get('success', False)
         captcha_errors = verify_rs.get('error-codes', [])
         if not isinstance(captcha_errors, list):
             captcha_errors = [captcha_errors]
         captcha_errors = ', '.join(captcha_errors)
         captcha_message = ''
         if captcha_status is False:
             captcha_message = "Bad captcha. Errors: {}".format(
                 captcha_errors)
 
         return captcha_status, captcha_message
 
     def login(self):
         c = self.load_default_context()
         auth_user = self._rhodecode_user
 
         # redirect if already logged in
         if (auth_user.is_authenticated and
                 not auth_user.is_default and auth_user.ip_allowed):
             raise HTTPFound(c.came_from)
 
         # check if we use headers plugin, and try to login using it.
         try:
             log.debug('Running PRE-AUTH for headers based authentication')
             auth_info = authenticate(
                 '', '', self.request.environ, HTTP_TYPE, skip_missing=True)
             if auth_info:
                 headers = store_user_in_session(
                     self.session, auth_info.get('username'))
                 raise HTTPFound(c.came_from, headers=headers)
         except UserCreationError as e:
             log.error(e)
             h.flash(e, category='error')
 
         return self._get_template_context(c)
 
     def login_post(self):
         c = self.load_default_context()
 
         login_form = LoginForm(self.request.translate)()
 
         try:
             self.session.invalidate()
             form_result = login_form.to_python(self.request.POST)
             # form checks for username/password, now we're authenticated
             username = form_result['username']
             if (user := User.get_by_username_or_primary_email(username)).has_enabled_2fa:
                 user.has_check_2fa_flag = True
 
             headers = store_user_in_session(
                 self.session,
                 user_identifier=username,
                 remember=form_result['remember'])
             log.debug('Redirecting to "%s" after login.', c.came_from)
 
             audit_user = audit_logger.UserWrap(
                 username=self.request.POST.get('username'),
                 ip_addr=self.request.remote_addr)
             action_data = {'user_agent': self.request.user_agent}
             audit_logger.store_web(
                 'user.login.success', action_data=action_data,
                 user=audit_user, commit=True)
 
             raise HTTPFound(c.came_from, headers=headers)
         except formencode.Invalid as errors:
             defaults = errors.value
             # remove password from filling in form again
             defaults.pop('password', None)
             render_ctx = {
                 'errors': errors.error_dict,
                 'defaults': defaults,
             }
 
             audit_user = audit_logger.UserWrap(
                 username=self.request.POST.get('username'),
                 ip_addr=self.request.remote_addr)
             action_data = {'user_agent': self.request.user_agent}
             audit_logger.store_web(
                 'user.login.failure', action_data=action_data,
                 user=audit_user, commit=True)
             return self._get_template_context(c, **render_ctx)
 
         except UserCreationError as e:
             # headers auth or other auth functions that create users on
             # the fly can throw this exception signaling that there's issue
             # with user creation, explanation should be provided in
             # Exception itself
             h.flash(e, category='error')
             return self._get_template_context(c)
 
     @CSRFRequired()
     def logout(self):
         auth_user = self._rhodecode_user
         log.info('Deleting session for user: `%s`', auth_user)
 
         action_data = {'user_agent': self.request.user_agent}
         audit_logger.store_web(
             'user.logout', action_data=action_data,
             user=auth_user, commit=True)
         self.session.delete()
         return HTTPFound(h.route_path('home'))
 
     @HasPermissionAnyDecorator(
         'hg.admin', 'hg.register.auto_activate', 'hg.register.manual_activate')
     def register(self, defaults=None, errors=None):
         c = self.load_default_context()
         defaults = defaults or {}
         errors = errors or {}
 
         settings = SettingsModel().get_all_settings()
         register_message = settings.get('rhodecode_register_message') or ''
         captcha = self._get_captcha_data()
         auto_active = 'hg.register.auto_activate' in User.get_default_user()\
             .AuthUser().permissions['global']
 
         render_ctx = self._get_template_context(c)
         render_ctx.update({
             'defaults': defaults,
             'errors': errors,
             'auto_active': auto_active,
             'captcha_active': captcha.active,
             'captcha_public_key': captcha.public_key,
             'register_message': register_message,
         })
         return render_ctx
 
     @HasPermissionAnyDecorator(
         'hg.admin', 'hg.register.auto_activate', 'hg.register.manual_activate')
     def register_post(self):
         from rhodecode.authentication.plugins import auth_rhodecode
 
         self.load_default_context()
         captcha = self._get_captcha_data()
         auto_active = 'hg.register.auto_activate' in User.get_default_user()\
             .AuthUser().permissions['global']
 
         extern_name = auth_rhodecode.RhodeCodeAuthPlugin.uid
         extern_type = auth_rhodecode.RhodeCodeAuthPlugin.uid
 
         register_form = RegisterForm(self.request.translate)()
         try:
 
             form_result = register_form.to_python(self.request.POST)
             form_result['active'] = auto_active
             external_identity = self.request.POST.get('external_identity')
 
             if external_identity:
                 extern_name = external_identity
                 extern_type = external_identity
 
             if captcha.active:
                 captcha_status, captcha_message = self.validate_captcha(
                     captcha.private_key)
 
                 if not captcha_status:
                     _value = form_result
                     _msg = _('Bad captcha')
                     error_dict = {'recaptcha_field': captcha_message}
                     raise formencode.Invalid(
                         _msg, _value, None, error_dict=error_dict)
 
             new_user = UserModel().create_registration(
                 form_result, extern_name=extern_name, extern_type=extern_type)
 
             action_data = {'data': new_user.get_api_data(),
                            'user_agent': self.request.user_agent}
 
             if external_identity:
                 action_data['external_identity'] = external_identity
 
             audit_user = audit_logger.UserWrap(
                 username=new_user.username,
                 user_id=new_user.user_id,
                 ip_addr=self.request.remote_addr)
 
             audit_logger.store_web(
                 'user.register', action_data=action_data,
                 user=audit_user)
 
             event = UserRegistered(user=new_user, session=self.session)
             trigger(event)
             h.flash(
                 _('You have successfully registered with RhodeCode. You can log-in now.'),
                 category='success')
             if external_identity:
                 h.flash(
                     _('Please use the {identity} button to log-in').format(
                         identity=external_identity),
                     category='success')
             Session().commit()
 
             redirect_ro = self.request.route_path('login')
             raise HTTPFound(redirect_ro)
 
         except formencode.Invalid as errors:
             errors.value.pop('password', None)
             errors.value.pop('password_confirmation', None)
             return self.register(
                 defaults=errors.value, errors=errors.error_dict)
 
         except UserCreationError as e:
             # container auth or other auth functions that create users on
             # the fly can throw this exception signaling that there's issue
             # with user creation, explanation should be provided in
             # Exception itself
             h.flash(e, category='error')
             return self.register()
 
     def password_reset(self):
         c = self.load_default_context()
         captcha = self._get_captcha_data()
 
         template_context = {
             'captcha_active': captcha.active,
             'captcha_public_key': captcha.public_key,
             'defaults': {},
             'errors': {},
         }
 
         # always send implicit message to prevent from discovery of
         # matching emails
         msg = _('If such email exists, a password reset link was sent to it.')
 
         def default_response():
             log.debug('faking response on invalid password reset')
             # make this take 2s, to prevent brute forcing.
             time.sleep(2)
             h.flash(msg, category='success')
             return HTTPFound(self.request.route_path('reset_password'))
 
         if self.request.POST:
             if h.HasPermissionAny('hg.password_reset.disabled')():
                 _email = self.request.POST.get('email', '')
                 log.error('Failed attempt to reset password for `%s`.', _email)
                 h.flash(_('Password reset has been disabled.'), category='error')
                 return HTTPFound(self.request.route_path('reset_password'))
 
             password_reset_form = PasswordResetForm(self.request.translate)()
             description = 'Generated token for password reset from {}'.format(
                 datetime.datetime.now().isoformat())
 
             try:
                 form_result = password_reset_form.to_python(
                     self.request.POST)
                 user_email = form_result['email']
 
                 if captcha.active:
                     captcha_status, captcha_message = self.validate_captcha(
                         captcha.private_key)
 
                     if not captcha_status:
                         _value = form_result
                         _msg = _('Bad captcha')
                         error_dict = {'recaptcha_field': captcha_message}
                         raise formencode.Invalid(
                             _msg, _value, None, error_dict=error_dict)
 
                 # Generate reset URL and send mail.
                 user = User.get_by_email(user_email)
 
                 # only allow rhodecode based users to reset their password
                 # external auth shouldn't allow password reset
                 if user and user.extern_type != auth_rhodecode.RhodeCodeAuthPlugin.uid:
                     log.warning('User %s with external type `%s` tried a password reset. '
                                 'This try was rejected', user, user.extern_type)
                     return default_response()
 
                 # generate password reset token that expires in 10 minutes
                 reset_token = UserModel().add_auth_token(
                     user=user, lifetime_minutes=10,
                     role=UserModel.auth_token_role.ROLE_PASSWORD_RESET,
                     description=description)
                 Session().commit()
 
                 log.debug('Successfully created password recovery token')
                 password_reset_url = self.request.route_url(
                     'reset_password_confirmation',
                     _query={'key': reset_token.api_key})
                 UserModel().reset_password_link(
                     form_result, password_reset_url)
 
                 action_data = {'email': user_email,
                                'user_agent': self.request.user_agent}
                 audit_logger.store_web(
                     'user.password.reset_request', action_data=action_data,
                     user=self._rhodecode_user, commit=True)
 
                 return default_response()
 
             except formencode.Invalid as errors:
                 template_context.update({
                     'defaults': errors.value,
                     'errors': errors.error_dict,
                 })
                 if not self.request.POST.get('email'):
                     # case of empty email, we want to report that
                     return self._get_template_context(c, **template_context)
 
                 if 'recaptcha_field' in errors.error_dict:
                     # case of failed captcha
                     return self._get_template_context(c, **template_context)
 
             return default_response()
 
         return self._get_template_context(c, **template_context)
 
     @LoginRequired()
     @NotAnonymous()
     def password_reset_confirmation(self):
         self.load_default_context()
         if self.request.GET and self.request.GET.get('key'):
             # make this take 2s, to prevent brute forcing.
             time.sleep(2)
 
             token = AuthTokenModel().get_auth_token(
                 self.request.GET.get('key'))
 
             # verify token is the correct role
             if token is None or token.role != UserApiKeys.ROLE_PASSWORD_RESET:
                 log.debug('Got token with role:%s expected is %s',
                           getattr(token, 'role', 'EMPTY_TOKEN'),
                           UserApiKeys.ROLE_PASSWORD_RESET)
                 h.flash(
                     _('Given reset token is invalid'), category='error')
                 return HTTPFound(self.request.route_path('reset_password'))
 
             try:
                 owner = token.user
                 data = {'email': owner.email, 'token': token.api_key}
                 UserModel().reset_password(data)
                 h.flash(
                     _('Your password reset was successful, '
                       'a new password has been sent to your email'),
                     category='success')
             except Exception as e:
                 log.error(e)
                 return HTTPFound(self.request.route_path('reset_password'))
 
         return HTTPFound(self.request.route_path('login'))
 
     @LoginRequired()
     @NotAnonymous()
     def setup_2fa(self):
         _ = self.request.translate
         c = self.load_default_context()
         user_instance = self._rhodecode_db_user
         form = TOTPForm(_, user_instance)()
         render_ctx = {}
         if self.request.method == 'POST':
             post_items = dict(self.request.POST)
 
             try:
                 form_details = form.to_python(post_items)
                 secret = form_details['secret_totp']
 
                 user_instance.init_2fa_recovery_codes(persist=True, force=True)
                 user_instance.set_2fa_secret(secret)
 
                 Session().commit()
-                raise HTTPFound(self.request.route_path('my_account_enable_2fa', _query={'show-recovery-codes': 1}))
+                raise HTTPFound(self.request.route_path('my_account_configure_2fa', _query={'show-recovery-codes': 1}))
             except formencode.Invalid as errors:
                 defaults = errors.value
                 render_ctx = {
                     'errors': errors.error_dict,
                     'defaults': defaults,
                 }
 
         # NOTE: here we DO NOT persist the secret 2FA, since this is only for setup, once a setup is completed
         # only then we should persist it
         secret = user_instance.init_secret_2fa(persist=False)
 
         totp_name = f'RhodeCode token ({self.request.user.username})'
 
         qr = qrcode.QRCode(version=1, box_size=10, border=5)
         qr.add_data(pyotp.totp.TOTP(secret).provisioning_uri(name=totp_name))
         qr.make(fit=True)
         img = qr.make_image(fill_color='black', back_color='white')
         buffered = BytesIO()
         img.save(buffered)
         return self._get_template_context(
             c,
             qr=b64encode(buffered.getvalue()).decode("utf-8"),
             key=secret,
             totp_name=totp_name,
             ** render_ctx
         )
 
     @LoginRequired()
     @NotAnonymous()
     def verify_2fa(self):
         _ = self.request.translate
         c = self.load_default_context()
         render_ctx = {}
         user_instance = self._rhodecode_db_user
         totp_form = TOTPForm(_, user_instance, allow_recovery_code_use=True)()
         if self.request.method == 'POST':
             post_items = dict(self.request.POST)
             # NOTE: inject secret, as it's a post configured saved item.
             post_items['secret_totp'] = user_instance.get_secret_2fa()
             try:
                 totp_form.to_python(post_items)
                 user_instance.has_check_2fa_flag = False
                 Session().commit()
                 raise HTTPFound(c.came_from)
             except formencode.Invalid as errors:
                 defaults = errors.value
                 render_ctx = {
                     'errors': errors.error_dict,
                     'defaults': defaults,
                 }
         return self._get_template_context(c, **render_ctx)

rhodecode/apps/my_account/__init__.py

@@ -1,370 +1,370 b''
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 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 <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 from rhodecode.apps._base import ADMIN_PREFIX
 
 
 def includeme(config):
     from rhodecode.apps.my_account.views.my_account import MyAccountView
     from rhodecode.apps.my_account.views.my_account_notifications import MyAccountNotificationsView
     from rhodecode.apps.my_account.views.my_account_ssh_keys import MyAccountSshKeysView
 
     config.add_route(
         name='my_account_profile',
         pattern=ADMIN_PREFIX + '/my_account/profile')
     config.add_view(
         MyAccountView,
         attr='my_account_profile',
         route_name='my_account_profile', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     # my account edit details
     config.add_route(
         name='my_account_edit',
         pattern=ADMIN_PREFIX + '/my_account/edit')
     config.add_view(
         MyAccountView,
         attr='my_account_edit',
         route_name='my_account_edit',
         request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_update',
         pattern=ADMIN_PREFIX + '/my_account/update')
     config.add_view(
         MyAccountView,
         attr='my_account_update',
         route_name='my_account_update',
         request_method='POST',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     # my account password
     config.add_route(
         name='my_account_password',
         pattern=ADMIN_PREFIX + '/my_account/password')
     config.add_view(
         MyAccountView,
         attr='my_account_password',
         route_name='my_account_password', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_password_update',
         pattern=ADMIN_PREFIX + '/my_account/password/update')
     config.add_view(
         MyAccountView,
         attr='my_account_password_update',
         route_name='my_account_password_update', request_method='POST',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     # my account 2fa
     config.add_route(
-        name='my_account_enable_2fa',
-        pattern=ADMIN_PREFIX + '/my_account/enable_2fa')
+        name='my_account_configure_2fa',
+        pattern=ADMIN_PREFIX + '/my_account/configure_2fa')
     config.add_view(
         MyAccountView,
         attr='my_account_2fa',
-        route_name='my_account_enable_2fa', request_method='GET',
+        route_name='my_account_configure_2fa', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
     # my account 2fa save
     config.add_route(
-        name='my_account_enable_2fa_save',
-        pattern=ADMIN_PREFIX + '/my_account/enable_2fa_save')
+        name='my_account_configure_2fa_update',
+        pattern=ADMIN_PREFIX + '/my_account/configure_2fa_update')
     config.add_view(
         MyAccountView,
         attr='my_account_2fa_update',
-        route_name='my_account_enable_2fa_save', request_method='POST',
+        route_name='my_account_configure_2fa_update', request_method='POST',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     # my account 2fa recovery code-reset
     config.add_route(
         name='my_account_show_2fa_recovery_codes',
         pattern=ADMIN_PREFIX + '/my_account/recovery_codes')
     config.add_view(
         MyAccountView,
         attr='my_account_2fa_show_recovery_codes',
         route_name='my_account_show_2fa_recovery_codes', request_method='POST', xhr=True,
         renderer='json_ext')
 
     # my account 2fa recovery code-reset
     config.add_route(
         name='my_account_regenerate_2fa_recovery_codes',
         pattern=ADMIN_PREFIX + '/my_account/regenerate_recovery_codes')
     config.add_view(
         MyAccountView,
         attr='my_account_2fa_regenerate_recovery_codes',
         route_name='my_account_regenerate_2fa_recovery_codes', request_method='POST',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     # my account tokens
     config.add_route(
         name='my_account_auth_tokens',
         pattern=ADMIN_PREFIX + '/my_account/auth_tokens')
     config.add_view(
         MyAccountView,
         attr='my_account_auth_tokens',
         route_name='my_account_auth_tokens', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_auth_tokens_view',
         pattern=ADMIN_PREFIX + '/my_account/auth_tokens/view')
     config.add_view(
         MyAccountView,
         attr='my_account_auth_tokens_view',
         route_name='my_account_auth_tokens_view', request_method='POST', xhr=True,
         renderer='json_ext')
 
     config.add_route(
         name='my_account_auth_tokens_add',
         pattern=ADMIN_PREFIX + '/my_account/auth_tokens/new')
     config.add_view(
         MyAccountView,
         attr='my_account_auth_tokens_add',
         route_name='my_account_auth_tokens_add', request_method='POST')
 
     config.add_route(
         name='my_account_auth_tokens_delete',
         pattern=ADMIN_PREFIX + '/my_account/auth_tokens/delete')
     config.add_view(
         MyAccountView,
         attr='my_account_auth_tokens_delete',
         route_name='my_account_auth_tokens_delete', request_method='POST')
 
     # my account ssh keys
     config.add_route(
         name='my_account_ssh_keys',
         pattern=ADMIN_PREFIX + '/my_account/ssh_keys')
     config.add_view(
         MyAccountSshKeysView,
         attr='my_account_ssh_keys',
         route_name='my_account_ssh_keys', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_ssh_keys_generate',
         pattern=ADMIN_PREFIX + '/my_account/ssh_keys/generate')
     config.add_view(
         MyAccountSshKeysView,
         attr='ssh_keys_generate_keypair',
         route_name='my_account_ssh_keys_generate', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_ssh_keys_add',
         pattern=ADMIN_PREFIX + '/my_account/ssh_keys/new')
     config.add_view(
         MyAccountSshKeysView,
         attr='my_account_ssh_keys_add',
         route_name='my_account_ssh_keys_add', request_method='POST',)
 
     config.add_route(
         name='my_account_ssh_keys_delete',
         pattern=ADMIN_PREFIX + '/my_account/ssh_keys/delete')
     config.add_view(
         MyAccountSshKeysView,
         attr='my_account_ssh_keys_delete',
         route_name='my_account_ssh_keys_delete', request_method='POST')
 
     # my account user group membership
     config.add_route(
         name='my_account_user_group_membership',
         pattern=ADMIN_PREFIX + '/my_account/user_group_membership')
     config.add_view(
         MyAccountView,
         attr='my_account_user_group_membership',
         route_name='my_account_user_group_membership',
         request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     # my account emails
     config.add_route(
         name='my_account_emails',
         pattern=ADMIN_PREFIX + '/my_account/emails')
     config.add_view(
         MyAccountView,
         attr='my_account_emails',
         route_name='my_account_emails', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_emails_add',
         pattern=ADMIN_PREFIX + '/my_account/emails/new')
     config.add_view(
         MyAccountView,
         attr='my_account_emails_add',
         route_name='my_account_emails_add', request_method='POST',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_emails_delete',
         pattern=ADMIN_PREFIX + '/my_account/emails/delete')
     config.add_view(
         MyAccountView,
         attr='my_account_emails_delete',
         route_name='my_account_emails_delete', request_method='POST')
 
     config.add_route(
         name='my_account_repos',
         pattern=ADMIN_PREFIX + '/my_account/repos')
     config.add_view(
         MyAccountView,
         attr='my_account_repos',
         route_name='my_account_repos', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_watched',
         pattern=ADMIN_PREFIX + '/my_account/watched')
     config.add_view(
         MyAccountView,
         attr='my_account_watched',
         route_name='my_account_watched', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_bookmarks',
         pattern=ADMIN_PREFIX + '/my_account/bookmarks')
     config.add_view(
         MyAccountView,
         attr='my_account_bookmarks',
         route_name='my_account_bookmarks', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_bookmarks_update',
         pattern=ADMIN_PREFIX + '/my_account/bookmarks/update')
     config.add_view(
         MyAccountView,
         attr='my_account_bookmarks_update',
         route_name='my_account_bookmarks_update', request_method='POST')
 
     config.add_route(
         name='my_account_goto_bookmark',
         pattern=ADMIN_PREFIX + '/my_account/bookmark/{bookmark_id}')
     config.add_view(
         MyAccountView,
         attr='my_account_goto_bookmark',
         route_name='my_account_goto_bookmark', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_perms',
         pattern=ADMIN_PREFIX + '/my_account/perms')
     config.add_view(
         MyAccountView,
         attr='my_account_perms',
         route_name='my_account_perms', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_notifications',
         pattern=ADMIN_PREFIX + '/my_account/notifications')
     config.add_view(
         MyAccountView,
         attr='my_notifications',
         route_name='my_account_notifications', request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_notifications_toggle_visibility',
         pattern=ADMIN_PREFIX + '/my_account/toggle_visibility')
     config.add_view(
         MyAccountView,
         attr='my_notifications_toggle_visibility',
         route_name='my_account_notifications_toggle_visibility',
         request_method='POST', renderer='json_ext')
 
     # my account pull requests
     config.add_route(
         name='my_account_pullrequests',
         pattern=ADMIN_PREFIX + '/my_account/pull_requests')
     config.add_view(
         MyAccountView,
         attr='my_account_pullrequests',
         route_name='my_account_pullrequests',
         request_method='GET',
         renderer='rhodecode:templates/admin/my_account/my_account.mako')
 
     config.add_route(
         name='my_account_pullrequests_data',
         pattern=ADMIN_PREFIX + '/my_account/pull_requests/data')
     config.add_view(
         MyAccountView,
         attr='my_account_pullrequests_data',
         route_name='my_account_pullrequests_data',
         request_method='GET', renderer='json_ext')
 
     # channelstream test
     config.add_route(
         name='my_account_notifications_test_channelstream',
         pattern=ADMIN_PREFIX + '/my_account/test_channelstream')
     config.add_view(
         MyAccountView,
         attr='my_account_notifications_test_channelstream',
         route_name='my_account_notifications_test_channelstream',
         request_method='POST', renderer='json_ext')
 
     # notifications
     config.add_route(
         name='notifications_show_all',
         pattern=ADMIN_PREFIX + '/notifications')
     config.add_view(
         MyAccountNotificationsView,
         attr='notifications_show_all',
         route_name='notifications_show_all', request_method='GET',
         renderer='rhodecode:templates/admin/notifications/notifications_show_all.mako')
 
     # notifications
     config.add_route(
         name='notifications_mark_all_read',
         pattern=ADMIN_PREFIX + '/notifications_mark_all_read')
     config.add_view(
         MyAccountNotificationsView,
         attr='notifications_mark_all_read',
         route_name='notifications_mark_all_read', request_method='POST',
         renderer='rhodecode:templates/admin/notifications/notifications_show_all.mako')
 
     config.add_route(
         name='notifications_show',
         pattern=ADMIN_PREFIX + '/notifications/{notification_id}')
     config.add_view(
         MyAccountNotificationsView,
         attr='notifications_show',
         route_name='notifications_show', request_method='GET',
         renderer='rhodecode:templates/admin/notifications/notifications_show.mako')
 
     config.add_route(
         name='notifications_update',
         pattern=ADMIN_PREFIX + '/notifications/{notification_id}/update')
     config.add_view(
         MyAccountNotificationsView,
         attr='notification_update',
         route_name='notifications_update', request_method='POST',
         renderer='json_ext')
 
     config.add_route(
         name='notifications_delete',
         pattern=ADMIN_PREFIX + '/notifications/{notification_id}/delete')
     config.add_view(
         MyAccountNotificationsView,
         attr='notification_delete',
         route_name='notifications_delete', request_method='POST',
         renderer='json_ext')

rhodecode/apps/my_account/views/my_account.py

@@ -1,858 +1,858 b''
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 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 <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import time
 import logging
 import datetime
 import string
 
 import formencode
 import formencode.htmlfill
 import peppercorn
 from pyramid.httpexceptions import HTTPFound, HTTPNotFound
 
 from rhodecode.apps._base import BaseAppView, DataGridAppView
 from rhodecode import forms
 from rhodecode.lib import helpers as h
 from rhodecode.lib import audit_logger
 from rhodecode.lib import ext_json
 from rhodecode.lib.auth import (
     LoginRequired, NotAnonymous, CSRFRequired,
     HasRepoPermissionAny, HasRepoGroupPermissionAny, AuthUser)
 from rhodecode.lib.channelstream import (
     channelstream_request, ChannelstreamException)
 from rhodecode.lib.hash_utils import md5_safe
 from rhodecode.lib.utils2 import safe_int, md5, str2bool
 from rhodecode.model.auth_token import AuthTokenModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     IntegrityError, or_, in_filter_generator, select,
     Repository, UserEmailMap, UserApiKeys, UserFollowing,
     PullRequest, UserBookmark, RepoGroup, ChangesetStatus)
 from rhodecode.model.forms import TOTPForm
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.validation_schema.schemas import user_schema
 
 log = logging.getLogger(__name__)
 
 
 class MyAccountView(BaseAppView, DataGridAppView):
     ALLOW_SCOPED_TOKENS = False
     """
     This view has alternative version inside EE, if modified please take a look
     in there as well.
     """
 
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         c.user = c.auth_user.get_instance()
         c.allow_scoped_tokens = self.ALLOW_SCOPED_TOKENS
         return c
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_profile(self):
         c = self.load_default_context()
         c.active = 'profile'
         c.extern_type = c.user.extern_type
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_edit(self):
         c = self.load_default_context()
         c.active = 'profile_edit'
         c.extern_type = c.user.extern_type
         c.extern_name = c.user.extern_name
 
         schema = user_schema.UserProfileSchema().bind(
             username=c.user.username, user_emails=c.user.emails)
         appstruct = {
             'username': c.user.username,
             'email': c.user.email,
             'firstname': c.user.firstname,
             'lastname': c.user.lastname,
             'description': c.user.description,
         }
         c.form = forms.RcForm(
             schema, appstruct=appstruct,
             action=h.route_path('my_account_update'),
             buttons=(forms.buttons.save, forms.buttons.reset))
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'profile_edit'
         c.perm_user = c.auth_user
         c.extern_type = c.user.extern_type
         c.extern_name = c.user.extern_name
 
         schema = user_schema.UserProfileSchema().bind(
             username=c.user.username, user_emails=c.user.emails)
         form = forms.RcForm(
             schema, buttons=(forms.buttons.save, forms.buttons.reset))
 
         controls = list(self.request.POST.items())
         try:
             valid_data = form.validate(controls)
             skip_attrs = ['admin', 'active', 'extern_type', 'extern_name',
                           'new_password', 'password_confirmation']
             if c.extern_type != "rhodecode":
                 # forbid updating username for external accounts
                 skip_attrs.append('username')
             old_email = c.user.email
             UserModel().update_user(
                      self._rhodecode_user.user_id, skip_attrs=skip_attrs,
                      **valid_data)
             if old_email != valid_data['email']:
                 old = UserEmailMap.query() \
                     .filter(UserEmailMap.user == c.user)\
                     .filter(UserEmailMap.email == valid_data['email'])\
                     .first()
                 old.email = old_email
             h.flash(_('Your account was updated successfully'), category='success')
             Session().commit()
         except forms.ValidationFailure as e:
             c.form = e
             return self._get_template_context(c)
 
         except Exception:
             log.exception("Exception updating user")
             h.flash(_('Error occurred during update of user'),
                     category='error')
         raise HTTPFound(h.route_path('my_account_profile'))
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_password(self):
         c = self.load_default_context()
         c.active = 'password'
         c.extern_type = c.user.extern_type
 
         schema = user_schema.ChangePasswordSchema().bind(
             username=c.user.username)
 
         form = forms.Form(
             schema,
             action=h.route_path('my_account_password_update'),
             buttons=(forms.buttons.save, forms.buttons.reset))
 
         c.form = form
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_password_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'password'
         c.extern_type = c.user.extern_type
 
         schema = user_schema.ChangePasswordSchema().bind(
             username=c.user.username)
 
         form = forms.Form(
             schema, buttons=(forms.buttons.save, forms.buttons.reset))
 
         if c.extern_type != 'rhodecode':
             raise HTTPFound(self.request.route_path('my_account_password'))
 
         controls = list(self.request.POST.items())
         try:
             valid_data = form.validate(controls)
             UserModel().update_user(c.user.user_id, **valid_data)
             c.user.update_userdata(force_password_change=False)
             Session().commit()
         except forms.ValidationFailure as e:
             c.form = e
             return self._get_template_context(c)
 
         except Exception:
             log.exception("Exception updating password")
             h.flash(_('Error occurred during update of user password'),
                     category='error')
         else:
             instance = c.auth_user.get_instance()
             self.session.setdefault('rhodecode_user', {}).update(
                 {'password': md5_safe(instance.password)})
             self.session.save()
             h.flash(_("Successfully updated password"), category='success')
 
         raise HTTPFound(self.request.route_path('my_account_password'))
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_2fa(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = '2FA'
         user_instance = c.auth_user.get_instance()
         locked_by_admin = user_instance.has_forced_2fa
         c.state_of_2fa = user_instance.has_enabled_2fa
         c.user_seen_2fa_recovery_codes = user_instance.has_seen_2fa_codes
         c.locked_2fa = str2bool(locked_by_admin)
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_2fa_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = '2FA'
         user_instance = c.auth_user.get_instance()
 
         state = self.request.POST.get('2fa_status') == '1'
         user_instance.has_enabled_2fa = state
         user_instance.update_userdata(update_2fa=time.time())
         Session().commit()
         h.flash(_("Successfully saved 2FA settings"), category='success')
-        raise HTTPFound(self.request.route_path('my_account_enable_2fa'))
+        raise HTTPFound(self.request.route_path('my_account_configure_2fa'))
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_2fa_show_recovery_codes(self):
         c = self.load_default_context()
         user_instance = c.auth_user.get_instance()
         user_instance.has_seen_2fa_codes = True
         Session().commit()
         return {'recovery_codes': user_instance.get_2fa_recovery_codes()}
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_2fa_regenerate_recovery_codes(self):
         _ = self.request.translate
         c = self.load_default_context()
         user_instance = c.auth_user.get_instance()
 
         totp_form = TOTPForm(_, user_instance, allow_recovery_code_use=True)()
 
         post_items = dict(self.request.POST)
         # NOTE: inject secret, as it's a post configured saved item.
         post_items['secret_totp'] = user_instance.get_secret_2fa()
         try:
             totp_form.to_python(post_items)
             user_instance.regenerate_2fa_recovery_codes()
             Session().commit()
         except formencode.Invalid as errors:
             h.flash(_("Failed to generate new recovery codes: {}").format(errors), category='error')
-            raise HTTPFound(self.request.route_path('my_account_enable_2fa'))
+            raise HTTPFound(self.request.route_path('my_account_configure_2fa'))
         except Exception as e:
             h.flash(_("Failed to generate new recovery codes: {}").format(e), category='error')
-            raise HTTPFound(self.request.route_path('my_account_enable_2fa'))
+            raise HTTPFound(self.request.route_path('my_account_configure_2fa'))
 
-        raise HTTPFound(self.request.route_path('my_account_enable_2fa', _query={'show-recovery-codes': 1}))
+        raise HTTPFound(self.request.route_path('my_account_configure_2fa', _query={'show-recovery-codes': 1}))
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_auth_tokens(self):
         _ = self.request.translate
 
         c = self.load_default_context()
         c.active = 'auth_tokens'
         c.lifetime_values = AuthTokenModel.get_lifetime_values(translator=_)
         c.role_values = [
             (x, AuthTokenModel.cls._get_role_name(x))
             for x in AuthTokenModel.cls.ROLES]
         c.role_options = [(c.role_values, _("Role"))]
         c.user_auth_tokens = AuthTokenModel().get_auth_tokens(
             c.user.user_id, show_expired=True)
         c.role_vcs = AuthTokenModel.cls.ROLE_VCS
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_auth_tokens_view(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         auth_token_id = self.request.POST.get('auth_token_id')
 
         if auth_token_id:
             token = UserApiKeys.get_or_404(auth_token_id)
             if token.user.user_id != c.user.user_id:
                 raise HTTPNotFound()
 
             return {
                 'auth_token': token.api_key
             }
 
     def maybe_attach_token_scope(self, token):
         # implemented in EE edition
         pass
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_auth_tokens_add(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         lifetime = safe_int(self.request.POST.get('lifetime'), -1)
         description = self.request.POST.get('description')
         role = self.request.POST.get('role')
 
         token = UserModel().add_auth_token(
             user=c.user.user_id,
             lifetime_minutes=lifetime, role=role, description=description,
             scope_callback=self.maybe_attach_token_scope)
         token_data = token.get_api_data()
 
         audit_logger.store_web(
             'user.edit.token.add', action_data={
                 'data': {'token': token_data, 'user': 'self'}},
             user=self._rhodecode_user, )
         Session().commit()
 
         h.flash(_("Auth token successfully created"), category='success')
         return HTTPFound(h.route_path('my_account_auth_tokens'))
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_auth_tokens_delete(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         del_auth_token = self.request.POST.get('del_auth_token')
 
         if del_auth_token:
             token = UserApiKeys.get_or_404(del_auth_token)
             token_data = token.get_api_data()
 
             AuthTokenModel().delete(del_auth_token, c.user.user_id)
             audit_logger.store_web(
                 'user.edit.token.delete', action_data={
                     'data': {'token': token_data, 'user': 'self'}},
                 user=self._rhodecode_user,)
             Session().commit()
             h.flash(_("Auth token successfully deleted"), category='success')
 
         return HTTPFound(h.route_path('my_account_auth_tokens'))
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_emails(self):
         _ = self.request.translate
 
         c = self.load_default_context()
         c.active = 'emails'
 
         c.user_email_map = UserEmailMap.query()\
             .filter(UserEmailMap.user == c.user).all()
 
         schema = user_schema.AddEmailSchema().bind(
             username=c.user.username, user_emails=c.user.emails)
 
         form = forms.RcForm(schema,
                             action=h.route_path('my_account_emails_add'),
                             buttons=(forms.buttons.save, forms.buttons.reset))
 
         c.form = form
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_emails_add(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'emails'
 
         schema = user_schema.AddEmailSchema().bind(
             username=c.user.username, user_emails=c.user.emails)
 
         form = forms.RcForm(
             schema, action=h.route_path('my_account_emails_add'),
             buttons=(forms.buttons.save, forms.buttons.reset))
 
         controls = list(self.request.POST.items())
         try:
             valid_data = form.validate(controls)
             UserModel().add_extra_email(c.user.user_id, valid_data['email'])
             audit_logger.store_web(
                 'user.edit.email.add', action_data={
                     'data': {'email': valid_data['email'], 'user': 'self'}},
                 user=self._rhodecode_user,)
             Session().commit()
         except formencode.Invalid as error:
             h.flash(h.escape(error.error_dict['email']), category='error')
         except forms.ValidationFailure as e:
             c.user_email_map = UserEmailMap.query() \
                 .filter(UserEmailMap.user == c.user).all()
             c.form = e
             return self._get_template_context(c)
         except Exception:
             log.exception("Exception adding email")
             h.flash(_('Error occurred during adding email'),
                     category='error')
         else:
             h.flash(_("Successfully added email"), category='success')
 
         raise HTTPFound(self.request.route_path('my_account_emails'))
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_emails_delete(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         del_email_id = self.request.POST.get('del_email_id')
         if del_email_id:
             email = UserEmailMap.get_or_404(del_email_id).email
             UserModel().delete_extra_email(c.user.user_id, del_email_id)
             audit_logger.store_web(
                 'user.edit.email.delete', action_data={
                     'data': {'email': email, 'user': 'self'}},
                 user=self._rhodecode_user,)
             Session().commit()
             h.flash(_("Email successfully deleted"),
                     category='success')
         return HTTPFound(h.route_path('my_account_emails'))
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_notifications_test_channelstream(self):
         message = 'Test message sent via Channelstream by user: {}, on {}'.format(
             self._rhodecode_user.username, datetime.datetime.now())
         payload = {
             # 'channel': 'broadcast',
             'type': 'message',
             'timestamp': datetime.datetime.utcnow(),
             'user': 'system',
             'pm_users': [self._rhodecode_user.username],
             'message': {
                 'message': message,
                 'level': 'info',
                 'topic': '/notifications'
             }
         }
 
         registry = self.request.registry
         rhodecode_plugins = getattr(registry, 'rhodecode_plugins', {})
         channelstream_config = rhodecode_plugins.get('channelstream', {})
 
         try:
             channelstream_request(channelstream_config, [payload], '/message')
         except ChannelstreamException as e:
             log.exception('Failed to send channelstream data')
             return {"response": f'ERROR: {e.__class__.__name__}'}
         return {"response": 'Channelstream data sent. '
                             'You should see a new live message now.'}
 
     def _load_my_repos_data(self, watched=False):
 
         allowed_ids = [-1] + self._rhodecode_user.repo_acl_ids_from_stack(AuthUser.repo_read_perms)
 
         if watched:
             # repos user watch
             repo_list = Session().query(
                     Repository
                 ) \
                 .join(
                     (UserFollowing, UserFollowing.follows_repo_id == Repository.repo_id)
                 ) \
                 .filter(
                     UserFollowing.user_id == self._rhodecode_user.user_id
                 ) \
                 .filter(or_(
                     # generate multiple IN to fix limitation problems
                     *in_filter_generator(Repository.repo_id, allowed_ids))
                 ) \
                 .order_by(Repository.repo_name) \
                 .all()
 
         else:
             # repos user is owner of
             repo_list = Session().query(
                     Repository
                 ) \
                 .filter(
                     Repository.user_id == self._rhodecode_user.user_id
                 ) \
                 .filter(or_(
                     # generate multiple IN to fix limitation problems
                     *in_filter_generator(Repository.repo_id, allowed_ids))
                 ) \
                 .order_by(Repository.repo_name) \
                 .all()
 
         _render = self.request.get_partial_renderer(
             'rhodecode:templates/data_table/_dt_elements.mako')
 
         def repo_lnk(name, rtype, rstate, private, archived, fork_of):
             return _render('repo_name', name, rtype, rstate, private, archived, fork_of,
                            short_name=False, admin=False)
 
         repos_data = []
         for repo in repo_list:
             row = {
                 "name": repo_lnk(repo.repo_name, repo.repo_type, repo.repo_state,
                                  repo.private, repo.archived, repo.fork),
                 "name_raw": repo.repo_name.lower(),
             }
 
             repos_data.append(row)
 
         # json used to render the grid
         return ext_json.str_json(repos_data)
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_repos(self):
         c = self.load_default_context()
         c.active = 'repos'
 
         # json used to render the grid
         c.data = self._load_my_repos_data()
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_watched(self):
         c = self.load_default_context()
         c.active = 'watched'
 
         # json used to render the grid
         c.data = self._load_my_repos_data(watched=True)
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_bookmarks(self):
         c = self.load_default_context()
         c.active = 'bookmarks'
 
         user_bookmarks = \
             select(UserBookmark, Repository, RepoGroup) \
             .where(UserBookmark.user_id == self._rhodecode_user.user_id) \
             .outerjoin(Repository, Repository.repo_id == UserBookmark.bookmark_repo_id) \
             .outerjoin(RepoGroup, RepoGroup.group_id == UserBookmark.bookmark_repo_group_id) \
             .order_by(UserBookmark.position.asc())
 
         c.user_bookmark_items = Session().execute(user_bookmarks).all()
         return self._get_template_context(c)
 
     def _process_bookmark_entry(self, entry, user_id):
         position = safe_int(entry.get('position'))
         cur_position = safe_int(entry.get('cur_position'))
         if position is None:
             return
 
         # check if this is an existing entry
         is_new = False
         db_entry = UserBookmark().get_by_position_for_user(cur_position, user_id)
 
         if db_entry and str2bool(entry.get('remove')):
             log.debug('Marked bookmark %s for deletion', db_entry)
             Session().delete(db_entry)
             return
 
         if not db_entry:
             # new
             db_entry = UserBookmark()
             is_new = True
 
         should_save = False
         default_redirect_url = ''
 
         # save repo
         if entry.get('bookmark_repo') and safe_int(entry.get('bookmark_repo')):
             repo = Repository.get(entry['bookmark_repo'])
             perm_check = HasRepoPermissionAny(
                 'repository.read', 'repository.write', 'repository.admin')
             if repo and perm_check(repo_name=repo.repo_name):
                 db_entry.repository = repo
                 should_save = True
                 default_redirect_url = '${repo_url}'
         # save repo group
         elif entry.get('bookmark_repo_group') and safe_int(entry.get('bookmark_repo_group')):
             repo_group = RepoGroup.get(entry['bookmark_repo_group'])
             perm_check = HasRepoGroupPermissionAny(
                 'group.read', 'group.write', 'group.admin')
 
             if repo_group and perm_check(group_name=repo_group.group_name):
                 db_entry.repository_group = repo_group
                 should_save = True
                 default_redirect_url = '${repo_group_url}'
         # save generic info
         elif entry.get('title') and entry.get('redirect_url'):
             should_save = True
 
         if should_save:
             # mark user and position
             db_entry.user_id = user_id
             db_entry.position = position
             db_entry.title = entry.get('title')
             db_entry.redirect_url = entry.get('redirect_url') or default_redirect_url
             log.debug('Saving bookmark %s, new:%s', db_entry, is_new)
 
             Session().add(db_entry)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_account_bookmarks_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'bookmarks'
 
         controls = peppercorn.parse(self.request.POST.items())
         user_id = c.user.user_id
 
         # validate positions
         positions = {}
         for entry in controls.get('bookmarks', []):
             position = safe_int(entry['position'])
             if position is None:
                 continue
 
             if position in positions:
                 h.flash(_("Position {} is defined twice. "
                           "Please correct this error.").format(position), category='error')
                 return HTTPFound(h.route_path('my_account_bookmarks'))
 
             entry['position'] = position
             entry['cur_position'] = safe_int(entry.get('cur_position'))
             positions[position] = entry
 
         try:
             for entry in positions.values():
                 self._process_bookmark_entry(entry, user_id)
 
             Session().commit()
             h.flash(_("Update Bookmarks"), category='success')
         except IntegrityError:
             h.flash(_("Failed to update bookmarks. "
                       "Make sure an unique position is used."), category='error')
 
         return HTTPFound(h.route_path('my_account_bookmarks'))
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_goto_bookmark(self):
 
         bookmark_id = self.request.matchdict['bookmark_id']
         user_bookmark = UserBookmark().query()\
             .filter(UserBookmark.user_id == self.request.user.user_id) \
             .filter(UserBookmark.position == bookmark_id).scalar()
 
         redirect_url = h.route_path('my_account_bookmarks')
         if not user_bookmark:
             raise HTTPFound(redirect_url)
 
         # repository set
         if user_bookmark.repository:
             repo_name = user_bookmark.repository.repo_name
             base_redirect_url = h.route_path(
                 'repo_summary', repo_name=repo_name)
             if user_bookmark.redirect_url and \
                     '${repo_url}' in user_bookmark.redirect_url:
                 redirect_url = string.Template(user_bookmark.redirect_url)\
                     .safe_substitute({'repo_url': base_redirect_url})
             else:
                 redirect_url = base_redirect_url
         # repository group set
         elif user_bookmark.repository_group:
             repo_group_name = user_bookmark.repository_group.group_name
             base_redirect_url = h.route_path(
                 'repo_group_home', repo_group_name=repo_group_name)
             if user_bookmark.redirect_url and \
                     '${repo_group_url}' in user_bookmark.redirect_url:
                 redirect_url = string.Template(user_bookmark.redirect_url)\
                     .safe_substitute({'repo_group_url': base_redirect_url})
             else:
                 redirect_url = base_redirect_url
         # custom URL set
         elif user_bookmark.redirect_url:
             server_url = h.route_url('home').rstrip('/')
             redirect_url = string.Template(user_bookmark.redirect_url) \
                 .safe_substitute({'server_url': server_url})
 
         log.debug('Redirecting bookmark %s to %s', user_bookmark, redirect_url)
         raise HTTPFound(redirect_url)
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_perms(self):
         c = self.load_default_context()
         c.active = 'perms'
 
         c.perm_user = c.auth_user
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     def my_notifications(self):
         c = self.load_default_context()
         c.active = 'notifications'
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def my_notifications_toggle_visibility(self):
         user = self._rhodecode_db_user
         new_status = not user.user_data.get('notification_status', True)
         user.update_userdata(notification_status=new_status)
         Session().commit()
         return user.user_data['notification_status']
 
     def _get_pull_requests_list(self, statuses, filter_type=None):
         draw, start, limit = self._extract_chunk(self.request)
         search_q, order_by, order_dir = self._extract_ordering(self.request)
 
         _render = self.request.get_partial_renderer(
             'rhodecode:templates/data_table/_dt_elements.mako')
 
         if filter_type == 'awaiting_my_review':
             pull_requests = PullRequestModel().get_im_participating_in_for_review(
                 user_id=self._rhodecode_user.user_id,
                 statuses=statuses, query=search_q,
                 offset=start, length=limit, order_by=order_by,
                 order_dir=order_dir)
 
             pull_requests_total_count = PullRequestModel().count_im_participating_in_for_review(
                 user_id=self._rhodecode_user.user_id, statuses=statuses, query=search_q)
         else:
             pull_requests = PullRequestModel().get_im_participating_in(
                 user_id=self._rhodecode_user.user_id,
                 statuses=statuses, query=search_q,
                 offset=start, length=limit, order_by=order_by,
                 order_dir=order_dir)
 
             pull_requests_total_count = PullRequestModel().count_im_participating_in(
                 user_id=self._rhodecode_user.user_id, statuses=statuses, query=search_q)
 
         data = []
         comments_model = CommentsModel()
         for pr in pull_requests:
             repo_id = pr.target_repo_id
             comments_count = comments_model.get_all_comments(
                 repo_id, pull_request=pr, include_drafts=False, count_only=True)
             owned = pr.user_id == self._rhodecode_user.user_id
 
             review_statuses = pr.reviewers_statuses(user=self._rhodecode_db_user)
             my_review_status = ChangesetStatus.STATUS_NOT_REVIEWED
             if review_statuses and review_statuses[4]:
                 _review_obj, _user, _reasons, _mandatory, statuses = review_statuses
                 my_review_status = statuses[0][1].status
 
             data.append({
                 'target_repo': _render('pullrequest_target_repo',
                                        pr.target_repo.repo_name),
                 'name': _render('pullrequest_name',
                                 pr.pull_request_id, pr.pull_request_state,
                                 pr.work_in_progress, pr.target_repo.repo_name,
                                 short=True),
                 'name_raw': pr.pull_request_id,
                 'status': _render('pullrequest_status',
                                   pr.calculated_review_status()),
                 'my_status': _render('pullrequest_status',
                                      my_review_status),
                 'title': _render('pullrequest_title', pr.title, pr.description),
                 'pr_flow': _render('pullrequest_commit_flow', pr),
                 'description': h.escape(pr.description),
                 'updated_on': _render('pullrequest_updated_on',
                                       h.datetime_to_time(pr.updated_on),
                                       pr.versions_count),
                 'updated_on_raw': h.datetime_to_time(pr.updated_on),
                 'created_on': _render('pullrequest_updated_on',
                                       h.datetime_to_time(pr.created_on)),
                 'created_on_raw': h.datetime_to_time(pr.created_on),
                 'state': pr.pull_request_state,
                 'author': _render('pullrequest_author',
                                   pr.author.full_contact, ),
                 'author_raw': pr.author.full_name,
                 'comments': _render('pullrequest_comments', comments_count),
                 'comments_raw': comments_count,
                 'closed': pr.is_closed(),
                 'owned': owned
             })
 
         # json used to render the grid
         data = ({
             'draw': draw,
             'data': data,
             'recordsTotal': pull_requests_total_count,
             'recordsFiltered': pull_requests_total_count,
         })
         return data
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_pullrequests(self):
         c = self.load_default_context()
         c.active = 'pullrequests'
         req_get = self.request.GET
 
         c.closed = str2bool(req_get.get('closed'))
         c.awaiting_my_review = str2bool(req_get.get('awaiting_my_review'))
 
         c.selected_filter = 'all'
         if c.closed:
             c.selected_filter = 'all_closed'
         if c.awaiting_my_review:
             c.selected_filter = 'awaiting_my_review'
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_pullrequests_data(self):
         self.load_default_context()
         req_get = self.request.GET
 
         awaiting_my_review = str2bool(req_get.get('awaiting_my_review'))
         closed = str2bool(req_get.get('closed'))
 
         statuses = [PullRequest.STATUS_NEW, PullRequest.STATUS_OPEN]
         if closed:
             statuses += [PullRequest.STATUS_CLOSED]
 
         filter_type = \
             'awaiting_my_review' if awaiting_my_review \
             else None
 
         data = self._get_pull_requests_list(statuses=statuses, filter_type=filter_type)
         return data
 
     @LoginRequired()
     @NotAnonymous()
     def my_account_user_group_membership(self):
         c = self.load_default_context()
         c.active = 'user_group_membership'
         groups = [UserGroupModel.get_user_groups_as_dict(group.users_group)
                   for group in self._rhodecode_db_user.group_member]
         c.user_groups = ext_json.str_json(groups)
         return self._get_template_context(c)

rhodecode/public/js/rhodecode/routes.js

@@ -1,419 +1,419 b''
 
 /******************************************************************************
  *                                                                            *
  *                      DO NOT CHANGE THIS FILE MANUALLY                      *
  *                                                                            *
  *                                                                            *
  *        This file is automatically generated when the app starts up with    *
  *                         generate_js_files = true                           *
  *                                                                            *
  *  To add a route here pass jsroute=True to the route definition in the app  *
  *                                                                            *
  ******************************************************************************/
 function registerRCRoutes() {
     // routes registration
     pyroutes.register('admin_artifacts', '/_admin/artifacts', []);
     pyroutes.register('admin_artifacts_data', '/_admin/artifacts-data', []);
     pyroutes.register('admin_artifacts_delete', '/_admin/artifacts/%(uid)s/delete', ['uid']);
     pyroutes.register('admin_artifacts_show_all', '/_admin/artifacts', []);
     pyroutes.register('admin_artifacts_show_info', '/_admin/artifacts/%(uid)s', ['uid']);
     pyroutes.register('admin_artifacts_update', '/_admin/artifacts/%(uid)s/update', ['uid']);
     pyroutes.register('admin_audit_log_entry', '/_admin/audit_logs/%(audit_log_id)s', ['audit_log_id']);
     pyroutes.register('admin_audit_logs', '/_admin/audit_logs', []);
     pyroutes.register('admin_automation', '/_admin/automation', []);
     pyroutes.register('admin_automation_update', '/_admin/automation/%(entry_id)s/update', ['entry_id']);
     pyroutes.register('admin_defaults_repositories', '/_admin/defaults/repositories', []);
     pyroutes.register('admin_defaults_repositories_update', '/_admin/defaults/repositories/update', []);
     pyroutes.register('admin_home', '/_admin', []);
     pyroutes.register('admin_permissions_application', '/_admin/permissions/application', []);
     pyroutes.register('admin_permissions_application_update', '/_admin/permissions/application/update', []);
     pyroutes.register('admin_permissions_auth_token_access', '/_admin/permissions/auth_token_access', []);
     pyroutes.register('admin_permissions_branch', '/_admin/permissions/branch', []);
     pyroutes.register('admin_permissions_branch_update', '/_admin/permissions/branch/update', []);
     pyroutes.register('admin_permissions_global', '/_admin/permissions/global', []);
     pyroutes.register('admin_permissions_global_update', '/_admin/permissions/global/update', []);
     pyroutes.register('admin_permissions_ips', '/_admin/permissions/ips', []);
     pyroutes.register('admin_permissions_object', '/_admin/permissions/object', []);
     pyroutes.register('admin_permissions_object_update', '/_admin/permissions/object/update', []);
     pyroutes.register('admin_permissions_overview', '/_admin/permissions/overview', []);
     pyroutes.register('admin_permissions_ssh_keys', '/_admin/permissions/ssh_keys', []);
     pyroutes.register('admin_permissions_ssh_keys_data', '/_admin/permissions/ssh_keys/data', []);
     pyroutes.register('admin_permissions_ssh_keys_update', '/_admin/permissions/ssh_keys/update', []);
     pyroutes.register('admin_scheduler', '/_admin/scheduler', []);
     pyroutes.register('admin_scheduler_show_tasks', '/_admin/scheduler/_tasks', []);
     pyroutes.register('admin_settings', '/_admin/settings', []);
     pyroutes.register('admin_settings_email', '/_admin/settings/email', []);
     pyroutes.register('admin_settings_email_update', '/_admin/settings/email/update', []);
     pyroutes.register('admin_settings_exception_tracker', '/_admin/settings/exceptions', []);
     pyroutes.register('admin_settings_exception_tracker_delete', '/_admin/settings/exceptions/%(exception_id)s/delete', ['exception_id']);
     pyroutes.register('admin_settings_exception_tracker_delete_all', '/_admin/settings/exceptions_delete_all', []);
     pyroutes.register('admin_settings_exception_tracker_show', '/_admin/settings/exceptions/%(exception_id)s', ['exception_id']);
     pyroutes.register('admin_settings_global', '/_admin/settings/global', []);
     pyroutes.register('admin_settings_global_update', '/_admin/settings/global/update', []);
     pyroutes.register('admin_settings_hooks', '/_admin/settings/hooks', []);
     pyroutes.register('admin_settings_hooks_delete', '/_admin/settings/hooks/delete', []);
     pyroutes.register('admin_settings_hooks_update', '/_admin/settings/hooks/update', []);
     pyroutes.register('admin_settings_issuetracker', '/_admin/settings/issue-tracker', []);
     pyroutes.register('admin_settings_issuetracker_delete', '/_admin/settings/issue-tracker/delete', []);
     pyroutes.register('admin_settings_issuetracker_test', '/_admin/settings/issue-tracker/test', []);
     pyroutes.register('admin_settings_issuetracker_update', '/_admin/settings/issue-tracker/update', []);
     pyroutes.register('admin_settings_labs', '/_admin/settings/labs', []);
     pyroutes.register('admin_settings_labs_update', '/_admin/settings/labs/update', []);
     pyroutes.register('admin_settings_license', '/_admin/settings/license', []);
     pyroutes.register('admin_settings_license_unlock', '/_admin/settings/license_unlock', []);
     pyroutes.register('admin_settings_mapping', '/_admin/settings/mapping', []);
     pyroutes.register('admin_settings_mapping_update', '/_admin/settings/mapping/update', []);
     pyroutes.register('admin_settings_open_source', '/_admin/settings/open_source', []);
     pyroutes.register('admin_settings_process_management', '/_admin/settings/process_management', []);
     pyroutes.register('admin_settings_process_management_data', '/_admin/settings/process_management/data', []);
     pyroutes.register('admin_settings_process_management_master_signal', '/_admin/settings/process_management/master_signal', []);
     pyroutes.register('admin_settings_process_management_signal', '/_admin/settings/process_management/signal', []);
     pyroutes.register('admin_settings_scheduler_create', '/_admin/scheduler/create', []);
     pyroutes.register('admin_settings_scheduler_delete', '/_admin/scheduler/%(schedule_id)s/delete', ['schedule_id']);
     pyroutes.register('admin_settings_scheduler_edit', '/_admin/scheduler/%(schedule_id)s', ['schedule_id']);
     pyroutes.register('admin_settings_scheduler_execute', '/_admin/scheduler/%(schedule_id)s/execute', ['schedule_id']);
     pyroutes.register('admin_settings_scheduler_new', '/_admin/scheduler/new', []);
     pyroutes.register('admin_settings_scheduler_update', '/_admin/scheduler/%(schedule_id)s/update', ['schedule_id']);
     pyroutes.register('admin_settings_search', '/_admin/settings/search', []);
     pyroutes.register('admin_settings_sessions', '/_admin/settings/sessions', []);
     pyroutes.register('admin_settings_sessions_cleanup', '/_admin/settings/sessions/cleanup', []);
     pyroutes.register('admin_settings_system', '/_admin/settings/system', []);
     pyroutes.register('admin_settings_system_update', '/_admin/settings/system/updates', []);
     pyroutes.register('admin_settings_update', '/_admin/settings/update', []);
     pyroutes.register('admin_settings_vcs', '/_admin/settings/vcs', []);
     pyroutes.register('admin_settings_vcs_svn_generate_cfg', '/_admin/settings/vcs/svn_generate_cfg', []);
     pyroutes.register('admin_settings_vcs_svn_pattern_delete', '/_admin/settings/vcs/svn_pattern_delete', []);
     pyroutes.register('admin_settings_vcs_update', '/_admin/settings/vcs/update', []);
     pyroutes.register('admin_settings_visual', '/_admin/settings/visual', []);
     pyroutes.register('admin_settings_visual_update', '/_admin/settings/visual/update', []);
     pyroutes.register('apiv2', '/_admin/api', []);
     pyroutes.register('atom_feed_home', '/%(repo_name)s/feed-atom', ['repo_name']);
     pyroutes.register('atom_feed_home_old', '/%(repo_name)s/feed/atom', ['repo_name']);
     pyroutes.register('auth_home', '/_admin/auth*traverse', []);
     pyroutes.register('bookmarks_home', '/%(repo_name)s/bookmarks', ['repo_name']);
     pyroutes.register('branches_home', '/%(repo_name)s/branches', ['repo_name']);
     pyroutes.register('channelstream_connect', '/_admin/channelstream/connect', []);
     pyroutes.register('channelstream_proxy', '/_channelstream', []);
     pyroutes.register('channelstream_subscribe', '/_admin/channelstream/subscribe', []);
     pyroutes.register('check_2fa', '/_admin/check_2fa', []);
     pyroutes.register('commit_draft_comments_submit', '/%(repo_name)s/changeset/%(commit_id)s/draft_comments_submit', ['repo_name', 'commit_id']);
     pyroutes.register('debug_style_email', '/_admin/debug_style/email/%(email_id)s', ['email_id']);
     pyroutes.register('debug_style_email_plain_rendered', '/_admin/debug_style/email-rendered/%(email_id)s', ['email_id']);
     pyroutes.register('debug_style_home', '/_admin/debug_style', []);
     pyroutes.register('debug_style_template', '/_admin/debug_style/t/%(t_path)s', ['t_path']);
     pyroutes.register('download_file', '/_file_store/download/%(fid)s', ['fid']);
     pyroutes.register('download_file_by_token', '/_file_store/token-download/%(_auth_token)s/%(fid)s', ['_auth_token', 'fid']);
     pyroutes.register('edit_repo', '/%(repo_name)s/settings', ['repo_name']);
     pyroutes.register('edit_repo_advanced', '/%(repo_name)s/settings/advanced', ['repo_name']);
     pyroutes.register('edit_repo_advanced_archive', '/%(repo_name)s/settings/advanced/archive', ['repo_name']);
     pyroutes.register('edit_repo_advanced_delete', '/%(repo_name)s/settings/advanced/delete', ['repo_name']);
     pyroutes.register('edit_repo_advanced_fork', '/%(repo_name)s/settings/advanced/fork', ['repo_name']);
     pyroutes.register('edit_repo_advanced_hooks', '/%(repo_name)s/settings/advanced/hooks', ['repo_name']);
     pyroutes.register('edit_repo_advanced_journal', '/%(repo_name)s/settings/advanced/journal', ['repo_name']);
     pyroutes.register('edit_repo_advanced_locking', '/%(repo_name)s/settings/advanced/locking', ['repo_name']);
     pyroutes.register('edit_repo_audit_logs', '/%(repo_name)s/settings/audit_logs', ['repo_name']);
     pyroutes.register('edit_repo_caches', '/%(repo_name)s/settings/caches', ['repo_name']);
     pyroutes.register('edit_repo_fields', '/%(repo_name)s/settings/fields', ['repo_name']);
     pyroutes.register('edit_repo_fields_create', '/%(repo_name)s/settings/fields/create', ['repo_name']);
     pyroutes.register('edit_repo_fields_delete', '/%(repo_name)s/settings/fields/%(field_id)s/delete', ['repo_name', 'field_id']);
     pyroutes.register('edit_repo_group', '/%(repo_group_name)s/_edit', ['repo_group_name']);
     pyroutes.register('edit_repo_group_advanced', '/%(repo_group_name)s/_settings/advanced', ['repo_group_name']);
     pyroutes.register('edit_repo_group_advanced_delete', '/%(repo_group_name)s/_settings/advanced/delete', ['repo_group_name']);
     pyroutes.register('edit_repo_group_perms', '/%(repo_group_name)s/_settings/permissions', ['repo_group_name']);
     pyroutes.register('edit_repo_group_perms_update', '/%(repo_group_name)s/_settings/permissions/update', ['repo_group_name']);
     pyroutes.register('edit_repo_issuetracker', '/%(repo_name)s/settings/issue_trackers', ['repo_name']);
     pyroutes.register('edit_repo_issuetracker_delete', '/%(repo_name)s/settings/issue_trackers/delete', ['repo_name']);
     pyroutes.register('edit_repo_issuetracker_test', '/%(repo_name)s/settings/issue_trackers/test', ['repo_name']);
     pyroutes.register('edit_repo_issuetracker_update', '/%(repo_name)s/settings/issue_trackers/update', ['repo_name']);
     pyroutes.register('edit_repo_maintenance', '/%(repo_name)s/settings/maintenance', ['repo_name']);
     pyroutes.register('edit_repo_maintenance_execute', '/%(repo_name)s/settings/maintenance/execute', ['repo_name']);
     pyroutes.register('edit_repo_perms', '/%(repo_name)s/settings/permissions', ['repo_name']);
     pyroutes.register('edit_repo_perms_branch', '/%(repo_name)s/settings/branch_permissions', ['repo_name']);
     pyroutes.register('edit_repo_perms_branch_delete', '/%(repo_name)s/settings/branch_permissions/%(rule_id)s/delete', ['repo_name', 'rule_id']);
     pyroutes.register('edit_repo_perms_set_private', '/%(repo_name)s/settings/permissions/set_private', ['repo_name']);
     pyroutes.register('edit_repo_remote', '/%(repo_name)s/settings/remote', ['repo_name']);
     pyroutes.register('edit_repo_remote_pull', '/%(repo_name)s/settings/remote/pull', ['repo_name']);
     pyroutes.register('edit_repo_remote_push', '/%(repo_name)s/settings/remote/push', ['repo_name']);
     pyroutes.register('edit_repo_statistics', '/%(repo_name)s/settings/statistics', ['repo_name']);
     pyroutes.register('edit_repo_statistics_reset', '/%(repo_name)s/settings/statistics/update', ['repo_name']);
     pyroutes.register('edit_repo_strip', '/%(repo_name)s/settings/strip', ['repo_name']);
     pyroutes.register('edit_repo_vcs', '/%(repo_name)s/settings/vcs', ['repo_name']);
     pyroutes.register('edit_repo_vcs_svn_pattern_delete', '/%(repo_name)s/settings/vcs/svn_pattern/delete', ['repo_name']);
     pyroutes.register('edit_repo_vcs_update', '/%(repo_name)s/settings/vcs/update', ['repo_name']);
     pyroutes.register('edit_user_audit_logs', '/_admin/users/%(user_id)s/edit/audit', ['user_id']);
     pyroutes.register('edit_user_audit_logs_download', '/_admin/users/%(user_id)s/edit/audit/download', ['user_id']);
     pyroutes.register('edit_user_auth_tokens', '/_admin/users/%(user_id)s/edit/auth_tokens', ['user_id']);
     pyroutes.register('edit_user_auth_tokens_add', '/_admin/users/%(user_id)s/edit/auth_tokens/new', ['user_id']);
     pyroutes.register('edit_user_auth_tokens_delete', '/_admin/users/%(user_id)s/edit/auth_tokens/delete', ['user_id']);
     pyroutes.register('edit_user_auth_tokens_view', '/_admin/users/%(user_id)s/edit/auth_tokens/view', ['user_id']);
     pyroutes.register('edit_user_caches', '/_admin/users/%(user_id)s/edit/caches', ['user_id']);
     pyroutes.register('edit_user_caches_update', '/_admin/users/%(user_id)s/edit/caches/update', ['user_id']);
     pyroutes.register('edit_user_emails', '/_admin/users/%(user_id)s/edit/emails', ['user_id']);
     pyroutes.register('edit_user_emails_add', '/_admin/users/%(user_id)s/edit/emails/new', ['user_id']);
     pyroutes.register('edit_user_emails_delete', '/_admin/users/%(user_id)s/edit/emails/delete', ['user_id']);
     pyroutes.register('edit_user_group', '/_admin/user_groups/%(user_group_id)s/edit', ['user_group_id']);
     pyroutes.register('edit_user_group_advanced', '/_admin/user_groups/%(user_group_id)s/edit/advanced', ['user_group_id']);
     pyroutes.register('edit_user_group_advanced_sync', '/_admin/user_groups/%(user_group_id)s/edit/advanced/sync', ['user_group_id']);
     pyroutes.register('edit_user_group_global_perms', '/_admin/user_groups/%(user_group_id)s/edit/global_permissions', ['user_group_id']);
     pyroutes.register('edit_user_group_global_perms_update', '/_admin/user_groups/%(user_group_id)s/edit/global_permissions/update', ['user_group_id']);
     pyroutes.register('edit_user_group_perms', '/_admin/user_groups/%(user_group_id)s/edit/permissions', ['user_group_id']);
     pyroutes.register('edit_user_group_perms_summary', '/_admin/user_groups/%(user_group_id)s/edit/permissions_summary', ['user_group_id']);
     pyroutes.register('edit_user_group_perms_summary_json', '/_admin/user_groups/%(user_group_id)s/edit/permissions_summary/json', ['user_group_id']);
     pyroutes.register('edit_user_group_perms_update', '/_admin/user_groups/%(user_group_id)s/edit/permissions/update', ['user_group_id']);
     pyroutes.register('edit_user_groups_management', '/_admin/users/%(user_id)s/edit/groups_management', ['user_id']);
     pyroutes.register('edit_user_groups_management_updates', '/_admin/users/%(user_id)s/edit/edit_user_groups_management/updates', ['user_id']);
     pyroutes.register('edit_user_ips', '/_admin/users/%(user_id)s/edit/ips', ['user_id']);
     pyroutes.register('edit_user_ips_add', '/_admin/users/%(user_id)s/edit/ips/new', ['user_id']);
     pyroutes.register('edit_user_ips_delete', '/_admin/users/%(user_id)s/edit/ips/delete', ['user_id']);
     pyroutes.register('edit_user_perms_summary', '/_admin/users/%(user_id)s/edit/permissions_summary', ['user_id']);
     pyroutes.register('edit_user_perms_summary_json', '/_admin/users/%(user_id)s/edit/permissions_summary/json', ['user_id']);
     pyroutes.register('edit_user_ssh_keys', '/_admin/users/%(user_id)s/edit/ssh_keys', ['user_id']);
     pyroutes.register('edit_user_ssh_keys_add', '/_admin/users/%(user_id)s/edit/ssh_keys/new', ['user_id']);
     pyroutes.register('edit_user_ssh_keys_delete', '/_admin/users/%(user_id)s/edit/ssh_keys/delete', ['user_id']);
     pyroutes.register('edit_user_ssh_keys_generate_keypair', '/_admin/users/%(user_id)s/edit/ssh_keys/generate', ['user_id']);
     pyroutes.register('favicon', '/favicon.ico', []);
     pyroutes.register('file_preview', '/_file_preview', []);
     pyroutes.register('gist_delete', '/_admin/gists/%(gist_id)s/delete', ['gist_id']);
     pyroutes.register('gist_edit', '/_admin/gists/%(gist_id)s/edit', ['gist_id']);
     pyroutes.register('gist_edit_check_revision', '/_admin/gists/%(gist_id)s/edit/check_revision', ['gist_id']);
     pyroutes.register('gist_show', '/_admin/gists/%(gist_id)s', ['gist_id']);
     pyroutes.register('gist_show_formatted', '/_admin/gists/%(gist_id)s/rev/%(revision)s/%(format)s', ['gist_id', 'revision', 'format']);
     pyroutes.register('gist_show_formatted_path', '/_admin/gists/%(gist_id)s/rev/%(revision)s/%(format)s/%(f_path)s', ['gist_id', 'revision', 'format', 'f_path']);
     pyroutes.register('gist_show_rev', '/_admin/gists/%(gist_id)s/rev/%(revision)s', ['gist_id', 'revision']);
     pyroutes.register('gist_update', '/_admin/gists/%(gist_id)s/update', ['gist_id']);
     pyroutes.register('gists_create', '/_admin/gists/create', []);
     pyroutes.register('gists_new', '/_admin/gists/new', []);
     pyroutes.register('gists_show', '/_admin/gists', []);
     pyroutes.register('global_integrations_create', '/_admin/integrations/%(integration)s/new', ['integration']);
     pyroutes.register('global_integrations_edit', '/_admin/integrations/%(integration)s/%(integration_id)s', ['integration', 'integration_id']);
     pyroutes.register('global_integrations_home', '/_admin/integrations', []);
     pyroutes.register('global_integrations_list', '/_admin/integrations/%(integration)s', ['integration']);
     pyroutes.register('global_integrations_new', '/_admin/integrations/new', []);
     pyroutes.register('goto_switcher_data', '/_goto_data', []);
     pyroutes.register('home', '/', []);
     pyroutes.register('hovercard_pull_request', '/_hovercard/pull_request/%(pull_request_id)s', ['pull_request_id']);
     pyroutes.register('hovercard_repo_commit', '/_hovercard/commit/%(repo_name)s/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('hovercard_user', '/_hovercard/user/%(user_id)s', ['user_id']);
     pyroutes.register('hovercard_user_group', '/_hovercard/user_group/%(user_group_id)s', ['user_group_id']);
     pyroutes.register('hovercard_username', '/_hovercard/username/%(username)s', ['username']);
     pyroutes.register('journal', '/_admin/journal', []);
     pyroutes.register('journal_atom', '/_admin/journal/atom', []);
     pyroutes.register('journal_public', '/_admin/public_journal', []);
     pyroutes.register('journal_public_atom', '/_admin/public_journal/atom', []);
     pyroutes.register('journal_public_atom_old', '/_admin/public_journal_atom', []);
     pyroutes.register('journal_public_rss', '/_admin/public_journal/rss', []);
     pyroutes.register('journal_public_rss_old', '/_admin/public_journal_rss', []);
     pyroutes.register('journal_rss', '/_admin/journal/rss', []);
     pyroutes.register('login', '/_admin/login', []);
     pyroutes.register('logout', '/_admin/logout', []);
     pyroutes.register('main_page_repo_groups_data', '/_home_repo_groups', []);
     pyroutes.register('main_page_repos_data', '/_home_repos', []);
     pyroutes.register('markup_preview', '/_markup_preview', []);
     pyroutes.register('my_account_auth_tokens', '/_admin/my_account/auth_tokens', []);
     pyroutes.register('my_account_auth_tokens_add', '/_admin/my_account/auth_tokens/new', []);
     pyroutes.register('my_account_auth_tokens_delete', '/_admin/my_account/auth_tokens/delete', []);
     pyroutes.register('my_account_auth_tokens_view', '/_admin/my_account/auth_tokens/view', []);
     pyroutes.register('my_account_bookmarks', '/_admin/my_account/bookmarks', []);
     pyroutes.register('my_account_bookmarks_update', '/_admin/my_account/bookmarks/update', []);
+    pyroutes.register('my_account_configure_2fa', '/_admin/my_account/configure_2fa', []);
+    pyroutes.register('my_account_configure_2fa_update', '/_admin/my_account/configure_2fa_update', []);
     pyroutes.register('my_account_edit', '/_admin/my_account/edit', []);
     pyroutes.register('my_account_emails', '/_admin/my_account/emails', []);
     pyroutes.register('my_account_emails_add', '/_admin/my_account/emails/new', []);
     pyroutes.register('my_account_emails_delete', '/_admin/my_account/emails/delete', []);
-    pyroutes.register('my_account_enable_2fa', '/_admin/my_account/enable_2fa', []);
-    pyroutes.register('my_account_enable_2fa_save', '/_admin/my_account/enable_2fa_save', []);
     pyroutes.register('my_account_external_identity', '/_admin/my_account/external-identity', []);
     pyroutes.register('my_account_external_identity_delete', '/_admin/my_account/external-identity/delete', []);
     pyroutes.register('my_account_goto_bookmark', '/_admin/my_account/bookmark/%(bookmark_id)s', ['bookmark_id']);
     pyroutes.register('my_account_notifications', '/_admin/my_account/notifications', []);
     pyroutes.register('my_account_notifications_test_channelstream', '/_admin/my_account/test_channelstream', []);
     pyroutes.register('my_account_notifications_toggle_visibility', '/_admin/my_account/toggle_visibility', []);
     pyroutes.register('my_account_password', '/_admin/my_account/password', []);
     pyroutes.register('my_account_password_update', '/_admin/my_account/password/update', []);
     pyroutes.register('my_account_perms', '/_admin/my_account/perms', []);
     pyroutes.register('my_account_profile', '/_admin/my_account/profile', []);
     pyroutes.register('my_account_pullrequests', '/_admin/my_account/pull_requests', []);
     pyroutes.register('my_account_pullrequests_data', '/_admin/my_account/pull_requests/data', []);
     pyroutes.register('my_account_regenerate_2fa_recovery_codes', '/_admin/my_account/regenerate_recovery_codes', []);
     pyroutes.register('my_account_repos', '/_admin/my_account/repos', []);
     pyroutes.register('my_account_show_2fa_recovery_codes', '/_admin/my_account/recovery_codes', []);
     pyroutes.register('my_account_ssh_keys', '/_admin/my_account/ssh_keys', []);
     pyroutes.register('my_account_ssh_keys_add', '/_admin/my_account/ssh_keys/new', []);
     pyroutes.register('my_account_ssh_keys_delete', '/_admin/my_account/ssh_keys/delete', []);
     pyroutes.register('my_account_ssh_keys_generate', '/_admin/my_account/ssh_keys/generate', []);
     pyroutes.register('my_account_update', '/_admin/my_account/update', []);
     pyroutes.register('my_account_user_group_membership', '/_admin/my_account/user_group_membership', []);
     pyroutes.register('my_account_watched', '/_admin/my_account/watched', []);
     pyroutes.register('notifications_delete', '/_admin/notifications/%(notification_id)s/delete', ['notification_id']);
     pyroutes.register('notifications_mark_all_read', '/_admin/notifications_mark_all_read', []);
     pyroutes.register('notifications_show', '/_admin/notifications/%(notification_id)s', ['notification_id']);
     pyroutes.register('notifications_show_all', '/_admin/notifications', []);
     pyroutes.register('notifications_update', '/_admin/notifications/%(notification_id)s/update', ['notification_id']);
     pyroutes.register('ops_error_test', '/_admin/ops/error', []);
     pyroutes.register('ops_healthcheck', '/_admin/ops/status', []);
     pyroutes.register('ops_ping', '/_admin/ops/ping', []);
     pyroutes.register('ops_redirect_test', '/_admin/ops/redirect', []);
     pyroutes.register('plugin_admin_chat', '/_admin/plugin_admin_chat/%(action)s', ['action']);
     pyroutes.register('pull_requests_global', '/_admin/pull-request/%(pull_request_id)s', ['pull_request_id']);
     pyroutes.register('pull_requests_global_0', '/_admin/pull_requests/%(pull_request_id)s', ['pull_request_id']);
     pyroutes.register('pull_requests_global_1', '/_admin/pull-requests/%(pull_request_id)s', ['pull_request_id']);
     pyroutes.register('pullrequest_comment_create', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_comment_delete', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment/%(comment_id)s/delete', ['repo_name', 'pull_request_id', 'comment_id']);
     pyroutes.register('pullrequest_comment_edit', '/%(repo_name)s/pull-request/%(pull_request_id)s/comment/%(comment_id)s/edit', ['repo_name', 'pull_request_id', 'comment_id']);
     pyroutes.register('pullrequest_comments', '/%(repo_name)s/pull-request/%(pull_request_id)s/comments', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_create', '/%(repo_name)s/pull-request/create', ['repo_name']);
     pyroutes.register('pullrequest_delete', '/%(repo_name)s/pull-request/%(pull_request_id)s/delete', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_draft_comments_submit', '/%(repo_name)s/pull-request/%(pull_request_id)s/draft_comments_submit', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_drafts', '/%(repo_name)s/pull-request/%(pull_request_id)s/drafts', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_merge', '/%(repo_name)s/pull-request/%(pull_request_id)s/merge', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_new', '/%(repo_name)s/pull-request/new', ['repo_name']);
     pyroutes.register('pullrequest_repo_refs', '/%(repo_name)s/pull-request/refs/%(target_repo_name)s', ['repo_name', 'target_repo_name']);
     pyroutes.register('pullrequest_repo_targets', '/%(repo_name)s/pull-request/repo-targets', ['repo_name']);
     pyroutes.register('pullrequest_show', '/%(repo_name)s/pull-request/%(pull_request_id)s', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_show_all', '/%(repo_name)s/pull-request', ['repo_name']);
     pyroutes.register('pullrequest_show_all_data', '/%(repo_name)s/pull-request-data', ['repo_name']);
     pyroutes.register('pullrequest_todos', '/%(repo_name)s/pull-request/%(pull_request_id)s/todos', ['repo_name', 'pull_request_id']);
     pyroutes.register('pullrequest_update', '/%(repo_name)s/pull-request/%(pull_request_id)s/update', ['repo_name', 'pull_request_id']);
     pyroutes.register('register', '/_admin/register', []);
     pyroutes.register('repo_archivefile', '/%(repo_name)s/archive/%(fname)s', ['repo_name', 'fname']);
     pyroutes.register('repo_artifacts_data', '/%(repo_name)s/artifacts_data', ['repo_name']);
     pyroutes.register('repo_artifacts_delete', '/%(repo_name)s/artifacts/delete/%(uid)s', ['repo_name', 'uid']);
     pyroutes.register('repo_artifacts_get', '/%(repo_name)s/artifacts/download/%(uid)s', ['repo_name', 'uid']);
     pyroutes.register('repo_artifacts_info', '/%(repo_name)s/artifacts/info/%(uid)s', ['repo_name', 'uid']);
     pyroutes.register('repo_artifacts_list', '/%(repo_name)s/artifacts', ['repo_name']);
     pyroutes.register('repo_artifacts_new', '/%(repo_name)s/artifacts/new', ['repo_name']);
     pyroutes.register('repo_artifacts_store', '/%(repo_name)s/artifacts/store', ['repo_name']);
     pyroutes.register('repo_artifacts_stream_script', '/_file_store/stream-upload-script', []);
     pyroutes.register('repo_artifacts_stream_store', '/_file_store/stream-upload', []);
     pyroutes.register('repo_artifacts_update', '/%(repo_name)s/artifacts/update/%(uid)s', ['repo_name', 'uid']);
     pyroutes.register('repo_automation', '/%(repo_name)s/settings/automation', ['repo_name']);
     pyroutes.register('repo_automation_update', '/%(repo_name)s/settings/automation/%(entry_id)s/update', ['repo_name', 'entry_id']);
     pyroutes.register('repo_changelog', '/%(repo_name)s/changelog', ['repo_name']);
     pyroutes.register('repo_changelog_file', '/%(repo_name)s/changelog/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_commit', '/%(repo_name)s/changeset/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_children', '/%(repo_name)s/changeset_children/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_comment_attachment_upload', '/%(repo_name)s/changeset/%(commit_id)s/comment/attachment_upload', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_comment_create', '/%(repo_name)s/changeset/%(commit_id)s/comment/create', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_comment_delete', '/%(repo_name)s/changeset/%(commit_id)s/comment/%(comment_id)s/delete', ['repo_name', 'commit_id', 'comment_id']);
     pyroutes.register('repo_commit_comment_edit', '/%(repo_name)s/changeset/%(commit_id)s/comment/%(comment_id)s/edit', ['repo_name', 'commit_id', 'comment_id']);
     pyroutes.register('repo_commit_comment_history_view', '/%(repo_name)s/changeset/%(commit_id)s/comment/%(comment_id)s/history_view/%(comment_history_id)s', ['repo_name', 'commit_id', 'comment_id', 'comment_history_id']);
     pyroutes.register('repo_commit_comment_preview', '/%(repo_name)s/changeset/%(commit_id)s/comment/preview', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_data', '/%(repo_name)s/changeset-data/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_download', '/%(repo_name)s/changeset-download/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_parents', '/%(repo_name)s/changeset_parents/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_patch', '/%(repo_name)s/changeset-patch/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_raw', '/%(repo_name)s/changeset-diff/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commit_raw_deprecated', '/%(repo_name)s/raw-changeset/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_commits', '/%(repo_name)s/commits', ['repo_name']);
     pyroutes.register('repo_commits_elements', '/%(repo_name)s/commits_elements', ['repo_name']);
     pyroutes.register('repo_commits_elements_file', '/%(repo_name)s/commits_elements/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_commits_file', '/%(repo_name)s/commits/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_compare', '/%(repo_name)s/compare/%(source_ref_type)s@%(source_ref)s...%(target_ref_type)s@%(target_ref)s', ['repo_name', 'source_ref_type', 'source_ref', 'target_ref_type', 'target_ref']);
     pyroutes.register('repo_compare_select', '/%(repo_name)s/compare', ['repo_name']);
     pyroutes.register('repo_create', '/_admin/repos/create', []);
     pyroutes.register('repo_creating', '/%(repo_name)s/repo_creating', ['repo_name']);
     pyroutes.register('repo_creating_check', '/%(repo_name)s/repo_creating_check', ['repo_name']);
     pyroutes.register('repo_default_reviewers_data', '/%(repo_name)s/settings/review/default-reviewers', ['repo_name']);
     pyroutes.register('repo_file_authors', '/%(repo_name)s/authors/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_download', '/%(repo_name)s/download/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_download:legacy', '/%(repo_name)s/rawfile/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_history', '/%(repo_name)s/history/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_file_raw', '/%(repo_name)s/raw/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files', '/%(repo_name)s/files/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files:annotated', '/%(repo_name)s/annotate/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files:annotated_previous', '/%(repo_name)s/annotate-previous/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files:default_commit', '/%(repo_name)s/files', ['repo_name']);
     pyroutes.register('repo_files:default_path', '/%(repo_name)s/files/%(commit_id)s/', ['repo_name', 'commit_id']);
     pyroutes.register('repo_files:rendered', '/%(repo_name)s/render/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_add_file', '/%(repo_name)s/add_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_check_head', '/%(repo_name)s/check_head/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_create_file', '/%(repo_name)s/create_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_delete_file', '/%(repo_name)s/delete_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_diff', '/%(repo_name)s/diff/%(f_path)s', ['repo_name', 'f_path']);
     pyroutes.register('repo_files_diff_2way_redirect', '/%(repo_name)s/diff-2way/%(f_path)s', ['repo_name', 'f_path']);
     pyroutes.register('repo_files_edit_file', '/%(repo_name)s/edit_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_nodelist', '/%(repo_name)s/nodelist/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_remove_file', '/%(repo_name)s/remove_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_replace_binary', '/%(repo_name)s/replace_binary/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_update_file', '/%(repo_name)s/update_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_files_upload_file', '/%(repo_name)s/upload_file/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_fork_create', '/%(repo_name)s/fork/create', ['repo_name']);
     pyroutes.register('repo_fork_new', '/%(repo_name)s/fork', ['repo_name']);
     pyroutes.register('repo_forks_data', '/%(repo_name)s/forks/data', ['repo_name']);
     pyroutes.register('repo_forks_show_all', '/%(repo_name)s/forks', ['repo_name']);
     pyroutes.register('repo_group_create', '/_admin/repo_group/create', []);
     pyroutes.register('repo_group_home', '/%(repo_group_name)s', ['repo_group_name']);
     pyroutes.register('repo_group_home_slash', '/%(repo_group_name)s/', ['repo_group_name']);
     pyroutes.register('repo_group_integrations_create', '/%(repo_group_name)s/_settings/integrations/%(integration)s/new', ['repo_group_name', 'integration']);
     pyroutes.register('repo_group_integrations_edit', '/%(repo_group_name)s/_settings/integrations/%(integration)s/%(integration_id)s', ['repo_group_name', 'integration', 'integration_id']);
     pyroutes.register('repo_group_integrations_home', '/%(repo_group_name)s/_settings/integrations', ['repo_group_name']);
     pyroutes.register('repo_group_integrations_list', '/%(repo_group_name)s/_settings/integrations/%(integration)s', ['repo_group_name', 'integration']);
     pyroutes.register('repo_group_integrations_new', '/%(repo_group_name)s/_settings/integrations/new', ['repo_group_name']);
     pyroutes.register('repo_group_list_data', '/_repo_groups', []);
     pyroutes.register('repo_group_new', '/_admin/repo_group/new', []);
     pyroutes.register('repo_groups', '/_admin/repo_groups', []);
     pyroutes.register('repo_groups_data', '/_admin/repo_groups_data', []);
     pyroutes.register('repo_integrations_create', '/%(repo_name)s/settings/integrations/%(integration)s/new', ['repo_name', 'integration']);
     pyroutes.register('repo_integrations_edit', '/%(repo_name)s/settings/integrations/%(integration)s/%(integration_id)s', ['repo_name', 'integration', 'integration_id']);
     pyroutes.register('repo_integrations_home', '/%(repo_name)s/settings/integrations', ['repo_name']);
     pyroutes.register('repo_integrations_list', '/%(repo_name)s/settings/integrations/%(integration)s', ['repo_name', 'integration']);
     pyroutes.register('repo_integrations_new', '/%(repo_name)s/settings/integrations/new', ['repo_name']);
     pyroutes.register('repo_list_data', '/_repos', []);
     pyroutes.register('repo_new', '/_admin/repos/new', []);
     pyroutes.register('repo_nodetree_full', '/%(repo_name)s/nodetree_full/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
     pyroutes.register('repo_nodetree_full:default_path', '/%(repo_name)s/nodetree_full/%(commit_id)s/', ['repo_name', 'commit_id']);
     pyroutes.register('repo_refs_changelog_data', '/%(repo_name)s/refs-data-changelog', ['repo_name']);
     pyroutes.register('repo_refs_data', '/%(repo_name)s/refs-data', ['repo_name']);
     pyroutes.register('repo_reviewers', '/%(repo_name)s/settings/review/rules', ['repo_name']);
     pyroutes.register('repo_reviewers_review_rule_delete', '/%(repo_name)s/settings/review/rules/%(rule_id)s/delete', ['repo_name', 'rule_id']);
     pyroutes.register('repo_reviewers_review_rule_edit', '/%(repo_name)s/settings/review/rules/%(rule_id)s', ['repo_name', 'rule_id']);
     pyroutes.register('repo_reviewers_review_rule_new', '/%(repo_name)s/settings/review/rules/new', ['repo_name']);
     pyroutes.register('repo_settings_quick_actions', '/%(repo_name)s/settings/quick-action', ['repo_name']);
     pyroutes.register('repo_stats', '/%(repo_name)s/repo_stats/%(commit_id)s', ['repo_name', 'commit_id']);
     pyroutes.register('repo_summary', '/%(repo_name)s', ['repo_name']);
     pyroutes.register('repo_summary_commits', '/%(repo_name)s/summary-commits', ['repo_name']);
     pyroutes.register('repo_summary_explicit', '/%(repo_name)s/summary', ['repo_name']);
     pyroutes.register('repo_summary_slash', '/%(repo_name)s/', ['repo_name']);
     pyroutes.register('repos', '/_admin/repos', []);
     pyroutes.register('repos_data', '/_admin/repos_data', []);
     pyroutes.register('reset_password', '/_admin/password_reset', []);
     pyroutes.register('reset_password_confirmation', '/_admin/password_reset_confirmation', []);
     pyroutes.register('robots', '/robots.txt', []);
     pyroutes.register('rss_feed_home', '/%(repo_name)s/feed-rss', ['repo_name']);
     pyroutes.register('rss_feed_home_old', '/%(repo_name)s/feed/rss', ['repo_name']);
     pyroutes.register('search', '/_admin/search', []);
     pyroutes.register('search_repo', '/%(repo_name)s/_search', ['repo_name']);
     pyroutes.register('search_repo_alt', '/%(repo_name)s/search', ['repo_name']);
     pyroutes.register('search_repo_group', '/%(repo_group_name)s/_search', ['repo_group_name']);
     pyroutes.register('setup_2fa', '/_admin/setup_2fa', []);
     pyroutes.register('store_user_session_value', '/_store_session_attr', []);
     pyroutes.register('strip_check', '/%(repo_name)s/settings/strip_check', ['repo_name']);
     pyroutes.register('strip_execute', '/%(repo_name)s/settings/strip_execute', ['repo_name']);
     pyroutes.register('tags_home', '/%(repo_name)s/tags', ['repo_name']);
     pyroutes.register('toggle_following', '/_admin/toggle_following', []);
     pyroutes.register('upload_file', '/_file_store/upload', []);
     pyroutes.register('user_autocomplete_data', '/_users', []);
     pyroutes.register('user_create_personal_repo_group', '/_admin/users/%(user_id)s/create_repo_group', ['user_id']);
     pyroutes.register('user_delete', '/_admin/users/%(user_id)s/delete', ['user_id']);
     pyroutes.register('user_disable_force_password_reset', '/_admin/users/%(user_id)s/password_reset_disable', ['user_id']);
     pyroutes.register('user_edit', '/_admin/users/%(user_id)s/edit', ['user_id']);
     pyroutes.register('user_edit_advanced', '/_admin/users/%(user_id)s/edit/advanced', ['user_id']);
     pyroutes.register('user_edit_global_perms', '/_admin/users/%(user_id)s/edit/global_permissions', ['user_id']);
     pyroutes.register('user_edit_global_perms_update', '/_admin/users/%(user_id)s/edit/global_permissions/update', ['user_id']);
     pyroutes.register('user_enable_force_password_reset', '/_admin/users/%(user_id)s/password_reset_enable', ['user_id']);
     pyroutes.register('user_group_autocomplete_data', '/_user_groups', []);
     pyroutes.register('user_group_members_data', '/_admin/user_groups/%(user_group_id)s/members', ['user_group_id']);
     pyroutes.register('user_group_profile', '/_profile_user_group/%(user_group_name)s', ['user_group_name']);
     pyroutes.register('user_groups', '/_admin/user_groups', []);
     pyroutes.register('user_groups_create', '/_admin/user_groups/create', []);
     pyroutes.register('user_groups_data', '/_admin/user_groups_data', []);
     pyroutes.register('user_groups_delete', '/_admin/user_groups/%(user_group_id)s/delete', ['user_group_id']);
     pyroutes.register('user_groups_new', '/_admin/user_groups/new', []);
     pyroutes.register('user_groups_update', '/_admin/user_groups/%(user_group_id)s/update', ['user_group_id']);
     pyroutes.register('user_notice_dismiss', '/_admin/users/%(user_id)s/notice_dismiss', ['user_id']);
     pyroutes.register('user_profile', '/_profiles/%(username)s', ['username']);
     pyroutes.register('user_update', '/_admin/users/%(user_id)s/update', ['user_id']);
     pyroutes.register('users', '/_admin/users', []);
     pyroutes.register('users_create', '/_admin/users/create', []);
     pyroutes.register('users_data', '/_admin/users_data', []);
     pyroutes.register('users_new', '/_admin/users/new', []);
 }

rhodecode/templates/admin/my_account/my_account.mako

@@ -1,57 +1,57 b''
 <%inherit file="/base/base.mako"/>
 
 <%def name="title()">
     ${_('My account')} ${c.rhodecode_user.username}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${_('My Account')}
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='my_account')}
 </%def>
 
 <%def name="main()">
 <div class="box">
   <div class="title">
       ${self.breadcrumbs()}
   </div>
 
   <div class="sidebar-col-wrapper scw-small">
     ##main
     <div class="sidebar">
         <ul class="nav nav-pills nav-stacked">
           <li class="${h.is_active(['profile', 'profile_edit'], c.active)}"><a href="${h.route_path('my_account_profile')}">${_('Profile')}</a></li>
           <li class="${h.is_active('emails', c.active)}"><a href="${h.route_path('my_account_emails')}">${_('Emails')}</a></li>
           <li class="${h.is_active('password', c.active)}"><a href="${h.route_path('my_account_password')}">${_('Password')}</a></li>
-          <li class="${h.is_active('2FA', c.active)}"><a href="${h.route_path('my_account_enable_2fa')}">${_('2FA')}</a></li>
+          <li class="${h.is_active('2FA', c.active)}"><a href="${h.route_path('my_account_configure_2fa')}">${_('2FA')}</a></li>
           <li class="${h.is_active('bookmarks', c.active)}"><a href="${h.route_path('my_account_bookmarks')}">${_('Bookmarks')}</a></li>
           <li class="${h.is_active('auth_tokens', c.active)}"><a href="${h.route_path('my_account_auth_tokens')}">${_('Auth Tokens')}</a></li>
           <li class="${h.is_active(['ssh_keys', 'ssh_keys_generate'], c.active)}"><a href="${h.route_path('my_account_ssh_keys')}">${_('SSH Keys')}</a></li>
           <li class="${h.is_active('user_group_membership', c.active)}"><a href="${h.route_path('my_account_user_group_membership')}">${_('User Group Membership')}</a></li>
 
           ## TODO: Find a better integration of oauth/saml views into navigation.
           <% my_account_external_url = h.route_path_or_none('my_account_external_identity') %>
           % if my_account_external_url:
           <li class="${h.is_active('external_identity', c.active)}"><a href="${my_account_external_url}">${_('External Identities')}</a></li>
           % endif
 
           <li class="${h.is_active('repos', c.active)}"><a href="${h.route_path('my_account_repos')}">${_('Owned Repositories')}</a></li>
           <li class="${h.is_active('watched', c.active)}"><a href="${h.route_path('my_account_watched')}">${_('Watched Repositories')}</a></li>
           <li class="${h.is_active('pullrequests', c.active)}"><a href="${h.route_path('my_account_pullrequests')}">${_('Pull Requests')}</a></li>
           <li class="${h.is_active('perms', c.active)}"><a href="${h.route_path('my_account_perms')}">${_('Permissions')}</a></li>
           <li class="${h.is_active('my_notifications', c.active)}"><a href="${h.route_path('my_account_notifications')}">${_('Live Notifications')}</a></li>
         </ul>
     </div>
 
     <div class="main-content-full-width">
         <%include file="/admin/my_account/my_account_${c.active}.mako"/>
     </div>
   </div>
 </div>
 
 </%def>

rhodecode/templates/admin/my_account/my_account_2fa.mako

@@ -1,134 +1,134 b''
 <%namespace name="base" file="/base/base.mako"/>
 
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Enable/Disable 2FA for your account')}</h3>
     </div>
-    ${h.secure_form(h.route_path('my_account_enable_2fa_save'), request=request)}
+    ${h.secure_form(h.route_path('my_account_configure_2fa_update'), request=request)}
     <div class="panel-body">
         <div class="form">
             <div class="fields">
                 <div class="field">
                     <div class="label">
                         <label>${_('2FA status')}:</label>
                     </div>
                     <div class="checkboxes">
                         % if c.locked_2fa:
                         <span class="help-block">${_('2FA settings cannot be changed here, because 2FA was forced enabled by RhodeCode Administrator.')}</span>
 
                         % else:
                         <div class="form-check">
                             <input type="radio" id="2faEnabled" name="2fa_status" value="1" ${'checked=1' if c.state_of_2fa else ''}/>
                             <label for="2faEnabled">${_('Enable 2FA')}</label>
 
                             <input type="radio" id="2faDisabled" name="2fa_status" value="0" ${'checked=1' if not c.state_of_2fa else ''} />
                             <label for="2faDisabled">${_('Disable 2FA')}</label>
                         </div>
                         % endif
 
                     </div>
                 </div>
             </div>
             <button id="saveBtn" class="btn btn-primary" ${'disabled' if c.locked_2fa else ''}>${_('Save')}</button>
         </div>
     </div>
     ${h.end_form()}
 </div>
 
 % if c.state_of_2fa:
 
 
 % if not c.user_seen_2fa_recovery_codes:
 
 <div class="panel panel-warning">
     <div class="panel-heading" id="advanced-archive">
         <h3 class="panel-title">${_('2FA Recovery codes')} <a class="permalink" href="#advanced-archive"> ¶</a></h3>
     </div>
     <div class="panel-body">
         <p>
             ${_('You have not seen your 2FA recovery codes yet.')}
             ${_('Please save them in a safe place, or you will lose access to your account in case of lost access to authenticator app.')}
         </p>
         <br/>
-        <a href="${request.route_path('my_account_enable_2fa', _query={'show-recovery-codes': 1})}" class="btn btn-primary">${_('Show recovery codes')}</a>
+        <a href="${request.route_path('my_account_configure_2fa', _query={'show-recovery-codes': 1})}" class="btn btn-primary">${_('Show recovery codes')}</a>
     </div>
 </div>
 % endif
 
 
 ${h.secure_form(h.route_path('my_account_regenerate_2fa_recovery_codes'), request=request)}
 <div class="panel panel-default">
     <div class="panel-heading">
         <h3 class="panel-title">${_('Regenerate 2FA recovery codes for your account')}</h3>
     </div>
     <div class="panel-body">
         <form id="2faForm">
             <input type="text" name="totp" placeholder="${_('Verify the code from the app')}" pattern="\d{6}" style="width: 20%">
             <button type="submit" class="btn btn-primary">${_('Verify and generate new codes')}</button>
         </form>
     </div>
 
 </div>
 ${h.end_form()}
 % endif
 
 
 <script>
 
     function showRecoveryCodesPopup() {
 
         SwalNoAnimation.fire({
             title: _gettext('2FA recovery codes'),
             html: '<span>Should you ever lose your phone or access to your one time password secret, each of these recovery codes can be used one time each to regain access to your account. Please save them in a safe place, or you will lose access to your account.</span>',
             showCancelButton: false,
             showConfirmButton: true,
             showLoaderOnConfirm: true,
             confirmButtonText: _gettext('Show now'),
             allowOutsideClick: function () {
                 !Swal.isLoading()
             },
 
             preConfirm: function () {
 
                 var postData = {
                     'csrf_token': CSRF_TOKEN
                 };
                 return new Promise(function (resolve, reject) {
                     $.ajax({
                         type: 'POST',
                         data: postData,
                         url: pyroutes.url('my_account_show_2fa_recovery_codes'),
                         headers: {'X-PARTIAL-XHR': true}
                     })
                         .done(function (data) {
                             resolve(data);
                         })
                         .fail(function (jqXHR, textStatus, errorThrown) {
                             var message = formatErrorMessage(jqXHR, textStatus, errorThrown);
                             ajaxErrorSwal(message);
                         });
                 })
             }
 
         })
             .then(function (result) {
                 if (result.value) {
                     let funcData = {'recoveryCodes': result.value.recovery_codes}
                     let recoveryCodesHtml = renderTemplate('recoveryCodes', funcData);
                     SwalNoAnimation.fire({
                         allowOutsideClick: false,
                         confirmButtonText: _gettext('I Copied the codes'),
                         title: _gettext('2FA Recovery Codes'),
                         html: recoveryCodesHtml
                     }).then(function (result) {
                         if (result.isConfirmed) {
                             window.location.reload()
                         }
                     })
                 }
             })
     }
     % if request.GET.get('show-recovery-codes') == '1' and not c.user_seen_2fa_recovery_codes:
         showRecoveryCodesPopup();
     % endif
 </script>