issue-tracker: moved example to the input box

- removed docs which had bad examples
- improved regex for matching newline character properly
- added nicer formatting in examples

docs/issue-trackers/issue-trackers.rst

@@ -1,81 +1,76 b''
 .. _rhodecode-issue-trackers-ref:
 
 Issue Tracker Integration
 =========================
 
 You can set an issue tracker connection in two ways with |RCE|.
 
 * At the instance level, you can set a default issue tracker.
 * At the |repo| level, you can configure an integration with a different issue
   tracker.
 
 To integrate |RCE| with an issue tracker, you need to define a regular
 expression that will fetch the issue ID stored in commit messages, and replace
 it with a URL. This enables |RCE| to generate a link matching each issue to the
 target |repo|.
 
 Default Issue Tracker Configuration
 -----------------------------------
 
 To integrate your issue tracker, use the following steps:
 
 1. Open :menuselection:`Admin --> Settings --> Issue Tracker`.
 2. In the new entry field, enter the following information:
 
     * :guilabel:`Description`: A name for this set of rules.
     * :guilabel:`Pattern`: The regular expression that will match issues
       tagged in commit messages, or more see :ref:`issue-tr-eg-ref`.
     * :guilabel:`URL`: The URL to your issue tracker.
     * :guilabel:`Prefix`: The prefix with which you want to mark issues.
 
 3. Select **Add** so save the rule to your issue tracker configuration.
 
 Repository Issue Tracker Configuration
 --------------------------------------
 
 You can configure specific |repos| to use a different issue tracker than the
 default one. See the instructions in :ref:`repo-it`
 
 .. _issue-tr-eg-ref:
 
+
 Jira Integration
 ----------------
 
