rhodecode-enterprise-ce Commit - r4038:4a4a02a9

emails: updated emails design and data structure they provide....

dan -

r4038:4a4a02a9 default

parent child

rhodecode/templates/debug_style/email.mako

0 created 644 +29 0

@@ -0,0 +1,29 b''
	1	<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
	2
	3	<html>
	4	<head></head>
	5
	6	<body>
	7
	8	SUBJECT:
	9	<pre>${c.subject}</pre>
	10
	11	HEADERS:
	12	<pre>
	13	${c.headers}
	14	</pre>
	15
	16	PLAINTEXT:
	17	<pre>
	18	${c.email_body_plaintext\|n}
	19	</pre>
	20
	21	</body>
	22	</html>
	23	<br/><br/>
	24
	25	HTML:
	26
	27	${c.email_body\|n}
	28
	29

rhodecode/templates/debug_style/email_plain_rendered.mako

0 created 644 +49 0

@@ -0,0 +1,49 b''
	1	## -- coding: utf-8 --
	2	<%inherit file="/base/base.mako"/>
	3
	4	<%def name="title()">
	5	${_('Show notification')} ${c.rhodecode_user.username}
	6	%if c.rhodecode_name:
	7	· ${h.branding(c.rhodecode_name)}
	8	%endif
	9	</%def>
	10
	11	<%def name="breadcrumbs_links()">
	12	${h.link_to(_('My Notifications'), h.route_path('notifications_show_all'))}
	13	»
	14	${_('Show notification')}
	15	</%def>
	16
	17	<%def name="menu_bar_nav()">
	18	${self.menu_items(active='admin')}
	19	</%def>
	20
	21	<%def name="main()">
	22	<div class="box">
	23
	24	<!-- box / title -->
	25	<div class="title">
	26	Rendered plain text using markup renderer
	27	</div>
	28	<div class="table">
	29	<div >
	30	<div class="notification-header">
	31	GRAVATAR
	32	<div class="desc">
	33	DESC
	34	</div>
	35	</div>
	36	<div class="notification-body">
	37	<div class="notification-subject">
	38	<h3>${_('Subject')}: ${c.subject}</h3>
	39	</div>
	40	${c.email_body\|n}
	41	</div>
	42	</div>
	43	</div>
	44	</div>
	45
	46	</%def>
	47
	48
	49

rhodecode/templates/debug_style/emails.html

0 created 644 +34 0

@@ -0,0 +1,34 b''
	1	## -- coding: utf-8 --
	2	<%inherit file="/debug_style/index.html"/>
	3
	4	<%def name="breadcrumbs_links()">
	5	${h.link_to(_('Style'), h.route_path('debug_style_home'))}
	6	»
	7	${c.active}
	8	</%def>
	9
	10
	11	<%def name="real_main()">
	12	<div class="box">
	13	<div class="title">
	14	${self.breadcrumbs()}
	15	</div>
	16
	17	<div class='sidebar-col-wrapper'>
	18	${self.sidebar()}
	19	<div class="main-content">
	20	<h2>Emails</h2>
	21	<ul>
	22	% for elem in sorted(c.email_types.keys()):
	23	<li>
	24	<a href="${request.route_path('debug_style_email', email_id=elem, _query={'user':c.rhodecode_user.username})}">${elem}</a>
	25	\|
	26	<a href="${request.route_path('debug_style_email_plain_rendered', email_id=elem, _query={'user':c.rhodecode_user.username})}">plain rendered</a>
	27	</li>
	28	% endfor
	29	</ul>
	30
	31	</div> <!-- .main-content -->
	32	</div>
	33	</div> <!-- .box -->
	34	</%def>

rhodecode/apps/debug_style/__init__.py

0 +8 0

             # -*- coding: utf-8 -*-
             # Copyright (C) 2016-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/
             from rhodecode.apps._base import ADMIN_PREFIX
             from rhodecode.lib.utils2 import str2bool
             class DebugStylePredicate(object):
                 def __init__(self, val, config):
                     self.val = val
                 def text(self):
                     return 'debug style route = %s' % self.val
                 phash = text
                 def __call__(self, info, request):
                     return str2bool(request.registry.settings.get('debug_style'))
             def includeme(config):
                 config.add_route_predicate(
                     'debug_style', DebugStylePredicate)
                 config.add_route(
                     name='debug_style_home',
                     pattern=ADMIN_PREFIX + '/debug_style',
                     debug_style=True)
                 config.add_route(
+                    name='debug_style_email',
+                    pattern=ADMIN_PREFIX + '/debug_style/email/{email_id}',
+                    debug_style=True)
+                config.add_route(
+                    name='debug_style_email_plain_rendered',
+                    pattern=ADMIN_PREFIX + '/debug_style/email-rendered/{email_id}',
+                    debug_style=True)
+                config.add_route(
                     name='debug_style_template',
                     pattern=ADMIN_PREFIX + '/debug_style/t/{t_path}',
                     debug_style=True)
                 # Scan module for configuration decorators.
                 config.scan('.views', ignore='.tests')

rhodecode/apps/debug_style/views.py

0 +280 -1

@@ -1,59 +1,338 b''
1	# -- coding: utf-8 --	1	# -- coding: utf-8 --
2		2
3	# Copyright (C) 2016-2019 RhodeCode GmbH	3	# Copyright (C) 2016-2019 RhodeCode GmbH
4	#	4	#
5	# This program is free software: you can redistribute it and/or modify	5	# This program is free software: you can redistribute it and/or modify
6	# it under the terms of the GNU Affero General Public License, version 3	6	# it under the terms of the GNU Affero General Public License, version 3
7	# (only), as published by the Free Software Foundation.	7	# (only), as published by the Free Software Foundation.
8	#	8	#
9	# This program is distributed in the hope that it will be useful,	9	# This program is distributed in the hope that it will be useful,
10	# but WITHOUT ANY WARRANTY; without even the implied warranty of	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	# GNU General Public License for more details.	12	# GNU General Public License for more details.
13	#	13	#
14	# You should have received a copy of the GNU Affero General Public License	14	# You should have received a copy of the GNU Affero General Public License
15	# along with this program. If not, see <http://www.gnu.org/licenses/>.	15	# along with this program. If not, see <http://www.gnu.org/licenses/>.
16	#	16	#
17	# This program is dual-licensed. If you wish to learn more about the	17	# This program is dual-licensed. If you wish to learn more about the
18	# RhodeCode Enterprise Edition, including its added features, Support services,	18	# RhodeCode Enterprise Edition, including its added features, Support services,
19	# and proprietary license terms, please see https://rhodecode.com/licenses/	19	# and proprietary license terms, please see https://rhodecode.com/licenses/
20		20
21	import os	21	import os
22	import logging	22	import logging
		23	import datetime
23		24
24	from pyramid.view import view_config	25	from pyramid.view import view_config
25	from pyramid.renderers import render_to_response	26	from pyramid.renderers import render_to_response
26	from rhodecode.apps._base import BaseAppView	27	from rhodecode.apps._base import BaseAppView
		28	from rhodecode.lib.celerylib import run_task, tasks
		29	from rhodecode.lib.utils2 import AttributeDict
		30	from rhodecode.model.db import User
		31	from rhodecode.model.notification import EmailNotificationModel
27		32
28	log = logging.getLogger(__name__)	33	log = logging.getLogger(__name__)
29		34
30		35
31	class DebugStyleView(BaseAppView):	36	class DebugStyleView(BaseAppView):
32	def load_default_context(self):	37	def load_default_context(self):
33	c = self._get_local_tmpl_context()	38	c = self._get_local_tmpl_context()
34		39
35	return c	40	return c
36		41
37	@view_config(	42	@view_config(
38	route_name='debug_style_home', request_method='GET',	43	route_name='debug_style_home', request_method='GET',
39	renderer=None)	44	renderer=None)
40	def index(self):	45	def index(self):
41	c = self.load_default_context()	46	c = self.load_default_context()
42	c.active = 'index'	47	c.active = 'index'
43		48
44	return render_to_response(	49	return render_to_response(
45	'debug_style/index.html', self._get_template_context(c),	50	'debug_style/index.html', self._get_template_context(c),
46	request=self.request)	51	request=self.request)
47		52
48	@view_config(	53	@view_config(
		54	route_name='debug_style_email', request_method='GET',
		55	renderer=None)
		56	@view_config(
		57	route_name='debug_style_email_plain_rendered', request_method='GET',
		58	renderer=None)
		59	def render_email(self):
		60	c = self.load_default_context()
		61	email_id = self.request.matchdict['email_id']
		62	c.active = 'emails'
		63
		64	pr = AttributeDict(
		65	pull_request_id=123,
		66	title='digital_ocean: fix redis, elastic search start on boot, '
		67	'fix fd limits on supervisor, set postgres 11 version',
		68	description='''
		69	Check if we should use full-topic or mini-topic.
		70
		71	- full topic produces some problems with merge states etc
		72	- server-mini-topic needs probably tweeks.
		73	''',
		74	repo_name='foobar',
		75	source_ref_parts=AttributeDict(type='branch', name='fix-ticket-2000'),
		76	target_ref_parts=AttributeDict(type='branch', name='master'),
		77	)
		78	target_repo = AttributeDict(repo_name='repo_group/target_repo')
		79	source_repo = AttributeDict(repo_name='repo_group/source_repo')
		80	user = User.get_by_username(self.request.GET.get('user')) or self._rhodecode_db_user
		81
		82	email_kwargs = {
		83	'test': {},
		84	'message': {
		85	'body': 'message body !'
		86	},
		87	'email_test': {
		88	'user': user,
		89	'date': datetime.datetime.now(),
		90	'rhodecode_version': c.rhodecode_version
		91	},
		92	'password_reset': {
		93	'password_reset_url': 'http://example.com/reset-rhodecode-password/token',
		94
		95	'user': user,
		96	'date': datetime.datetime.now(),
		97	'email': 'test@rhodecode.com',
		98	'first_admin_email': User.get_first_super_admin().email
		99	},
		100	'password_reset_confirmation': {
		101	'new_password': 'new-password-example',
		102	'user': user,
		103	'date': datetime.datetime.now(),
		104	'email': 'test@rhodecode.com',
		105	'first_admin_email': User.get_first_super_admin().email
		106	},
		107	'registration': {
		108	'user': user,
		109	'date': datetime.datetime.now(),
		110	},
		111
		112	'pull_request_comment': {
		113	'user': user,
		114
		115	'status_change': None,
		116	'status_change_type': None,
		117
		118	'pull_request': pr,
		119	'pull_request_commits': [],
		120
		121	'pull_request_target_repo': target_repo,
		122	'pull_request_target_repo_url': 'http://target-repo/url',
		123
		124	'pull_request_source_repo': source_repo,
		125	'pull_request_source_repo_url': 'http://source-repo/url',
		126
		127	'pull_request_url': 'http://localhost/pr1',
		128	'pr_comment_url': 'http://comment-url',
		129
		130	'comment_file': None,
		131	'comment_line': None,
		132	'comment_type': 'note',
		133	'comment_body': 'This is my comment body. I like !',
		134
		135	'renderer_type': 'markdown',
		136	'mention': True,
		137
		138	},
		139	'pull_request_comment+status': {
		140	'user': user,
		141
		142	'status_change': 'approved',
		143	'status_change_type': 'approved',
		144
		145	'pull_request': pr,
		146	'pull_request_commits': [],
		147
		148	'pull_request_target_repo': target_repo,
		149	'pull_request_target_repo_url': 'http://target-repo/url',
		150
		151	'pull_request_source_repo': source_repo,
		152	'pull_request_source_repo_url': 'http://source-repo/url',
		153
		154	'pull_request_url': 'http://localhost/pr1',
		155	'pr_comment_url': 'http://comment-url',
		156
		157	'comment_type': 'todo',
		158	'comment_file': None,
		159	'comment_line': None,
		160	'comment_body': '''
		161	I think something like this would be better
		162
		163	```py
		164
		165	def db():
		166	global connection
		167	return connection
		168
		169	```
		170
		171	''',
		172
		173	'renderer_type': 'markdown',
		174	'mention': True,
		175
		176	},
		177	'pull_request_comment+file': {
		178	'user': user,
		179
		180	'status_change': None,
		181	'status_change_type': None,
		182
		183	'pull_request': pr,
		184	'pull_request_commits': [],
		185
		186	'pull_request_target_repo': target_repo,
		187	'pull_request_target_repo_url': 'http://target-repo/url',
		188
		189	'pull_request_source_repo': source_repo,
		190	'pull_request_source_repo_url': 'http://source-repo/url',
		191
		192	'pull_request_url': 'http://localhost/pr1',
		193
		194	'pr_comment_url': 'http://comment-url',
		195
		196	'comment_file': 'rhodecode/model/db.py',
		197	'comment_line': 'o1210',
		198	'comment_type': 'todo',
		199	'comment_body': '''
		200	I like this !
		201
		202	But please check this code::
		203
		204	def main():
		205	print 'ok'
		206
		207	This should work better !
		208	''',
		209
		210	'renderer_type': 'rst',
		211	'mention': True,
		212
		213	},
		214
		215	'cs_comment': {
		216	'user': user,
		217	'commit': AttributeDict(idx=123, raw_id='a'*40, message='Commit message'),
		218	'status_change': None,
		219	'status_change_type': None,
		220
		221	'commit_target_repo_url': 'http://foo.example.com/#comment1',
		222	'repo_name': 'test-repo',
		223	'comment_type': 'note',
		224	'comment_file': None,
		225	'comment_line': None,
		226	'commit_comment_url': 'http://comment-url',
		227	'comment_body': 'This is my comment body. I like !',
		228	'renderer_type': 'markdown',
		229	'mention': True,
		230	},
		231	'cs_comment+status': {
		232	'user': user,
		233	'commit': AttributeDict(idx=123, raw_id='a' * 40, message='Commit message'),
		234	'status_change': 'approved',
		235	'status_change_type': 'approved',
		236
		237	'commit_target_repo_url': 'http://foo.example.com/#comment1',
		238	'repo_name': 'test-repo',
		239	'comment_type': 'note',
		240	'comment_file': None,
		241	'comment_line': None,
		242	'commit_comment_url': 'http://comment-url',
		243	'comment_body': '''
		244	Hello world
		245
		246	This is a multiline comment :)
		247
		248	- list
		249	- list2
		250	''',
		251	'renderer_type': 'markdown',
		252	'mention': True,
		253	},
		254	'cs_comment+file': {
		255	'user': user,
		256	'commit': AttributeDict(idx=123, raw_id='a' * 40, message='Commit message'),
		257	'status_change': None,
		258	'status_change_type': None,
		259
		260	'commit_target_repo_url': 'http://foo.example.com/#comment1',
		261	'repo_name': 'test-repo',
		262
		263	'comment_type': 'note',
		264	'comment_file': 'test-file.py',
		265	'comment_line': 'n100',
		266
		267	'commit_comment_url': 'http://comment-url',
		268	'comment_body': 'This is my comment body. I like !',
		269	'renderer_type': 'markdown',
		270	'mention': True,
		271	},
		272
		273	'pull_request': {
		274	'user': user,
		275	'pull_request': pr,
		276	'pull_request_commits': [
		277	('472d1df03bf7206e278fcedc6ac92b46b01c4e21', '''\
		278	my-account: moved email closer to profile as it's similar data just moved outside.
		279	'''),
		280	('cbfa3061b6de2696c7161ed15ba5c6a0045f90a7', '''\
		281	users: description edit fixes
		282
		283	- tests
		284	- added metatags info
		285	'''),
		286	],
		287
		288	'pull_request_target_repo': target_repo,
		289	'pull_request_target_repo_url': 'http://target-repo/url',
		290
		291	'pull_request_source_repo': source_repo,
		292	'pull_request_source_repo_url': 'http://source-repo/url',
		293
		294	'pull_request_url': 'http://code.rhodecode.com/_pull-request/123',
		295	}
		296
		297	}
		298
		299	template_type = email_id.split('+')[0]
		300	(c.subject, c.headers, c.email_body,
		301	c.email_body_plaintext) = EmailNotificationModel().render_email(
		302	template_type, **email_kwargs.get(email_id, {}))
		303
		304	test_email = self.request.GET.get('email')
		305	if test_email:
		306	recipients = [test_email]
		307	run_task(tasks.send_email, recipients, c.subject,
		308	c.email_body_plaintext, c.email_body)
		309
		310	if self.request.matched_route.name == 'debug_style_email_plain_rendered':
		311	template = 'debug_style/email_plain_rendered.mako'
		312	else:
		313	template = 'debug_style/email.mako'
		314	return render_to_response(
		315	template, self._get_template_context(c),
		316	request=self.request)
		317
		318	@view_config(
49	route_name='debug_style_template', request_method='GET',	319	route_name='debug_style_template', request_method='GET',
50	renderer=None)	320	renderer=None)
51	def template(self):	321	def template(self):
52	t_path = self.request.matchdict['t_path']	322	t_path = self.request.matchdict['t_path']
53	c = self.load_default_context()	323	c = self.load_default_context()
54	c.active = os.path.splitext(t_path)[0]	324	c.active = os.path.splitext(t_path)[0]
55	c.came_from = ''	325	c.came_from = ''
		326	c.email_types = {
		327	'cs_comment+file': {},
		328	'cs_comment+status': {},
		329
		330	'pull_request_comment+file': {},
		331	'pull_request_comment+status': {},
		332	}
		333	c.email_types.update(EmailNotificationModel.email_types)
56		334
57	return render_to_response(	335	return render_to_response(
58	'debug_style/' + t_path, self._get_template_context(c),	336	'debug_style/' + t_path, self._get_template_context(c),
59	request=self.request) No newline at end of file	337	request=self.request)
		338

rhodecode/apps/repository/tests/test_repo_commit_comments.py

0 +3 -3

             # -*- 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.tests import TestController
             from rhodecode.model.db import (
                 ChangesetComment, Notification, UserNotification)
             from rhodecode.model.meta import Session
             from rhodecode.lib import helpers as h
             def route_path(name, params=None, **kwargs):
                 import urllib
                 base_url = {
                     'repo_commit': '/{repo_name}/changeset/{commit_id}',
                     'repo_commit_comment_create': '/{repo_name}/changeset/{commit_id}/comment/create',
                     'repo_commit_comment_preview': '/{repo_name}/changeset/{commit_id}/comment/preview',
                     'repo_commit_comment_delete': '/{repo_name}/changeset/{commit_id}/comment/{comment_id}/delete',
                 }[name].format(**kwargs)
                 if params:
                     base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
                 return base_url
             @pytest.mark.backends("git", "hg", "svn")
             class TestRepoCommitCommentsView(TestController):
                 @pytest.fixture(autouse=True)
                 def prepare(self, request, baseapp):
                     for x in ChangesetComment.query().all():
                         Session().delete(x)
                     Session().commit()
                     for x in Notification.query().all():
                         Session().delete(x)
                     Session().commit()
                     request.addfinalizer(self.cleanup)
                 def cleanup(self):
                     for x in ChangesetComment.query().all():
                         Session().delete(x)
                     Session().commit()
                     for x in Notification.query().all():
                         Session().delete(x)
                     Session().commit()
                 @pytest.mark.parametrize('comment_type', ChangesetComment.COMMENT_TYPES)
                 def test_create(self, comment_type, backend):
                     self.log_user()
                     commit = backend.repo.get_commit('300')
                     commit_id = commit.raw_id
                     text = u'CommentOnCommit'
                     params = {'text': text, 'csrf_token': self.csrf_token,
                               'comment_type': comment_type}
                     self.app.post(
                         route_path('repo_commit_comment_create',
                                    repo_name=backend.repo_name, commit_id=commit_id),
                         params=params)
                     response = self.app.get(
                         route_path('repo_commit',
                                    repo_name=backend.repo_name, commit_id=commit_id))
                     # test DB
                     assert ChangesetComment.query().count() == 1
                     assert_comment_links(response, ChangesetComment.query().count(), 0)
                     assert Notification.query().count() == 1
                     assert ChangesetComment.query().count() == 1
                     notification = Notification.query().all()[0]
                     comment_id = ChangesetComment.query().first().comment_id
                     assert notification.type_ == Notification.TYPE_CHANGESET_COMMENT
                     author = notification.created_by_user.username_and_name