-* Regex = ``(?:^#|\s#)(\w+-\d+)``
-* URL = ``https://myissueserver.com/browse/${id}``
-* Issue Prefix = ``#``
+Please check examples in the view for configuration the issue trackers.
+
 
 Confluence (Wiki)
 -----------------
 
-* Regex = ``(?:conf-)([A-Z0-9]+)``
-* URL = ``https://example.atlassian.net/display/wiki/${id}/${repo_name}``
-* issue prefix = ``CONF-``
+Please check examples in the view for configuration the issue trackers.
+
 
 Redmine Integration
 -------------------
 
-* Regex = ``(issue-+\d+)``
-* URL = ``https://myissueserver.com/redmine/issue/${id}``
-* Issue Prefix = ``issue-``
+Please check examples in the view for configuration the issue trackers.
+
 
-Redmine (wiki)
---------------
+Redmine wiki Integration
+------------------------
 
-* Regex = ``(?:wiki-)([a-zA-Z0-9]+)``
-* URL = ``https://example.com/redmine/projects/wiki/${repo_name}``
-* Issue prefix = ``Issue-``
+Please check examples in the view for configuration the issue trackers.
+
 
 Pivotal Tracker
 ---------------
 
-* Regex = ``(?:pivot-)(?<project_id>\d+)-(?<story>\d+)``
-* URL = ``https://www.pivotaltracker.com/s/projects/${project_id}/stories/${story}``
-* Issue prefix = ``Piv-``
+Please check examples in the view for configuration the issue trackers.
+
 
 Trello
 ------
 
-* Regex = ``(?:trello-)(?<card_id>[a-zA-Z0-9]+)``
-* URL = ``https://trello.com/example.com/${card_id}``
-* Issue prefix = ``Trello-``
+Please check examples in the view for configuration the issue trackers.
+

rhodecode/apps/admin/tests/test_admin_settings.py

@@ -1,742 +1,742 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 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 mock
 import pytest
 
 import rhodecode
 from rhodecode.apps._base import ADMIN_PREFIX
 from rhodecode.lib.utils2 import md5
 from rhodecode.model.db import RhodeCodeUi
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel, IssueTrackerSettingsModel
 from rhodecode.tests import assert_session_flash
 from rhodecode.tests.utils import AssertResponse
 
 
 UPDATE_DATA_QUALNAME = 'rhodecode.model.update.UpdateModel.get_update_data'
 
 
 def route_path(name, params=None, **kwargs):
     import urllib
     from rhodecode.apps._base import ADMIN_PREFIX
 
     base_url = {
 
         'admin_settings':
             ADMIN_PREFIX +'/settings',
         'admin_settings_update':
             ADMIN_PREFIX + '/settings/update',
         'admin_settings_global':
             ADMIN_PREFIX + '/settings/global',
         'admin_settings_global_update':
             ADMIN_PREFIX + '/settings/global/update',
         'admin_settings_vcs':
             ADMIN_PREFIX + '/settings/vcs',
         'admin_settings_vcs_update':
             ADMIN_PREFIX + '/settings/vcs/update',
         'admin_settings_vcs_svn_pattern_delete':
             ADMIN_PREFIX + '/settings/vcs/svn_pattern_delete',
         'admin_settings_mapping':
             ADMIN_PREFIX + '/settings/mapping',
         'admin_settings_mapping_update':
             ADMIN_PREFIX + '/settings/mapping/update',
         'admin_settings_visual':
             ADMIN_PREFIX + '/settings/visual',
         'admin_settings_visual_update':
             ADMIN_PREFIX + '/settings/visual/update',
         'admin_settings_issuetracker':
             ADMIN_PREFIX + '/settings/issue-tracker',
         'admin_settings_issuetracker_update':
             ADMIN_PREFIX + '/settings/issue-tracker/update',
         'admin_settings_issuetracker_test':
             ADMIN_PREFIX + '/settings/issue-tracker/test',
         'admin_settings_issuetracker_delete':
             ADMIN_PREFIX + '/settings/issue-tracker/delete',
         'admin_settings_email':
             ADMIN_PREFIX + '/settings/email',
         'admin_settings_email_update':
             ADMIN_PREFIX + '/settings/email/update',
         'admin_settings_hooks':
             ADMIN_PREFIX + '/settings/hooks',
         'admin_settings_hooks_update':
             ADMIN_PREFIX + '/settings/hooks/update',
         'admin_settings_hooks_delete':
             ADMIN_PREFIX + '/settings/hooks/delete',
         'admin_settings_search':
             ADMIN_PREFIX + '/settings/search',
         'admin_settings_labs':
             ADMIN_PREFIX + '/settings/labs',
         'admin_settings_labs_update':
             ADMIN_PREFIX + '/settings/labs/update',
 
         'admin_settings_sessions':
             ADMIN_PREFIX + '/settings/sessions',
         'admin_settings_sessions_cleanup':
             ADMIN_PREFIX + '/settings/sessions/cleanup',
         'admin_settings_system':
             ADMIN_PREFIX + '/settings/system',
         'admin_settings_system_update':
             ADMIN_PREFIX + '/settings/system/updates',
         'admin_settings_open_source':
             ADMIN_PREFIX + '/settings/open_source',
 
 
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
     return base_url
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsController(object):
 
     @pytest.mark.parametrize('urlname', [
         'admin_settings_vcs',
         'admin_settings_mapping',
         'admin_settings_global',
         'admin_settings_visual',
         'admin_settings_email',
         'admin_settings_hooks',
         'admin_settings_search',
     ])
     def test_simple_get(self, urlname):
         self.app.get(route_path(urlname))
 
     def test_create_custom_hook(self, csrf_token):
         response = self.app.post(
             route_path('admin_settings_hooks_update'),
             params={
                 'new_hook_ui_key': 'test_hooks_1',
                 'new_hook_ui_value': 'cd /tmp',
                 'csrf_token': csrf_token})
 
         response = response.follow()
         response.mustcontain('test_hooks_1')
         response.mustcontain('cd /tmp')
 
     def test_create_custom_hook_delete(self, csrf_token):
         response = self.app.post(
             route_path('admin_settings_hooks_update'),
             params={
                 'new_hook_ui_key': 'test_hooks_2',
                 'new_hook_ui_value': 'cd /tmp2',
                 'csrf_token': csrf_token})
 
         response = response.follow()
         response.mustcontain('test_hooks_2')
         response.mustcontain('cd /tmp2')
 
         hook_id = SettingsModel().get_ui_by_key('test_hooks_2').ui_id
 
         # delete
         self.app.post(
             route_path('admin_settings_hooks_delete'),
             params={'hook_id': hook_id, 'csrf_token': csrf_token})
         response = self.app.get(route_path('admin_settings_hooks'))
         response.mustcontain(no=['test_hooks_2'])
         response.mustcontain(no=['cd /tmp2'])
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsGlobal(object):
 
     def test_pre_post_code_code_active(self, csrf_token):
         pre_code = 'rc-pre-code-187652122'
         post_code = 'rc-postcode-98165231'
 
         response = self.post_and_verify_settings({
             'rhodecode_pre_code': pre_code,
             'rhodecode_post_code': post_code,
             'csrf_token': csrf_token,
         })
 
         response = response.follow()
         response.mustcontain(pre_code, post_code)
 
     def test_pre_post_code_code_inactive(self, csrf_token):
         pre_code = 'rc-pre-code-187652122'
         post_code = 'rc-postcode-98165231'
         response = self.post_and_verify_settings({
             'rhodecode_pre_code': '',
             'rhodecode_post_code': '',
             'csrf_token': csrf_token,
         })
 
         response = response.follow()
         response.mustcontain(no=[pre_code, post_code])
 
     def test_captcha_activate(self, csrf_token):
         self.post_and_verify_settings({
             'rhodecode_captcha_private_key': '1234567890',
             'rhodecode_captcha_public_key': '1234567890',
             'csrf_token': csrf_token,
         })
 
         response = self.app.get(ADMIN_PREFIX + '/register')
         response.mustcontain('captcha')
 
     def test_captcha_deactivate(self, csrf_token):
         self.post_and_verify_settings({
             'rhodecode_captcha_private_key': '',
             'rhodecode_captcha_public_key': '1234567890',
             'csrf_token': csrf_token,
         })
 
         response = self.app.get(ADMIN_PREFIX + '/register')
         response.mustcontain(no=['captcha'])
 
     def test_title_change(self, csrf_token):
         old_title = 'RhodeCode'
 
         for new_title in ['Changed', 'Żółwik', old_title]:
             response = self.post_and_verify_settings({
                 'rhodecode_title': new_title,
                 'csrf_token': csrf_token,
             })
 
             response = response.follow()
             response.mustcontain(new_title)
 
     def post_and_verify_settings(self, settings):
         old_title = 'RhodeCode'
         old_realm = 'RhodeCode authentication'
         params = {
             'rhodecode_title': old_title,
             'rhodecode_realm': old_realm,
             'rhodecode_pre_code': '',
             'rhodecode_post_code': '',
             'rhodecode_captcha_private_key': '',
             'rhodecode_captcha_public_key': '',
             'rhodecode_create_personal_repo_group': False,
             'rhodecode_personal_repo_group_pattern': '${username}',
         }
         params.update(settings)
         response = self.app.post(
             route_path('admin_settings_global_update'), params=params)
 
         assert_session_flash(response, 'Updated application settings')
         app_settings = SettingsModel().get_all_settings()
         del settings['csrf_token']
         for key, value in settings.iteritems():
             assert app_settings[key] == value.decode('utf-8')
 
         return response
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsVcs(object):
 
     def test_contains_svn_default_patterns(self):
         response = self.app.get(route_path('admin_settings_vcs'))
         expected_patterns = [
             '/trunk',
             '/branches/*',
             '/tags/*',
         ]
         for pattern in expected_patterns:
             response.mustcontain(pattern)
 
     def test_add_new_svn_branch_and_tag_pattern(
             self, backend_svn, form_defaults, disable_sql_cache,
             csrf_token):
         form_defaults.update({
             'new_svn_branch': '/exp/branches/*',
             'new_svn_tag': '/important_tags/*',
             'csrf_token': csrf_token,
         })
 
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults, status=302)
         response = response.follow()
 
         # Expect to find the new values on the page
         response.mustcontain('/exp/branches/*')
         response.mustcontain('/important_tags/*')
 
         # Expect that those patterns are used to match branches and tags now
         repo = backend_svn['svn-simple-layout'].scm_instance()
         assert 'exp/branches/exp-sphinx-docs' in repo.branches
         assert 'important_tags/v0.5' in repo.tags
 
     def test_add_same_svn_value_twice_shows_an_error_message(
             self, form_defaults, csrf_token, settings_util):
         settings_util.create_rhodecode_ui('vcs_svn_branch', '/test')
         settings_util.create_rhodecode_ui('vcs_svn_tag', '/test')
 
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params={
                 'paths_root_path': form_defaults['paths_root_path'],
                 'new_svn_branch': '/test',
                 'new_svn_tag': '/test',
                 'csrf_token': csrf_token,
             },
             status=200)
 
         response.mustcontain("Pattern already exists")
         response.mustcontain("Some form inputs contain invalid data.")
 
     @pytest.mark.parametrize('section', [
         'vcs_svn_branch',
         'vcs_svn_tag',
     ])
     def test_delete_svn_patterns(
             self, section, csrf_token, settings_util):
         setting = settings_util.create_rhodecode_ui(
             section, '/test_delete', cleanup=False)
 
         self.app.post(
             route_path('admin_settings_vcs_svn_pattern_delete'),
             params={
                 'delete_svn_pattern': setting.ui_id,
                 'csrf_token': csrf_token},
             headers={'X-REQUESTED-WITH': 'XMLHttpRequest'})
 
     @pytest.mark.parametrize('section', [
         'vcs_svn_branch',
         'vcs_svn_tag',
     ])
     def test_delete_svn_patterns_raises_404_when_no_xhr(
             self, section, csrf_token, settings_util):
         setting = settings_util.create_rhodecode_ui(section, '/test_delete')
 
         self.app.post(
             route_path('admin_settings_vcs_svn_pattern_delete'),
             params={
                 'delete_svn_pattern': setting.ui_id,
                 'csrf_token': csrf_token},
             status=404)
 
     def test_extensions_hgsubversion(self, form_defaults, csrf_token):
         form_defaults.update({
             'csrf_token': csrf_token,
             'extensions_hgsubversion': 'True',
         })
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
 
         response = response.follow()
         extensions_input = (
             '<input id="extensions_hgsubversion" '
             'name="extensions_hgsubversion" type="checkbox" '
             'value="True" checked="checked" />')
         response.mustcontain(extensions_input)
 
     def test_extensions_hgevolve(self, form_defaults, csrf_token):
         form_defaults.update({
             'csrf_token': csrf_token,
             'extensions_evolve': 'True',
         })
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
 
         response = response.follow()
         extensions_input = (
             '<input id="extensions_evolve" '
             'name="extensions_evolve" type="checkbox" '
             'value="True" checked="checked" />')
         response.mustcontain(extensions_input)
 
     def test_has_a_section_for_pull_request_settings(self):
         response = self.app.get(route_path('admin_settings_vcs'))
         response.mustcontain('Pull Request Settings')
 
     def test_has_an_input_for_invalidation_of_inline_comments(self):
         response = self.app.get(route_path('admin_settings_vcs'))
         assert_response = response.assert_response()
         assert_response.one_element_exists(
             '[name=rhodecode_use_outdated_comments]')
 
     @pytest.mark.parametrize('new_value', [True, False])
     def test_allows_to_change_invalidation_of_inline_comments(
             self, form_defaults, csrf_token, new_value):
         setting_key = 'use_outdated_comments'
         setting = SettingsModel().create_or_update_setting(
             setting_key, not new_value, 'bool')
         Session().add(setting)
         Session().commit()
 
         form_defaults.update({
             'csrf_token': csrf_token,
             'rhodecode_use_outdated_comments': str(new_value),
         })
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
         response = response.follow()
         setting = SettingsModel().get_setting_by_name(setting_key)
         assert setting.app_settings_value is new_value
 
     @pytest.mark.parametrize('new_value', [True, False])
     def test_allows_to_change_hg_rebase_merge_strategy(
             self, form_defaults, csrf_token, new_value):
         setting_key = 'hg_use_rebase_for_merging'
 
         form_defaults.update({
             'csrf_token': csrf_token,
             'rhodecode_' + setting_key: str(new_value),
         })
 
         with mock.patch.dict(
                 rhodecode.CONFIG, {'labs_settings_active': 'true'}):
             self.app.post(
                 route_path('admin_settings_vcs_update'),
                 params=form_defaults,
                 status=302)
 
         setting = SettingsModel().get_setting_by_name(setting_key)
         assert setting.app_settings_value is new_value
 
     @pytest.fixture()
     def disable_sql_cache(self, request):
         patcher = mock.patch(
             'rhodecode.lib.caching_query.FromCache.process_query')
         request.addfinalizer(patcher.stop)
         patcher.start()
 
     @pytest.fixture()
     def form_defaults(self):
         from rhodecode.apps.admin.views.settings import AdminSettingsView
         return AdminSettingsView._form_defaults()
 
     # TODO: johbo: What we really want is to checkpoint before a test run and
     # reset the session afterwards.
     @pytest.fixture(scope='class', autouse=True)
     def cleanup_settings(self, request, baseapp):
         ui_id = RhodeCodeUi.ui_id
         original_ids = list(
             r.ui_id for r in RhodeCodeUi.query().values(ui_id))
 
         @request.addfinalizer
         def cleanup():
             RhodeCodeUi.query().filter(
                 ui_id.notin_(original_ids)).delete(False)
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestLabsSettings(object):
     def test_get_settings_page_disabled(self):
         with mock.patch.dict(
                 rhodecode.CONFIG, {'labs_settings_active': 'false'}):
 
             response = self.app.get(
                 route_path('admin_settings_labs'), status=302)
 
         assert response.location.endswith(route_path('admin_settings'))
 
     def test_get_settings_page_enabled(self):
         from rhodecode.apps.admin.views import settings
         lab_settings = [
             settings.LabSetting(
                 key='rhodecode_bool',
                 type='bool',
                 group='bool group',
                 label='bool label',
                 help='bool help'
             ),
             settings.LabSetting(
                 key='rhodecode_text',
                 type='unicode',
                 group='text group',
                 label='text label',
                 help='text help'
             ),
         ]
         with mock.patch.dict(rhodecode.CONFIG,
                              {'labs_settings_active': 'true'}):
             with mock.patch.object(settings, '_LAB_SETTINGS', lab_settings):
                 response = self.app.get(route_path('admin_settings_labs'))
 
         assert '<label>bool group:</label>' in response
         assert '<label for="rhodecode_bool">bool label</label>' in response
         assert '<p class="help-block">bool help</p>' in response
         assert 'name="rhodecode_bool" type="checkbox"' in response
 
         assert '<label>text group:</label>' in response
         assert '<label for="rhodecode_text">text label</label>' in response
         assert '<p class="help-block">text help</p>' in response
         assert 'name="rhodecode_text" size="60" type="text"' in response
 
 
 @pytest.mark.usefixtures('app')
 class TestOpenSourceLicenses(object):
 
     def test_records_are_displayed(self, autologin_user):
         sample_licenses = [
             {
                 "license": [
                     {
                         "fullName": "BSD 4-clause \"Original\" or \"Old\" License",
                         "shortName": "bsdOriginal",
                         "spdxId": "BSD-4-Clause",
                         "url": "http://spdx.org/licenses/BSD-4-Clause.html"
                     }
                 ],
                 "name": "python2.7-coverage-3.7.1"
             },
             {
                 "license": [
                     {
                         "fullName": "MIT License",
                         "shortName": "mit",
                         "spdxId": "MIT",
                         "url": "http://spdx.org/licenses/MIT.html"
                     }
                 ],
                 "name": "python2.7-bootstrapped-pip-9.0.1"
             },
         ]
         read_licenses_patch = mock.patch(
             'rhodecode.apps.admin.views.open_source_licenses.read_opensource_licenses',
             return_value=sample_licenses)
         with read_licenses_patch:
             response = self.app.get(
                 route_path('admin_settings_open_source'), status=200)
 
         assert_response = response.assert_response()
         assert_response.element_contains(
             '.panel-heading', 'Licenses of Third Party Packages')
         for license_data in sample_licenses:
             response.mustcontain(license_data["license"][0]["spdxId"])
             assert_response.element_contains('.panel-body', license_data["name"])
 
     def test_records_can_be_read(self, autologin_user):
         response = self.app.get(
             route_path('admin_settings_open_source'), status=200)
         assert_response = response.assert_response()
         assert_response.element_contains(
             '.panel-heading', 'Licenses of Third Party Packages')
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
         self.app.get(
             route_path('admin_settings_open_source'), status=404)
 
 
 @pytest.mark.usefixtures('app')
 class TestUserSessions(object):
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
         self.app.get(route_path('admin_settings_sessions'), status=404)
 
     def test_show_sessions_page(self, autologin_user):
         response = self.app.get(route_path('admin_settings_sessions'), status=200)
         response.mustcontain('file')
 
     def test_cleanup_old_sessions(self, autologin_user, csrf_token):
 
         post_data = {
             'csrf_token': csrf_token,
             'expire_days': '60'
         }
         response = self.app.post(
             route_path('admin_settings_sessions_cleanup'), params=post_data,
             status=302)
         assert_session_flash(response, 'Cleaned up old sessions')
 
 
 @pytest.mark.usefixtures('app')
 class TestAdminSystemInfo(object):
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
         self.app.get(route_path('admin_settings_system'), status=404)
 
     def test_system_info_page(self, autologin_user):
         response = self.app.get(route_path('admin_settings_system'))
         response.mustcontain('RhodeCode Community Edition, version {}'.format(
             rhodecode.__version__))
 
     def test_system_update_new_version(self, autologin_user):
         update_data = {
             'versions': [
                 {
                     'version': '100.3.1415926535',
                     'general': 'The latest version we are ever going to ship'
                 },
                 {
                     'version': '0.0.0',
                     'general': 'The first version we ever shipped'
                 }
             ]
         }
         with mock.patch(UPDATE_DATA_QUALNAME, return_value=update_data):
             response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain('A <b>new version</b> is available')
 
     def test_system_update_nothing_new(self, autologin_user):
         update_data = {
             'versions': [
                 {
                     'version': '0.0.0',
                     'general': 'The first version we ever shipped'
                 }
             ]
         }
         with mock.patch(UPDATE_DATA_QUALNAME, return_value=update_data):
             response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain(
                 'This instance is already running the <b>latest</b> stable version')
 
     def test_system_update_bad_response(self, autologin_user):
         with mock.patch(UPDATE_DATA_QUALNAME, side_effect=ValueError('foo')):
             response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain(
                 'Bad data sent from update server')
 
 
 @pytest.mark.usefixtures("app")
 class TestAdminSettingsIssueTracker(object):
     RC_PREFIX = 'rhodecode_'
     SHORT_PATTERN_KEY = 'issuetracker_pat_'
     PATTERN_KEY = RC_PREFIX + SHORT_PATTERN_KEY
 
     def test_issuetracker_index(self, autologin_user):
         response = self.app.get(route_path('admin_settings_issuetracker'))
         assert response.status_code == 200
 
     def test_add_empty_issuetracker_pattern(
             self, request, autologin_user, csrf_token):
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
 
     def test_add_issuetracker_pattern(
             self, request, autologin_user, csrf_token):
         pattern = 'issuetracker_pat'
         another_pattern = pattern+'1'
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'http://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'new_pattern_pattern_1': another_pattern,
             'new_pattern_url_1': 'https://url1',
             'new_pattern_prefix_1': 'prefix1',
             'new_pattern_description_1': 'description1',
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         self.uid = md5(pattern)
         assert settings[self.PATTERN_KEY+self.uid] == pattern
         self.another_uid = md5(another_pattern)
         assert settings[self.PATTERN_KEY+self.another_uid] == another_pattern
 
         @request.addfinalizer
         def cleanup():
             defaults = SettingsModel().get_all_settings()
 
             entries = [name for name in defaults if (
                 (self.uid in name) or (self.another_uid) in name)]
             start = len(self.RC_PREFIX)
             for del_key in entries:
                 # TODO: anderson: get_by_name needs name without prefix
                 entry = SettingsModel().get_setting_by_name(del_key[start:])
                 Session().delete(entry)
 
             Session().commit()
 
     def test_edit_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, request):
         old_pattern = 'issuetracker_pat'
         old_uid = md5(old_pattern)
         pattern = 'issuetracker_pat_new'
         self.new_uid = md5(pattern)
 
         SettingsModel().create_or_update_setting(
             self.SHORT_PATTERN_KEY+old_uid, old_pattern, 'unicode')
 
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'https://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'uid': old_uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         assert settings[self.PATTERN_KEY+self.new_uid] == pattern
         assert self.PATTERN_KEY+old_uid not in settings
 
         @request.addfinalizer
         def cleanup():
             IssueTrackerSettingsModel().delete_entries(self.new_uid)
 
     def test_replace_issuetracker_pattern_description(
             self, autologin_user, csrf_token, request, settings_util):
         prefix = 'issuetracker'
         pattern = 'issuetracker_pat'
         self.uid = md5(pattern)
         pattern_key = '_'.join([prefix, 'pat', self.uid])
         rc_pattern_key = '_'.join(['rhodecode', pattern_key])
         desc_key = '_'.join([prefix, 'desc', self.uid])
         rc_desc_key = '_'.join(['rhodecode', desc_key])
         new_description = 'new_description'
 
         settings_util.create_rhodecode_setting(
             pattern_key, pattern, 'unicode', cleanup=False)
         settings_util.create_rhodecode_setting(
             desc_key, 'old description', 'unicode', cleanup=False)
 
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'https://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': new_description,
             'uid': self.uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         assert settings[rc_pattern_key] == pattern
         assert settings[rc_desc_key] == new_description
 
         @request.addfinalizer
         def cleanup():
             IssueTrackerSettingsModel().delete_entries(self.uid)
 
     def test_delete_issuetracker_pattern(
-            self, autologin_user, backend, csrf_token, settings_util):
+            self, autologin_user, backend, csrf_token, settings_util, xhr_header):
         pattern = 'issuetracker_pat'
         uid = md5(pattern)
         settings_util.create_rhodecode_setting(
             self.SHORT_PATTERN_KEY+uid, pattern, 'unicode', cleanup=False)
 
         post_url = route_path('admin_settings_issuetracker_delete')
         post_data = {
             'uid': uid,
             'csrf_token': csrf_token
         }