-                    sbj = '{0} left a {1} on commit `{2}` in the {3} repository'.format(
+                    sbj = '@{0} left a {1} on commit `{2}` in the `{3}` repository'.format(
                         author, comment_type, h.show_id(commit), backend.repo_name)
                     assert sbj == notification.subject
                     lnk = (u'/{0}/changeset/{1}#comment-{2}'.format(
                         backend.repo_name, commit_id, comment_id))
                     assert lnk in notification.body
                 @pytest.mark.parametrize('comment_type', ChangesetComment.COMMENT_TYPES)
                 def test_create_inline(self, comment_type, backend):
                     self.log_user()
                     commit = backend.repo.get_commit('300')
                     commit_id = commit.raw_id
                     text = u'CommentOnCommit'
                     f_path = 'vcs/web/simplevcs/views/repository.py'
                     line = 'n1'
                     params = {'text': text, 'f_path': f_path, 'line': line,
                               'comment_type': comment_type,
                               'csrf_token': self.csrf_token}
                     self.app.post(
                         route_path('repo_commit_comment_create',
                                    repo_name=backend.repo_name, commit_id=commit_id),
                         params=params)
                     response = self.app.get(
                         route_path('repo_commit',
                                    repo_name=backend.repo_name, commit_id=commit_id))
                     # test DB
                     assert ChangesetComment.query().count() == 1
                     assert_comment_links(response, 0, ChangesetComment.query().count())
                     if backend.alias == 'svn':
                         response.mustcontain(
                             '''data-f-path="vcs/commands/summary.py" '''
                             '''data-anchor-id="c-300-ad05457a43f8"'''
                         )
                     if backend.alias == 'git':
                         response.mustcontain(
                             '''data-f-path="vcs/backends/hg.py" '''
                             '''data-anchor-id="c-883e775e89ea-9c390eb52cd6"'''
                         )
                     if backend.alias == 'hg':
                         response.mustcontain(
                             '''data-f-path="vcs/backends/hg.py" '''
                             '''data-anchor-id="c-e58d85a3973b-9c390eb52cd6"'''
                         )
                     assert Notification.query().count() == 1
                     assert ChangesetComment.query().count() == 1
                     notification = Notification.query().all()[0]
                     comment = ChangesetComment.query().first()
                     assert notification.type_ == Notification.TYPE_CHANGESET_COMMENT
                     assert comment.revision == commit_id
                     author = notification.created_by_user.username_and_name
-                    sbj = '{0} left a {1} on file `{2}` in commit `{3}` in the {4} repository'.format(
+                    sbj = '@{0} left a {1} on file `{2}` in commit `{3}` in the `{4}` repository'.format(
                         author, comment_type, f_path, h.show_id(commit), backend.repo_name)
                     assert sbj == notification.subject
                     lnk = (u'/{0}/changeset/{1}#comment-{2}'.format(
                         backend.repo_name, commit_id, comment.comment_id))
                     assert lnk in notification.body
                     assert 'on line n1' in notification.body
                 def test_create_with_mention(self, backend):
                     self.log_user()
                     commit_id = backend.repo.get_commit('300').raw_id
                     text = u'@test_regular check CommentOnCommit'
                     params = {'text': text, 'csrf_token': self.csrf_token}
                     self.app.post(
                         route_path('repo_commit_comment_create',
                                    repo_name=backend.repo_name, commit_id=commit_id),
                         params=params)
                     response = self.app.get(
                         route_path('repo_commit',
                                    repo_name=backend.repo_name, commit_id=commit_id))
                     # test DB
                     assert ChangesetComment.query().count() == 1
                     assert_comment_links(response, ChangesetComment.query().count(), 0)
                     notification = Notification.query().one()
                     assert len(notification.recipients) == 2
                     users = [x.username for x in notification.recipients]
                     # test_regular gets notification by @mention
                     assert sorted(users) == [u'test_admin', u'test_regular']
                 def test_create_with_status_change(self, backend):
                     self.log_user()
                     commit = backend.repo.get_commit('300')
                     commit_id = commit.raw_id
                     text = u'CommentOnCommit'
                     f_path = 'vcs/web/simplevcs/views/repository.py'
                     line = 'n1'
                     params = {'text': text, 'changeset_status': 'approved',
                               'csrf_token': self.csrf_token}
                     self.app.post(
                         route_path(
                             'repo_commit_comment_create',
                             repo_name=backend.repo_name, commit_id=commit_id),
                         params=params)
                     response = self.app.get(
                         route_path('repo_commit',
                                    repo_name=backend.repo_name, commit_id=commit_id))
                     # test DB
                     assert ChangesetComment.query().count() == 1
                     assert_comment_links(response, ChangesetComment.query().count(), 0)
                     assert Notification.query().count() == 1
                     assert ChangesetComment.query().count() == 1
                     notification = Notification.query().all()[0]
                     comment_id = ChangesetComment.query().first().comment_id
                     assert notification.type_ == Notification.TYPE_CHANGESET_COMMENT
                     author = notification.created_by_user.username_and_name
-                    sbj = '[status: Approved] {0} left a note on commit `{1}` in the {2} repository'.format(
+                    sbj = '[status: Approved] @{0} left a note on commit `{1}` in the `{2}` repository'.format(
                         author, h.show_id(commit), backend.repo_name)
                     assert sbj == notification.subject
                     lnk = (u'/{0}/changeset/{1}#comment-{2}'.format(
                         backend.repo_name, commit_id, comment_id))
                     assert lnk in notification.body
                 def test_delete(self, backend):
                     self.log_user()
                     commit_id = backend.repo.get_commit('300').raw_id
                     text = u'CommentOnCommit'
                     params = {'text': text, 'csrf_token': self.csrf_token}
                     self.app.post(
                         route_path(
                             'repo_commit_comment_create',
                             repo_name=backend.repo_name, commit_id=commit_id),
                         params=params)
                     comments = ChangesetComment.query().all()
                     assert len(comments) == 1
                     comment_id = comments[0].comment_id
                     self.app.post(
                         route_path('repo_commit_comment_delete',
                                    repo_name=backend.repo_name,
                                    commit_id=commit_id,
                                    comment_id=comment_id),
                         params={'csrf_token': self.csrf_token})
                     comments = ChangesetComment.query().all()
                     assert len(comments) == 0
                     response = self.app.get(
                         route_path('repo_commit',
                                    repo_name=backend.repo_name, commit_id=commit_id))
                     assert_comment_links(response, 0, 0)
                 @pytest.mark.parametrize('renderer, input, output', [
                     ('rst', 'plain text', '<p>plain text</p>'),
                     ('rst', 'header\n======', '<h1 class="title">header</h1>'),
                     ('rst', '*italics*', '<em>italics</em>'),
                     ('rst', '**bold**', '<strong>bold</strong>'),
                     ('markdown', 'plain text', '<p>plain text</p>'),
                     ('markdown', '# header', '<h1>header</h1>'),
                     ('markdown', '*italics*', '<em>italics</em>'),
                     ('markdown', '**bold**', '<strong>bold</strong>'),
                 ], ids=['rst-plain', 'rst-header', 'rst-italics', 'rst-bold', 'md-plain',
                         'md-header', 'md-italics', 'md-bold', ])
                 def test_preview(self, renderer, input, output, backend, xhr_header):
                     self.log_user()
                     params = {
                         'renderer': renderer,
                         'text': input,
                         'csrf_token': self.csrf_token
                     }
                     commit_id = '0' * 16  # fake this for tests
                     response = self.app.post(
                         route_path('repo_commit_comment_preview',
                                    repo_name=backend.repo_name, commit_id=commit_id,),
                         params=params,
                         extra_environ=xhr_header)
                     response.mustcontain(output)
             def assert_comment_links(response, comments, inline_comments):
                 if comments == 1:
                     comments_text = "%d General" % comments
                 else:
                     comments_text = "%d General" % comments
                 if inline_comments == 1:
                     inline_comments_text = "%d Inline" % inline_comments
                 else:
                     inline_comments_text = "%d Inline" % inline_comments
                 if comments:
                     response.mustcontain('<a href="#comments">%s</a>,' % comments_text)
                 else:
                     response.mustcontain(comments_text)
                 if inline_comments:
                     response.mustcontain(
                         'id="inline-comments-counter">%s' % inline_comments_text)
                 else:
                     response.mustcontain(inline_comments_text)

rhodecode/apps/repository/tests/test_repo_pullrequests.py

0 +15 -19

             # -*- 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.lib.vcs.backends.base import MergeResponse, MergeFailureReason
             from rhodecode.lib.vcs.nodes import FileNode
             from rhodecode.lib import helpers as h
             from rhodecode.model.changeset_status import ChangesetStatusModel
             from rhodecode.model.db import (
                 PullRequest, ChangesetStatus, UserLog, Notification, ChangesetComment, Repository)
             from rhodecode.model.meta import Session
             from rhodecode.model.pull_request import PullRequestModel
             from rhodecode.model.user import UserModel
             from rhodecode.tests import (
                 assert_session_flash, TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN)
             def route_path(name, params=None, **kwargs):
                 import urllib
                 base_url = {
                     'repo_changelog': '/{repo_name}/changelog',
                     'repo_changelog_file': '/{repo_name}/changelog/{commit_id}/{f_path}',
                     'repo_commits': '/{repo_name}/commits',
                     'repo_commits_file': '/{repo_name}/commits/{commit_id}/{f_path}',
                     'pullrequest_show': '/{repo_name}/pull-request/{pull_request_id}',
                     'pullrequest_show_all': '/{repo_name}/pull-request',
                     'pullrequest_show_all_data': '/{repo_name}/pull-request-data',
                     'pullrequest_repo_refs': '/{repo_name}/pull-request/refs/{target_repo_name:.*?[^/]}',
                     'pullrequest_repo_targets': '/{repo_name}/pull-request/repo-destinations',
                     'pullrequest_new': '/{repo_name}/pull-request/new',
                     'pullrequest_create': '/{repo_name}/pull-request/create',
                     'pullrequest_update': '/{repo_name}/pull-request/{pull_request_id}/update',
                     'pullrequest_merge': '/{repo_name}/pull-request/{pull_request_id}/merge',
                     'pullrequest_delete': '/{repo_name}/pull-request/{pull_request_id}/delete',
                     'pullrequest_comment_create': '/{repo_name}/pull-request/{pull_request_id}/comment',
                     'pullrequest_comment_delete': '/{repo_name}/pull-request/{pull_request_id}/comment/{comment_id}/delete',
                 }[name].format(**kwargs)
                 if params:
                     base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
                 return base_url
             @pytest.mark.usefixtures('app', 'autologin_user')
             @pytest.mark.backends("git", "hg")
             class TestPullrequestsView(object):
                 def test_index(self, backend):
                     self.app.get(route_path(
                         'pullrequest_new',
                         repo_name=backend.repo_name))
                 def test_option_menu_create_pull_request_exists(self, backend):
                     repo_name = backend.repo_name
                     response = self.app.get(h.route_path('repo_summary', repo_name=repo_name))
                     create_pr_link = '<a href="%s">Create Pull Request</a>' % route_path(
                         'pullrequest_new', repo_name=repo_name)
                     response.mustcontain(create_pr_link)
                 def test_create_pr_form_with_raw_commit_id(self, backend):
                     repo = backend.repo
                     self.app.get(
                         route_path('pullrequest_new', repo_name=repo.repo_name,
                                    commit=repo.get_commit().raw_id),
                         status=200)
                 @pytest.mark.parametrize('pr_merge_enabled', [True, False])
                 @pytest.mark.parametrize('range_diff', ["0", "1"])
                 def test_show(self, pr_util, pr_merge_enabled, range_diff):
                     pull_request = pr_util.create_pull_request(
                         mergeable=pr_merge_enabled, enable_notifications=False)
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id,
                         params={'range-diff': range_diff}))
                     for commit_id in pull_request.revisions:
                         response.mustcontain(commit_id)
                     assert pull_request.target_ref_parts.type in response
                     assert pull_request.target_ref_parts.name in response
                     target_clone_url = pull_request.target_repo.clone_url()
                     assert target_clone_url in response
                     assert 'class="pull-request-merge"' in response
                     if pr_merge_enabled:
                         response.mustcontain('Pull request reviewer approval is pending')
                     else:
                         response.mustcontain('Server-side pull request merging is disabled.')
                     if range_diff == "1":
                         response.mustcontain('Turn off: Show the diff as commit range')
                 def test_close_status_visibility(self, pr_util, user_util, csrf_token):
                     # Logout
                     response = self.app.post(
                         h.route_path('logout'),
                         params={'csrf_token': csrf_token})
                     # Login as regular user
                     response = self.app.post(h.route_path('login'),
                                              {'username': TEST_USER_REGULAR_LOGIN,
                                               'password': 'test12'})
                     pull_request = pr_util.create_pull_request(
                         author=TEST_USER_REGULAR_LOGIN)
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                     response.mustcontain('Server-side pull request merging is disabled.')
                     assert_response = response.assert_response()
                     # for regular user without a merge permissions, we don't see it
                     assert_response.no_element_exists('#close-pull-request-action')
                     user_util.grant_user_permission_to_repo(
                         pull_request.target_repo,
                         UserModel().get_by_username(TEST_USER_REGULAR_LOGIN),
                         'repository.write')
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                     response.mustcontain('Server-side pull request merging is disabled.')
                     assert_response = response.assert_response()
                     # now regular user has a merge permissions, we have CLOSE button
                     assert_response.one_element_exists('#close-pull-request-action')
                 def test_show_invalid_commit_id(self, pr_util):
                     # Simulating invalid revisions which will cause a lookup error
                     pull_request = pr_util.create_pull_request()
                     pull_request.revisions = ['invalid']
                     Session().add(pull_request)
                     Session().commit()
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                     for commit_id in pull_request.revisions:
                         response.mustcontain(commit_id)
                 def test_show_invalid_source_reference(self, pr_util):
                     pull_request = pr_util.create_pull_request()
                     pull_request.source_ref = 'branch:b:invalid'
                     Session().add(pull_request)
                     Session().commit()
                     self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                 def test_edit_title_description(self, pr_util, csrf_token):
                     pull_request = pr_util.create_pull_request()
                     pull_request_id = pull_request.pull_request_id
                     response = self.app.post(
                         route_path('pullrequest_update',
                             repo_name=pull_request.target_repo.repo_name,
                             pull_request_id=pull_request_id),
                         params={
                             'edit_pull_request': 'true',
                             'title': 'New title',
                             'description': 'New description',
                             'csrf_token': csrf_token})
                     assert_session_flash(
                         response, u'Pull request title & description updated.',
                         category='success')
                     pull_request = PullRequest.get(pull_request_id)
                     assert pull_request.title == 'New title'
                     assert pull_request.description == 'New description'
                 def test_edit_title_description_closed(self, pr_util, csrf_token):
                     pull_request = pr_util.create_pull_request()
                     pull_request_id = pull_request.pull_request_id
                     repo_name = pull_request.target_repo.repo_name
                     pr_util.close()
                     response = self.app.post(
                         route_path('pullrequest_update',
                                    repo_name=repo_name, pull_request_id=pull_request_id),
                         params={
                             'edit_pull_request': 'true',
                             'title': 'New title',
                             'description': 'New description',
                             'csrf_token': csrf_token}, status=200)
                     assert_session_flash(
                         response, u'Cannot update closed pull requests.',
                         category='error')
                 def test_update_invalid_source_reference(self, pr_util, csrf_token):
                     from rhodecode.lib.vcs.backends.base import UpdateFailureReason
                     pull_request = pr_util.create_pull_request()
                     pull_request.source_ref = 'branch:invalid-branch:invalid-commit-id'
                     Session().add(pull_request)
                     Session().commit()
                     pull_request_id = pull_request.pull_request_id
                     response = self.app.post(
                         route_path('pullrequest_update',
                             repo_name=pull_request.target_repo.repo_name,
                             pull_request_id=pull_request_id),
                         params={'update_commits': 'true', 'csrf_token': csrf_token})
                     expected_msg = str(PullRequestModel.UPDATE_STATUS_MESSAGES[
                         UpdateFailureReason.MISSING_SOURCE_REF])
                     assert_session_flash(response, expected_msg, category='error')
                 def test_missing_target_reference(self, pr_util, csrf_token):
                     from rhodecode.lib.vcs.backends.base import MergeFailureReason
                     pull_request = pr_util.create_pull_request(
                         approved=True, mergeable=True)
                     unicode_reference = u'branch:invalid-branch:invalid-commit-id'
                     pull_request.target_ref = unicode_reference
                     Session().add(pull_request)
                     Session().commit()
                     pull_request_id = pull_request.pull_request_id
                     pull_request_url = route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.repo_name,
                         pull_request_id=pull_request_id)
                     response = self.app.get(pull_request_url)
                     target_ref_id = 'invalid-branch'
                     merge_resp = MergeResponse(
                         True, True, '', MergeFailureReason.MISSING_TARGET_REF,
                         metadata={'target_ref': PullRequest.unicode_to_reference(unicode_reference)})
                     response.assert_response().element_contains(
                         'span[data-role="merge-message"]', merge_resp.merge_status_message)
                 def test_comment_and_close_pull_request_custom_message_approved(
                         self, pr_util, csrf_token, xhr_header):
                     pull_request = pr_util.create_pull_request(approved=True)
                     pull_request_id = pull_request.pull_request_id
                     author = pull_request.user_id
                     repo = pull_request.target_repo.repo_id
                     self.app.post(
                         route_path('pullrequest_comment_create',
                                    repo_name=pull_request.target_repo.scm_instance().name,
                                    pull_request_id=pull_request_id),
                         params={
                             'close_pull_request': '1',
                             'text': 'Closing a PR',
                             'csrf_token': csrf_token},
                         extra_environ=xhr_header,)
                     journal = UserLog.query()\
                         .filter(UserLog.user_id == author)\
                         .filter(UserLog.repository_id == repo) \
                         .order_by(UserLog.user_log_id.asc()) \
                         .all()
                     assert journal[-1].action == 'repo.pull_request.close'
                     pull_request = PullRequest.get(pull_request_id)
                     assert pull_request.is_closed()
                     status = ChangesetStatusModel().get_status(
                         pull_request.source_repo, pull_request=pull_request)
                     assert status == ChangesetStatus.STATUS_APPROVED
                     comments = ChangesetComment().query() \
                         .filter(ChangesetComment.pull_request == pull_request) \
                         .order_by(ChangesetComment.comment_id.asc())\
                         .all()
                     assert comments[-1].text == 'Closing a PR'
                 def test_comment_force_close_pull_request_rejected(
                         self, pr_util, csrf_token, xhr_header):
                     pull_request = pr_util.create_pull_request()
                     pull_request_id = pull_request.pull_request_id
                     PullRequestModel().update_reviewers(
                         pull_request_id, [(1, ['reason'], False, []), (2, ['reason2'], False, [])],
                         pull_request.author)
                     author = pull_request.user_id
                     repo = pull_request.target_repo.repo_id
                     self.app.post(
                         route_path('pullrequest_comment_create',
                             repo_name=pull_request.target_repo.scm_instance().name,
                             pull_request_id=pull_request_id),
                         params={
                             'close_pull_request': '1',
                             'csrf_token': csrf_token},
                         extra_environ=xhr_header)
                     pull_request = PullRequest.get(pull_request_id)
                     journal = UserLog.query()\
                         .filter(UserLog.user_id == author, UserLog.repository_id == repo) \
                         .order_by(UserLog.user_log_id.asc()) \
                         .all()
                     assert journal[-1].action == 'repo.pull_request.close'
                     # check only the latest status, not the review status
                     status = ChangesetStatusModel().get_status(
                         pull_request.source_repo, pull_request=pull_request)
                     assert status == ChangesetStatus.STATUS_REJECTED
                 def test_comment_and_close_pull_request(
                         self, pr_util, csrf_token, xhr_header):
                     pull_request = pr_util.create_pull_request()
                     pull_request_id = pull_request.pull_request_id
                     response = self.app.post(
                         route_path('pullrequest_comment_create',
                             repo_name=pull_request.target_repo.scm_instance().name,
                             pull_request_id=pull_request.pull_request_id),
                         params={
                             'close_pull_request': 'true',
                             'csrf_token': csrf_token},
                         extra_environ=xhr_header)
                     assert response.json
                     pull_request = PullRequest.get(pull_request_id)
                     assert pull_request.is_closed()
                     # check only the latest status, not the review status
                     status = ChangesetStatusModel().get_status(
                         pull_request.source_repo, pull_request=pull_request)
                     assert status == ChangesetStatus.STATUS_REJECTED
                 def test_create_pull_request(self, backend, csrf_token):
                     commits = [
                         {'message': 'ancestor'},
                         {'message': 'change'},
                         {'message': 'change2'},
                     ]
                     commit_ids = backend.create_master_repo(commits)
                     target = backend.create_repo(heads=['ancestor'])
                     source = backend.create_repo(heads=['change2'])
                     response = self.app.post(
                         route_path('pullrequest_create', repo_name=source.repo_name),
                         [
                             ('source_repo', source.repo_name),
                             ('source_ref', 'branch:default:' + commit_ids['change2']),
                             ('target_repo', target.repo_name),
                             ('target_ref',  'branch:default:' + commit_ids['ancestor']),
                             ('common_ancestor', commit_ids['ancestor']),
                             ('pullrequest_title', 'Title'),
                             ('pullrequest_desc', 'Description'),
                             ('description_renderer', 'markdown'),
                             ('__start__', 'review_members:sequence'),
                                 ('__start__', 'reviewer:mapping'),
                                     ('user_id', '1'),
                                     ('__start__', 'reasons:sequence'),
                                         ('reason', 'Some reason'),
                                     ('__end__', 'reasons:sequence'),
                                     ('__start__', 'rules:sequence'),
                                     ('__end__', 'rules:sequence'),
                                     ('mandatory', 'False'),
                                 ('__end__', 'reviewer:mapping'),
                             ('__end__', 'review_members:sequence'),
                             ('__start__', 'revisions:sequence'),
                                 ('revisions', commit_ids['change']),
                                 ('revisions', commit_ids['change2']),
                             ('__end__', 'revisions:sequence'),
                             ('user', ''),
                             ('csrf_token', csrf_token),
                         ],
                         status=302)
                     location = response.headers['Location']
                     pull_request_id = location.rsplit('/', 1)[1]
                     assert pull_request_id != 'new'
                     pull_request = PullRequest.get(int(pull_request_id))
                     # check that we have now both revisions
                     assert pull_request.revisions == [commit_ids['change2'], commit_ids['change']]
                     assert pull_request.source_ref == 'branch:default:' + commit_ids['change2']
                     expected_target_ref = 'branch:default:' + commit_ids['ancestor']
                     assert pull_request.target_ref == expected_target_ref
                 def test_reviewer_notifications(self, backend, csrf_token):
                     # We have to use the app.post for this test so it will create the
                     # notifications properly with the new PR
                     commits = [
                         {'message': 'ancestor',
                          'added': [FileNode('file_A', content='content_of_ancestor')]},
                         {'message': 'change',
                          'added': [FileNode('file_a', content='content_of_change')]},
                         {'message': 'change-child'},
                         {'message': 'ancestor-child', 'parents': ['ancestor'],
                          'added': [
                             FileNode('file_B', content='content_of_ancestor_child')]},
                         {'message': 'ancestor-child-2'},
                     ]
                     commit_ids = backend.create_master_repo(commits)
                     target = backend.create_repo(heads=['ancestor-child'])
                     source = backend.create_repo(heads=['change'])
                     response = self.app.post(
                         route_path('pullrequest_create', repo_name=source.repo_name),
                         [
                             ('source_repo', source.repo_name),
                             ('source_ref', 'branch:default:' + commit_ids['change']),
                             ('target_repo', target.repo_name),
                             ('target_ref',  'branch:default:' + commit_ids['ancestor-child']),
                             ('common_ancestor', commit_ids['ancestor']),
                             ('pullrequest_title', 'Title'),
                             ('pullrequest_desc', 'Description'),
                             ('description_renderer', 'markdown'),
                             ('__start__', 'review_members:sequence'),
                                 ('__start__', 'reviewer:mapping'),
                                     ('user_id', '2'),
                                     ('__start__', 'reasons:sequence'),
                                         ('reason', 'Some reason'),
                                     ('__end__', 'reasons:sequence'),
                                     ('__start__', 'rules:sequence'),
                                     ('__end__', 'rules:sequence'),
                                     ('mandatory', 'False'),
                                 ('__end__', 'reviewer:mapping'),
                             ('__end__', 'review_members:sequence'),
                             ('__start__', 'revisions:sequence'),
                                 ('revisions', commit_ids['change']),
                             ('__end__', 'revisions:sequence'),
                             ('user', ''),
                             ('csrf_token', csrf_token),
                         ],
                         status=302)
                     location = response.headers['Location']
                     pull_request_id = location.rsplit('/', 1)[1]
                     assert pull_request_id != 'new'
                     pull_request = PullRequest.get(int(pull_request_id))
                     # Check that a notification was made
                     notifications = Notification.query()\
                         .filter(Notification.created_by == pull_request.author.user_id,
                                 Notification.type_ == Notification.TYPE_PULL_REQUEST,
                                 Notification.subject.contains(
-                                    "wants you to review pull request #%s" % pull_request_id))
+                                    "requested a pull request review. !%s" % pull_request_id))
                     assert len(notifications.all()) == 1
                     # Change reviewers and check that a notification was made
                     PullRequestModel().update_reviewers(
                         pull_request.pull_request_id, [(1, [], False, [])],
                         pull_request.author)
                     assert len(notifications.all()) == 2
                 def test_create_pull_request_stores_ancestor_commit_id(self, backend,
                                                                        csrf_token):
                     commits = [
                         {'message': 'ancestor',
                          'added': [FileNode('file_A', content='content_of_ancestor')]},
                         {'message': 'change',
                          'added': [FileNode('file_a', content='content_of_change')]},
                         {'message': 'change-child'},
                         {'message': 'ancestor-child', 'parents': ['ancestor'],
                          'added': [
                             FileNode('file_B', content='content_of_ancestor_child')]},
                         {'message': 'ancestor-child-2'},
                     ]
                     commit_ids = backend.create_master_repo(commits)
                     target = backend.create_repo(heads=['ancestor-child'])
                     source = backend.create_repo(heads=['change'])
                     response = self.app.post(
                         route_path('pullrequest_create', repo_name=source.repo_name),
                         [
                             ('source_repo', source.repo_name),
                             ('source_ref', 'branch:default:' + commit_ids['change']),
                             ('target_repo', target.repo_name),
                             ('target_ref',  'branch:default:' + commit_ids['ancestor-child']),
                             ('common_ancestor', commit_ids['ancestor']),
                             ('pullrequest_title', 'Title'),
                             ('pullrequest_desc', 'Description'),
                             ('description_renderer', 'markdown'),
                             ('__start__', 'review_members:sequence'),
                                 ('__start__', 'reviewer:mapping'),
                                     ('user_id', '1'),
                                     ('__start__', 'reasons:sequence'),
                                         ('reason', 'Some reason'),
                                     ('__end__', 'reasons:sequence'),
                                     ('__start__', 'rules:sequence'),
                                     ('__end__', 'rules:sequence'),
                                     ('mandatory', 'False'),
                                 ('__end__', 'reviewer:mapping'),
                             ('__end__', 'review_members:sequence'),
                             ('__start__', 'revisions:sequence'),
                                 ('revisions', commit_ids['change']),
                             ('__end__', 'revisions:sequence'),
                             ('user', ''),
                             ('csrf_token', csrf_token),
                         ],
                         status=302)
                     location = response.headers['Location']
                     pull_request_id = location.rsplit('/', 1)[1]
                     assert pull_request_id != 'new'
                     pull_request = PullRequest.get(int(pull_request_id))
                     # target_ref has to point to the ancestor's commit_id in order to
                     # show the correct diff
                     expected_target_ref = 'branch:default:' + commit_ids['ancestor']
                     assert pull_request.target_ref == expected_target_ref
                     # Check generated diff contents
                     response = response.follow()
                     assert 'content_of_ancestor' not in response.body
                     assert 'content_of_ancestor-child' not in response.body
                     assert 'content_of_change' in response.body
                 def test_merge_pull_request_enabled(self, pr_util, csrf_token):
                     # Clear any previous calls to rcextensions
                     rhodecode.EXTENSIONS.calls.clear()
                     pull_request = pr_util.create_pull_request(
                         approved=True, mergeable=True)
                     pull_request_id = pull_request.pull_request_id
                     repo_name = pull_request.target_repo.scm_instance().name,
-                    response = self.app.post(
+                    url = route_path('pullrequest_merge',
-                        route_path('pullrequest_merge',
                                      repo_name=str(repo_name[0]),
-                            pull_request_id=pull_request_id),
+                                     pull_request_id=pull_request_id)
-                        params={'csrf_token': csrf_token}).follow()
+                    response = self.app.post(url, params={'csrf_token': csrf_token}).follow()
                     pull_request = PullRequest.get(pull_request_id)
                     assert response.status_int == 200
                     assert pull_request.is_closed()
                     assert_pull_request_status(
                         pull_request, ChangesetStatus.STATUS_APPROVED)
                     # Check the relevant log entries were added
                     user_logs = UserLog.query().order_by(UserLog.user_log_id.desc()).limit(3)
                     actions = [log.action for log in user_logs]
                     pr_commit_ids = PullRequestModel()._get_commit_ids(pull_request)
                     expected_actions = [
                          u'repo.pull_request.close',
                          u'repo.pull_request.merge',
                          u'repo.pull_request.comment.create'
                     ]
                     assert actions == expected_actions
                     user_logs = UserLog.query().order_by(UserLog.user_log_id.desc()).limit(4)
                     actions = [log for log in user_logs]
                     assert actions[-1].action == 'user.push'
                     assert actions[-1].action_data['commit_ids'] == pr_commit_ids
                     # Check post_push rcextension was really executed
                     push_calls = rhodecode.EXTENSIONS.calls['_push_hook']
                     assert len(push_calls) == 1
                     unused_last_call_args, last_call_kwargs = push_calls[0]
                     assert last_call_kwargs['action'] == 'push'
                     assert last_call_kwargs['commit_ids'] == pr_commit_ids
                 def test_merge_pull_request_disabled(self, pr_util, csrf_token):
                     pull_request = pr_util.create_pull_request(mergeable=False)
                     pull_request_id = pull_request.pull_request_id
                     pull_request = PullRequest.get(pull_request_id)
                     response = self.app.post(
                         route_path('pullrequest_merge',
                             repo_name=pull_request.target_repo.scm_instance().name,
                             pull_request_id=pull_request.pull_request_id),
                         params={'csrf_token': csrf_token}).follow()
                     assert response.status_int == 200
                     response.mustcontain(
                         'Merge is not currently possible because of below failed checks.')
                     response.mustcontain('Server-side pull request merging is disabled.')
                 @pytest.mark.skip_backends('svn')
                 def test_merge_pull_request_not_approved(self, pr_util, csrf_token):
                     pull_request = pr_util.create_pull_request(mergeable=True)
                     pull_request_id = pull_request.pull_request_id
                     repo_name = pull_request.target_repo.scm_instance().name
                     response = self.app.post(
                         route_path('pullrequest_merge',
                                    repo_name=repo_name, pull_request_id=pull_request_id),
                         params={'csrf_token': csrf_token}).follow()
                     assert response.status_int == 200
                     response.mustcontain(
                         'Merge is not currently possible because of below failed checks.')
                     response.mustcontain('Pull request reviewer approval is pending.')
                 def test_merge_pull_request_renders_failure_reason(
                         self, user_regular, csrf_token, pr_util):
                     pull_request = pr_util.create_pull_request(mergeable=True, approved=True)
                     pull_request_id = pull_request.pull_request_id
                     repo_name = pull_request.target_repo.scm_instance().name
                     merge_resp = MergeResponse(True, False, 'STUB_COMMIT_ID',
                                                MergeFailureReason.PUSH_FAILED,
                                                metadata={'target': 'shadow repo',
                                                          'merge_commit': 'xxx'})
                     model_patcher = mock.patch.multiple(
                         PullRequestModel,
                         merge_repo=mock.Mock(return_value=merge_resp),
                         merge_status=mock.Mock(return_value=(True, 'WRONG_MESSAGE')))
                     with model_patcher:
                         response = self.app.post(
                             route_path('pullrequest_merge',
                                        repo_name=repo_name,
                                        pull_request_id=pull_request_id),
                             params={'csrf_token': csrf_token}, status=302)
                         merge_resp = MergeResponse(True, True, '', MergeFailureReason.PUSH_FAILED,
                                                    metadata={'target': 'shadow repo',
                                                              'merge_commit': 'xxx'})
                     assert_session_flash(response, merge_resp.merge_status_message)
                 def test_update_source_revision(self, backend, csrf_token):
                     commits = [
                         {'message': 'ancestor'},
                         {'message': 'change'},
                         {'message': 'change-2'},
                     ]
                     commit_ids = backend.create_master_repo(commits)
                     target = backend.create_repo(heads=['ancestor'])
                     source = backend.create_repo(heads=['change'])
                     # create pr from a in source to A in target
                     pull_request = PullRequest()
                     pull_request.source_repo = source
                     pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=backend.default_branch_name, commit_id=commit_ids['change'])
                     pull_request.target_repo = target
                     pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=backend.default_branch_name, commit_id=commit_ids['ancestor'])
                     pull_request.revisions = [commit_ids['change']]
                     pull_request.title = u"Test"
                     pull_request.description = u"Description"
                     pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
                     pull_request.pull_request_state = PullRequest.STATE_CREATED
                     Session().add(pull_request)
                     Session().commit()
                     pull_request_id = pull_request.pull_request_id
                     # source has ancestor - change - change-2
                     backend.pull_heads(source, heads=['change-2'])
                     # update PR
                     self.app.post(
                         route_path('pullrequest_update',
                                    repo_name=target.repo_name, pull_request_id=pull_request_id),
                         params={'update_commits': 'true', 'csrf_token': csrf_token})
                     response = self.app.get(
                         route_path('pullrequest_show',
                                    repo_name=target.repo_name,
                                    pull_request_id=pull_request.pull_request_id))
                     assert response.status_int == 200
                     assert 'Pull request updated to' in response.body
                     assert 'with 1 added, 0 removed commits.' in response.body
                     # check that we have now both revisions
                     pull_request = PullRequest.get(pull_request_id)
                     assert pull_request.revisions == [commit_ids['change-2'], commit_ids['change']]
                 def test_update_target_revision(self, backend, csrf_token):
                     commits = [
                         {'message': 'ancestor'},
                         {'message': 'change'},
                         {'message': 'ancestor-new', 'parents': ['ancestor']},
                         {'message': 'change-rebased'},
                     ]
                     commit_ids = backend.create_master_repo(commits)
                     target = backend.create_repo(heads=['ancestor'])
                     source = backend.create_repo(heads=['change'])
                     # create pr from a in source to A in target
                     pull_request = PullRequest()
                     pull_request.source_repo = source
                     pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=backend.default_branch_name, commit_id=commit_ids['change'])
                     pull_request.target_repo = target
                     pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=backend.default_branch_name, commit_id=commit_ids['ancestor'])
                     pull_request.revisions = [commit_ids['change']]
                     pull_request.title = u"Test"
                     pull_request.description = u"Description"
                     pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
                     pull_request.pull_request_state = PullRequest.STATE_CREATED
                     Session().add(pull_request)
                     Session().commit()
                     pull_request_id = pull_request.pull_request_id
                     # target has ancestor - ancestor-new
                     # source has ancestor - ancestor-new - change-rebased
                     backend.pull_heads(target, heads=['ancestor-new'])
                     backend.pull_heads(source, heads=['change-rebased'])
                     # update PR
-                    self.app.post(
+                    url = route_path('pullrequest_update',
-                        route_path('pullrequest_update',
                                      repo_name=target.repo_name,
-                                   pull_request_id=pull_request_id),
+                                     pull_request_id=pull_request_id)
+                    self.app.post(url,
                                   params={'update_commits': 'true', 'csrf_token': csrf_token},
                                   status=200)
                     # check that we have now both revisions
                     pull_request = PullRequest.get(pull_request_id)
                     assert pull_request.revisions == [commit_ids['change-rebased']]
                     assert pull_request.target_ref == 'branch:{branch}:{commit_id}'.format(
                         branch=backend.default_branch_name, commit_id=commit_ids['ancestor-new'])
                     response = self.app.get(
                         route_path('pullrequest_show',
                                    repo_name=target.repo_name,
                                    pull_request_id=pull_request.pull_request_id))
                     assert response.status_int == 200
                     assert 'Pull request updated to' in response.body
                     assert 'with 1 added, 1 removed commits.' in response.body
                 def test_update_target_revision_with_removal_of_1_commit_git(self, backend_git, csrf_token):
                     backend = backend_git
                     commits = [
                         {'message': 'master-commit-1'},
                         {'message': 'master-commit-2-change-1'},
                         {'message': 'master-commit-3-change-2'},
                         {'message': 'feat-commit-1', 'parents': ['master-commit-1']},
                         {'message': 'feat-commit-2'},
                     ]
                     commit_ids = backend.create_master_repo(commits)
                     target = backend.create_repo(heads=['master-commit-3-change-2'])
                     source = backend.create_repo(heads=['feat-commit-2'])
                     # create pr from a in source to A in target
                     pull_request = PullRequest()
                     pull_request.source_repo = source
                     pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=backend.default_branch_name,
                         commit_id=commit_ids['master-commit-3-change-2'])
                     pull_request.target_repo = target
                     pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=backend.default_branch_name, commit_id=commit_ids['feat-commit-2'])
                     pull_request.revisions = [
                         commit_ids['feat-commit-1'],
                         commit_ids['feat-commit-2']
                     ]
                     pull_request.title = u"Test"
                     pull_request.description = u"Description"
                     pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
                     pull_request.pull_request_state = PullRequest.STATE_CREATED
                     Session().add(pull_request)
                     Session().commit()
                     pull_request_id = pull_request.pull_request_id
                     # PR is created, now we simulate a force-push into target,
                     # that drops a 2 last commits
                     vcsrepo = target.scm_instance()
                     vcsrepo.config.clear_section('hooks')
                     vcsrepo.run_git_command(['reset', '--soft', 'HEAD~2'])
                     # update PR
-                    self.app.post(
+                    url = route_path('pullrequest_update',
-                        route_path('pullrequest_update',
                                      repo_name=target.repo_name,
-                            pull_request_id=pull_request_id),
+                                     pull_request_id=pull_request_id)
+                    self.app.post(url,
                                   params={'update_commits': 'true', 'csrf_token': csrf_token},
                                   status=200)
                     response = self.app.get(route_path('pullrequest_new', repo_name=target.repo_name))
                     assert response.status_int == 200
                     response.mustcontain('Pull request updated to')
                     response.mustcontain('with 0 added, 0 removed commits.')
                 def test_update_of_ancestor_reference(self, backend, csrf_token):
                     commits = [
                         {'message': 'ancestor'},
                         {'message': 'change'},
                         {'message': 'change-2'},
                         {'message': 'ancestor-new', 'parents': ['ancestor']},
                         {'message': 'change-rebased'},
                     ]
                     commit_ids = backend.create_master_repo(commits)
                     target = backend.create_repo(heads=['ancestor'])
                     source = backend.create_repo(heads=['change'])
                     # create pr from a in source to A in target
                     pull_request = PullRequest()
                     pull_request.source_repo = source
                     pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=backend.default_branch_name, commit_id=commit_ids['change'])
                     pull_request.target_repo = target
                     pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=backend.default_branch_name, commit_id=commit_ids['ancestor'])
                     pull_request.revisions = [commit_ids['change']]
                     pull_request.title = u"Test"
                     pull_request.description = u"Description"
                     pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
                     pull_request.pull_request_state = PullRequest.STATE_CREATED
                     Session().add(pull_request)
                     Session().commit()
                     pull_request_id = pull_request.pull_request_id
                     # target has ancestor - ancestor-new
                     # source has ancestor - ancestor-new - change-rebased
                     backend.pull_heads(target, heads=['ancestor-new'])
                     backend.pull_heads(source, heads=['change-rebased'])
                     # update PR
                     self.app.post(
                         route_path('pullrequest_update',
                                    repo_name=target.repo_name, pull_request_id=pull_request_id),
                         params={'update_commits': 'true', 'csrf_token': csrf_token},
                         status=200)
                     # Expect the target reference to be updated correctly
                     pull_request = PullRequest.get(pull_request_id)
                     assert pull_request.revisions == [commit_ids['change-rebased']]
                     expected_target_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=backend.default_branch_name,
                         commit_id=commit_ids['ancestor-new'])
                     assert pull_request.target_ref == expected_target_ref
                 def test_remove_pull_request_branch(self, backend_git, csrf_token):
                     branch_name = 'development'
                     commits = [
                         {'message': 'initial-commit'},
                         {'message': 'old-feature'},
                         {'message': 'new-feature', 'branch': branch_name},
                     ]
                     repo = backend_git.create_repo(commits)
                     repo_name = repo.repo_name
                     commit_ids = backend_git.commit_ids
                     pull_request = PullRequest()
                     pull_request.source_repo = repo
                     pull_request.target_repo = repo
                     pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=branch_name, commit_id=commit_ids['new-feature'])
                     pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
                         branch=backend_git.default_branch_name, commit_id=commit_ids['old-feature'])
                     pull_request.revisions = [commit_ids['new-feature']]
                     pull_request.title = u"Test"
                     pull_request.description = u"Description"
                     pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
                     pull_request.pull_request_state = PullRequest.STATE_CREATED
                     Session().add(pull_request)
                     Session().commit()
                     pull_request_id = pull_request.pull_request_id
                     vcs = repo.scm_instance()
                     vcs.remove_ref('refs/heads/{}'.format(branch_name))
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=repo_name,
                         pull_request_id=pull_request_id))
                     assert response.status_int == 200
                     response.assert_response().element_contains(
                         '#changeset_compare_view_content .alert strong',
                         'Missing commits')
                     response.assert_response().element_contains(
                         '#changeset_compare_view_content .alert',
                         'This pull request cannot be displayed, because one or more'
                         ' commits no longer exist in the source repository.')
                 def test_strip_commits_from_pull_request(
                         self, backend, pr_util, csrf_token):
                     commits = [
                         {'message': 'initial-commit'},
                         {'message': 'old-feature'},
                         {'message': 'new-feature', 'parents': ['initial-commit']},
                     ]
                     pull_request = pr_util.create_pull_request(
                         commits, target_head='initial-commit', source_head='new-feature',
                         revisions=['new-feature'])
                     vcs = pr_util.source_repository.scm_instance()
                     if backend.alias == 'git':
                         vcs.strip(pr_util.commit_ids['new-feature'], branch_name='master')
                     else:
                         vcs.strip(pr_util.commit_ids['new-feature'])
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pr_util.target_repository.repo_name,
                         pull_request_id=pull_request.pull_request_id))
                     assert response.status_int == 200
                     response.assert_response().element_contains(
                         '#changeset_compare_view_content .alert strong',
                         'Missing commits')
                     response.assert_response().element_contains(
                         '#changeset_compare_view_content .alert',
                         'This pull request cannot be displayed, because one or more'
                         ' commits no longer exist in the source repository.')
                     response.assert_response().element_contains(
                         '#update_commits',
                         'Update commits')
                 def test_strip_commits_and_update(
                         self, backend, pr_util, csrf_token):
                     commits = [
                         {'message': 'initial-commit'},
                         {'message': 'old-feature'},
                         {'message': 'new-feature', 'parents': ['old-feature']},
                     ]
                     pull_request = pr_util.create_pull_request(
                         commits, target_head='old-feature', source_head='new-feature',
                         revisions=['new-feature'], mergeable=True)
                     vcs = pr_util.source_repository.scm_instance()
                     if backend.alias == 'git':
                         vcs.strip(pr_util.commit_ids['new-feature'], branch_name='master')
                     else:
                         vcs.strip(pr_util.commit_ids['new-feature'])
-                    response = self.app.post(
+                    url = route_path('pullrequest_update',
-                        route_path('pullrequest_update',
                                      repo_name=pull_request.target_repo.repo_name,
-                            pull_request_id=pull_request.pull_request_id),
+                                     pull_request_id=pull_request.pull_request_id)
+                    response = self.app.post(url,
                                              params={'update_commits': 'true',
                                                      'csrf_token': csrf_token})
                     assert response.status_int == 200
                     assert response.body == 'true'
                     # Make sure that after update, it won't raise 500 errors
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pr_util.target_repository.repo_name,
                         pull_request_id=pull_request.pull_request_id))
                     assert response.status_int == 200
                     response.assert_response().element_contains(
                         '#changeset_compare_view_content .alert strong',
                         'Missing commits')
                 def test_branch_is_a_link(self, pr_util):
                     pull_request = pr_util.create_pull_request()
                     pull_request.source_ref = 'branch:origin:1234567890abcdef'
                     pull_request.target_ref = 'branch:target:abcdef1234567890'
                     Session().add(pull_request)
                     Session().commit()
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                     assert response.status_int == 200
                     origin = response.assert_response().get_element('.pr-origininfo .tag')
                     origin_children = origin.getchildren()
                     assert len(origin_children) == 1
                     target = response.assert_response().get_element('.pr-targetinfo .tag')
                     target_children = target.getchildren()
                     assert len(target_children) == 1
                     expected_origin_link = route_path(
                         'repo_commits',
                         repo_name=pull_request.source_repo.scm_instance().name,
                         params=dict(branch='origin'))
                     expected_target_link = route_path(
                         'repo_commits',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         params=dict(branch='target'))
                     assert origin_children[0].attrib['href'] == expected_origin_link
                     assert origin_children[0].text == 'branch: origin'
                     assert target_children[0].attrib['href'] == expected_target_link
                     assert target_children[0].text == 'branch: target'
                 def test_bookmark_is_not_a_link(self, pr_util):
                     pull_request = pr_util.create_pull_request()
                     pull_request.source_ref = 'bookmark:origin:1234567890abcdef'
                     pull_request.target_ref = 'bookmark:target:abcdef1234567890'
                     Session().add(pull_request)
                     Session().commit()
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                     assert response.status_int == 200
                     origin = response.assert_response().get_element('.pr-origininfo .tag')
                     assert origin.text.strip() == 'bookmark: origin'
                     assert origin.getchildren() == []
                     target = response.assert_response().get_element('.pr-targetinfo .tag')
                     assert target.text.strip() == 'bookmark: target'
                     assert target.getchildren() == []
                 def test_tag_is_not_a_link(self, pr_util):
                     pull_request = pr_util.create_pull_request()
                     pull_request.source_ref = 'tag:origin:1234567890abcdef'
                     pull_request.target_ref = 'tag:target:abcdef1234567890'
                     Session().add(pull_request)
                     Session().commit()
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                     assert response.status_int == 200
                     origin = response.assert_response().get_element('.pr-origininfo .tag')
                     assert origin.text.strip() == 'tag: origin'
                     assert origin.getchildren() == []
                     target = response.assert_response().get_element('.pr-targetinfo .tag')
                     assert target.text.strip() == 'tag: target'
                     assert target.getchildren() == []
                 @pytest.mark.parametrize('mergeable', [True, False])
                 def test_shadow_repository_link(
                         self, mergeable, pr_util, http_host_only_stub):
                     """
                     Check that the pull request summary page displays a link to the shadow
                     repository if the pull request is mergeable. If it is not mergeable
                     the link should not be displayed.
                     """
                     pull_request = pr_util.create_pull_request(
                         mergeable=mergeable, enable_notifications=False)
                     target_repo = pull_request.target_repo.scm_instance()
                     pr_id = pull_request.pull_request_id
                     shadow_url = '{host}/{repo}/pull-request/{pr_id}/repository'.format(
                         host=http_host_only_stub, repo=target_repo.name, pr_id=pr_id)
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=target_repo.name,
                         pull_request_id=pr_id))
                     if mergeable:
                         response.assert_response().element_value_contains(
                             'input.pr-mergeinfo', shadow_url)
                         response.assert_response().element_value_contains(
                             'input.pr-mergeinfo ', 'pr-merge')
                     else:
                         response.assert_response().no_element_exists('.pr-mergeinfo')
             @pytest.mark.usefixtures('app')
             @pytest.mark.backends("git", "hg")
             class TestPullrequestsControllerDelete(object):
                 def test_pull_request_delete_button_permissions_admin(
                         self, autologin_user, user_admin, pr_util):
                     pull_request = pr_util.create_pull_request(
                         author=user_admin.username, enable_notifications=False)
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                     response.mustcontain('id="delete_pullrequest"')
                     response.mustcontain('Confirm to delete this pull request')
                 def test_pull_request_delete_button_permissions_owner(
                         self, autologin_regular_user, user_regular, pr_util):
                     pull_request = pr_util.create_pull_request(
                         author=user_regular.username, enable_notifications=False)
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                     response.mustcontain('id="delete_pullrequest"')
                     response.mustcontain('Confirm to delete this pull request')
                 def test_pull_request_delete_button_permissions_forbidden(
                         self, autologin_regular_user, user_regular, user_admin, pr_util):
                     pull_request = pr_util.create_pull_request(
                         author=user_admin.username, enable_notifications=False)
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                     response.mustcontain(no=['id="delete_pullrequest"'])
                     response.mustcontain(no=['Confirm to delete this pull request'])
                 def test_pull_request_delete_button_permissions_can_update_cannot_delete(
                         self, autologin_regular_user, user_regular, user_admin, pr_util,
                         user_util):
                     pull_request = pr_util.create_pull_request(
                         author=user_admin.username, enable_notifications=False)
                     user_util.grant_user_permission_to_repo(
                         pull_request.target_repo, user_regular,
                         'repository.write')
                     response = self.app.get(route_path(
                         'pullrequest_show',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id))
                     response.mustcontain('id="open_edit_pullrequest"')
                     response.mustcontain('id="delete_pullrequest"')
                     response.mustcontain(no=['Confirm to delete this pull request'])
                 def test_delete_comment_returns_404_if_comment_does_not_exist(
                         self, autologin_user, pr_util, user_admin, csrf_token, xhr_header):
                     pull_request = pr_util.create_pull_request(
                         author=user_admin.username, enable_notifications=False)
                     self.app.post(
                         route_path(
                         'pullrequest_comment_delete',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id,
                         comment_id=1024404),
                         extra_environ=xhr_header,
                         params={'csrf_token': csrf_token},
                         status=404
                     )
                 def test_delete_comment(
                         self, autologin_user, pr_util, user_admin, csrf_token, xhr_header):
                     pull_request = pr_util.create_pull_request(
                         author=user_admin.username, enable_notifications=False)
                     comment = pr_util.create_comment()
                     comment_id = comment.comment_id
                     response = self.app.post(
                         route_path(
                         'pullrequest_comment_delete',
                         repo_name=pull_request.target_repo.scm_instance().name,
                         pull_request_id=pull_request.pull_request_id,
                         comment_id=comment_id),
                         extra_environ=xhr_header,
                         params={'csrf_token': csrf_token},
                         status=200
                     )
                     assert response.body == 'true'
                 @pytest.mark.parametrize('url_type', [
                     'pullrequest_new',
                     'pullrequest_create',
                     'pullrequest_update',
                     'pullrequest_merge',
                 ])
                 def test_pull_request_is_forbidden_on_archived_repo(
                         self, autologin_user, backend, xhr_header, user_util, url_type):
                     # create a temporary repo
                     source = user_util.create_repo(repo_type=backend.alias)
                     repo_name = source.repo_name
                     repo = Repository.get_by_repo_name(repo_name)
                     repo.archived = True
                     Session().commit()
                     response = self.app.get(
                         route_path(url_type, repo_name=repo_name, pull_request_id=1), status=302)
                     msg = 'Action not supported for archived repository.'
                     assert_session_flash(response, msg)
             def assert_pull_request_status(pull_request, expected_status):
-                status = ChangesetStatusModel().calculated_review_status(
+                status = ChangesetStatusModel().calculated_review_status(pull_request=pull_request)
-                    pull_request=pull_request)
                 assert status == expected_status
             @pytest.mark.parametrize('route', ['pullrequest_new', 'pullrequest_create'])
             @pytest.mark.usefixtures("autologin_user")
             def test_forbidde_to_repo_summary_for_svn_repositories(backend_svn, app, route):
-                response = app.get(
+                app.get(route_path(route, repo_name=backend_svn.repo_name), status=404)
-                    route_path(route, repo_name=backend_svn.repo_name), status=404)

rhodecode/model/comment.py