-        self.app.post(post_url, post_data, status=302)
+        self.app.post(post_url, post_data, extra_environ=xhr_header, status=200)
         settings = SettingsModel().get_all_settings()
         assert 'rhodecode_%s%s' % (self.SHORT_PATTERN_KEY, uid) not in settings

rhodecode/apps/admin/views/settings.py

@@ -1,780 +1,783 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 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 logging
 import collections
 
 import datetime
 import formencode
 import formencode.htmlfill
 
 import rhodecode
 from pyramid.view import view_config
 from pyramid.httpexceptions import HTTPFound, HTTPNotFound
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode.apps._base import BaseAppView
 from rhodecode.apps._base.navigation import navigation_list
 from rhodecode.apps.svn_support.config_keys import generate_config
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import (
     LoginRequired, HasPermissionAllDecorator, CSRFRequired)
 from rhodecode.lib.celerylib import tasks, run_task
 from rhodecode.lib.utils import repo2db_mapper
 from rhodecode.lib.utils2 import str2bool, safe_unicode, AttributeDict
 from rhodecode.lib.index import searcher_from_config
 
 from rhodecode.model.db import RhodeCodeUi, Repository
 from rhodecode.model.forms import (ApplicationSettingsForm,
     ApplicationUiSettingsForm, ApplicationVisualisationForm,
     LabsSettingsForm, IssueTrackerPatternsForm)
 from rhodecode.model.repo_group import RepoGroupModel
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.notification import EmailNotificationModel
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import (
     IssueTrackerSettingsModel, VcsSettingsModel, SettingNotFound,
     SettingsModel)
 
 
 log = logging.getLogger(__name__)
 
 
 class AdminSettingsView(BaseAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         c.labs_active = str2bool(
             rhodecode.CONFIG.get('labs_settings_active', 'true'))
         c.navlist = navigation_list(self.request)
 
         return c
 
     @classmethod
     def _get_ui_settings(cls):
         ret = RhodeCodeUi.query().all()
 
         if not ret:
             raise Exception('Could not get application ui settings !')
         settings = {}
         for each in ret:
             k = each.ui_key
             v = each.ui_value
             if k == '/':
                 k = 'root_path'
 
             if k in ['push_ssl', 'publish', 'enabled']:
                 v = str2bool(v)
 
             if k.find('.') != -1:
                 k = k.replace('.', '_')
 
             if each.ui_section in ['hooks', 'extensions']:
                 v = each.ui_active
 
             settings[each.ui_section + '_' + k] = v
         return settings
 
     @classmethod
     def _form_defaults(cls):
         defaults = SettingsModel().get_all_settings()
         defaults.update(cls._get_ui_settings())
 
         defaults.update({
             'new_svn_branch': '',
             'new_svn_tag': '',
         })
         return defaults
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_vcs', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_vcs(self):
         c = self.load_default_context()
         c.active = 'vcs'
         model = VcsSettingsModel()
         c.svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.svn_tag_patterns = model.get_global_svn_tag_patterns()
 
         settings = self.request.registry.settings
         c.svn_proxy_generate_config = settings[generate_config]
 
         defaults = self._form_defaults()
 
         model.create_largeobjects_dirs_if_needed(defaults['paths_root_path'])
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_vcs_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_vcs_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'vcs'
 
         model = VcsSettingsModel()
         c.svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.svn_tag_patterns = model.get_global_svn_tag_patterns()
 
         settings = self.request.registry.settings
         c.svn_proxy_generate_config = settings[generate_config]
 
         application_form = ApplicationUiSettingsForm(self.request.translate)()
 
         try:
             form_result = application_form.to_python(dict(self.request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             data = render('rhodecode:templates/admin/settings/settings.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         try:
             if c.visual.allow_repo_location_change:
                 model.update_global_path_setting(form_result['paths_root_path'])
 
             model.update_global_ssl_setting(form_result['web_push_ssl'])
             model.update_global_hook_settings(form_result)
 
             model.create_or_update_global_svn_settings(form_result)
             model.create_or_update_global_hg_settings(form_result)
             model.create_or_update_global_git_settings(form_result)
             model.create_or_update_global_pr_settings(form_result)
         except Exception:
             log.exception("Exception while updating settings")
             h.flash(_('Error occurred during updating '
                       'application settings'), category='error')
         else:
             Session().commit()
             h.flash(_('Updated VCS settings'), category='success')
             raise HTTPFound(h.route_path('admin_settings_vcs'))
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_vcs_svn_pattern_delete', request_method='POST',
         renderer='json_ext', xhr=True)
     def settings_vcs_delete_svn_pattern(self):
         delete_pattern_id = self.request.POST.get('delete_svn_pattern')
         model = VcsSettingsModel()
         try:
             model.delete_global_svn_pattern(delete_pattern_id)
         except SettingNotFound:
             log.exception(
                 'Failed to delete svn_pattern with id %s', delete_pattern_id)
             raise HTTPNotFound()
 
         Session().commit()
         return True
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_mapping', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_mapping(self):
         c = self.load_default_context()
         c.active = 'mapping'
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_mapping_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_mapping_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'mapping'
         rm_obsolete = self.request.POST.get('destroy', False)
         invalidate_cache = self.request.POST.get('invalidate', False)
         log.debug(
             'rescanning repo location with destroy obsolete=%s', rm_obsolete)
 
         if invalidate_cache:
             log.debug('invalidating all repositories cache')
             for repo in Repository.get_all():
                 ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
 
         filesystem_repos = ScmModel().repo_scan()
         added, removed = repo2db_mapper(filesystem_repos, rm_obsolete)
         _repr = lambda l: ', '.join(map(safe_unicode, l)) or '-'
         h.flash(_('Repositories successfully '
                   'rescanned added: %s ; removed: %s') %
                 (_repr(added), _repr(removed)),
                 category='success')
         raise HTTPFound(h.route_path('admin_settings_mapping'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     @view_config(
         route_name='admin_settings_global', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_global(self):
         c = self.load_default_context()
         c.active = 'global'
         c.personal_repo_group_default_pattern = RepoGroupModel()\
             .get_personal_group_name_pattern()
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     @view_config(
         route_name='admin_settings_global_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_global_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'global'
         c.personal_repo_group_default_pattern = RepoGroupModel()\
             .get_personal_group_name_pattern()
         application_form = ApplicationSettingsForm(self.request.translate)()
         try:
             form_result = application_form.to_python(dict(self.request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             data = render('rhodecode:templates/admin/settings/settings.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         settings = [
             ('title', 'rhodecode_title', 'unicode'),
             ('realm', 'rhodecode_realm', 'unicode'),
             ('pre_code', 'rhodecode_pre_code', 'unicode'),
             ('post_code', 'rhodecode_post_code', 'unicode'),
             ('captcha_public_key', 'rhodecode_captcha_public_key', 'unicode'),
             ('captcha_private_key', 'rhodecode_captcha_private_key', 'unicode'),
             ('create_personal_repo_group', 'rhodecode_create_personal_repo_group', 'bool'),
             ('personal_repo_group_pattern', 'rhodecode_personal_repo_group_pattern', 'unicode'),
         ]
         try:
             for setting, form_key, type_ in settings:
                 sett = SettingsModel().create_or_update_setting(
                     setting, form_result[form_key], type_)
                 Session().add(sett)
 
             Session().commit()
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated application settings'), category='success')
         except Exception:
             log.exception("Exception while updating application settings")
             h.flash(
                 _('Error occurred during updating application settings'),
                 category='error')
 
         raise HTTPFound(h.route_path('admin_settings_global'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_visual', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_visual(self):
         c = self.load_default_context()
         c.active = 'visual'
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_visual_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_visual_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'visual'
         application_form = ApplicationVisualisationForm(self.request.translate)()
         try:
             form_result = application_form.to_python(dict(self.request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             data = render('rhodecode:templates/admin/settings/settings.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         try:
             settings = [
                 ('show_public_icon', 'rhodecode_show_public_icon', 'bool'),
                 ('show_private_icon', 'rhodecode_show_private_icon', 'bool'),
                 ('stylify_metatags', 'rhodecode_stylify_metatags', 'bool'),
                 ('repository_fields', 'rhodecode_repository_fields', 'bool'),
                 ('dashboard_items', 'rhodecode_dashboard_items', 'int'),
                 ('admin_grid_items', 'rhodecode_admin_grid_items', 'int'),
                 ('show_version', 'rhodecode_show_version', 'bool'),
                 ('use_gravatar', 'rhodecode_use_gravatar', 'bool'),
                 ('markup_renderer', 'rhodecode_markup_renderer', 'unicode'),
                 ('gravatar_url', 'rhodecode_gravatar_url', 'unicode'),
                 ('clone_uri_tmpl', 'rhodecode_clone_uri_tmpl', 'unicode'),
                 ('clone_uri_ssh_tmpl', 'rhodecode_clone_uri_ssh_tmpl', 'unicode'),
                 ('support_url', 'rhodecode_support_url', 'unicode'),
                 ('show_revision_number', 'rhodecode_show_revision_number', 'bool'),
                 ('show_sha_length', 'rhodecode_show_sha_length', 'int'),
             ]
             for setting, form_key, type_ in settings:
                 sett = SettingsModel().create_or_update_setting(
                     setting, form_result[form_key], type_)
                 Session().add(sett)
 
             Session().commit()
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated visualisation settings'), category='success')
         except Exception:
             log.exception("Exception updating visualization settings")
             h.flash(_('Error occurred during updating '
                       'visualisation settings'),
                     category='error')
 
         raise HTTPFound(h.route_path('admin_settings_visual'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_issuetracker', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_issuetracker(self):
         c = self.load_default_context()
         c.active = 'issuetracker'
         defaults = c.rc_config
 
         entry_key = 'rhodecode_issuetracker_pat_'
 
         c.issuetracker_entries = {}
         for k, v in defaults.items():
             if k.startswith(entry_key):
                 uid = k[len(entry_key):]
                 c.issuetracker_entries[uid] = None
 
         for uid in c.issuetracker_entries:
             c.issuetracker_entries[uid] = AttributeDict({
                 'pat': defaults.get('rhodecode_issuetracker_pat_' + uid),
                 'url': defaults.get('rhodecode_issuetracker_url_' + uid),
                 'pref': defaults.get('rhodecode_issuetracker_pref_' + uid),
                 'desc': defaults.get('rhodecode_issuetracker_desc_' + uid),
             })
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_issuetracker_test', request_method='POST',
         renderer='string', xhr=True)
     def settings_issuetracker_test(self):
         return h.urlify_commit_message(
             self.request.POST.get('test_text', ''),
             'repo_group/test_repo1')
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_issuetracker_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_issuetracker_update(self):
         _ = self.request.translate
         self.load_default_context()
         settings_model = IssueTrackerSettingsModel()
 
         try:
             form = IssueTrackerPatternsForm(self.request.translate)()
             data = form.to_python(self.request.POST)
         except formencode.Invalid as errors:
             log.exception('Failed to add new pattern')
             error = errors
             h.flash(_('Invalid issue tracker pattern: {}'.format(error)),
                     category='error')
             raise HTTPFound(h.route_path('admin_settings_issuetracker'))
 
         if data:
             for uid in data.get('delete_patterns', []):
                 settings_model.delete_entries(uid)
 
             for pattern in data.get('patterns', []):
                 for setting, value, type_ in pattern:
                     sett = settings_model.create_or_update_setting(
                         setting, value, type_)
                     Session().add(sett)
 
                 Session().commit()
 
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated issue tracker entries'), category='success')
         raise HTTPFound(h.route_path('admin_settings_issuetracker'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_issuetracker_delete', request_method='POST',
-        renderer='rhodecode:templates/admin/settings/settings.mako')
+        renderer='json_ext', xhr=True)
     def settings_issuetracker_delete(self):
         _ = self.request.translate
         self.load_default_context()
         uid = self.request.POST.get('uid')
         try:
             IssueTrackerSettingsModel().delete_entries(uid)
         except Exception:
             log.exception('Failed to delete issue tracker setting %s', uid)
             raise HTTPNotFound()
-        h.flash(_('Removed issue tracker entry'), category='success')
-        raise HTTPFound(h.route_path('admin_settings_issuetracker'))
+
+        SettingsModel().invalidate_settings_cache()
+        h.flash(_('Removed issue tracker entry.'), category='success')
+
+        return {'deleted': uid}
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_email', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_email(self):
         c = self.load_default_context()
         c.active = 'email'
         c.rhodecode_ini = rhodecode.CONFIG
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_email_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_email_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'email'
 
         test_email = self.request.POST.get('test_email')
 
         if not test_email:
             h.flash(_('Please enter email address'), category='error')
             raise HTTPFound(h.route_path('admin_settings_email'))
 
         email_kwargs = {
             'date': datetime.datetime.now(),
             'user': c.rhodecode_user,
             'rhodecode_version': c.rhodecode_version
         }
 
         (subject, headers, email_body,
          email_body_plaintext) = EmailNotificationModel().render_email(
             EmailNotificationModel.TYPE_EMAIL_TEST, **email_kwargs)
 
         recipients = [test_email] if test_email else None
 
         run_task(tasks.send_email, recipients, subject,
                  email_body_plaintext, email_body)
 
         h.flash(_('Send email task created'), category='success')
         raise HTTPFound(h.route_path('admin_settings_email'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_hooks', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_hooks(self):
         c = self.load_default_context()
         c.active = 'hooks'
 
         model = SettingsModel()
         c.hooks = model.get_builtin_hooks()
         c.custom_hooks = model.get_custom_hooks()
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_hooks_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     @view_config(
         route_name='admin_settings_hooks_delete', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_hooks_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'hooks'
         if c.visual.allow_custom_hooks_settings:
             ui_key = self.request.POST.get('new_hook_ui_key')
             ui_value = self.request.POST.get('new_hook_ui_value')
 
             hook_id = self.request.POST.get('hook_id')
             new_hook = False
 
             model = SettingsModel()
             try:
                 if ui_value and ui_key:
                     model.create_or_update_hook(ui_key, ui_value)
                     h.flash(_('Added new hook'), category='success')
                     new_hook = True
                 elif hook_id:
                     RhodeCodeUi.delete(hook_id)
                     Session().commit()
 
                 # check for edits
                 update = False
                 _d = self.request.POST.dict_of_lists()
                 for k, v in zip(_d.get('hook_ui_key', []),
                                 _d.get('hook_ui_value_new', [])):
                     model.create_or_update_hook(k, v)
                     update = True
 
                 if update and not new_hook:
                     h.flash(_('Updated hooks'), category='success')
                 Session().commit()
             except Exception:
                 log.exception("Exception during hook creation")
                 h.flash(_('Error occurred during hook creation'),
                         category='error')
 
         raise HTTPFound(h.route_path('admin_settings_hooks'))
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_search', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_search(self):
         c = self.load_default_context()
         c.active = 'search'
 
         c.searcher = searcher_from_config(self.request.registry.settings)
         c.statistics = c.searcher.statistics(self.request.translate)
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_automation', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_automation(self):
         c = self.load_default_context()
         c.active = 'automation'
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_labs', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_labs(self):
         c = self.load_default_context()
         if not c.labs_active:
             raise HTTPFound(h.route_path('admin_settings'))
 
         c.active = 'labs'
         c.lab_settings = _LAB_SETTINGS
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @CSRFRequired()
     @view_config(
         route_name='admin_settings_labs_update', request_method='POST',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_labs_update(self):
         _ = self.request.translate
         c = self.load_default_context()
         c.active = 'labs'
 
         application_form = LabsSettingsForm(self.request.translate)()
         try:
             form_result = application_form.to_python(dict(self.request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             data = render('rhodecode:templates/admin/settings/settings.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         try:
             session = Session()
             for setting in _LAB_SETTINGS:
                 setting_name = setting.key[len('rhodecode_'):]
                 sett = SettingsModel().create_or_update_setting(
                     setting_name, form_result[setting.key], setting.type)
                 session.add(sett)
 
         except Exception:
             log.exception('Exception while updating lab settings')
             h.flash(_('Error occurred during updating labs settings'),
                     category='error')
         else:
             Session().commit()
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated Labs settings'), category='success')
             raise HTTPFound(h.route_path('admin_settings_labs'))
 
         data = render('rhodecode:templates/admin/settings/settings.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
 
 # :param key: name of the setting including the 'rhodecode_' prefix
 # :param type: the RhodeCodeSetting type to use.
 # :param group: the i18ned group in which we should dispaly this setting
 # :param label: the i18ned label we should display for this setting
 # :param help: the i18ned help we should dispaly for this setting
 LabSetting = collections.namedtuple(
     'LabSetting', ('key', 'type', 'group', 'label', 'help'))
 
 
 # This list has to be kept in sync with the form
 # rhodecode.model.forms.LabsSettingsForm.
 _LAB_SETTINGS = [
 
 ]

rhodecode/apps/repository/tests/test_repo_issue_tracker.py

@@ -1,148 +1,149 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 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 pytest
 
 from rhodecode.lib.utils2 import md5
 from rhodecode.model.db import Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel, IssueTrackerSettingsModel
 
 
 def route_path(name, params=None, **kwargs):
     import urllib
 
     base_url = {
         'repo_summary': '/{repo_name}',
         'edit_repo_issuetracker': '/{repo_name}/settings/issue_trackers',
         'edit_repo_issuetracker_test': '/{repo_name}/settings/issue_trackers/test',
         'edit_repo_issuetracker_delete': '/{repo_name}/settings/issue_trackers/delete',
         'edit_repo_issuetracker_update': '/{repo_name}/settings/issue_trackers/update',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
     return base_url
 
 
 @pytest.mark.usefixtures("app")
 class TestRepoIssueTracker(object):
     def test_issuetracker_index(self, autologin_user, backend):
         repo = backend.create_repo()
         response = self.app.get(route_path('edit_repo_issuetracker',
                                 repo_name=repo.repo_name))
         assert response.status_code == 200
 
     def test_add_and_test_issuetracker_patterns(
             self, autologin_user, backend, csrf_token, request, xhr_header):
         pattern = 'issuetracker_pat'
         another_pattern = pattern+'1'
         post_url = route_path(
             'edit_repo_issuetracker_update', repo_name=backend.repo.repo_name)
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'http://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'new_pattern_pattern_1': another_pattern,
             'new_pattern_url_1': '/url1',
             'new_pattern_prefix_1': 'prefix1',
             'new_pattern_description_1': 'description1',
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         self.settings_model = IssueTrackerSettingsModel(repo=backend.repo)
         settings = self.settings_model.get_repo_settings()
         self.uid = md5(pattern)
         assert settings[self.uid]['pat'] == pattern
         self.another_uid = md5(another_pattern)
         assert settings[self.another_uid]['pat'] == another_pattern
 
         # test pattern
         data = {'test_text': 'example of issuetracker_pat replacement',
                 'csrf_token': csrf_token}
         response = self.app.post(
             route_path('edit_repo_issuetracker_test',
                        repo_name=backend.repo.repo_name),
             extra_environ=xhr_header, params=data)
 
         assert response.body == \
                'example of <a class="tooltip issue-tracker-link" href="http://url" title="description">prefix</a> replacement'
 
         @request.addfinalizer
         def cleanup():
             self.settings_model.delete_entries(self.uid)
             self.settings_model.delete_entries(self.another_uid)
 
     def test_edit_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, request):
         entry_key = 'issuetracker_pat_'
         pattern = 'issuetracker_pat2'
         old_pattern = 'issuetracker_pat'
         old_uid = md5(old_pattern)
 
         sett = SettingsModel(repo=backend.repo).create_or_update_setting(
             entry_key+old_uid, old_pattern, 'unicode')
         Session().add(sett)
         Session().commit()
         post_url = route_path(
             'edit_repo_issuetracker_update', repo_name=backend.repo.repo_name)
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': '/url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'uid': old_uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         self.settings_model = IssueTrackerSettingsModel(repo=backend.repo)
         settings = self.settings_model.get_repo_settings()
         self.uid = md5(pattern)
         assert settings[self.uid]['pat'] == pattern
         with pytest.raises(KeyError):
             key = settings[old_uid]
 
         @request.addfinalizer
         def cleanup():
             self.settings_model.delete_entries(self.uid)
 
     def test_delete_issuetracker_pattern(
-            self, autologin_user, backend, csrf_token, settings_util):
+            self, autologin_user, backend, csrf_token, settings_util, xhr_header):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         entry_key = 'issuetracker_pat_'
         pattern = 'issuetracker_pat3'
         uid = md5(pattern)
         settings_util.create_repo_rhodecode_setting(
             repo=backend.repo, name=entry_key+uid,
             value=entry_key, type_='unicode', cleanup=False)
 
         self.app.post(
             route_path(
                 'edit_repo_issuetracker_delete',
                 repo_name=backend.repo.repo_name),
             {
                 'uid': uid,
-                'csrf_token': csrf_token
-            }, status=302)
+                'csrf_token': csrf_token,
+                '': ''
+            }, extra_environ=xhr_header, status=200)
         settings = IssueTrackerSettingsModel(
             repo=Repository.get_by_repo_name(repo_name)).get_repo_settings()
         assert 'rhodecode_%s%s' % (entry_key, uid) not in settings

rhodecode/apps/repository/views/repo_settings_issue_trackers.py

@@ -1,137 +1,139 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2017-2019 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 logging
 
-from pyramid.httpexceptions import HTTPFound
+from pyramid.httpexceptions import HTTPFound, HTTPNotFound
 from pyramid.view import view_config
 import formencode
 
 from rhodecode.apps._base import RepoAppView
 from rhodecode.lib import audit_logger
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, CSRFRequired)
 from rhodecode.model.forms import IssueTrackerPatternsForm
 from rhodecode.model.meta import Session
-from rhodecode.model.settings import IssueTrackerSettingsModel
+from rhodecode.model.settings import IssueTrackerSettingsModel, SettingsModel
 
 log = logging.getLogger(__name__)
 
 
 class RepoSettingsIssueTrackersView(RepoAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
 
 
         return c
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @view_config(
         route_name='edit_repo_issuetracker', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repo_edit.mako')
     def repo_issuetracker(self):
         c = self.load_default_context()
         c.active = 'issuetracker'
         c.data = 'data'
 
         c.settings_model = IssueTrackerSettingsModel(repo=self.db_repo)
         c.global_patterns = c.settings_model.get_global_settings()
         c.repo_patterns = c.settings_model.get_repo_settings()
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='edit_repo_issuetracker_test', request_method='POST',
-        xhr=True, renderer='string')
+        renderer='string', xhr=True)
     def repo_issuetracker_test(self):
         return h.urlify_commit_message(
             self.request.POST.get('test_text', ''),
             self.db_repo_name)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='edit_repo_issuetracker_delete', request_method='POST',
-        renderer='rhodecode:templates/admin/repos/repo_edit.mako')
+        renderer='json_ext', xhr=True)
     def repo_issuetracker_delete(self):
         _ = self.request.translate
         uid = self.request.POST.get('uid')
         repo_settings = IssueTrackerSettingsModel(repo=self.db_repo_name)
         try:
             repo_settings.delete_entries(uid)
         except Exception:
             h.flash(_('Error occurred during deleting issue tracker entry'),
                     category='error')
-        else:
-            h.flash(_('Removed issue tracker entry'), category='success')
-        raise HTTPFound(
-            h.route_path('edit_repo_issuetracker', repo_name=self.db_repo_name))
+            raise HTTPNotFound()
+
+        SettingsModel().invalidate_settings_cache()
+        h.flash(_('Removed issue tracker entry.'), category='success')
+
+        return {'deleted': uid}
 
     def _update_patterns(self, form, repo_settings):
         for uid in form['delete_patterns']:
             repo_settings.delete_entries(uid)
 
         for pattern_data in form['patterns']:
             for setting_key, pattern, type_ in pattern_data:
                 sett = repo_settings.create_or_update_setting(
                     setting_key, pattern.strip(), type_)
                 Session().add(sett)
 
             Session().commit()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='edit_repo_issuetracker_update', request_method='POST',
         renderer='rhodecode:templates/admin/repos/repo_edit.mako')
     def repo_issuetracker_update(self):
         _ = self.request.translate
         # Save inheritance
         repo_settings = IssueTrackerSettingsModel(repo=self.db_repo_name)
         inherited = (
             self.request.POST.get('inherit_global_issuetracker') == "inherited")
         repo_settings.inherit_global_settings = inherited
         Session().commit()
 
         try:
             form = IssueTrackerPatternsForm(self.request.translate)().to_python(self.request.POST)
         except formencode.Invalid as errors:
             log.exception('Failed to add new pattern')
             error = errors
             h.flash(_('Invalid issue tracker pattern: {}'.format(error)),
                     category='error')
             raise HTTPFound(
                 h.route_path('edit_repo_issuetracker',
                              repo_name=self.db_repo_name))
 
         if form:
             self._update_patterns(form, repo_settings)
 
         h.flash(_('Updated issue tracker entries'), category='success')
         raise HTTPFound(
             h.route_path('edit_repo_issuetracker', repo_name=self.db_repo_name))
 

rhodecode/public/css/tables.less

@@ -1,524 +1,542 b''
 
 // tables.less
 // For use in RhodeCode application tables;
 // see style guide documentation for guidelines.
 
 // TABLES
 
 .rctable,
 table.rctable,
 table.dataTable {
     clear:both;
     width: 100%;
     margin: 0 auto @padding;
     padding: 0;
     vertical-align: baseline;
     line-height:1.5em;
     border: none;
     outline: none;
     border-collapse: collapse;
     border-spacing: 0;
     color: @grey2;
 
     b {
         font-weight: normal;
     }
 
     em {
         font-weight: bold;
         font-style: normal;
     }
 
     .td-user {
       .rc-user {
         white-space: nowrap;
       }
     }
 
     .td-email {
       white-space: nowrap;
     }
 
     th,
     td {
         height: auto;
         max-width: 20%;
         padding: .65em 0 .65em 1em;
         vertical-align: middle;
         border-bottom: @border-thickness solid @grey5;
         white-space: normal;
 
         &.td-radio,
         &.td-checkbox {
             padding-right: 0;
             text-align: center;
 
             input {
                 margin: 0 1em;
             }
         }
 
         &.truncate-wrap {
             white-space: nowrap !important;
         }
 
         pre {
             margin: 0;
         }
 
         .show_more {
             height: inherit;
         }
     }
 
     .expired td {
         background-color: @grey7;
     }
     .inactive td {
         background-color: @grey6;
     }
     th {
         text-align: left;
         font-weight: @text-semibold-weight;
         font-family: @text-semibold;
     }
 
     .hl {
         td {
             background-color: lighten(@alert4,25%);
         }
     }
 
 // Special Data Cell Types
 // See style guide for desciptions and examples.
 
     td {
 
         &.user {
             padding-left: 1em;
         }
 
         &.td-rss {
             width: 20px;
             min-width: 0;
             margin: 0;
         }
 
         &.quick_repo_menu {
             width: 15px;
             text-align: center;
 
             &:hover {
                 background-color: @grey5;
             }
         }
 
         &.td-icon {
             min-width: 20px;
             width: 20px;
         }
 
         &.td-hash {
             min-width: 80px;
             width: 200px;
 
             .obsolete {
                 text-decoration: line-through;
                 color: lighten(@grey2,25%);
             }
         }
 
         &.td-sha {
             white-space: nowrap;
         }
 
         &.td-graphbox {
             width: 100px;
             max-width: 100px;
             min-width: 100px;
         }
 
         &.td-time {
             width: 160px;
             white-space: nowrap;
         }
 
         &.annotate{
             padding-right: 0;
 
             div.annotatediv{
                 margin: 0 0.7em;
             }
         }
 
         &.tags-col {
             padding-right: 0;
         }
 
         &.td-description {
             min-width: 350px;
 
             &.truncate, .truncate-wrap {
                 white-space: nowrap;
                 overflow: hidden;
                 text-overflow: ellipsis;
                 max-width: 350px;
             }
         }
 
         &.td-grid-name {
             white-space: nowrap;
             min-width: 300px;
         }
 
         &.td-componentname {
             white-space: nowrap;
         }
 
         &.td-name {
 
         }
 
         &.td-journalaction {
             min-width: 300px;
 
             .journal_action_params {
                 // waiting for feedback
             }
         }
 
         &.td-active {
             padding-left: .65em;
         }
 
+        &.td-issue-tracker-name {
+            width: 180px;
+            input {
+                width: 180px;
+            }
+
+        }
+
+        &.td-issue-tracker-regex {
+            white-space: nowrap;
+
+            min-width: 300px;
+            input {
+                min-width: 300px;
+            }
+
+        }
+
         &.td-url {
             white-space: nowrap;
         }
 
         &.td-comments {
             min-width: 3em;
         }
 
         &.td-buttons {
             padding: .3em 0;
         }
         &.td-align-top {
             vertical-align: text-top
         }
         &.td-action {
             // this is for the remove/delete/edit buttons
             padding-right: 0;
             min-width: 95px;
             text-transform: capitalize;
 
             i {
                 display: none;
             }
         }
 
         // TODO: lisa: this needs to be cleaned up with the buttons
         .grid_edit,
         .grid_delete {
             display: inline-block;
             margin: 0 @padding/3 0 0;
             font-family: @text-light;
 
             i {
                 display: none;
             }
         }
 
         .grid_edit + .grid_delete {
             border-left: @border-thickness solid @grey5;
             padding-left: @padding/2;
         }
 
         &.td-compare {
 
             input {
                 margin-right: 1em;
             }
 
             .compare-radio-button {
                 margin: 0 1em 0 0;
             }
 
 
         }
 
         &.td-tags {
             padding: .5em 1em .5em 0;
             width: 140px;
 
             .tag {
                 margin: 1px;
                 float: left;
             }
         }
 
         .icon-svn, .icon-hg, .icon-git {
             font-size: 1.4em;
         }
 
         &.collapse_commit,
         &.expand_commit {
             padding-right: 0;
             padding-left: 1em;
             cursor: pointer;
             width: 20px;
         }
     }
 
     .perm_admin_row {
         color: @grey4;
         background-color: @grey6;
     }
 
     .noborder {
         border: none;
 
         td {
             border: none;
         }
     }
 }
 .rctable.audit-log {
     td {
                 vertical-align: top;
     }
 }
 
 // TRUNCATING
 // TODO: lisaq: should this possibly be moved out of tables.less?
 // for truncated text
 // used inside of table cells and in code block headers
 .truncate-wrap {
     white-space: nowrap !important;
 
     //truncated text
     .truncate {
         max-width: 450px;
         width: 300px;
         overflow: hidden;
         text-overflow: ellipsis;
         -o-text-overflow: ellipsis;
         -ms-text-overflow: ellipsis;
 
         &.autoexpand {
             width: 120px;
             margin-right: 200px;
         }
     }
     &:hover .truncate.autoexpand {
         overflow: visible;
     }
 
     .tags-truncate {
         width: 150px;
         height: 22px;
         overflow: hidden;
 
         .tag {
             display: inline-block;
         }
 
         &.truncate {
             height: 22px;
             max-height:2em;
             width: 140px;
         }
     }
 }
 
 .apikeys_wrap {
     margin-bottom: @padding;
 
     table.rctable td:first-child {
         width: 340px;
     }
 }
 
 
 
 // SPECIAL CASES
 
 // Repository Followers
 table.rctable.followers_data {
     width: 75%;
     margin: 0;
 }
 
 // Repository List
 // Group Members List
 table.rctable.group_members,
 table#repo_list_table {
     min-width: 600px;
 }
 
 // Keyboard mappings
 table.keyboard-mappings {
     th {
         text-align: left;
         font-weight: @text-semibold-weight;
         font-family: @text-semibold;
     }
 }
 
 // Branches, Tags, and Bookmarks
 #obj_list_table.dataTable {
     td.td-time {
         padding-right: 1em;
     }
 }
 
 // User Admin
 .rctable.useremails,
 .rctable.account_emails {
     .tag,
     .btn {
         float: right;
     }
     .btn { //to line up with tags
         margin-right: 1.65em;
     }
 }
 
 // User List
 #user_list_table {
 
     td.td-user {
         min-width: 100px;
     }
 }
 
 // Pull Request List Table
 #pull_request_list_table.dataTable {
 
     //TODO: lisa: This needs to be removed once the description is adjusted
     //            for using an expand_commit button (see issue 765)
      td {
          vertical-align: middle;
      }
 }
 
 // Settings (no border)
 table.rctable.dl-settings {
     td {
         border: none;
         vertical-align: baseline;
     }
 }
 
 
 // Statistics
 table.trending_language_tbl {
     width: 100%;
     line-height: 1em;
 
     td div {
         overflow: visible;
     }
 }
 
 .trending_language_tbl, .trending_language_tbl td {
     border: 0;
     margin: 0;
     padding: 0;
     background: transparent;
 }
 
 .trending_language_tbl, .trending_language_tbl tr {
     border-spacing: 0 3px;
 }
 
 .trending_language {
     position: relative;
     overflow: hidden;
     color: @text-color;
     width: 400px;
 
     .lang-bar {
         z-index: 1;
         overflow: hidden;
         background-color: @rcblue;
         color: #FFF;
         text-decoration: none;
     }
 
 }
 
 // Changesets
 #changesets.rctable {
     th {
         padding: 0 1em 0.65em 0;
     }
 
     // td must be fixed height for graph
     td {
         height: 32px;
         padding: 0 1em 0 0;
         vertical-align: middle;
         white-space: nowrap;
 
         &.td-description {
             white-space: normal;
         }
 
         &.expand_commit {
             padding-right: 0;
             cursor: pointer;
             width: 20px;
         }
     }
 }
 
 // Compare
 table.compare_view_commits {
     margin-top: @space;
 
     td.td-time {
         padding-left: .5em;
     }
 
     // special case to not show hover actions on hidden indicator
     tr.compare_select_hidden:hover {
         cursor: inherit;
 
         td {
             background-color: inherit;
         }
     }
 
     tr:hover {
         cursor: pointer;
 
         td {
             background-color: lighten(@alert4,25%);
         }
     }
 
 
 }
 
 .file_history {
     td.td-actions {
         text-align: right;
     }
 }
 
 
 // Gist List
 #gist_list_table {
     td {
         vertical-align: middle;
 
         div{
             display: inline-block;
             vertical-align: middle;
         }
 
         img{
             vertical-align: middle;
         }
     }
 }

rhodecode/templates/base/issue_tracker_settings.mako

@@ -1,221 +1,321 b''
 ## snippet for displaying issue tracker settings
 ## usage:
 ##    <%namespace name="its" file="/base/issue_tracker_settings.mako"/>
 ##    ${its.issue_tracker_settings_table(patterns, form_url, delete_url)}
 ##    ${its.issue_tracker_settings_test(test_url)}
 
 <%def name="issue_tracker_settings_table(patterns, form_url, delete_url)">
+<%
+# Name/desc, pattern, issue prefix
+examples = [
+    (
+    ' ',
+    ' ',
+    ' ',
+    ' '
+    ),
+
+    (
+    'Redmine',
+    '(^#|\s#)(?P<issue_id>\d+)',
+    'https://myissueserver.com/${repo}/issue/${issue_id}',
+    ''
+    ),
+
+    (
+    'Redmine - Alternative',
+    '(?:issue-)(\d+)',
+    'https://myissueserver.com/redmine/issue/${id}',
+    ''
+    ),
+
+    (
+    'Redmine - Wiki',
+    '(?:wiki-)([a-zA-Z0-9]+)',
+    'http://example.org/projects/${repo_name}/wiki/${id}',
+    'wiki-'
+    ),
+
+    (
+    'JIRA - All tickets',
+    '(^|\s\w+-\d+)',
+    'https://myjira.com/browse/${id}',
+    ''
+    ),
+
+    (
+    'JIRA - Project (JRA)',
+    '(?:(^|\s)(?P<issue_id>(?:JRA-|JRA-)(?:\d+)))',
+    'https://myjira.com/${issue_id}',
+    ''
+    ),
+
+    (
+    'Confluence WIKI',
+    '(?:conf-)([A-Z0-9]+)',
+    'https://example.atlassian.net/display/wiki/${id}/${repo_name}',
+    'CONF-',
+    ),
+
+    (
+    'Pivotal Tracker',
+    '(?:pivot-)(?<project_id>\d+)-(?<story>\d+)',
+    'https://www.pivotaltracker.com/s/projects/${project_id}/stories/${story}',
+    'PIV-',
+    ),
+
+    (
+    'Trello',
+    '(?:trello-)(?<card_id>[a-zA-Z0-9]+)',
+    'https://trello.com/example.com/${card_id}',
+    'TRELLO-',
+    ),
+]
+%>
+
     <table class="rctable issuetracker">
       <tr>
           <th>${_('Description')}</th>
           <th>${_('Pattern')}</th>
           <th>${_('Url')}</th>
-          <th>${_('Prefix')}</th>
+          <th>${_('Extra Prefix')}</th>
           <th ></th>
       </tr>
-      <tr>
-          <td class="td-description issue-tracker-example">Example</td>
-          <td class="td-regex issue-tracker-example">${'(?:#)(?P<issue_id>\d+)'}</td>
-          <td class="td-url issue-tracker-example">${'https://myissueserver.com/${repo}/issue/${issue_id}'}</td>
-          <td class="td-prefix issue-tracker-example">#</td>
-          <td class="issue-tracker-example"><a href="${h.route_url('enterprise_issue_tracker_settings')}" target="_blank">${_('Read more')}</a></td>
-      </tr>
+        % for name, pat, url, pref in examples:
+        <tr class="it-examples" style="${'' if loop.index == 0 else 'display:none'}">
+          <td class="td-issue-tracker-name issue-tracker-example">${name}</td>
+          <td class="td-regex issue-tracker-example">${pat}</td>
+          <td class="td-url issue-tracker-example">${url}</td>
+          <td class="td-prefix issue-tracker-example">${pref}</td>
+          <td>
+              % if loop.index == 0:
+              <a href="#showMore" onclick="$('.it-examples').toggle(); return false">${_('show examples')}</a>
+              % else:
+              <a href="#copyToInput" onclick="copyToInput(this, '${h.json.dumps(name)}', '${h.json.dumps(pat)}', '${h.json.dumps(url)}', '${h.json.dumps(pref)}'); return false">copy to input</a>
+              % endif
+          </td>
+        </tr>
+        % endfor
+
       %for uid, entry in patterns:
         <tr id="entry_${uid}">
-                <td class="td-description issuetracker_desc">
+                <td class="td-issue-tracker-name issuetracker_desc">
                     <span class="entry">
                         ${entry.desc}
                     </span>
                     <span class="edit">
                         ${h.text('new_pattern_description_'+uid, class_='medium-inline', value=entry.desc or '')}
                     </span>
                 </td>
-                <td class="td-regex issuetracker_pat">
+                <td class="td-issue-tracker-regex issuetracker_pat">
                     <span class="entry">
                         ${entry.pat}
                     </span>
                     <span class="edit">
                         ${h.text('new_pattern_pattern_'+uid, class_='medium-inline', value=entry.pat or '')}
                     </span>
                 </td>
                 <td class="td-url issuetracker_url">
                     <span class="entry">
                         ${entry.url}
                     </span>
                     <span class="edit">
                         ${h.text('new_pattern_url_'+uid, class_='medium-inline', value=entry.url or '')}
                     </span>
                 </td>
                 <td class="td-prefix issuetracker_pref">
                     <span class="entry">
                         ${entry.pref}
                     </span>
                     <span class="edit">
                         ${h.text('new_pattern_prefix_'+uid, class_='medium-inline', value=entry.pref or '')}
                     </span>
                 </td>
                 <td class="td-action">
                     <div  class="grid_edit">
                         <span class="entry">
                             <a class="edit_issuetracker_entry" href="">${_('Edit')}</a>
                         </span>
                         <span class="edit">
                             <input id="uid_${uid}" name="uid" type="hidden" value="${uid}">
                         </span>
                     </div>
                     <div  class="grid_delete">
                         <span class="entry">
                             <a class="btn btn-link btn-danger delete_issuetracker_entry" data-desc="${entry.desc}" data-uid="${uid}">
                                 ${_('Delete')}
                             </a>
                         </span>
                         <span class="edit">
                             <a class="btn btn-link btn-danger edit_issuetracker_cancel" data-uid="${uid}">${_('Cancel')}</a>
                         </span>
                    </div>
                 </td>
         </tr>
       %endfor
       <tr id="last-row"></tr>
     </table>
     <p>
       <a id="add_pattern" class="link">
           ${_('Add new')}
       </a>
     </p>
 
     <script type="text/javascript">
         var newEntryLabel = $('label[for="new_entry"]');
 
         var resetEntry = function() {
           newEntryLabel.text("${_('New Entry')}:");
         };
 
         var delete_pattern = function(entry) {
           if (confirm("${_('Confirm to remove this pattern:')} "+$(entry).data('desc'))) {
             $.ajax({
               type: "POST",
-              url: "${delete_url}", 
+              url: "${delete_url}",
               data: {
                 'csrf_token': CSRF_TOKEN,
                 'uid':$(entry).data('uid')
               },
               success: function(){
-                location.reload();
+                window.location.reload();
               },
               error: function(data, textStatus, errorThrown){
                   alert("Error while deleting entry.\nError code {0} ({1}). URL: {2}".format(data.status,data.statusText,$(entry)[0].url));
               }
             });
           }
         };
 
         $('.delete_issuetracker_entry').on('click', function(e){
           e.preventDefault();
           delete_pattern(this);
         });
 
         $('.edit_issuetracker_entry').on('click', function(e){
             e.preventDefault();
             $(this).parents('tr').addClass('editopen');
         });
 
         $('.edit_issuetracker_cancel').on('click', function(e){
             e.preventDefault();
             $(this).parents('tr').removeClass('editopen');
             // Reset to original value
             var uid = $(this).data('uid');
             $('#'+uid+' input').each(function(e) {
                 this.value = this.defaultValue;
             });
         });
 
         $('input#reset').on('click', function(e) {
             resetEntry();
         });
 
         $('#add_pattern').on('click', function(e) {
             addNewPatternInput();
         });
+
+        var copied = false;
+        copyToInput = function (elem, name, pat, url, pref) {
+            if (copied === false) {
+                addNewPatternInput();
+                copied = true;
+            }
+            $(elem).hide();
+            var load = function(text){
+                return text.replace(/["]/g, "")
+            };
+            $('#description_1').val(load(name));
+            $('#pattern_1').val(load(pat));
+            $('#url_1').val(load(url));
+            $('#prefix_1').val(load(pref));
+
+        }
+
     </script>    
 </%def>
 
 <%def name="issue_tracker_new_row()">
   <table id="add-row-tmpl" style="display: none;">
     <tbody>
     <tr class="new_pattern">
-        <td class="td-description issuetracker_desc">
+        <td class="td-issue-tracker-name issuetracker_desc">
           <span class="entry">
-                    <input class="medium-inline" id="description_##UUID##" name="new_pattern_description_##UUID##" value="##DESCRIPTION##" type="text">
+                <input class="medium-inline" id="description_##UUID##" name="new_pattern_description_##UUID##" value="##DESCRIPTION##" type="text">
           </span>
         </td>
-        <td class="td-regex issuetracker_pat">
+        <td class="td-issue-tracker-regex issuetracker_pat">
           <span class="entry">
                     <input class="medium-inline" id="pattern_##UUID##" name="new_pattern_pattern_##UUID##" placeholder="Pattern" 
                     value="##PATTERN##" type="text">
           </span>
         </td>
         <td class="td-url issuetracker_url">
           <span class="entry">
                   <input class="medium-inline" id="url_##UUID##" name="new_pattern_url_##UUID##" placeholder="Url" value="##URL##" type="text">
           </span>
         </td>
         <td class="td-prefix issuetracker_pref">
             <span class="entry">
                   <input class="medium-inline" id="prefix_##UUID##" name="new_pattern_prefix_##UUID##" placeholder="Prefix" value="##PREFIX##" type="text"> 
             </span>
         </td>
         <td class="td-action">
         </td>
         <input id="uid_##UUID##" name="uid_##UUID##" type="hidden" value="">
     </tr>
     </tbody>
   </table>
 </%def>
 
 <%def name="issue_tracker_settings_test(test_url)">
     <div class="form-vertical">
         <div class="fields">
             <div class="field">
                 <div class='textarea-full'>
-                    <textarea id="test_pattern_data" rows="10">
+                    <textarea id="test_pattern_data" rows="12">
 This is an example text for testing issue tracker patterns.
-This commit fixes ticket #451.
+This commit fixes ticket #451 and ticket #910.
+Following tickets will get mentioned:
+#123
+#456
+JRA-123
+JRA-456
 Open a pull request !101 to contribute !
 Added tag v1.3.0 for commit 0f3b629be725
 
 Add a test pattern here and hit preview to see the link.
                     </textarea>
                 </div>
             </div>
         </div>
         <div class="test_pattern_preview">
             <div id="test_pattern" class="btn btn-small" >${_('Preview')}</div>
             <p>${_('Test Pattern Preview')}</p>
             <div id="test_pattern_result" style="white-space: pre-wrap"></div>
         </div>
     </div>
 
     <script type="text/javascript">
         $('#test_pattern').on('click', function(e) {
           $.ajax({
               type: "POST",
               url: "${test_url}",
               data: {
                 'test_text': $('#test_pattern_data').val(),
                 'csrf_token': CSRF_TOKEN
               },
               success: function(data){
                   $('#test_pattern_result').html(data);
                   tooltipActivate();
               },
               error: function(jqXHR, textStatus, errorThrown){
                   $('#test_pattern_result').html('Error: ' + errorThrown);
               }
           });
           $('#test_pattern_result').show();
         });
     </script>
 </%def>