0 +11 -5

             # -*- coding: utf-8 -*-
             # Copyright (C) 2011-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/
             """
             comments model for RhodeCode
             """
             import logging
             import traceback
             import collections
             from pyramid.threadlocal import get_current_registry, get_current_request
             from sqlalchemy.sql.expression import null
             from sqlalchemy.sql.functions import coalesce
             from rhodecode.lib import helpers as h, diffs, channelstream
             from rhodecode.lib import audit_logger
             from rhodecode.lib.utils2 import extract_mentioned_users, safe_str
             from rhodecode.model import BaseModel
             from rhodecode.model.db import (
                 ChangesetComment, User, Notification, PullRequest, AttributeDict)
             from rhodecode.model.notification import NotificationModel
             from rhodecode.model.meta import Session
             from rhodecode.model.settings import VcsSettingsModel
             from rhodecode.model.notification import EmailNotificationModel
             from rhodecode.model.validation_schema.schemas import comment_schema
             log = logging.getLogger(__name__)
             class CommentsModel(BaseModel):
                 cls = ChangesetComment
                 DIFF_CONTEXT_BEFORE = 3
                 DIFF_CONTEXT_AFTER = 3
                 def __get_commit_comment(self, changeset_comment):
                     return self._get_instance(ChangesetComment, changeset_comment)
                 def __get_pull_request(self, pull_request):
                     return self._get_instance(PullRequest, pull_request)
                 def _extract_mentions(self, s):
                     user_objects = []
                     for username in extract_mentioned_users(s):
                         user_obj = User.get_by_username(username, case_insensitive=True)
                         if user_obj:
                             user_objects.append(user_obj)
                     return user_objects
                 def _get_renderer(self, global_renderer='rst', request=None):
                     request = request or get_current_request()
                     try:
                         global_renderer = request.call_context.visual.default_renderer
                     except AttributeError:
                         log.debug("Renderer not set, falling back "
                                   "to default renderer '%s'", global_renderer)
                     except Exception:
                         log.error(traceback.format_exc())
                     return global_renderer
                 def aggregate_comments(self, comments, versions, show_version, inline=False):
                     # group by versions, and count until, and display objects
                     comment_groups = collections.defaultdict(list)
                     [comment_groups[
                          _co.pull_request_version_id].append(_co) for _co in comments]
                     def yield_comments(pos):
                         for co in comment_groups[pos]:
                             yield co
                     comment_versions = collections.defaultdict(
                         lambda: collections.defaultdict(list))
                     prev_prvid = -1
                     # fake last entry with None, to aggregate on "latest" version which
                     # doesn't have an pull_request_version_id
                     for ver in versions + [AttributeDict({'pull_request_version_id': None})]:
                         prvid = ver.pull_request_version_id
                         if prev_prvid == -1:
                             prev_prvid = prvid
                         for co in yield_comments(prvid):
                             comment_versions[prvid]['at'].append(co)
                         # save until
                         current = comment_versions[prvid]['at']
                         prev_until = comment_versions[prev_prvid]['until']
                         cur_until = prev_until + current
                         comment_versions[prvid]['until'].extend(cur_until)
                         # save outdated
                         if inline:
                             outdated = [x for x in cur_until
                                         if x.outdated_at_version(show_version)]
                         else:
                             outdated = [x for x in cur_until
                                         if x.older_than_version(show_version)]
                         display = [x for x in cur_until if x not in outdated]
                         comment_versions[prvid]['outdated'] = outdated
                         comment_versions[prvid]['display'] = display
                         prev_prvid = prvid
                     return comment_versions
                 def get_repository_comments(self, repo, comment_type=None, user=None, commit_id=None):
                     qry = Session().query(ChangesetComment) \
                         .filter(ChangesetComment.repo == repo)
                     if comment_type and comment_type in ChangesetComment.COMMENT_TYPES:
                         qry = qry.filter(ChangesetComment.comment_type == comment_type)
                     if user:
                         user = self._get_user(user)
                         if user:
                             qry = qry.filter(ChangesetComment.user_id == user.user_id)
                     if commit_id:
                         qry = qry.filter(ChangesetComment.revision == commit_id)
                     qry = qry.order_by(ChangesetComment.created_on)
                     return qry.all()
                 def get_repository_unresolved_todos(self, repo):
                     todos = Session().query(ChangesetComment) \
                         .filter(ChangesetComment.repo == repo) \
                         .filter(ChangesetComment.resolved_by == None) \
                         .filter(ChangesetComment.comment_type
                                 == ChangesetComment.COMMENT_TYPE_TODO)
                     todos = todos.all()
                     return todos
                 def get_pull_request_unresolved_todos(self, pull_request, show_outdated=True):
                     todos = Session().query(ChangesetComment) \
                         .filter(ChangesetComment.pull_request == pull_request) \
                         .filter(ChangesetComment.resolved_by == None) \
                         .filter(ChangesetComment.comment_type
                                 == ChangesetComment.COMMENT_TYPE_TODO)
                     if not show_outdated:
                         todos = todos.filter(
                             coalesce(ChangesetComment.display_state, '') !=
                             ChangesetComment.COMMENT_OUTDATED)
                     todos = todos.all()
                     return todos
                 def get_pull_request_resolved_todos(self, pull_request, show_outdated=True):
                     todos = Session().query(ChangesetComment) \
                         .filter(ChangesetComment.pull_request == pull_request) \
                         .filter(ChangesetComment.resolved_by != None) \
                         .filter(ChangesetComment.comment_type
                                 == ChangesetComment.COMMENT_TYPE_TODO)
                     if not show_outdated:
                         todos = todos.filter(
                             coalesce(ChangesetComment.display_state, '') !=
                             ChangesetComment.COMMENT_OUTDATED)
                     todos = todos.all()
                     return todos
                 def get_commit_unresolved_todos(self, commit_id, show_outdated=True):
                     todos = Session().query(ChangesetComment) \
                         .filter(ChangesetComment.revision == commit_id) \
                         .filter(ChangesetComment.resolved_by == None) \
                         .filter(ChangesetComment.comment_type
                                 == ChangesetComment.COMMENT_TYPE_TODO)
                     if not show_outdated:
                         todos = todos.filter(
                             coalesce(ChangesetComment.display_state, '') !=
                             ChangesetComment.COMMENT_OUTDATED)
                     todos = todos.all()
                     return todos
                 def get_commit_resolved_todos(self, commit_id, show_outdated=True):
                     todos = Session().query(ChangesetComment) \
                         .filter(ChangesetComment.revision == commit_id) \
                         .filter(ChangesetComment.resolved_by != None) \
                         .filter(ChangesetComment.comment_type
                                 == ChangesetComment.COMMENT_TYPE_TODO)
                     if not show_outdated:
                         todos = todos.filter(
                             coalesce(ChangesetComment.display_state, '') !=
                             ChangesetComment.COMMENT_OUTDATED)
                     todos = todos.all()
                     return todos
                 def _log_audit_action(self, action, action_data, auth_user, comment):
                     audit_logger.store(
                         action=action,
                         action_data=action_data,
                         user=auth_user,
                         repo=comment.repo)
                 def create(self, text, repo, user, commit_id=None, pull_request=None,
                            f_path=None, line_no=None, status_change=None,
                            status_change_type=None, comment_type=None,
                            resolves_comment_id=None, closing_pr=False, send_email=True,
                            renderer=None, auth_user=None):
                     """
                     Creates new comment for commit or pull request.
                     IF status_change is not none this comment is associated with a
                     status change of commit or commit associated with pull request
                     :param text:
                     :param repo:
                     :param user:
                     :param commit_id:
                     :param pull_request:
                     :param f_path:
                     :param line_no:
                     :param status_change: Label for status change
                     :param comment_type: Type of comment
                     :param status_change_type: type of status change
                     :param closing_pr:
                     :param send_email:
                     :param renderer: pick renderer for this comment
                     """
                     if not text:
                         log.warning('Missing text for comment, skipping...')
                         return
                     request = get_current_request()
                     _ = request.translate
                     if not renderer:
                         renderer = self._get_renderer(request=request)
                     repo = self._get_repo(repo)
                     user = self._get_user(user)
                     auth_user = auth_user or user
                     schema = comment_schema.CommentSchema()
                     validated_kwargs = schema.deserialize(dict(
                         comment_body=text,
                         comment_type=comment_type,
                         comment_file=f_path,
                         comment_line=line_no,
                         renderer_type=renderer,
                         status_change=status_change_type,
                         resolves_comment_id=resolves_comment_id,
                         repo=repo.repo_id,
                         user=user.user_id,
                     ))
                     comment = ChangesetComment()
                     comment.renderer = validated_kwargs['renderer_type']
                     comment.text = validated_kwargs['comment_body']
                     comment.f_path = validated_kwargs['comment_file']
                     comment.line_no = validated_kwargs['comment_line']
                     comment.comment_type = validated_kwargs['comment_type']
                     comment.repo = repo
                     comment.author = user
                     resolved_comment = self.__get_commit_comment(
                         validated_kwargs['resolves_comment_id'])
                     # check if the comment actually belongs to this PR
                     if resolved_comment and resolved_comment.pull_request and \
                             resolved_comment.pull_request != pull_request:
                         log.warning('Comment tried to resolved unrelated todo comment: %s',
                                     resolved_comment)
                         # comment not bound to this pull request, forbid
                         resolved_comment = None
                     elif resolved_comment and resolved_comment.repo and \
                             resolved_comment.repo != repo:
                         log.warning('Comment tried to resolved unrelated todo comment: %s',
                                     resolved_comment)
                         # comment not bound to this repo, forbid
                         resolved_comment = None
                     comment.resolved_comment = resolved_comment
                     pull_request_id = pull_request
                     commit_obj = None
                     pull_request_obj = None
                     if commit_id:
                         notification_type = EmailNotificationModel.TYPE_COMMIT_COMMENT
                         # do a lookup, so we don't pass something bad here
                         commit_obj = repo.scm_instance().get_commit(commit_id=commit_id)
                         comment.revision = commit_obj.raw_id
                     elif pull_request_id:
                         notification_type = EmailNotificationModel.TYPE_PULL_REQUEST_COMMENT
                         pull_request_obj = self.__get_pull_request(pull_request_id)
                         comment.pull_request = pull_request_obj
                     else:
                         raise Exception('Please specify commit or pull_request_id')
                     Session().add(comment)
                     Session().flush()
                     kwargs = {
                         'user': user,
                         'renderer_type': renderer,
                         'repo_name': repo.repo_name,
                         'status_change': status_change,
                         'status_change_type': status_change_type,
                         'comment_body': text,
                         'comment_file': f_path,
                         'comment_line': line_no,
                         'comment_type': comment_type or 'note'
                     }
                     if commit_obj:
                         recipients = ChangesetComment.get_users(
                             revision=commit_obj.raw_id)
                         # add commit author if it's in RhodeCode system
                         cs_author = User.get_from_cs_author(commit_obj.author)
                         if not cs_author:
                             # use repo owner if we cannot extract the author correctly
                             cs_author = repo.user
                         recipients += [cs_author]
                         commit_comment_url = self.get_url(comment, request=request)
                         target_repo_url = h.link_to(
                             repo.repo_name,
                             h.route_url('repo_summary', repo_name=repo.repo_name))
                         # commit specifics
                         kwargs.update({
                             'commit': commit_obj,
                             'commit_message': commit_obj.message,
-                            'commit_target_repo': target_repo_url,
+                            'commit_target_repo_url': target_repo_url,
                             'commit_comment_url': commit_comment_url,
                         })
                     elif pull_request_obj:
                         # get the current participants of this pull request
                         recipients = ChangesetComment.get_users(
                             pull_request_id=pull_request_obj.pull_request_id)
                         # add pull request author
                         recipients += [pull_request_obj.author]
                         # add the reviewers to notification
                         recipients += [x.user for x in pull_request_obj.reviewers]
                         pr_target_repo = pull_request_obj.target_repo
                         pr_source_repo = pull_request_obj.source_repo
                         pr_comment_url = h.route_url(
                             'pullrequest_show',
                             repo_name=pr_target_repo.repo_name,
                             pull_request_id=pull_request_obj.pull_request_id,
                             _anchor='comment-%s' % comment.comment_id)
+                        pr_url = h.route_url(
+                            'pullrequest_show',
+                            repo_name=pr_target_repo.repo_name,
+                            pull_request_id=pull_request_obj.pull_request_id, )
                         # set some variables for email notification
                         pr_target_repo_url = h.route_url(
                             'repo_summary', repo_name=pr_target_repo.repo_name)
                         pr_source_repo_url = h.route_url(
                             'repo_summary', repo_name=pr_source_repo.repo_name)
                         # pull request specifics
                         kwargs.update({
                             'pull_request': pull_request_obj,
                             'pr_id': pull_request_obj.pull_request_id,
-                            'pr_target_repo': pr_target_repo,
+                            'pull_request_url': pr_url,
-                            'pr_target_repo_url': pr_target_repo_url,
+                            'pull_request_target_repo': pr_target_repo,
-                            'pr_source_repo': pr_source_repo,
+                            'pull_request_target_repo_url': pr_target_repo_url,
-                            'pr_source_repo_url': pr_source_repo_url,
+                            'pull_request_source_repo': pr_source_repo,
+                            'pull_request_source_repo_url': pr_source_repo_url,
                             'pr_comment_url': pr_comment_url,
                             'pr_closing': closing_pr,
                         })
                     if send_email:
                         # pre-generate the subject for notification itself
                         (subject,
                          _h, _e,  # we don't care about those
                          body_plaintext) = EmailNotificationModel().render_email(
                             notification_type, **kwargs)
                         mention_recipients = set(
                             self._extract_mentions(text)).difference(recipients)
                         # create notification objects, and emails
                         NotificationModel().create(
                             created_by=user,
                             notification_subject=subject,
                             notification_body=body_plaintext,
                             notification_type=notification_type,
                             recipients=recipients,
                             mention_recipients=mention_recipients,
                             email_kwargs=kwargs,
                         )
                     Session().flush()
                     if comment.pull_request:
                         action = 'repo.pull_request.comment.create'
                     else:
                         action = 'repo.commit.comment.create'
                     comment_data = comment.get_api_data()
                     self._log_audit_action(
                         action, {'data': comment_data}, auth_user, comment)
                     msg_url = ''
                     channel = None
                     if commit_obj:
                         msg_url = commit_comment_url
                         repo_name = repo.repo_name
                         channel = u'/repo${}$/commit/{}'.format(
                             repo_name,
                             commit_obj.raw_id
                         )
                     elif pull_request_obj:
                         msg_url = pr_comment_url
                         repo_name = pr_target_repo.repo_name
                         channel = u'/repo${}$/pr/{}'.format(
                             repo_name,
                             pull_request_id
                         )
                     message = '<strong>{}</strong> {} - ' \
                               '<a onclick="window.location=\'{}\';' \
                               'window.location.reload()">' \
                               '<strong>{}</strong></a>'
                     message = message.format(
                         user.username, _('made a comment'), msg_url,
                         _('Show it now'))
                     channelstream.post_message(
                         channel, message, user.username,
                         registry=get_current_registry())
                     return comment
                 def delete(self, comment, auth_user):
                     """
                     Deletes given comment
                     """
                     comment = self.__get_commit_comment(comment)
                     old_data = comment.get_api_data()
                     Session().delete(comment)
                     if comment.pull_request:
                         action = 'repo.pull_request.comment.delete'
                     else:
                         action = 'repo.commit.comment.delete'
                     self._log_audit_action(
                         action, {'old_data': old_data}, auth_user, comment)
                     return comment
                 def get_all_comments(self, repo_id, revision=None, pull_request=None):
                     q = ChangesetComment.query()\
                             .filter(ChangesetComment.repo_id == repo_id)
                     if revision:
                         q = q.filter(ChangesetComment.revision == revision)
                     elif pull_request:
                         pull_request = self.__get_pull_request(pull_request)
                         q = q.filter(ChangesetComment.pull_request == pull_request)
                     else:
                         raise Exception('Please specify commit or pull_request')
                     q = q.order_by(ChangesetComment.created_on)
                     return q.all()
                 def get_url(self, comment, request=None, permalink=False):
                     if not request:
                         request = get_current_request()
                     comment = self.__get_commit_comment(comment)
                     if comment.pull_request:
                         pull_request = comment.pull_request
                         if permalink:
                             return request.route_url(
                                 'pull_requests_global',
                                 pull_request_id=pull_request.pull_request_id,
                                 _anchor='comment-%s' % comment.comment_id)
                         else:
                             return request.route_url(
                                 'pullrequest_show',
                                 repo_name=safe_str(pull_request.target_repo.repo_name),
                                 pull_request_id=pull_request.pull_request_id,
                                 _anchor='comment-%s' % comment.comment_id)
                     else:
                         repo = comment.repo
                         commit_id = comment.revision
                         if permalink:
                             return request.route_url(
                                 'repo_commit', repo_name=safe_str(repo.repo_id),
                                 commit_id=commit_id,
                                 _anchor='comment-%s' % comment.comment_id)
                         else:
                             return request.route_url(
                                 'repo_commit', repo_name=safe_str(repo.repo_name),
                                 commit_id=commit_id,
                                 _anchor='comment-%s' % comment.comment_id)
                 def get_comments(self, repo_id, revision=None, pull_request=None):
                     """
                     Gets main comments based on revision or pull_request_id
                     :param repo_id:
                     :param revision:
                     :param pull_request:
                     """
                     q = ChangesetComment.query()\
                             .filter(ChangesetComment.repo_id == repo_id)\
                             .filter(ChangesetComment.line_no == None)\
                             .filter(ChangesetComment.f_path == None)
                     if revision:
                         q = q.filter(ChangesetComment.revision == revision)
                     elif pull_request:
                         pull_request = self.__get_pull_request(pull_request)
                         q = q.filter(ChangesetComment.pull_request == pull_request)
                     else:
                         raise Exception('Please specify commit or pull_request')
                     q = q.order_by(ChangesetComment.created_on)
                     return q.all()
                 def get_inline_comments(self, repo_id, revision=None, pull_request=None):
                     q = self._get_inline_comments_query(repo_id, revision, pull_request)
                     return self._group_comments_by_path_and_line_number(q)
                 def get_inline_comments_count(self, inline_comments, skip_outdated=True,
                                               version=None):
                     inline_cnt = 0
                     for fname, per_line_comments in inline_comments.iteritems():
                         for lno, comments in per_line_comments.iteritems():
                             for comm in comments:
                                 if not comm.outdated_at_version(version) and skip_outdated:
                                     inline_cnt += 1
                     return inline_cnt
                 def get_outdated_comments(self, repo_id, pull_request):
                     # TODO: johbo: Remove `repo_id`, it is not needed to find the comments
                     # of a pull request.
                     q = self._all_inline_comments_of_pull_request(pull_request)
                     q = q.filter(
                         ChangesetComment.display_state ==
                         ChangesetComment.COMMENT_OUTDATED
                     ).order_by(ChangesetComment.comment_id.asc())
                     return self._group_comments_by_path_and_line_number(q)
                 def _get_inline_comments_query(self, repo_id, revision, pull_request):
                     # TODO: johbo: Split this into two methods: One for PR and one for
                     # commit.
                     if revision:
                         q = Session().query(ChangesetComment).filter(
                             ChangesetComment.repo_id == repo_id,
                             ChangesetComment.line_no != null(),
                             ChangesetComment.f_path != null(),
                             ChangesetComment.revision == revision)
                     elif pull_request:
                         pull_request = self.__get_pull_request(pull_request)
                         if not CommentsModel.use_outdated_comments(pull_request):
                             q = self._visible_inline_comments_of_pull_request(pull_request)
                         else:
                             q = self._all_inline_comments_of_pull_request(pull_request)
                     else:
                         raise Exception('Please specify commit or pull_request_id')
                     q = q.order_by(ChangesetComment.comment_id.asc())
                     return q
                 def _group_comments_by_path_and_line_number(self, q):
                     comments = q.all()
                     paths = collections.defaultdict(lambda: collections.defaultdict(list))
                     for co in comments:
                         paths[co.f_path][co.line_no].append(co)
                     return paths
                 @classmethod
                 def needed_extra_diff_context(cls):
                     return max(cls.DIFF_CONTEXT_BEFORE, cls.DIFF_CONTEXT_AFTER)
                 def outdate_comments(self, pull_request, old_diff_data, new_diff_data):
                     if not CommentsModel.use_outdated_comments(pull_request):
                         return
                     comments = self._visible_inline_comments_of_pull_request(pull_request)
                     comments_to_outdate = comments.all()
                     for comment in comments_to_outdate:
                         self._outdate_one_comment(comment, old_diff_data, new_diff_data)
                 def _outdate_one_comment(self, comment, old_diff_proc, new_diff_proc):
                     diff_line = _parse_comment_line_number(comment.line_no)
                     try:
                         old_context = old_diff_proc.get_context_of_line(
                             path=comment.f_path, diff_line=diff_line)
                         new_context = new_diff_proc.get_context_of_line(
                             path=comment.f_path, diff_line=diff_line)
                     except (diffs.LineNotInDiffException,
                             diffs.FileNotInDiffException):
                         comment.display_state = ChangesetComment.COMMENT_OUTDATED
                         return
                     if old_context == new_context:
                         return
                     if self._should_relocate_diff_line(diff_line):
                         new_diff_lines = new_diff_proc.find_context(
                             path=comment.f_path, context=old_context,
                             offset=self.DIFF_CONTEXT_BEFORE)
                         if not new_diff_lines:
                             comment.display_state = ChangesetComment.COMMENT_OUTDATED
                         else:
                             new_diff_line = self._choose_closest_diff_line(
                                 diff_line, new_diff_lines)
                             comment.line_no = _diff_to_comment_line_number(new_diff_line)
                     else:
                         comment.display_state = ChangesetComment.COMMENT_OUTDATED
                 def _should_relocate_diff_line(self, diff_line):
                     """
                     Checks if relocation shall be tried for the given `diff_line`.
                     If a comment points into the first lines, then we can have a situation
                     that after an update another line has been added on top. In this case
                     we would find the context still and move the comment around. This
                     would be wrong.
                     """
                     should_relocate = (
                         (diff_line.new and diff_line.new > self.DIFF_CONTEXT_BEFORE) or
                         (diff_line.old and diff_line.old > self.DIFF_CONTEXT_BEFORE))
                     return should_relocate
                 def _choose_closest_diff_line(self, diff_line, new_diff_lines):
                     candidate = new_diff_lines[0]
                     best_delta = _diff_line_delta(diff_line, candidate)
                     for new_diff_line in new_diff_lines[1:]:
                         delta = _diff_line_delta(diff_line, new_diff_line)
                         if delta < best_delta:
                             candidate = new_diff_line
                             best_delta = delta
                     return candidate
                 def _visible_inline_comments_of_pull_request(self, pull_request):
                     comments = self._all_inline_comments_of_pull_request(pull_request)
                     comments = comments.filter(
                         coalesce(ChangesetComment.display_state, '') !=
                         ChangesetComment.COMMENT_OUTDATED)
                     return comments
                 def _all_inline_comments_of_pull_request(self, pull_request):
                     comments = Session().query(ChangesetComment)\
                         .filter(ChangesetComment.line_no != None)\
                         .filter(ChangesetComment.f_path != None)\
                         .filter(ChangesetComment.pull_request == pull_request)
                     return comments
                 def _all_general_comments_of_pull_request(self, pull_request):
                     comments = Session().query(ChangesetComment)\
                         .filter(ChangesetComment.line_no == None)\
                         .filter(ChangesetComment.f_path == None)\
                         .filter(ChangesetComment.pull_request == pull_request)
                     return comments
                 @staticmethod
                 def use_outdated_comments(pull_request):
                     settings_model = VcsSettingsModel(repo=pull_request.target_repo)
                     settings = settings_model.get_general_settings()
                     return settings.get('rhodecode_use_outdated_comments', False)
             def _parse_comment_line_number(line_no):
                 """
                 Parses line numbers of the form "(o|n)\d+" and returns them in a tuple.
                 """
                 old_line = None
                 new_line = None
                 if line_no.startswith('o'):
                     old_line = int(line_no[1:])
                 elif line_no.startswith('n'):
                     new_line = int(line_no[1:])
                 else:
                     raise ValueError("Comment lines have to start with either 'o' or 'n'.")
                 return diffs.DiffLineNumber(old_line, new_line)
             def _diff_to_comment_line_number(diff_line):
                 if diff_line.new is not None:
                     return u'n{}'.format(diff_line.new)
                 elif diff_line.old is not None:
                     return u'o{}'.format(diff_line.old)
                 return u''
             def _diff_line_delta(a, b):
                 if None not in (a.new, b.new):
                     return abs(a.new - b.new)
                 elif None not in (a.old, b.old):
                     return abs(a.old - b.old)
                 else:
                     raise ValueError(
                         "Cannot compute delta between {} and {}".format(a, b))

rhodecode/model/user.py

0 +4 -2

             # -*- 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/
             """
             users model for RhodeCode
             """
             import logging
             import traceback
             import datetime
             import ipaddress
             from pyramid.threadlocal import get_current_request
             from sqlalchemy.exc import DatabaseError
             from rhodecode import events
             from rhodecode.lib.user_log_filter import user_log_filter
             from rhodecode.lib.utils2 import (
                 safe_unicode, get_current_rhodecode_user, action_logger_generic,
                 AttributeDict, str2bool)
             from rhodecode.lib.exceptions import (
                 DefaultUserException, UserOwnsReposException, UserOwnsRepoGroupsException,
                 UserOwnsUserGroupsException, NotAllowedToCreateUserError, UserOwnsArtifactsException)
             from rhodecode.lib.caching_query import FromCache
             from rhodecode.model import BaseModel
             from rhodecode.model.auth_token import AuthTokenModel
             from rhodecode.model.db import (
                 _hash_key, true, false, or_, joinedload, User, UserToPerm,
                 UserEmailMap, UserIpMap, UserLog)
             from rhodecode.model.meta import Session
             from rhodecode.model.repo_group import RepoGroupModel
             log = logging.getLogger(__name__)
             class UserModel(BaseModel):
                 cls = User
                 def get(self, user_id, cache=False):
                     user = self.sa.query(User)
                     if cache:
                         user = user.options(
                             FromCache("sql_cache_short", "get_user_%s" % user_id))
                     return user.get(user_id)
                 def get_user(self, user):
                     return self._get_user(user)
                 def _serialize_user(self, user):
                     import rhodecode.lib.helpers as h
                     return {
                         'id': user.user_id,
                         'first_name': user.first_name,
                         'last_name': user.last_name,
                         'username': user.username,
                         'email': user.email,
                         'icon_link': h.gravatar_url(user.email, 30),
                         'profile_link':  h.link_to_user(user),
                         'value_display': h.escape(h.person(user)),
                         'value': user.username,
                         'value_type': 'user',
                         'active': user.active,
                     }
                 def get_users(self, name_contains=None, limit=20, only_active=True):
                     query = self.sa.query(User)
                     if only_active:
                         query = query.filter(User.active == true())
                     if name_contains:
                         ilike_expression = u'%{}%'.format(safe_unicode(name_contains))
                         query = query.filter(
                             or_(
                                 User.name.ilike(ilike_expression),
                                 User.lastname.ilike(ilike_expression),
                                 User.username.ilike(ilike_expression)
                             )
                         )
                         query = query.limit(limit)
                     users = query.all()
                     _users = [
                         self._serialize_user(user) for user in users
                     ]
                     return _users
                 def get_by_username(self, username, cache=False, case_insensitive=False):
                     if case_insensitive:
                         user = self.sa.query(User).filter(User.username.ilike(username))
                     else:
                         user = self.sa.query(User)\
                             .filter(User.username == username)
                     if cache:
                         name_key = _hash_key(username)
                         user = user.options(
                             FromCache("sql_cache_short", "get_user_%s" % name_key))
                     return user.scalar()
                 def get_by_email(self, email, cache=False, case_insensitive=False):
                     return User.get_by_email(email, case_insensitive, cache)
                 def get_by_auth_token(self, auth_token, cache=False):
                     return User.get_by_auth_token(auth_token, cache)
                 def get_active_user_count(self, cache=False):
                     qry = User.query().filter(
                         User.active == true()).filter(
                             User.username != User.DEFAULT_USER)
                     if cache:
                         qry = qry.options(
                             FromCache("sql_cache_short", "get_active_users"))
                     return qry.count()
                 def create(self, form_data, cur_user=None):
                     if not cur_user:
                         cur_user = getattr(get_current_rhodecode_user(), 'username', None)
                     user_data = {
                         'username': form_data['username'],
                         'password': form_data['password'],
                         'email': form_data['email'],
                         'firstname': form_data['firstname'],
                         'lastname': form_data['lastname'],
                         'active': form_data['active'],
                         'extern_type': form_data['extern_type'],
                         'extern_name': form_data['extern_name'],
                         'admin': False,
                         'cur_user': cur_user
                     }
                     if 'create_repo_group' in form_data:
                         user_data['create_repo_group'] = str2bool(
                             form_data.get('create_repo_group'))
                     try:
                         if form_data.get('password_change'):
                             user_data['force_password_change'] = True
                         return UserModel().create_or_update(**user_data)
                     except Exception:
                         log.error(traceback.format_exc())
                         raise
                 def update_user(self, user, skip_attrs=None, **kwargs):
                     from rhodecode.lib.auth import get_crypt_password
                     user = self._get_user(user)
                     if user.username == User.DEFAULT_USER:
                         raise DefaultUserException(
                             "You can't edit this user (`%(username)s`) since it's "
                             "crucial for entire application" % {
                             'username': user.username})
                     # first store only defaults
                     user_attrs = {
                         'updating_user_id': user.user_id,
                         'username': user.username,
                         'password': user.password,
                         'email': user.email,
                         'firstname': user.name,
                         'lastname': user.lastname,
                         'description': user.description,
                         'active': user.active,
                         'admin': user.admin,
                         'extern_name': user.extern_name,
                         'extern_type': user.extern_type,
                         'language': user.user_data.get('language')
                     }
                     # in case there's new_password, that comes from form, use it to
                     # store password
                     if kwargs.get('new_password'):
                         kwargs['password'] = kwargs['new_password']
                     # cleanups, my_account password change form
                     kwargs.pop('current_password', None)
                     kwargs.pop('new_password', None)
                     # cleanups, user edit password change form
                     kwargs.pop('password_confirmation', None)
                     kwargs.pop('password_change', None)
                     # create repo group on user creation
                     kwargs.pop('create_repo_group', None)
                     # legacy forms send name, which is the firstname
                     firstname = kwargs.pop('name', None)
                     if firstname:
                         kwargs['firstname'] = firstname
                     for k, v in kwargs.items():
                         # skip if we don't want to update this
                         if skip_attrs and k in skip_attrs:
                             continue
                         user_attrs[k] = v
                     try:
                         return self.create_or_update(**user_attrs)
                     except Exception:
                         log.error(traceback.format_exc())
                         raise
                 def create_or_update(
                         self, username, password, email, firstname='', lastname='',
                         active=True, admin=False, extern_type=None, extern_name=None,
                         cur_user=None, plugin=None, force_password_change=False,
                         allow_to_create_user=True, create_repo_group=None,
                         updating_user_id=None, language=None, description='',
                         strict_creation_check=True):
                     """
                     Creates a new instance if not found, or updates current one
                     :param username:
                     :param password:
                     :param email:
                     :param firstname:
                     :param lastname:
                     :param active:
                     :param admin:
                     :param extern_type:
                     :param extern_name:
                     :param cur_user:
                     :param plugin: optional plugin this method was called from
                     :param force_password_change: toggles new or existing user flag
                         for password change
                     :param allow_to_create_user: Defines if the method can actually create
                         new users
                     :param create_repo_group: Defines if the method should also
                         create an repo group with user name, and owner
                     :param updating_user_id: if we set it up this is the user we want to
                         update this allows to editing username.
                     :param language: language of user from interface.
                     :param description: user description
                     :param strict_creation_check: checks for allowed creation license wise etc.
                     :returns: new User object with injected `is_new_user` attribute.
                     """
                     if not cur_user:
                         cur_user = getattr(get_current_rhodecode_user(), 'username', None)
                     from rhodecode.lib.auth import (
                         get_crypt_password, check_password, generate_auth_token)
                     from rhodecode.lib.hooks_base import (
                         log_create_user, check_allowed_create_user)
                     def _password_change(new_user, password):
                         old_password = new_user.password or ''
                         # empty password
                         if not old_password:
                             return False
                         # password check is only needed for RhodeCode internal auth calls
                         # in case it's a plugin we don't care
                         if not plugin:
                             # first check if we gave crypted password back, and if it
                             # matches it's not password change
                             if new_user.password == password:
                                 return False
                             password_match = check_password(password, old_password)
                             if not password_match:
                                 return True
                         return False
                     # read settings on default personal repo group creation
                     if create_repo_group is None:
                         default_create_repo_group = RepoGroupModel()\
                             .get_default_create_personal_repo_group()
                         create_repo_group = default_create_repo_group
                     user_data = {
                         'username': username,
                         'password': password,
                         'email': email,
                         'firstname': firstname,
                         'lastname': lastname,
                         'active': active,
                         'admin': admin
                     }
                     if updating_user_id:
                         log.debug('Checking for existing account in RhodeCode '
                                   'database with user_id `%s` ', updating_user_id)
                         user = User.get(updating_user_id)
                     else:
                         log.debug('Checking for existing account in RhodeCode '
                                   'database with username `%s` ', username)
                         user = User.get_by_username(username, case_insensitive=True)
                     if user is None:
                         # we check internal flag if this method is actually allowed to
                         # create new user
                         if not allow_to_create_user:
                             msg = ('Method wants to create new user, but it is not '
                                    'allowed to do so')
                             log.warning(msg)
                             raise NotAllowedToCreateUserError(msg)
                         log.debug('Creating new user %s', username)
                         # only if we create user that is active
                         new_active_user = active
                         if new_active_user and strict_creation_check:
                             # raises UserCreationError if it's not allowed for any reason to
                             # create new active user, this also executes pre-create hooks
                             check_allowed_create_user(user_data, cur_user, strict_check=True)
                         events.trigger(events.UserPreCreate(user_data))
                         new_user = User()
                         edit = False
                     else:
                         log.debug('updating user `%s`', username)
                         events.trigger(events.UserPreUpdate(user, user_data))
                         new_user = user
                         edit = True
                         # we're not allowed to edit default user
                         if user.username == User.DEFAULT_USER:
                             raise DefaultUserException(
                                 "You can't edit this user (`%(username)s`) since it's "
                                 "crucial for entire application"
                                 % {'username': user.username})
                     # inject special attribute that will tell us if User is new or old
                     new_user.is_new_user = not edit
                     # for users that didn's specify auth type, we use RhodeCode built in
                     from rhodecode.authentication.plugins import auth_rhodecode
                     extern_name = extern_name or auth_rhodecode.RhodeCodeAuthPlugin.uid
                     extern_type = extern_type or auth_rhodecode.RhodeCodeAuthPlugin.uid
                     try:
                         new_user.username = username
                         new_user.admin = admin
                         new_user.email = email
                         new_user.active = active
                         new_user.extern_name = safe_unicode(extern_name)
                         new_user.extern_type = safe_unicode(extern_type)
                         new_user.name = firstname
                         new_user.lastname = lastname
                         new_user.description = description
                         # set password only if creating an user or password is changed
                         if not edit or _password_change(new_user, password):
                             reason = 'new password' if edit else 'new user'
                             log.debug('Updating password reason=>%s', reason)
                             new_user.password = get_crypt_password(password) if password else None
                         if force_password_change:
                             new_user.update_userdata(force_password_change=True)
                         if language:
                             new_user.update_userdata(language=language)
                         new_user.update_userdata(notification_status=True)
                         self.sa.add(new_user)
                         if not edit and create_repo_group:
                             RepoGroupModel().create_personal_repo_group(
                                 new_user, commit_early=False)
                         if not edit:
                             # add the RSS token
                             self.add_auth_token(
                                 user=username, lifetime_minutes=-1,
                                 role=self.auth_token_role.ROLE_FEED,
                                 description=u'Generated feed token')
                             kwargs = new_user.get_dict()
                             # backward compat, require api_keys present
                             kwargs['api_keys'] = kwargs['auth_tokens']
                             log_create_user(created_by=cur_user, **kwargs)
                             events.trigger(events.UserPostCreate(user_data))
                         return new_user
                     except (DatabaseError,):
                         log.error(traceback.format_exc())
                         raise
                 def create_registration(self, form_data,
                                         extern_name='rhodecode', extern_type='rhodecode'):
                     from rhodecode.model.notification import NotificationModel
                     from rhodecode.model.notification import EmailNotificationModel
                     try:
                         form_data['admin'] = False
                         form_data['extern_name'] = extern_name
                         form_data['extern_type'] = extern_type
                         new_user = self.create(form_data)
                         self.sa.add(new_user)
                         self.sa.flush()
                         user_data = new_user.get_dict()
                         kwargs = {
                             # use SQLALCHEMY safe dump of user data
                             'user': AttributeDict(user_data),
                             'date': datetime.datetime.now()
                         }
                         notification_type = EmailNotificationModel.TYPE_REGISTRATION
                         # pre-generate the subject for notification itself
                         (subject,
                          _h, _e,  # we don't care about those
                          body_plaintext) = EmailNotificationModel().render_email(
                             notification_type, **kwargs)
                         # create notification objects, and emails
                         NotificationModel().create(
                             created_by=new_user,
                             notification_subject=subject,
                             notification_body=body_plaintext,
                             notification_type=notification_type,
                             recipients=None,  # all admins
                             email_kwargs=kwargs,
                         )
                         return new_user
                     except Exception:
                         log.error(traceback.format_exc())
                         raise
                 def _handle_user_repos(self, username, repositories, handle_mode=None):
                     _superadmin = self.cls.get_first_super_admin()
                     left_overs = True
                     from rhodecode.model.repo import RepoModel
                     if handle_mode == 'detach':
                         for obj in repositories:
                             obj.user = _superadmin
                             # set description we know why we super admin now owns
                             # additional repositories that were orphaned !
                             obj.description += '  \n::detached repository from deleted user: %s' % (username,)
                             self.sa.add(obj)
                         left_overs = False
                     elif handle_mode == 'delete':
                         for obj in repositories:
                             RepoModel().delete(obj, forks='detach')
                         left_overs = False
                     # if nothing is done we have left overs left
                     return left_overs
                 def _handle_user_repo_groups(self, username, repository_groups,
                                              handle_mode=None):
                     _superadmin = self.cls.get_first_super_admin()
                     left_overs = True
                     from rhodecode.model.repo_group import RepoGroupModel
                     if handle_mode == 'detach':
                         for r in repository_groups:
                             r.user = _superadmin
                             # set description we know why we super admin now owns
                             # additional repositories that were orphaned !
                             r.group_description += '  \n::detached repository group from deleted user: %s' % (username,)
                             r.personal = False
                             self.sa.add(r)
                         left_overs = False
                     elif handle_mode == 'delete':
                         for r in repository_groups:
                             RepoGroupModel().delete(r)
                         left_overs = False
                     # if nothing is done we have left overs left
                     return left_overs
                 def _handle_user_user_groups(self, username, user_groups, handle_mode=None):
                     _superadmin = self.cls.get_first_super_admin()
                     left_overs = True
                     from rhodecode.model.user_group import UserGroupModel
                     if handle_mode == 'detach':
                         for r in user_groups:
                             for user_user_group_to_perm in r.user_user_group_to_perm:
                                 if user_user_group_to_perm.user.username == username:
                                     user_user_group_to_perm.user = _superadmin
                             r.user = _superadmin
                             # set description we know why we super admin now owns
                             # additional repositories that were orphaned !
                             r.user_group_description += '  \n::detached user group from deleted user: %s' % (username,)
                             self.sa.add(r)
                         left_overs = False
                     elif handle_mode == 'delete':
                         for r in user_groups:
                             UserGroupModel().delete(r)
                         left_overs = False
                     # if nothing is done we have left overs left
                     return left_overs
                 def _handle_user_artifacts(self, username, artifacts, handle_mode=None):
                     _superadmin = self.cls.get_first_super_admin()
                     left_overs = True
                     if handle_mode == 'detach':
                         for a in artifacts:
                             a.upload_user = _superadmin
                             # set description we know why we super admin now owns
                             # additional artifacts that were orphaned !
                             a.file_description += '  \n::detached artifact from deleted user: %s' % (username,)
                             self.sa.add(a)
                         left_overs = False
                     elif handle_mode == 'delete':
                         from rhodecode.apps.file_store import utils as store_utils
                         storage = store_utils.get_file_storage(self.request.registry.settings)
                         for a in artifacts:
                             file_uid = a.file_uid
                             storage.delete(file_uid)
                             self.sa.delete(a)
                         left_overs = False
                     # if nothing is done we have left overs left
                     return left_overs
                 def delete(self, user, cur_user=None, handle_repos=None,
                            handle_repo_groups=None, handle_user_groups=None, handle_artifacts=None):
                     from rhodecode.lib.hooks_base import log_delete_user
                     if not cur_user:
                         cur_user = getattr(get_current_rhodecode_user(), 'username', None)
                     user = self._get_user(user)
                     try:
                         if user.username == User.DEFAULT_USER:
                             raise DefaultUserException(
                                 u"You can't remove this user since it's"
                                 u" crucial for entire application")
                         left_overs = self._handle_user_repos(
                             user.username, user.repositories, handle_repos)
                         if left_overs and user.repositories:
                             repos = [x.repo_name for x in user.repositories]
                             raise UserOwnsReposException(
                                 u'user "%(username)s" still owns %(len_repos)s repositories and cannot be '
                                 u'removed. Switch owners or remove those repositories:%(list_repos)s'
                                 % {'username': user.username, 'len_repos': len(repos),
                                    'list_repos': ', '.join(repos)})
                         left_overs = self._handle_user_repo_groups(
                             user.username, user.repository_groups, handle_repo_groups)
                         if left_overs and user.repository_groups:
                             repo_groups = [x.group_name for x in user.repository_groups]
                             raise UserOwnsRepoGroupsException(
                                 u'user "%(username)s" still owns %(len_repo_groups)s repository groups and cannot be '
                                 u'removed. Switch owners or remove those repository groups:%(list_repo_groups)s'
                                 % {'username': user.username, 'len_repo_groups': len(repo_groups),
                                    'list_repo_groups': ', '.join(repo_groups)})
                         left_overs = self._handle_user_user_groups(
                             user.username, user.user_groups, handle_user_groups)
                         if left_overs and user.user_groups:
                             user_groups = [x.users_group_name for x in user.user_groups]
                             raise UserOwnsUserGroupsException(
                                 u'user "%s" still owns %s user groups and cannot be '
                                 u'removed. Switch owners or remove those user groups:%s'
                                 % (user.username, len(user_groups), ', '.join(user_groups)))
                         left_overs = self._handle_user_artifacts(
                             user.username, user.artifacts, handle_artifacts)
                         if left_overs and user.artifacts:
                             artifacts = [x.file_uid for x in user.artifacts]
                             raise UserOwnsArtifactsException(
                                 u'user "%s" still owns %s artifacts and cannot be '
                                 u'removed. Switch owners or remove those artifacts:%s'
                                 % (user.username, len(artifacts), ', '.join(artifacts)))
                         user_data = user.get_dict()  # fetch user data before expire
                         # we might change the user data with detach/delete, make sure
                         # the object is marked as expired before actually deleting !
                         self.sa.expire(user)
                         self.sa.delete(user)
                         log_delete_user(deleted_by=cur_user, **user_data)
                     except Exception:
                         log.error(traceback.format_exc())
                         raise
                 def reset_password_link(self, data, pwd_reset_url):
                     from rhodecode.lib.celerylib import tasks, run_task
                     from rhodecode.model.notification import EmailNotificationModel
                     user_email = data['email']
                     try:
                         user = User.get_by_email(user_email)
                         if user:
                             log.debug('password reset user found %s', user)
                             email_kwargs = {
                                 'password_reset_url': pwd_reset_url,
                                 'user': user,
                                 'email': user_email,
-                                'date': datetime.datetime.now()
+                                'date': datetime.datetime.now(),
+                                'first_admin_email': User.get_first_super_admin().email
                             }
                             (subject, headers, email_body,
                              email_body_plaintext) = EmailNotificationModel().render_email(
                                 EmailNotificationModel.TYPE_PASSWORD_RESET, **email_kwargs)
                             recipients = [user_email]
                             action_logger_generic(
                                 'sending password reset email to user: {}'.format(
                                     user), namespace='security.password_reset')
                             run_task(tasks.send_email, recipients, subject,
                                      email_body_plaintext, email_body)
                         else:
                             log.debug("password reset email %s not found", user_email)
                     except Exception:
                         log.error(traceback.format_exc())
                         return False
                     return True
                 def reset_password(self, data):
                     from rhodecode.lib.celerylib import tasks, run_task
                     from rhodecode.model.notification import EmailNotificationModel
                     from rhodecode.lib import auth
                     user_email = data['email']
                     pre_db = True
                     try:
                         user = User.get_by_email(user_email)
                         new_passwd = auth.PasswordGenerator().gen_password(
 , auth.PasswordGenerator.ALPHABETS_BIG_SMALL)
                         if user:
                             user.password = auth.get_crypt_password(new_passwd)
                             # also force this user to reset his password !
                             user.update_userdata(force_password_change=True)
                             Session().add(user)
                             # now delete the token in question
                             UserApiKeys = AuthTokenModel.cls
                             UserApiKeys().query().filter(
                                 UserApiKeys.api_key == data['token']).delete()
                             Session().commit()
                             log.info('successfully reset password for `%s`', user_email)
                         if new_passwd is None:
                             raise Exception('unable to generate new password')
                         pre_db = False
                         email_kwargs = {
                             'new_password': new_passwd,
                             'user': user,
                             'email': user_email,
-                            'date': datetime.datetime.now()
+                            'date': datetime.datetime.now(),
+                            'first_admin_email': User.get_first_super_admin().email
                         }
                         (subject, headers, email_body,
                          email_body_plaintext) = EmailNotificationModel().render_email(
                             EmailNotificationModel.TYPE_PASSWORD_RESET_CONFIRMATION,
                             **email_kwargs)
                         recipients = [user_email]
                         action_logger_generic(
                             'sent new password to user: {} with email: {}'.format(
                                 user, user_email), namespace='security.password_reset')
                         run_task(tasks.send_email, recipients, subject,
                                  email_body_plaintext, email_body)
                     except Exception:
                         log.error('Failed to update user password')
                         log.error(traceback.format_exc())
                         if pre_db:
                             # we rollback only if local db stuff fails. If it goes into
                             # run_task, we're pass rollback state this wouldn't work then
                             Session().rollback()
                     return True
                 def fill_data(self, auth_user, user_id=None, api_key=None, username=None):
                     """
                     Fetches auth_user by user_id,or api_key if present.
                     Fills auth_user attributes with those taken from database.
                     Additionally set's is_authenitated if lookup fails
                     present in database
                     :param auth_user: instance of user to set attributes
                     :param user_id: user id to fetch by
                     :param api_key: api key to fetch by
                     :param username: username to fetch by
                     """
                     def token_obfuscate(token):
                         if token:
                             return token[:4] + "****"
                     if user_id is None and api_key is None and username is None:
                         raise Exception('You need to pass user_id, api_key or username')
                     log.debug(
                         'AuthUser: fill data execution based on: '
                         'user_id:%s api_key:%s username:%s', user_id, api_key, username)
                     try:
                         dbuser = None
                         if user_id:
                             dbuser = self.get(user_id)
                         elif api_key:
                             dbuser = self.get_by_auth_token(api_key)
                         elif username:
                             dbuser = self.get_by_username(username)
                         if not dbuser:
                             log.warning(
                                 'Unable to lookup user by id:%s api_key:%s username:%s',
                                 user_id, token_obfuscate(api_key), username)
                             return False
                         if not dbuser.active:
                             log.debug('User `%s:%s` is inactive, skipping fill data',
                                       username, user_id)
                             return False
                         log.debug('AuthUser: filling found user:%s data', dbuser)
                         attrs = {
                             'user_id': dbuser.user_id,
                             'username': dbuser.username,
                             'name': dbuser.name,
                             'first_name': dbuser.first_name,
                             'firstname': dbuser.firstname,
                             'last_name': dbuser.last_name,
                             'lastname': dbuser.lastname,
                             'admin': dbuser.admin,
                             'active': dbuser.active,
                             'email': dbuser.email,
                             'emails': dbuser.emails_cached(),
                             'short_contact': dbuser.short_contact,
                             'full_contact': dbuser.full_contact,
                             'full_name': dbuser.full_name,
                             'full_name_or_username': dbuser.full_name_or_username,
                             '_api_key': dbuser._api_key,
                             '_user_data': dbuser._user_data,
                             'created_on': dbuser.created_on,
                             'extern_name': dbuser.extern_name,
                             'extern_type': dbuser.extern_type,
                             'inherit_default_permissions': dbuser.inherit_default_permissions,
                             'language': dbuser.language,
                             'last_activity': dbuser.last_activity,
                             'last_login': dbuser.last_login,
                             'password': dbuser.password,
                         }
                         auth_user.__dict__.update(attrs)
                     except Exception:
                         log.error(traceback.format_exc())
                         auth_user.is_authenticated = False
                         return False
                     return True
                 def has_perm(self, user, perm):
                     perm = self._get_perm(perm)
                     user = self._get_user(user)
                     return UserToPerm.query().filter(UserToPerm.user == user)\
                         .filter(UserToPerm.permission == perm).scalar() is not None
                 def grant_perm(self, user, perm):
                     """
                     Grant user global permissions
                     :param user:
                     :param perm:
                     """
                     user = self._get_user(user)
                     perm = self._get_perm(perm)
                     # if this permission is already granted skip it
                     _perm = UserToPerm.query()\
                         .filter(UserToPerm.user == user)\
                         .filter(UserToPerm.permission == perm)\
                         .scalar()
                     if _perm:
                         return
                     new = UserToPerm()
                     new.user = user
                     new.permission = perm
                     self.sa.add(new)
                     return new
                 def revoke_perm(self, user, perm):
                     """
                     Revoke users global permissions
                     :param user:
                     :param perm:
                     """
                     user = self._get_user(user)
                     perm = self._get_perm(perm)
                     obj = UserToPerm.query()\
                             .filter(UserToPerm.user == user)\
                             .filter(UserToPerm.permission == perm)\
                             .scalar()
                     if obj:
                         self.sa.delete(obj)
                 def add_extra_email(self, user, email):
                     """
                     Adds email address to UserEmailMap
                     :param user:
                     :param email:
                     """
                     user = self._get_user(user)
                     obj = UserEmailMap()
                     obj.user = user
                     obj.email = email
                     self.sa.add(obj)
                     return obj
                 def delete_extra_email(self, user, email_id):
                     """
                     Removes email address from UserEmailMap
                     :param user:
                     :param email_id:
                     """
                     user = self._get_user(user)
                     obj = UserEmailMap.query().get(email_id)
                     if obj and obj.user_id == user.user_id:
                         self.sa.delete(obj)
                 def parse_ip_range(self, ip_range):
                     ip_list = []
                     def make_unique(value):
                         seen = []
                         return [c for c in value if not (c in seen or seen.append(c))]
                     # firsts split by commas
                     for ip_range in ip_range.split(','):
                         if not ip_range:
                             continue
                         ip_range = ip_range.strip()
                         if '-' in ip_range:
                             start_ip, end_ip = ip_range.split('-', 1)
                             start_ip = ipaddress.ip_address(safe_unicode(start_ip.strip()))
                             end_ip = ipaddress.ip_address(safe_unicode(end_ip.strip()))
                             parsed_ip_range = []
                             for index in xrange(int(start_ip), int(end_ip) + 1):
                                 new_ip = ipaddress.ip_address(index)
                                 parsed_ip_range.append(str(new_ip))
                             ip_list.extend(parsed_ip_range)
                         else:
                             ip_list.append(ip_range)
                     return make_unique(ip_list)
                 def add_extra_ip(self, user, ip, description=None):
                     """
                     Adds ip address to UserIpMap
                     :param user:
                     :param ip:
                     """
                     user = self._get_user(user)
                     obj = UserIpMap()
                     obj.user = user
                     obj.ip_addr = ip
                     obj.description = description
                     self.sa.add(obj)
                     return obj
                 auth_token_role = AuthTokenModel.cls
                 def add_auth_token(self, user, lifetime_minutes, role, description=u'',
                                    scope_callback=None):
                     """
                     Add AuthToken for user.
                     :param user: username/user_id
                     :param lifetime_minutes: in minutes the lifetime for token, -1 equals no limit
                     :param role: one of AuthTokenModel.cls.ROLE_*
                     :param description: optional string description
                     """
                     token = AuthTokenModel().create(
                         user, description, lifetime_minutes, role)
                     if scope_callback and callable(scope_callback):
                         # call the callback if we provide, used to attach scope for EE edition
                         scope_callback(token)
                     return token
                 def delete_extra_ip(self, user, ip_id):
                     """
                     Removes ip address from UserIpMap
                     :param user:
                     :param ip_id:
                     """
                     user = self._get_user(user)
                     obj = UserIpMap.query().get(ip_id)
                     if obj and obj.user_id == user.user_id:
                         self.sa.delete(obj)
                 def get_accounts_in_creation_order(self, current_user=None):
                     """
                     Get accounts in order of creation for deactivation for license limits
                     pick currently logged in user, and append to the list in position 0
                     pick all super-admins in order of creation date and add it to the list
                     pick all other accounts in order of creation and add it to the list.
                     Based on that list, the last accounts can be disabled as they are
                     created at the end and don't include any of the super admins as well
                     as the current user.
                     :param current_user: optionally current user running this operation
                     """
                     if not current_user:
                         current_user = get_current_rhodecode_user()
                     active_super_admins = [
                         x.user_id for x in User.query()
                         .filter(User.user_id != current_user.user_id)
                         .filter(User.active == true())
                         .filter(User.admin == true())
                         .order_by(User.created_on.asc())]
                     active_regular_users = [
                         x.user_id for x in User.query()
                         .filter(User.user_id != current_user.user_id)
                         .filter(User.active == true())
                         .filter(User.admin == false())
                         .order_by(User.created_on.asc())]
                     list_of_accounts = [current_user.user_id]
                     list_of_accounts += active_super_admins
                     list_of_accounts += active_regular_users
                     return list_of_accounts
                 def deactivate_last_users(self, expected_users, current_user=None):
                     """
                     Deactivate accounts that are over the license limits.
                     Algorithm of which accounts to disabled is based on the formula:
                     Get current user, then super admins in creation order, then regular
                     active users in creation order.
                     Using that list we mark all accounts from the end of it as inactive.
                     This way we block only latest created accounts.
                     :param expected_users: list of users in special order, we deactivate
                         the end N amount of users from that list
                     """
                     list_of_accounts = self.get_accounts_in_creation_order(
                         current_user=current_user)
                     for acc_id in list_of_accounts[expected_users + 1:]:
                         user = User.get(acc_id)
                         log.info('Deactivating account %s for license unlock', user)
                         user.active = False
                         Session().add(user)
                         Session().commit()
                     return
                 def get_user_log(self, user, filter_term):
                     user_log = UserLog.query()\
                         .filter(or_(UserLog.user_id == user.user_id,
                                     UserLog.username == user.username))\
                         .options(joinedload(UserLog.user))\
                         .options(joinedload(UserLog.repository))\
                         .order_by(UserLog.action_date.desc())
                     user_log = user_log_filter(user_log, filter_term)
                     return user_log

rhodecode/public/js/rhodecode/routes.js

0 +2 0

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

rhodecode/templates/debug_style/index.html

0 +1 0

             ## -*- coding: utf-8 -*-
             <%inherit file="/base/base.mako"/>
             <%def name="title()">
                 ${_('Debug Style')}
                 %if c.rhodecode_name:
                     &middot; ${h.branding(c.rhodecode_name)}
                 %endif
             </%def>
             <%def name="breadcrumbs_links()">
                 ${_('Style')}
             </%def>
             <%def name="menu_bar_nav()">
                 ${self.menu_items(active='debug_style')}
             </%def>
             <%def name="main()">
               <div id="style-page">
                   ${self.real_main()}
               </div>
             </%def>
             <%def name="real_main()">
             <div class="box">
                 <div class="title">
                     ${self.breadcrumbs()}
                 </div>
                 <div class='sidebar-col-wrapper'>
                   ##main
                   ${self.sidebar()}
                   <div class="main-content">
                       <h2>Examples of styled elements</h2>
                       <p>Taken based on the examples from Bootstrap, form elements based
                          on our current markup.</p>
                       <p>
                         The objective of this section is to have a comprehensive style guide which out
                         lines any and all elements used throughout the application, as a reference for
                         both existing developers and as a training tool for future hires.
                       </p>
                   </div>
                 </div>
             </div>
             </%def>
             <%def name="sidebar()">
                 <div class="sidebar">
                   <ul class="nav nav-pills nav-stacked">
                       <li class="${'active' if c.active=='index' else ''}"><a href="${h.route_path('debug_style_home')}">${_('Index')}</a></li>
+                      <li class="${'active' if c.active=='emails' else ''}"><a href="${h.route_path('debug_style_template', t_path='emails.html')}">${_('Emails')}</a></li>
                       <li class="${'active' if c.active=='typography' else ''}"><a href="${h.route_path('debug_style_template', t_path='typography.html')}">${_('Typography')}</a></li>
                       <li class="${'active' if c.active=='forms' else ''}"><a href="${h.route_path('debug_style_template', t_path='forms.html')}">${_('Forms')}</a></li>
                       <li class="${'active' if c.active=='buttons' else ''}"><a href="${h.route_path('debug_style_template', t_path='buttons.html')}">${_('Buttons')}</a></li>
                       <li class="${'active' if c.active=='labels' else ''}"><a href="${h.route_path('debug_style_template', t_path='labels.html')}">${_('Labels')}</a></li>
                       <li class="${'active' if c.active=='alerts' else ''}"><a href="${h.route_path('debug_style_template', t_path='alerts.html')}">${_('Alerts')}</a></li>
                       <li class="${'active' if c.active=='tables' else ''}"><a href="${h.route_path('debug_style_template', t_path='tables.html')}">${_('Tables')}</a></li>
                       <li class="${'active' if c.active=='tables-wide' else ''}"><a href="${h.route_path('debug_style_template', t_path='tables-wide.html')}">${_('Tables wide')}</a></li>
                       <li class="${'active' if c.active=='collapsable-content' else ''}"><a href="${h.route_path('debug_style_template', t_path='collapsable-content.html')}">${_('Collapsable Content')}</a></li>
                       <li class="${'active' if c.active=='icons' else ''}"><a href="${h.route_path('debug_style_template', t_path='icons.html')}">${_('Icons')}</a></li>
                       <li class="${'active' if c.active=='layout-form-sidebar' else ''}"><a href="${h.route_path('debug_style_template', t_path='layout-form-sidebar.html')}">${_('Layout form with sidebar')}</a></li>
                       <li class="${'active' if c.active=='login' else ''}"><a href="${h.route_path('debug_style_template', t_path='login.html')}">${_('Login')}</a></li>
                       <li class="${'active' if c.active=='login2' else ''}"><a href="${h.route_path('debug_style_template', t_path='login2.html')}">${_('Login 2')}</a></li>
                       <li class="${'active' if c.active=='code-block' else ''}"><a href="${h.route_path('debug_style_template', t_path='code-block.html')}">${_('Code blocks')}</a></li>
                       <li class="divider"><strong>Experimental</strong></li>
                       <li class="${'active' if c.active=='panels' else ''}"><a href="${h.route_path('debug_style_template', t_path='panels.html')}">${_('Panels')}</a></li>
                       <li class="divider"><strong>Depreciated</strong></li>
                       <li class="${'active' if c.active=='form-elements' else ''}"><a href="${h.route_path('debug_style_template', t_path='form-elements.html')}">${_('Form elements')}</a></li>
                       <li class="${'active' if c.active=='form-elements-small' else ''}"><a href="${h.route_path('debug_style_template', t_path='form-elements-small.html')}">${_('Form elements small')}</a></li>
                       <li class="${'active' if c.active=='form-inline' else ''}"><a href="${h.route_path('debug_style_template', t_path='form-inline.html')}">${_('Form inline elements')}</a></li>
                       <li class="${'active' if c.active=='form-vertical' else ''}"><a href="${h.route_path('debug_style_template', t_path='form-vertical.html')}">${_('Form vertical')}</a></li>
                     </ul>
                 </div>
             </%def>

rhodecode/templates/email_templates/base.mako

0 +414 -31

@@ -1,142 +1,525 b''
1	## -- coding: utf-8 --	1	## -- coding: utf-8 --
2		2
3	## helpers	3	## helpers
4	<%def name="tag_button(text, tag_type=None)">	4	<%def name="tag_button(text, tag_type=None)">
5	<%	5	<%
6	color_scheme = {	6	color_scheme = {
7	'default': 'border:1px solid #979797;color:#666666;background-color:#f9f9f9',	7	'default': 'border:1px solid #979797;color:#666666;background-color:#f9f9f9',
8	'approved': 'border:1px solid #0ac878;color:#0ac878;background-color:#f9f9f9',	8	'approved': 'border:1px solid #0ac878;color:#0ac878;background-color:#f9f9f9',
9	'rejected': 'border:1px solid #e85e4d;color:#e85e4d;background-color:#f9f9f9',	9	'rejected': 'border:1px solid #e85e4d;color:#e85e4d;background-color:#f9f9f9',
10	'under_review': 'border:1px solid #ffc854;color:#ffc854;background-color:#f9f9f9',	10	'under_review': 'border:1px solid #ffc854;color:#ffc854;background-color:#f9f9f9',
11	}	11	}
		12
		13	css_style = ';'.join([
		14	'display:inline',
		15	'border-radius:2px',
		16	'font-size:12px',
		17	'padding:.2em',
		18	])
		19
12	%>	20	%>
13	<pre style="~~display:inline;border-radius:2px;font-size:12px;padding:.2em;~~${color_scheme.get(tag_type, color_scheme['default'])}">${text}</pre>	21	<pre style="${css_style}; ${color_scheme.get(tag_type, color_scheme['default'])}">${text}</pre>
14	</%def>	22	</%def>
15		23
16	<%def name="status_text(text, tag_type=None)">	24	<%def name="status_text(text, tag_type=None)">
17	<%	25	<%
18	color_scheme = {	26	color_scheme = {
19	'default': 'color:#666666',	27	'default': 'color:#666666',
20	'approved': 'color:#0ac878',	28	'approved': 'color:#0ac878',
21	'rejected': 'color:#e85e4d',	29	'rejected': 'color:#e85e4d',
22	'under_review': 'color:#ffc854',	30	'under_review': 'color:#ffc854',
23	}	31	}
24	%>	32	%>
25	<span style="font-weight:bold;font-size:12px;padding:.2em;${color_scheme.get(tag_type, color_scheme['default'])}">${text}</span>	33	<span style="font-weight:bold;font-size:12px;padding:.2em;${color_scheme.get(tag_type, color_scheme['default'])}">${text}</span>
26	</%def>	34	</%def>
27		35
		36	<%def name="gravatar_img(email, size=16)">
		37	<%
		38	css_style = ';'.join([
		39	'padding: 0',
		40	'margin: -4px 0',
		41	'border-radius: 50%',
		42	'box-sizing: content-box',
		43	'display: inline',
		44	'line-height: 1em',
		45	'min-width: 16px',
		46	'min-height: 16px',
		47	])
		48	%>
		49
		50	<img alt="gravatar" style="${css_style}" src="${h.gravatar_url(email, size)}" height="${size}" width="${size}">
		51	</%def>
		52
		53	<%def name="link_css()">\
		54	<%
		55	css_style = ';'.join([
		56	'color:#427cc9',
		57	'text-decoration:none',
		58	'cursor:pointer'
		59	])
		60	%>\
		61	${css_style}\
		62	</%def>
		63
28	## Constants	64	## Constants
29	<%	65	<%
30	text_regular = "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen-Sans, Ubuntu, Cantarell, 'Helvetica Neue', sans-serif;"	66	text_regular = "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen-Sans, Ubuntu, Cantarell, 'Helvetica Neue', sans-serif;"
31	text_monospace = "'Menlo', 'Liberation Mono', 'Consolas', 'DejaVu Sans Mono', 'Ubuntu Mono', 'Courier New', 'andale mono', 'lucida console', monospace;"	67	text_monospace = "'Menlo', 'Liberation Mono', 'Consolas', 'DejaVu Sans Mono', 'Ubuntu Mono', 'Courier New', 'andale mono', 'lucida console', monospace;"
32		68
33	%>	69	%>
34		70
35	## headers we additionally can set for email	71	## headers we additionally can set for email
36	<%def name="headers()" filter="n,trim"></%def>	72	<%def name="headers()" filter="n,trim"></%def>
37		73
38	<%def name="plaintext_footer()">	74	<%def name="plaintext_footer()" filter="trim">
39	${_('This is a notification from RhodeCode. ~~%(instance_url)s~~') % {~~'instance_url'~~: instance_url}}	75	${_('This is a notification from RhodeCode.')} ${instance_url}
40	</%def>	76	</%def>
41		77
42	<%def name="body_plaintext()" filter="n,trim">	78	<%def name="body_plaintext()" filter="n,trim">
43	## this example is not called itself but overridden in each template	79	## this example is not called itself but overridden in each template
44	## the plaintext_footer should be at the bottom of both html and text emails	80	## the plaintext_footer should be at the bottom of both html and text emails
45	${self.plaintext_footer()}	81	${self.plaintext_footer()}
46	</%def>	82	</%def>
47		83
48	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">	84	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
49	<html xmlns="http://www.w3.org/1999/xhtml">	85	<html xmlns="http://www.w3.org/1999/xhtml">
50	<head>	86	<head>
51	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />	87	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
52	<meta name="viewport" content="width=device-width, initial-scale=1.0"/>	88	<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
53	<title>${self.subject()}</title>	89	<title>${self.subject()}</title>
54	<style type="text/css">	90	<style type="text/css">
55	/* Based on The MailChimp Reset INLINE: Yes. */	91	/* Based on The MailChimp Reset INLINE: Yes. */
56	#outlook a {padding:0;} /* Force Outlook to provide a "view in browser" menu link. */	92	#outlook a {
57	body{width:100% !important; -webkit-text-size-adjust:100%; -ms-text-size-adjust:100%; margin:0; padding:0; font-family: ${text_regular\|n}}	93	padding: 0;
		94	}
		95
		96	/* Force Outlook to provide a "view in browser" menu link. */
		97	body {
		98	width: 100% !important;
		99	-webkit-text-size-adjust: 100%;
		100	-ms-text-size-adjust: 100%;
		101	margin: 0;
		102	padding: 0;
		103	font-family: ${text_regular\|n}
		104	}
		105
58	/* Prevent Webkit and Windows Mobile platforms from changing default font sizes.*/	106	/* Prevent Webkit and Windows Mobile platforms from changing default font sizes.*/
59	.ExternalClass {width:100%;} /* Force Hotmail to display emails at full width */	107	.ExternalClass {
60	.ExternalClass, .ExternalClass p, .ExternalClass span, .ExternalClass font, .ExternalClass td, .ExternalClass div {line-height: 100%;}	108	width: 100%;
		109	}
		110
		111	/* Force Hotmail to display emails at full width */
		112	.ExternalClass, .ExternalClass p, .ExternalClass span, .ExternalClass font, .ExternalClass td, .ExternalClass div {
		113	line-height: 100%;
		114	}
		115
61	/* Forces Hotmail to display normal line spacing. More on that: http://www.emailonacid.com/forum/viewthread/43/ */	116	/* Forces Hotmail to display normal line spacing. More on that: http://www.emailonacid.com/forum/viewthread/43/ */
62	#backgroundTable {margin:0; padding:0; line-height: 100% !important;}	117	#backgroundTable {
		118	margin: 0;
		119	padding: 0;
		120	line-height: 100% !important;
		121	}
		122
63	/* End reset */	123	/* End reset */
64		124
65	/* defaults for images*/	125	/* defaults for images*/
66	img {outline:none; text-decoration:none; -ms-interpolation-mode: bicubic;}	126	img {
67	a img {border:none;}	127	outline: none;
68	.image_fix {display:block;}	128	text-decoration: none;
		129	-ms-interpolation-mode: bicubic;
		130	}
		131
		132	a img {
		133	border: none;
		134	}
		135
		136	.image_fix {
		137	display: block;
		138	}
		139
		140	body {
		141	line-height: 1.2em;
		142	}
		143
		144	p {
		145	margin: 0 0 20px;
		146	}
		147
		148	h1, h2, h3, h4, h5, h6 {
		149	color: #323232 !important;
		150	}
		151
		152	a {
		153	color: #427cc9;
		154	text-decoration: none;
		155	outline: none;
		156	cursor: pointer;
		157	}
		158
		159	a:focus {
		160	outline: none;
		161	}
69		162
70	body {line-height:1.2em;}	163	a:hover {
71	p {margin: 0 0 20px;}	164	color: #305b91;
72	h1, h2, h3, h4, h5, h6 {color:#323232!important;}	165	}
73	a {color:#427cc9;text-decoration:none;outline:none;cursor:pointer;}	166
74	a:focus {outline:none;}	167	h1 a, h2 a, h3 a, h4 a, h5 a, h6 a {
75	a:hover {color: #305b91;}	168	color: #427cc9 !important;
76	h1 a, h2 a, h3 a, h4 a, h5 a, h6 a {color:#427cc9!important;text-decoration:none!important;}	169	text-decoration: none !important;
77	h1 a:active, h2 a:active, h3 a:active, h4 a:active, h5 a:active, h6 a:active {color: #305b91!important;}	170	}
78	h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited {color: #305b91!important;}	171
79	table {font-size:13px;border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;}	172	h1 a:active, h2 a:active, h3 a:active, h4 a:active, h5 a:active, h6 a:active {
80	table td {padding:.65em 1em .65em 0;border-collapse:collapse;vertical-align:top;text-align:left;}	173	color: #305b91 !important;
81	input {display:inline;border-radius:2px;border-style:solid;border: 1px solid #dbd9da;padding:.5em;}	174	}
82	input:focus {outline: 1px solid #979797}	175
		176	h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited {
		177	color: #305b91 !important;
		178	}
		179
		180	table {
		181	font-size: 13px;
		182	border-collapse: collapse;
		183	mso-table-lspace: 0pt;
		184	mso-table-rspace: 0pt;
		185	}
		186
		187	table td {
		188	padding: .65em 1em .65em 0;
		189	border-collapse: collapse;
		190	vertical-align: top;
		191	text-align: left;
		192	}
		193
		194	input {
		195	display: inline;
		196	border-radius: 2px;
		197	border: 1px solid #dbd9da;
		198	padding: .5em;
		199	}
		200
		201	input:focus {
		202	outline: 1px solid #979797
		203	}
		204
83	@media only screen and (-webkit-min-device-pixel-ratio: 2) {	205	@media only screen and (-webkit-min-device-pixel-ratio: 2) {
84	/* Put your iPhone 4g styles in here */	206	/* Put your iPhone 4g styles in here */
85	}	207	}
86		208
87	/* Android targeting */	209	/* Android targeting */
88	@media only screen and (-webkit-device-pixel-ratio:.75){	210	@media only screen and (-webkit-device-pixel-ratio:.75){
89	/* Put CSS for low density (ldpi) Android layouts in here */	211	/* Put CSS for low density (ldpi) Android layouts in here */
90	}	212	}
91	@media only screen and (-webkit-device-pixel-ratio:1){	213	@media only screen and (-webkit-device-pixel-ratio:1){
92	/* Put CSS for medium density (mdpi) Android layouts in here */	214	/* Put CSS for medium density (mdpi) Android layouts in here */
93	}	215	}
94	@media only screen and (-webkit-device-pixel-ratio:1.5){	216	@media only screen and (-webkit-device-pixel-ratio:1.5){
95	/* Put CSS for high density (hdpi) Android layouts in here */	217	/* Put CSS for high density (hdpi) Android layouts in here */
96	}	218	}
97	/* end Android targeting */	219	/* end Android targeting */
98		220
		221	/ MARKDOWN styling /
		222	div.markdown-block {
		223	clear: both;
		224	overflow: hidden;
		225	margin: 0;
		226	padding: 3px 5px 3px
		227	}
		228
		229	div.markdown-block h1, div.markdown-block h2, div.markdown-block h3, div.markdown-block h4, div.markdown-block h5, div.markdown-block h6 {
		230	border-bottom: none !important;
		231	padding: 0 !important;
		232	overflow: visible !important
		233	}
		234
		235	div.markdown-block h1, div.markdown-block h2 {
		236	border-bottom: 1px #e6e5e5 solid !important
		237	}
		238
		239	div.markdown-block h1 {
		240	font-size: 32px;
		241	margin: 15px 0 15px 0 !important;
		242	padding-bottom: 5px !important
		243	}
		244
		245	div.markdown-block h2 {
		246	font-size: 24px !important;
		247	margin: 34px 0 10px 0 !important;
		248	padding-top: 15px !important;
		249	padding-bottom: 8px !important
		250	}
		251
		252	div.markdown-block h3 {
		253	font-size: 18px !important;
		254	margin: 30px 0 8px 0 !important;
		255	padding-bottom: 2px !important
		256	}
		257
		258	div.markdown-block h4 {
		259	font-size: 13px !important;
		260	margin: 18px 0 3px 0 !important
		261	}
		262
		263	div.markdown-block h5 {
		264	font-size: 12px !important;
		265	margin: 15px 0 3px 0 !important
		266	}
		267
		268	div.markdown-block h6 {
		269	font-size: 12px;
		270	color: #777777;
		271	margin: 15px 0 3px 0 !important
		272	}
		273
		274	div.markdown-block hr {
		275	border: 0;
		276	color: #e6e5e5;
		277	background-color: #e6e5e5;
		278	height: 3px;
		279	margin-bottom: 13px
		280	}
		281
		282	div.markdown-block ol, div.markdown-block ul, div.markdown-block p, div.markdown-block blockquote, div.markdown-block dl, div.markdown-block li, div.markdown-block table {
		283	margin: 3px 0 13px 0 !important;
		284	color: #424242 !important;
		285	font-size: 13px !important;
		286	font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif;
		287	font-weight: normal !important;
		288	overflow: visible !important;
		289	line-height: 140% !important
		290	}
		291
		292	div.markdown-block pre {
		293	margin: 3px 0 13px 0 !important;
		294	padding: .5em;
		295	color: #424242 !important;
		296	font-size: 13px !important;
		297	overflow: visible !important;
		298	line-height: 140% !important;
		299	background-color: #F5F5F5
		300	}
		301
		302	div.markdown-block img {
		303	border-style: none;
		304	background-color: #fff;
		305	padding-right: 20px;
		306	max-width: 100%
		307	}
		308
		309	div.markdown-block strong {
		310	font-weight: 600;
		311	margin: 0
		312	}
		313
		314	div.markdown-block ul.checkbox, div.markdown-block ol.checkbox {
		315	padding-left: 20px !important;
		316	margin-top: 0 !important;
		317	margin-bottom: 18px !important
		318	}
		319
		320	div.markdown-block ul, div.markdown-block ol {
		321	padding-left: 30px !important;
		322	margin-top: 0 !important;
		323	margin-bottom: 18px !important
		324	}
		325
		326	div.markdown-block ul.checkbox li, div.markdown-block ol.checkbox li {
		327	list-style: none !important;
		328	margin: 6px !important;
		329	padding: 0 !important
		330	}
		331
		332	div.markdown-block ul li, div.markdown-block ol li {
		333	list-style: disc !important;
		334	margin: 6px !important;
		335	padding: 0 !important
		336	}
		337
		338	div.markdown-block ol li {
		339	list-style: decimal !important
		340	}
		341
		342	div.markdown-block #message {
		343	-webkit-border-radius: 2px;
		344	-moz-border-radius: 2px;
		345	border-radius: 2px;
		346	border: 1px solid #dbd9da;
		347	display: block;
		348	width: 100%;
		349	height: 60px;
		350	margin: 6px 0
		351	}
		352
		353	div.markdown-block button, div.markdown-block #ws {
		354	font-size: 13px;
		355	padding: 4px 6px;
		356	-webkit-border-radius: 2px;
		357	-moz-border-radius: 2px;
		358	border-radius: 2px;
		359	border: 1px solid #dbd9da;
		360	background-color: #eeeeee
		361	}
		362
		363	div.markdown-block code, div.markdown-block pre, div.markdown-block #ws, div.markdown-block #message {
		364	font-family: 'Menlo', 'Liberation Mono', 'Consolas', 'DejaVu Sans Mono', 'Ubuntu Mono', 'Courier New', 'andale mono', 'lucida console', monospace;
		365	font-size: 11px;
		366	-webkit-border-radius: 2px;
		367	-moz-border-radius: 2px;
		368	border-radius: 2px;
		369	background-color: white;
		370	color: #7E7F7F
		371	}
		372
		373	div.markdown-block code {
		374	border: 1px solid #eeeeee;
		375	margin: 0 2px;
		376	padding: 0 5px
		377	}
		378
		379	div.markdown-block pre {
		380	border: 1px solid #dbd9da;
		381	overflow: auto;
		382	padding: .5em;
		383	background-color: #F5F5F5
		384	}
		385
		386	div.markdown-block pre > code {
		387	border: 0;
		388	margin: 0;
		389	padding: 0
		390	}
		391
		392	div.rst-block {
		393	clear: both;
		394	overflow: hidden;
		395	margin: 0;
		396	padding: 3px 5px 3px
		397	}
		398
		399	div.rst-block h2 {
		400	font-weight: normal
		401	}
		402
		403	div.rst-block h1, div.rst-block h2, div.rst-block h3, div.rst-block h4, div.rst-block h5, div.rst-block h6 {
		404	border-bottom: 0 !important;
		405	margin: 0 !important;
		406	padding: 0 !important;
		407	line-height: 1.5em !important
		408	}
		409
		410	div.rst-block h1:first-child {
		411	padding-top: .25em !important
		412	}
		413
		414	div.rst-block h2, div.rst-block h3 {
		415	margin: 1em 0 !important
		416	}
		417
		418	div.rst-block h1, div.rst-block h2 {
		419	border-bottom: 1px #e6e5e5 solid !important
		420	}
		421
		422	div.rst-block h2 {
		423	margin-top: 1.5em !important;
		424	padding-top: .5em !important
		425	}
		426
		427	div.rst-block p {
		428	color: black !important;
		429	margin: 1em 0 !important;
		430	line-height: 1.5em !important
		431	}
		432
		433	div.rst-block ul {
		434	list-style: disc !important;
		435	margin: 1em 0 1em 2em !important;
		436	clear: both
		437	}
		438
		439	div.rst-block ol {
		440	list-style: decimal;
		441	margin: 1em 0 1em 2em !important
		442	}
		443
		444	div.rst-block pre, div.rst-block code {
		445	font: 12px "Bitstream Vera Sans Mono", "Courier", monospace
		446	}
		447
		448	div.rst-block code {
		449	font-size: 12px !important;
		450	background-color: ghostWhite !important;
		451	color: #444 !important;
		452	padding: 0 .2em !important;
		453	border: 1px solid #dedede !important
		454	}
		455
		456	div.rst-block pre code {
		457	padding: 0 !important;
		458	font-size: 12px !important;
		459	background-color: #eee !important;
		460	border: none !important
		461	}
		462
		463	div.rst-block pre {
		464	margin: 1em 0;
		465	padding: 15px;
		466	border: 1px solid #eeeeee;
		467	-webkit-border-radius: 2px;
		468	-moz-border-radius: 2px;
		469	border-radius: 2px;
		470	overflow: auto;
		471	font-size: 12px;
		472	color: #444;
		473	background-color: #F5F5F5
		474	}
		475
		476
99	</style>	477	</style>
100		478
101	<!-- Targeting Windows Mobile -->	479	<!-- Targeting Windows Mobile -->
102	<!--[if IEMobile 7]>	480	<!--[if IEMobile 7]>
103	<style type="text/css">	481	<style type="text/css">
104		482
105	</style>	483	</style>
106	<![endif]-->	484	<![endif]-->
107		485
108	<!--[if gte mso 9]>	486	<!--[if gte mso 9]>
109	<style>	487	<style>
110	/* Target Outlook 2007 and 2010 */	488	/* Target Outlook 2007 and 2010 */
111	</style>	489	</style>
112	<![endif]-->	490	<![endif]-->
113	</head>	491	</head>
114	<body>	492	<body>
115	<!-- Wrapper/Container Table: Use a wrapper table to control the width and the background color consistently of your email. Use this approach instead of setting attributes on the body tag. -->	493	<!-- Wrapper/Container Table: Use a wrapper table to control the width and the background color consistently of your email. Use this approach instead of setting attributes on the body tag. -->
116	<table cellpadding="0" cellspacing="0" border="0" id="backgroundTable" align="left" style="margin:1%;width:97%;padding:0;font-family:sans-serif;font-weight:100;border:1px solid #dbd9da">	494	<table cellpadding="0" cellspacing="0" border="0" id="backgroundTable" align="left" style="margin:1%;width:97%;padding:0;font-family:sans-serif;font-weight:100;border:1px solid #dbd9da">
117	<tr>	495	<tr>
118	<td valign="top" style="padding:0;">	496	<td valign="top" style="padding:0;">
119	<table cellpadding="0" cellspacing="0" border="0" align="left" width="100%">	497	<table cellpadding="0" cellspacing="0" border="0" align="left" width="100%">
120	<tr><td style="width:100%;padding:7px;background-color:#202020" valign="top">	498	<tr>
		499	<td style="width:100%;padding:10px 15px;background-color:#202020" valign="top">
121	<a style="color:#eeeeee;text-decoration:none;" href="${instance_url}">	500	<a style="color:#eeeeee;text-decoration:none;" href="${instance_url}">
122	${_('RhodeCode')}	501	${_('RhodeCode')}
123	% if rhodecode_instance_name:	502	% if rhodecode_instance_name:
124	- ${rhodecode_instance_name}	503	- ${rhodecode_instance_name}
125	% endif	504	% endif
126	</a>	505	</a>
127	</td></tr>	506	</td>
128	<tr><td style="padding:15px;" valign="top">${self.body()}</td></tr>	507	</tr>
		508	<tr>
		509	<td style="padding:15px;" valign="top">${self.body()}</td>
		510	</tr>
129	</table>	511	</table>
130	</td>	512	</td>
131	</tr>	513	</tr>
132	</table>	514	</table>
133	<!-- End of wrapper table -->	515	<!-- End of wrapper table -->
134		516
135	<div style="clear: both"></div>	517	<div style="clear: both"></div>
136	<p>	518	<div style="margin-left:1%;font-weight:100;font-size:11px;color:#666666;text-decoration:none;font-family:${text_monospace}">
137	<a style="margin-top:15px;margin-left:1%;font-weight:100;font-size:11px;color:#666666;text-decoration:none;font-family:${text_monospace} " href="${instance_url}">	519	${_('This is a notification from RhodeCode.')}
138	${self.plaintext_footer()}	520	<a style="font-weight:100;font-size:11px;color:#666666;text-decoration:none;font-family:${text_monospace}" href="${instance_url}">
		521	${instance_url}
139	</a>	522	</a>
140	</p>	523	</div>
141	</body>	524	</body>
142	</html>	525	</html>

rhodecode/templates/email_templates/commit_comment.mako

0 +84 -31

             ## -*- coding: utf-8 -*-
             <%inherit file="base.mako"/>
             <%namespace name="base" file="base.mako"/>
             ## EMAIL SUBJECT
             <%def name="subject()" filter="n,trim,whitespace_filter">
             <%
             data = {
-                'user': h.person(user),
+                'user': '@'+h.person(user),
                 'repo_name': repo_name,
-                'commit_id': h.show_id(commit),
                 'status': status_change,
                 'comment_file': comment_file,
                 'comment_line': comment_line,
                 'comment_type': comment_type,
+                'commit_id': h.show_id(commit),
             }
             %>
-            ${_('[mention]') if mention else ''} \
             % if comment_file:
-                ${_('{user} left a {comment_type} on file `{comment_file}` in commit `{commit_id}`').format(**data)} ${_('in the {repo_name} repository').format(**data) |n}
+                ${(_('[mention]') if mention else '')} ${_('{user} left a {comment_type} on file `{comment_file}` in commit `{commit_id}`').format(**data)} ${_('in the `{repo_name}` repository').format(**data) |n}
             % else:
                 % if status_change:
-                ${_('[status: {status}] {user} left a {comment_type} on commit `{commit_id}`').format(**data) |n} ${_('in the {repo_name} repository').format(**data) |n}
+                ${(_('[mention]') if mention else '')} ${_('[status: {status}] {user} left a {comment_type} on commit `{commit_id}`').format(**data) |n} ${_('in the `{repo_name}` repository').format(**data) |n}
                 % else:
-                ${_('{user} left a {comment_type} on commit `{commit_id}`').format(**data) |n} ${_('in the {repo_name} repository').format(**data) |n}
+                ${(_('[mention]') if mention else '')} ${_('{user} left a {comment_type} on commit `{commit_id}`').format(**data) |n} ${_('in the `{repo_name}` repository').format(**data) |n}
                 % endif
             % endif
             </%def>
             ## PLAINTEXT VERSION OF BODY
             <%def name="body_plaintext()" filter="n,trim">
             <%
             data = {
                 'user': h.person(user),
                 'repo_name': repo_name,
-                'commit_id': h.show_id(commit),
                 'status': status_change,
                 'comment_file': comment_file,
                 'comment_line': comment_line,
                 'comment_type': comment_type,
+                'commit_id': h.show_id(commit),
             }
             %>
-            ${self.subject()}
             * ${_('Comment link')}: ${commit_comment_url}
+            %if status_change:
+            * ${_('Commit status')}: ${_('Status was changed to')}: *${status_change}*
+            %endif
             * ${_('Commit')}: ${h.show_id(commit)}
+            * ${_('Commit message')}: ${commit.message}
             %if comment_file:
             * ${_('File: {comment_file} on line {comment_line}').format(**data)}
             %endif
+            % if comment_type == 'todo':
+            ${_('`TODO` comment')}:
+            % else:
+            ${_('`Note` comment')}:
+            % endif
+            ${comment_body |n, trim}
             ---
-            %if status_change:
-                ${_('Commit status was changed to')}: *${status_change}*
-            %endif
-            ${comment_body|n}
             ${self.plaintext_footer()}
             </%def>
             <%
             data = {
                 'user': h.person(user),
-                'repo': commit_target_repo,
-                'repo_name': repo_name,
-                'commit_id': h.show_id(commit),
                 'comment_file': comment_file,
                 'comment_line': comment_line,
                 'comment_type': comment_type,
+                'renderer_type': renderer_type or 'plain',
+                'repo': commit_target_repo_url,
+                'repo_name': repo_name,
+                'commit_id': h.show_id(commit),
             }
             %>
-            <table style="text-align:left;vertical-align:middle;">
-                <tr><td colspan="2" style="width:100%;padding-bottom:15px;border-bottom:1px solid #dbd9da;">
+            <table style="text-align:left;vertical-align:middle;width: 100%">
+                <tr>
+                <td style="width:100%;border-bottom:1px solid #dbd9da;">
+                    <h4 style="margin: 0">
+                        <div style="margin-bottom: 4px; color:#7E7F7F">
+                            @${h.person(user.username)}
+                        </div>
+                        ${_('left a')}
+                        <a href="${commit_comment_url}" style="${base.link_css()}">
                             % if comment_file:
-                    <h4><a href="${commit_comment_url}" style="color:#427cc9;text-decoration:none;cursor:pointer">${_('{user} left a {comment_type} on file `{comment_file}` in commit `{commit_id}`').format(**data)}</a> ${_('in the {repo} repository').format(**data) |n}</h4>
+                                ${_('{comment_type} on file `{comment_file}` in commit.').format(**data)}
                             % else:
-                    <h4><a href="${commit_comment_url}" style="color:#427cc9;text-decoration:none;cursor:pointer">${_('{user} left a {comment_type} on commit `{commit_id}`').format(**data) |n}</a> ${_('in the {repo} repository').format(**data) |n}</h4>
+                                ${_('{comment_type} on commit.').format(**data) |n}
                             % endif
-                </td></tr>
+                        </a>
+                        <div style="margin-top: 10px"></div>
+                        ${_('Commit')} <code>${data['commit_id']}</code> ${_('of repository')}: ${data['repo_name']}
+                    </h4>
+                </td>
+                </tr>
-                <tr><td style="padding-right:20px;padding-top:15px;">${_('Commit')}</td><td style="padding-top:15px;"><a href="${commit_comment_url}" style="color:#427cc9;text-decoration:none;cursor:pointer">${h.show_id(commit)}</a></td></tr>
+            </table>
-                <tr><td style="padding-right:20px;">${_('Description')}</td><td style="white-space:pre-wrap">${h.urlify_commit_message(commit.message, repo_name)}</td></tr>
+            <table style="text-align:left;vertical-align:middle;width: 100%">
+                ## spacing def
+                <tr>
+                    <td style="width: 130px"></td>
+                    <td></td>
+                </tr>
                 % if status_change:
                     <tr>
-                        <td style="padding-right:20px;">${_('Status')}</td>
+                        <td style="padding-right:20px;">${_('Commit Status')}:</td>
                         <td>
-                            ${_('The commit status was changed to')}: ${base.status_text(status_change, tag_type=status_change_type)}
+                            ${_('Status was changed to')}: ${base.status_text(status_change, tag_type=status_change_type)}
                         </td>
                     </tr>
                 % endif
                 <tr>
-                    <td style="padding-right:20px;">
+                    <td style="padding-right:20px;">${_('Commit')}:</td>
+                    <td>
+                        <a href="${commit_comment_url}" style="${base.link_css()}">${h.show_id(commit)}</a>
+                    </td>
+                </tr>
+                <tr>
+                    <td style="padding-right:20px;">${_('Commit message')}:</td>
+                    <td style="white-space:pre-wrap">${h.urlify_commit_message(commit.message, repo_name)}</td>
+                </tr>
+                % if comment_file:
+                    <tr>
+                        <td style="padding-right:20px;">${_('File')}:</td>
+                        <td><a href="${commit_comment_url}" style="${base.link_css()}">${_('`{comment_file}` on line {comment_line}').format(**data)}</a></td>
+                    </tr>
+                % endif
+                <tr style="background-image: linear-gradient(to right, black 33%, rgba(255,255,255,0) 0%);background-position: bottom;background-size: 3px 1px;background-repeat: repeat-x;">
+                    <td colspan="2" style="padding-right:20px;">
                         % if comment_type == 'todo':
-                            ${(_('TODO comment on line: {comment_line}') if comment_file else _('TODO comment')).format(**data)}
+                            ${_('`TODO` comment')}:
                         % else:
-                            ${(_('Note comment on line: {comment_line}') if comment_file else _('Note comment')).format(**data)}
+                            ${_('`Note` comment')}:
                         % endif
                     </td>
-                    <td style="line-height:1.2em;white-space:pre-wrap">${h.render(comment_body, renderer=renderer_type, mentions=True)}</td></tr>
+                </tr>
+                <td colspan="2" style="background: #F7F7F7">${h.render(comment_body, renderer=data['renderer_type'], mentions=True)}</td>
+                </tr>
             </table>

rhodecode/templates/email_templates/email_test.mako

0 +9 -2

             ## -*- coding: utf-8 -*-
             <%inherit file="base.mako"/>
+            <%namespace name="base" file="base.mako"/>
             <%def name="subject()" filter="n,trim,whitespace_filter">
             RhodeCode test email: ${h.format_date(date)}
             </%def>
             ## plain text version of the email. Empty by default
             <%def name="body_plaintext()" filter="n,trim">
-            Test Email from RhodeCode version: ${rhodecode_version}, sent by: ${user}
+            Test Email from RhodeCode version: ${rhodecode_version}
+            Email sent by: ${h.person(user)}
+            ---
+            ${self.plaintext_footer()}
             </%def>
-            ${body_plaintext()}
  No newline at end of file
+            Test Email from RhodeCode version: ${rhodecode_version}
+            <br/><br/>
+            Email sent by: <strong>${h.person(user)}</strong>

rhodecode/templates/email_templates/main.mako

0 +4 -4

             ## -*- coding: utf-8 -*-
             <%inherit file="base.mako"/>
             <%def name="subject()" filter="n,trim,whitespace_filter">
             </%def>
             ## plain text version of the email. Empty by default
             <%def name="body_plaintext()" filter="n,trim">
             ${body}
+            ---
             ${self.plaintext_footer()}
             </%def>
             ## BODY GOES BELOW
             <table style="text-align:left;vertical-align:top;">
-                <tr><td style="padding-right:20px;padding-top:15px;white-space:pre-wrap">${body}</td></tr>
+                <tr>
+                    <td style="padding-right:20px;padding-top:15px;white-space:pre-wrap">${body}</td>
+                </tr>
             </table>
-            <p><a style="margin-top:15px;margin-left:1%;font-family:sans-serif;font-weight:100;font-size:11px;display:block;color:#666666;text-decoration:none;" href="${instance_url}">
-                ${self.plaintext_footer()}
-            </a></p>
  No newline at end of file

rhodecode/templates/email_templates/password_reset.mako

0 +12 -8

             ## -*- coding: utf-8 -*-
             <%inherit file="base.mako"/>
+            <%namespace name="base" file="base.mako"/>
             <%def name="subject()" filter="n,trim,whitespace_filter">
             RhodeCode Password reset
             </%def>
             ## plain text version of the email. Empty by default
             <%def name="body_plaintext()" filter="n,trim">
-            Hi ${user.username},
+            Hello ${user.username},
-            There was a request to reset your password using the email address ${email} on ${h.format_date(date)}
+            On ${h.format_date(date)} there was a request to reset your password using the email address `${email}`
-            *If you didn't do this, please contact your RhodeCode administrator.*
+            *If you did not request a password reset, please contact your RhodeCode administrator at: ${first_admin_email}*
             You can continue, and generate new password by clicking following URL:
             ${password_reset_url}
             This link will be active for 10 minutes.
+            ---
             ${self.plaintext_footer()}
             </%def>
             ## BODY GOES BELOW
             <p>
             Hello ${user.username},
             </p><p>
-            There was a request to reset your password using the email address ${email} on ${h.format_date(date)}
+            On ${h.format_date(date)} there was a request to reset your password using the email address `${email}`
-            <br/>
+            <br/><br/>
-            <strong>If you did not request a password reset, please contact your RhodeCode administrator.</strong>
+            <strong>If you did not request a password reset, please contact your RhodeCode administrator at: ${first_admin_email}.</strong>
             </p><p>
-            <a href="${password_reset_url}">${_('Generate new password here')}.</a>
+            You can continue, and generate new password by clicking following URL:<br/><br/>
-            This link will be active for 10 minutes.
+            <a href="${password_reset_url}" style="${base.link_css()}">${password_reset_url}</a>
+            <br/><br/>This link will be active for 10 minutes.
             </p>

rhodecode/templates/email_templates/password_reset_confirmation.mako

0 +10 -8

             ## -*- coding: utf-8 -*-
             <%inherit file="base.mako"/>
+            <%namespace name="base" file="base.mako"/>
             <%def name="subject()" filter="n,trim,whitespace_filter">
             Your new RhodeCode password
             </%def>
             ## plain text version of the email. Empty by default
             <%def name="body_plaintext()" filter="n,trim">
-            Hi ${user.username},
+            Hello ${user.username},
-            Below is your new access password for RhodeCode.
+            Below is your new access password for RhodeCode requested via password reset link.
-            *If you didn't do this, please contact your RhodeCode administrator.*
+            *If you did not request a password reset, please contact your RhodeCode administrator at: ${first_admin_email}.*
-            password: ${new_password}
+            new password: ${new_password}
+            ---
             ${self.plaintext_footer()}
             </%def>
             ## BODY GOES BELOW
             <p>
             Hello ${user.username},
             </p><p>
-            Below is your new access password for RhodeCode.
+            Below is your new access password for RhodeCode requested via password reset link.
-            <br/>
+            <br/><br/>
-            <strong>If you didn't request a new password, please contact your RhodeCode administrator.</strong>
+            <strong>If you did not request a password reset, please contact your RhodeCode administrator at: ${first_admin_email}.</strong>
             </p>
-            <p>password: <pre>${new_password}</pre>
+            <p>new password: <code>${new_password}</code>

rhodecode/templates/email_templates/pull_request_comment.mako

0 +112 -35

@@ -1,114 +1,191 b''
1	## -- coding: utf-8 --	1	## -- coding: utf-8 --
2	<%inherit file="base.mako"/>	2	<%inherit file="base.mako"/>
3	<%namespace name="base" file="base.mako"/>	3	<%namespace name="base" file="base.mako"/>
4		4
5	## EMAIL SUBJECT	5	## EMAIL SUBJECT
6	<%def name="subject()" filter="n,trim,whitespace_filter">	6	<%def name="subject()" filter="n,trim,whitespace_filter">
7	<%	7	<%
8	data = {	8	data = {
9	'user': h.person(user),	9	'user': '@'+h.person(user),
10	'pr_title': pull_request.title,	10	'repo_name': repo_name,
11	'pr_id': pull_request.pull_request_id,
12	'status': status_change,	11	'status': status_change,
13	'comment_file': comment_file,	12	'comment_file': comment_file,
14	'comment_line': comment_line,	13	'comment_line': comment_line,
15	'comment_type': comment_type,	14	'comment_type': comment_type,
		15
		16	'pr_title': pull_request.title,
		17	'pr_id': pull_request.pull_request_id,
16	}	18	}
17	%>	19	%>
18		20
19	${(_('[mention]') if mention else '')} \
20		21
21	% if comment_file:	22	% if comment_file:
22	${_('{user} left a {comment_type} on file `{comment_file}` in pull request #{pr_id} "{pr_title}"').format(**data) \|n}	23	${(_('[mention]') if mention else '')} ${_('{user} left a {comment_type} on file `{comment_file}` in pull request !{pr_id}: "{pr_title}"').format(**data) \|n}
23	% else:	24	% else:
24	% if status_change:	25	% if status_change:
25	${_('[status: {status}] {user} left a {comment_type} on pull request #{pr_id} "{pr_title}"').format(**data) \|n}	26	${(_('[mention]') if mention else '')} ${_('[status: {status}] {user} left a {comment_type} on pull request !{pr_id}: "{pr_title}"').format(**data) \|n}
26	% else:	27	% else:
27	${_('{user} left a {comment_type} on pull request #{pr_id} "{pr_title}"').format(**data) \|n}	28	${(_('[mention]') if mention else '')} ${_('{user} left a {comment_type} on pull request !{pr_id}: "{pr_title}"').format(**data) \|n}
28	% endif	29	% endif
29	% endif	30	% endif
		31
30	</%def>	32	</%def>
31		33
32	## PLAINTEXT VERSION OF BODY	34	## PLAINTEXT VERSION OF BODY
33	<%def name="body_plaintext()" filter="n,trim">	35	<%def name="body_plaintext()" filter="n,trim">
34	<%	36	<%
35	data = {	37	data = {
36	'user': h.person(user),	38	'user': h.person(user),
37	'pr_title': pull_request.title,	39	'repo_name': repo_name,
38	'pr_id': pull_request.pull_request_id,
39	'status': status_change,	40	'status': status_change,
40	'comment_file': comment_file,	41	'comment_file': comment_file,
41	'comment_line': comment_line,	42	'comment_line': comment_line,
42	'comment_type': comment_type,	43	'comment_type': comment_type,
		44
		45	'pr_title': pull_request.title,
		46	'pr_id': pull_request.pull_request_id,
		47	'source_ref_type': pull_request.source_ref_parts.type,
		48	'source_ref_name': pull_request.source_ref_parts.name,
		49	'target_ref_type': pull_request.target_ref_parts.type,
		50	'target_ref_name': pull_request.target_ref_parts.name,
		51	'source_repo': pull_request_source_repo.repo_name,
		52	'target_repo': pull_request_target_repo.repo_name,
		53	'source_repo_url': pull_request_source_repo_url,
		54	'target_repo_url': pull_request_target_repo_url,
43	}	55	}
44	%>	56	%>
45	${self.subject()}	57
		58	${h.literal(_('Pull request !{pr_id}: `{pr_title}`').format(**data))}
		59
		60	* ${h.literal(_('Commit flow: {source_ref_type}:{source_ref_name} of {source_repo_url} into {target_ref_type}:{target_ref_name} of {target_repo_url}').format(**data))}
46		61
47	* ${_('Comment link')}: ${pr_comment_url}	62	* ${_('Comment link')}: ${pr_comment_url}
48		63
49	* ${_('Source repository')}: ${pr_source_repo_url}	64	%if status_change and not closing_pr:
		65	* ${_('{user} submitted pull request !{pr_id} status: {status}').format(**data)}
50		66
		67	%elif status_change and closing_pr:
		68	* ${_('{user} submitted pull request !{pr_id} status: {status} and closed').format(**data)}
		69
		70	%endif
51	%if comment_file:	71	%if comment_file:
52	* ${_('File: {comment_file} on line {comment_line}').format(~~comment_file=comment_file, comment_line=comment_line~~)}	72	* ${_('File: {comment_file} on line {comment_line}').format(**data)}
		73
53	%endif	74	%endif
		75	% if comment_type == 'todo':
		76	${_('`TODO` comment')}:
		77	% else:
		78	${_('`Note` comment')}:
		79	% endif
		80
		81	${comment_body \|n, trim}
54		82
55	---	83	---
56
57	%if status_change and not closing_pr:
58	${_('{user} submitted pull request #{pr_id} status: {status}').format(**data)}
59	%elif status_change and closing_pr:
60	${_('{user} submitted pull request #{pr_id} status: {status} and closed').format(**data)}
61	%endif
62
63	${comment_body \|n}
64
65	${self.plaintext_footer()}	84	${self.plaintext_footer()}
66	</%def>	85	</%def>
67		86
68		87
69	<%	88	<%
70	data = {	89	data = {
71	'user': h.person(user),	90	'user': h.person(user),
72	'pr_title': pull_request.title,
73	'pr_id': pull_request.pull_request_id,
74	'status': status_change,
75	'comment_file': comment_file,	91	'comment_file': comment_file,
76	'comment_line': comment_line,	92	'comment_line': comment_line,
77	'comment_type': comment_type,	93	'comment_type': comment_type,
		94	'renderer_type': renderer_type or 'plain',
		95
		96	'pr_title': pull_request.title,
		97	'pr_id': pull_request.pull_request_id,
		98	'status': status_change,
		99	'source_ref_type': pull_request.source_ref_parts.type,
		100	'source_ref_name': pull_request.source_ref_parts.name,
		101	'target_ref_type': pull_request.target_ref_parts.type,
		102	'target_ref_name': pull_request.target_ref_parts.name,
		103	'source_repo': pull_request_source_repo.repo_name,
		104	'target_repo': pull_request_target_repo.repo_name,
		105	'source_repo_url': h.link_to(pull_request_source_repo.repo_name, pull_request_source_repo_url),
		106	'target_repo_url': h.link_to(pull_request_target_repo.repo_name, pull_request_target_repo_url),
78	}	107	}
79	%>	108	%>
80	<table style="text-align:left;vertical-align:middle;">	109
81	<tr><td colspan="2" style="width:100%;padding-bottom:15px;border-bottom:1px solid #dbd9da;">	110	<table style="text-align:left;vertical-align:middle;width: 100%">
		111	<tr>
		112	<td style="width:100%;border-bottom:1px solid #dbd9da;">
82		113
		114	<h4 style="margin: 0">
		115	<div style="margin-bottom: 4px; color:#7E7F7F">
		116	@${h.person(user.username)}
		117	</div>
		118	${_('left a')}
		119	<a href="${pr_comment_url}" style="${base.link_css()}">
83	% if comment_file:	120	% if comment_file:
84	<h4><a href="${pr_comment_url}" style="color:#427cc9;text-decoration:none;cursor:pointer">${_('{user} left a {comment_type} on file `{comment_file}` in pull request #{pr_id} "{pr_title}"').format(**data) \|n}</a></h4>	121	${_('{comment_type} on file `{comment_file}` in pull request.').format(**data)}
85	% else:	122	% else:
86	<h4><a href="${pr_comment_url}" style="color:#427cc9;text-decoration:none;cursor:pointer">${_('{user} left a {comment_type} on pull request #{pr_id} "{pr_title}"').format(**data) \|n}</a></h4>	123	${_('{comment_type} on pull request.').format(**data) \|n}
87	% endif	124	% endif
		125	</a>
		126	<div style="margin-top: 10px"></div>
		127	${_('Pull request')} <code>!${data['pr_id']}: ${data['pr_title']}</code>
		128	</h4>
		129
		130	</td>
		131	</tr>
88		132
89	</td></tr>	133	</table>
90	<tr><td style="padding-right:20px;padding-top:15px;">${_('Source')}</td><td style="padding-top:15px;"><a style="color:#427cc9;text-decoration:none;cursor:pointer" href="${pr_source_repo_url}">${pr_source_repo.repo_name}</a></td></tr>	134
		135	<table style="text-align:left;vertical-align:middle;width: 100%">
		136
		137	## spacing def
		138	<tr>
		139	<td style="width: 130px"></td>
		140	<td></td>
		141	</tr>
91		142
92	% if status_change:	143	% if status_change:
93	<tr>	144	<tr>
94	<td style="padding-right:20px;">${_('Status')}</td>	145	<td style="padding-right:20px;">${_('Review Status')}:</td>
95	<td>	146	<td>
96	% if closing_pr:	147	% if closing_pr:
97	${_('Closed pull request with status')}: ${base.status_text(status_change, tag_type=status_change_type)}	148	${_('Closed pull request with status')}: ${base.status_text(status_change, tag_type=status_change_type)}
98	% else:	149	% else:
99	${_('Submitted review status')}: ${base.status_text(status_change, tag_type=status_change_type)}	150	${_('Submitted review status')}: ${base.status_text(status_change, tag_type=status_change_type)}
100	% endif	151	% endif
101	</td>	152	</td>
102	</tr>	153	</tr>
103	% endif	154	% endif
		155
104	<tr>	156	<tr>
105	<td style="padding-right:20px;">	157	<td style="padding-right:20px;line-height:20px;">${_('Commit Flow')}:</td>
		158	<td style="line-height:20px;">
		159	${base.tag_button('{}:{}'.format(data['source_ref_type'], pull_request.source_ref_parts.name))} ${_('of')} ${data['source_repo_url']}
		160	→
		161	${base.tag_button('{}:{}'.format(data['target_ref_type'], pull_request.target_ref_parts.name))} ${_('of')} ${data['target_repo_url']}
		162	</td>
		163	</tr>
		164	<tr>
		165	<td style="padding-right:20px;">${_('Pull request')}:</td>
		166	<td>
		167	<a href="${pull_request_url}" style="${base.link_css()}">
		168	!${pull_request.pull_request_id}
		169	</a>
		170	</td>
		171	</tr>
		172	% if comment_file:
		173	<tr>
		174	<td style="padding-right:20px;">${_('File')}:</td>
		175	<td><a href="${pr_comment_url}" style="${base.link_css()}">${_('`{comment_file}` on line {comment_line}').format(**data)}</a></td>
		176	</tr>
		177	% endif
		178
		179	<tr style="background-image: linear-gradient(to right, black 33%, rgba(255,255,255,0) 0%);background-position: bottom;background-size: 3px 1px;background-repeat: repeat-x;">
		180	<td colspan="2" style="padding-right:20px;">
106	% if comment_type == 'todo':	181	% if comment_type == 'todo':
107	${(_('TODO comment on line: {comment_line}') if comment_file else _('TODO comment')).format(**data)}	182	${_('`TODO` comment')}:
108	% else:	183	% else:
109	${(_('Note comment on line: {comment_line}') if comment_file else _('Note comment')).format(**data)}	184	${_('`Note` comment')}:
110	% endif	185	% endif
111	</td>	186	</td>
112	<td style="line-height:1.2em;white-space:pre-wrap">${h.render(comment_body, renderer=renderer_type, mentions=True)}</td>	187	</tr>
		188
		189	<td colspan="2" style="background: #F7F7F7">${h.render(comment_body, renderer=data['renderer_type'], mentions=True)}</td>
113	</tr>	190	</tr>
114	</table>	191	</table>

rhodecode/templates/email_templates/pull_request_review.mako

0 +79 -20

             ## -*- coding: utf-8 -*-
             <%inherit file="base.mako"/>
             <%namespace name="base" file="base.mako"/>
+            ## EMAIL SUBJECT
             <%def name="subject()" filter="n,trim,whitespace_filter">
             <%
             data = {
-                'user': h.person(user),
+                'user': '@'+h.person(user),
                 'pr_id': pull_request.pull_request_id,
                 'pr_title': pull_request.title,
             }
             %>
-            ${_('%(user)s wants you to review pull request #%(pr_id)s: "%(pr_title)s"') % data |n}
+            ${_('{user} requested a pull request review. !{pr_id}: "{pr_title}"').format(**data) |n}
             </%def>
+            ## PLAINTEXT VERSION OF BODY
             <%def name="body_plaintext()" filter="n,trim">
             <%
             data = {
                 'user': h.person(user),
                 'pr_id': pull_request.pull_request_id,
                 'pr_title': pull_request.title,
                 'source_ref_type': pull_request.source_ref_parts.type,
                 'source_ref_name': pull_request.source_ref_parts.name,
                 'target_ref_type': pull_request.target_ref_parts.type,
                 'target_ref_name': pull_request.target_ref_parts.name,
-                'repo_url': pull_request_source_repo_url
+                'repo_url': pull_request_source_repo_url,
+                'source_repo': pull_request_source_repo.repo_name,
+                'target_repo': pull_request_target_repo.repo_name,
+                'source_repo_url': pull_request_source_repo_url,
+                'target_repo_url': pull_request_target_repo_url,
             }
             %>
-            ${self.subject()}
+            ${h.literal(_('Pull request !{pr_id}: `{pr_title}`').format(**data))}
-            ${h.literal(_('Pull request from %(source_ref_type)s:%(source_ref_name)s of %(repo_url)s into %(target_ref_type)s:%(target_ref_name)s') % data)}
+            * ${h.literal(_('Commit flow: {source_ref_type}:{source_ref_name} of {source_repo_url} into {target_ref_type}:{target_ref_name} of {target_repo_url}').format(**data))}
+            * ${_('Pull Request link')}: ${pull_request_url}
-            * ${_('Link')}: ${pull_request_url}
             * ${_('Title')}: ${pull_request.title}
             * ${_('Description')}:
-            ${pull_request.description}
+            ${pull_request.description | trim}
             * ${_ungettext('Commit (%(num)s)', 'Commits (%(num)s)', len(pull_request_commits) ) % {'num': len(pull_request_commits)}}:
             % for commit_id, message in pull_request_commits:
                 - ${h.short_id(commit_id)}
                   ${h.chop_at_smart(message, '\n', suffix_if_chopped='...')}
             % endfor
+            ---
             ${self.plaintext_footer()}
             </%def>
             <%
             data = {
                 'user': h.person(user),
                 'pr_id': pull_request.pull_request_id,
                 'pr_title': pull_request.title,
                 'source_ref_type': pull_request.source_ref_parts.type,
                 'source_ref_name': pull_request.source_ref_parts.name,
                 'target_ref_type': pull_request.target_ref_parts.type,
                 'target_ref_name': pull_request.target_ref_parts.name,
                 'repo_url': pull_request_source_repo_url,
+                'source_repo': pull_request_source_repo.repo_name,
+                'target_repo': pull_request_target_repo.repo_name,
                 'source_repo_url': h.link_to(pull_request_source_repo.repo_name, pull_request_source_repo_url),
-                'target_repo_url': h.link_to(pull_request_target_repo.repo_name, pull_request_target_repo_url)
+                'target_repo_url': h.link_to(pull_request_target_repo.repo_name, pull_request_target_repo_url),
             }
             %>
-            <table style="text-align:left;vertical-align:middle;">
-                <tr><td colspan="2" style="width:100%;padding-bottom:15px;border-bottom:1px solid #dbd9da;"><h4><a href="${pull_request_url}" style="color:#427cc9;text-decoration:none;cursor:pointer">${_('%(user)s wants you to review pull request #%(pr_id)s: "%(pr_title)s".') % data }</a></h4></td></tr>
+            <table style="text-align:left;vertical-align:middle;width: 100%">
-                <tr><td style="padding-right:20px;padding-top:15px;">${_('Title')}</td><td style="padding-top:15px;">${pull_request.title}</td></tr>
+                <tr>
-                <tr><td style="padding-right:20px;">${_('Source')}</td><td>${base.tag_button(pull_request.source_ref_parts.name)} ${h.literal(_('%(source_ref_type)s of %(source_repo_url)s') % data)}</td></tr>
+                <td style="width:100%;border-bottom:1px solid #dbd9da;">
-                <tr><td style="padding-right:20px;">${_('Target')}</td><td>${base.tag_button(pull_request.target_ref_parts.name)} ${h.literal(_('%(target_ref_type)s of %(target_repo_url)s') % data)}</td></tr>
-                <tr><td style="padding-right:20px;">${_('Description')}</td><td style="white-space:pre-wrap">${pull_request.description}</td></tr>
+                    <h4 style="margin: 0">
-                <tr><td style="padding-right:20px;">${_ungettext('%(num)s Commit', '%(num)s Commits', len(pull_request_commits)) % {'num': len(pull_request_commits)}}</td>
+                        <div style="margin-bottom: 4px; color:#7E7F7F">
-                    <td><ol style="margin:0 0 0 1em;padding:0;text-align:left;">
+                            @${h.person(user.username)}
+                        </div>
+                        ${_('requested a')}
+                        <a href="${pull_request_url}" style="${base.link_css()}">
+                        ${_('pull request review.').format(**data) }
+                        </a>
+                        <div style="margin-top: 10px"></div>
+                        ${_('Pull request')} <code>!${data['pr_id']}: ${data['pr_title']}</code>
+                    </h4>
+                </td>
+                </tr>
+            </table>
+            <table style="text-align:left;vertical-align:middle;width: 100%">
+                ## spacing def
+                <tr>
+                    <td style="width: 130px"></td>
+                    <td></td>
+                </tr>
+                <tr>
+                    <td style="padding-right:20px;line-height:20px;">${_('Commit Flow')}:</td>
+                    <td style="line-height:20px;">
+                        ${base.tag_button('{}:{}'.format(data['source_ref_type'], pull_request.source_ref_parts.name))} ${_('of')} ${data['source_repo_url']}
+                        &rarr;
+                        ${base.tag_button('{}:{}'.format(data['target_ref_type'], pull_request.target_ref_parts.name))} ${_('of')}  ${data['target_repo_url']}
+                    </td>
+                </tr>
+                <tr>
+                    <td style="padding-right:20px;">${_('Pull request')}:</td>
+                    <td>
+                        <a href="${pull_request_url}" style="${base.link_css()}">
+                        !${pull_request.pull_request_id}
+                        </a>
+                    </td>
+                </tr>
+                <tr>
+                    <td style="padding-right:20px;">${_('Description')}:</td>
+                    <td style="white-space:pre-wrap"><code>${pull_request.description | trim}</code></td>
+                </tr>
+                <tr>
+                    <td style="padding-right:20px;">${_ungettext('Commit (%(num)s)', 'Commits (%(num)s)', len(pull_request_commits)) % {'num': len(pull_request_commits)}}:</td>
+                    <td></td>
+                </tr>
+                <tr>
+                    <td colspan="2">
+                        <ol style="margin:0 0 0 1em;padding:0;text-align:left;">
                             % for commit_id, message in pull_request_commits:
-                        <li style="margin:0 0 1em;"><pre style="margin:0 0 .5em">${h.short_id(commit_id)}</pre>
+                                <li style="margin:0 0 1em;">
+                                    <pre style="margin:0 0 .5em"><a href="${h.route_path('repo_commit', repo_name=pull_request_source_repo.repo_name, commit_id=commit_id)}" style="${base.link_css()}">${h.short_id(commit_id)}</a></pre>
                                     ${h.chop_at_smart(message, '\n', suffix_if_chopped='...')}
                                 </li>
                             % endfor
-                    </ol></td>
+                        </ol>
+                    </td>
                 </tr>
             </table>

rhodecode/templates/email_templates/test.mako

0 +5 -4

             ## -*- coding: utf-8 -*-
             <%inherit file="base.mako"/>
             <%def name="subject()" filter="n,trim,whitespace_filter">
             Test "Subject" ${_('hello "world"')|n}
             </%def>
             <%def name="headers()" filter="n,trim">
             X=Y
             </%def>
             ## plain text version of the email. Empty by default
             <%def name="body_plaintext()" filter="n,trim">
             Email Plaintext Body
             </%def>
             ## BODY GOES BELOW
-            <b>Email Body</b>
+            <strong>Email Body</strong>
+            <br/>
-            ${h.short_id('0' * 40)}
+            <br/>
-            ${_('Translation')}
  No newline at end of file
+            `h.short_id()`: ${h.short_id('0' * 40)}<br/>
+            ${_('Translation String')}<br/>

rhodecode/templates/email_templates/user_registration.mako

0 +40 -8

@@ -1,27 +1,59 b''
1	## -- coding: utf-8 --	1	## -- coding: utf-8 --
2	<%inherit file="base.mako"/>	2	<%inherit file="base.mako"/>
		3	<%namespace name="base" file="base.mako"/>
3		4
4	<%def name="subject()" filter="n,trim,whitespace_filter">	5	<%def name="subject()" filter="n,trim,whitespace_filter">
5	RhodeCode new user registration: ${user.username}	6	RhodeCode new user registration: ${user.username}
6	</%def>	7	</%def>
7		8
8	<%def name="body_plaintext()" filter="n,trim">	9	<%def name="body_plaintext()" filter="n,trim">
9		10
10	A new user `${user.username}` has registered on ${h.format_date(date)}	11	A new user `${user.username}` has registered on ${h.format_date(date)}
11		12
12	- Username: ${user.username}	13	- Username: ${user.username}
13	- Full Name: ${user.first_name} ${user.last_name}	14	- Full Name: ${user.first_name} ${user.last_name}
14	- Email: ${user.email}	15	- Email: ${user.email}
15	- Profile link: ${h.route_url('user_profile', username=user.username)}	16	- Profile link: ${h.route_url('user_profile', username=user.username)}
16		17
		18	---
17	${self.plaintext_footer()}	19	${self.plaintext_footer()}
18	</%def>	20	</%def>
19		21
20	## BODY GOES BELOW	22
21	<table style="text-align:left;vertical-align:middle;">	23	<table style="text-align:left;vertical-align:middle;width: 100%">
22	<tr><td colspan="2" style="width:100%;padding-bottom:15px;border-bottom:1px solid #dbd9da;"><h4><a href="${h.route_url('user_profile', username=user.username)}" style="color:#427cc9;text-decoration:none;cursor:pointer">${_('New user %(user)s has registered on %(date)s') % {'user': user.username, 'date': h.format_date(date)}}</a></h4></td></tr>	24	<tr>
23	<tr><td style="padding-right:20px;padding-top:20px;">${_('Username')}</td><td style="line-height:1;padding-top:20px;"><img style="margin-bottom:-5px;text-align:left;border:1px solid #dbd9da" src="${h.gravatar_url(user.email, 16)}" height="16" width="16"> ${user.username}</td></tr>	25	<td style="width:100%;border-bottom:1px solid #dbd9da;">
24	<tr><td style="padding-right:20px;">${_('Full Name')}</td><td>${user.first_name} ${user.last_name}</td></tr>	26	<h4 style="margin: 0">
25	<tr><td style="padding-right:20px;">${_('Email')}</td><td>${user.email}</td></tr>	27	<a href="${h.route_url('user_profile', username=user.username)}" style="${base.link_css()}">
26	<tr><td style="padding-right:20px;">${_('Profile')}</td><td><a href="${h.route_url('user_profile', username=user.username)}">${h.route_url('user_profile', username=user.username)}</a></td></tr>	28	${_('New user {user} has registered on {date}').format(user=user.username, date=h.format_date(date))}
27	</table> No newline at end of file	29	</a>
		30	</h4>
		31	</td>
		32	</tr>
		33	</table>
		34
		35	<table style="text-align:left;vertical-align:middle;width: 100%">
		36	## spacing def
		37	<tr>
		38	<td style="width: 130px"></td>
		39	<td></td>
		40	</tr>
		41	<tr>
		42	<td style="padding-right:20px;padding-top:20px;">${_('Username')}:</td>
		43	<td style="line-height:1;padding-top:20px;">${user.username}</td>
		44	</tr>
		45	<tr>
		46	<td style="padding-right:20px;">${_('Full Name')}:</td>
		47	<td>${user.first_name} ${user.last_name}</td>
		48	</tr>
		49	<tr>
		50	<td style="padding-right:20px;">${_('Email')}:</td>
		51	<td>${user.email}</td>
		52	</tr>
		53	<tr>
		54	<td style="padding-right:20px;">${_('Profile')}:</td>
		55	<td>
		56	<a href="${h.route_url('user_profile', username=user.username)}">${h.route_url('user_profile', username=user.username)}</a>
		57	</td>
		58	</tr>
		59	</table>

rhodecode/tests/lib/test_mako_emails.py

0 +20 -25

-            import collections
             # -*- 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
+            import collections
             from rhodecode.lib.partial_renderer import PyramidPartialRenderer
             from rhodecode.lib.utils2 import AttributeDict
+            from rhodecode.model.db import User
             from rhodecode.model.notification import EmailNotificationModel
             def test_get_template_obj(app, request_stub):
                 template = EmailNotificationModel().get_renderer(
                     EmailNotificationModel.TYPE_TEST, request_stub)
                 assert isinstance(template, PyramidPartialRenderer)
             def test_render_email(app, http_host_only_stub):
                 kwargs = {}
                 subject, headers, body, body_plaintext = EmailNotificationModel().render_email(
                     EmailNotificationModel.TYPE_TEST, **kwargs)
                 # subject
                 assert subject == 'Test "Subject" hello "world"'
                 # headers
                 assert headers == 'X=Y'
                 # body plaintext
                 assert body_plaintext == 'Email Plaintext Body'
                 # body
-                notification_footer = 'This is a notification from RhodeCode. http://%s/' \
+                notification_footer1 = 'This is a notification from RhodeCode.'
-                                      % http_host_only_stub
+                notification_footer2 = 'http://{}/'.format(http_host_only_stub)
-                assert notification_footer in body
+                assert notification_footer1 in body
+                assert notification_footer2 in body
                 assert 'Email Body' in body
             def test_render_pr_email(app, user_admin):
+                ref = collections.namedtuple(
-                ref = collections.namedtuple('Ref',
+                    'Ref', 'name, type')('fxies123', 'book')
-                    'name, type')(
-                    'fxies123', 'book'
                 pr = collections.namedtuple('PullRequest',
                     'pull_request_id, title, description, source_ref_parts, source_ref_name, target_ref_parts, target_ref_name')(
 , 'Example Pull Request', 'Desc of PR', ref, 'bookmark', ref, 'Branch')
-                source_repo = target_repo = collections.namedtuple('Repo',
+                source_repo = target_repo = collections.namedtuple(
-                    'type, repo_name')(
+                    'Repo', 'type, repo_name')('hg', 'pull_request_1')
-                    'hg', 'pull_request_1')
                 kwargs = {
-                    'user': '<marcin@rhodecode.com> Marcin Kuzminski',
+                    'user': User.get_first_super_admin(),
                     'pull_request': pr,
                     'pull_request_commits': [],
                     'pull_request_target_repo': target_repo,
                     'pull_request_target_repo_url': 'x',
                     'pull_request_source_repo': source_repo,
                     'pull_request_source_repo_url': 'x',
                     'pull_request_url': 'http://localhost/pr1',
                 }
                 subject, headers, body, body_plaintext = EmailNotificationModel().render_email(
                     EmailNotificationModel.TYPE_PULL_REQUEST, **kwargs)
                 # subject
-                assert subject == 'Marcin Kuzminski wants you to review pull request #200: "Example Pull Request"'
+                assert subject == '@test_admin (RhodeCode Admin) requested a pull request review. !200: "Example Pull Request"'
             @pytest.mark.parametrize('mention', [
                 True,
                 False
             ])
             @pytest.mark.parametrize('email_type', [
                 EmailNotificationModel.TYPE_COMMIT_COMMENT,
                 EmailNotificationModel.TYPE_PULL_REQUEST_COMMENT
             ])
             def test_render_comment_subject_no_newlines(app, mention, email_type):
-                ref = collections.namedtuple('Ref',
+                ref = collections.namedtuple(
-                    'name, type')(
+                    'Ref', 'name, type')('fxies123', 'book')
-                    'fxies123', 'book'
                 pr = collections.namedtuple('PullRequest',
                     'pull_request_id, title, description, source_ref_parts, source_ref_name, target_ref_parts, target_ref_name')(
 , 'Example Pull Request', 'Desc of PR', ref, 'bookmark', ref, 'Branch')
-                source_repo = target_repo = collections.namedtuple('Repo',
+                source_repo = target_repo = collections.namedtuple(
-                    'type, repo_name')(
+                    'Repo', 'type, repo_name')('hg', 'pull_request_1')
-                    'hg', 'pull_request_1')
                 kwargs = {
-                    'user': '<marcin@rhodecode.com> Marcin Kuzminski',
+                    'user': User.get_first_super_admin(),
                     'commit': AttributeDict(raw_id='a'*40, message='Commit message'),
                     'status_change': 'approved',
-                    'commit_target_repo': AttributeDict(),
+                    'commit_target_repo_url': 'http://foo.example.com/#comment1',
                     'repo_name': 'test-repo',
                     'comment_file': 'test-file.py',
                     'comment_line': 'n100',
                     'comment_type': 'note',
                     'commit_comment_url': 'http://comment-url',
                     'instance_url': 'http://rc-instance',
                     'comment_body': 'hello world',
                     'mention': mention,
                     'pr_comment_url': 'http://comment-url',
-                    'pr_source_repo': AttributeDict(repo_name='foobar'),
-                    'pr_source_repo_url': 'http://soirce-repo/url',
                     'pull_request': pr,
                     'pull_request_commits': [],
                     'pull_request_target_repo': target_repo,
                     'pull_request_target_repo_url': 'x',
                     'pull_request_source_repo': source_repo,
                     'pull_request_source_repo_url': 'x',
+                    'pull_request_url': 'http://code.rc.com/_pr/123'
                 }
                 subject, headers, body, body_plaintext = EmailNotificationModel().render_email(
                     email_type, **kwargs)
                 assert '\n' not in subject

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages