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 +25 -29

             # -*- 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]),
-                            repo_name=str(repo_name[0]),
+                                     pull_request_id=pull_request_id)
-                            pull_request_id=pull_request_id),
+                    response = self.app.post(url, params={'csrf_token': csrf_token}).follow()
-                        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,
-                                   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},
+                                  params={'update_commits': 'true', 'csrf_token': csrf_token},
-                        status=200)
+                                  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,
-                            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},
+                                  params={'update_commits': 'true', 'csrf_token': csrf_token},
-                        status=200)
+                                  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,
-                            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',
+                                             params={'update_commits': 'true',
-                                'csrf_token': csrf_token})
+                                                     '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/pull_request.py

0 +2 -2

             # -*- coding: utf-8 -*-
             # Copyright (C) 2012-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/
             """
             pull request model for RhodeCode
             """
             import json
             import logging
             import datetime
             import urllib
             import collections
             from pyramid import compat
             from pyramid.threadlocal import get_current_request
             from rhodecode import events
             from rhodecode.translation import lazy_ugettext
             from rhodecode.lib import helpers as h, hooks_utils, diffs
             from rhodecode.lib import audit_logger
             from rhodecode.lib.compat import OrderedDict
             from rhodecode.lib.hooks_daemon import prepare_callback_daemon
             from rhodecode.lib.markup_renderer import (
                 DEFAULT_COMMENTS_RENDERER, RstTemplateRenderer)
             from rhodecode.lib.utils2 import safe_unicode, safe_str, md5_safe
             from rhodecode.lib.vcs.backends.base import (
                 Reference, MergeResponse, MergeFailureReason, UpdateFailureReason)
             from rhodecode.lib.vcs.conf import settings as vcs_settings
             from rhodecode.lib.vcs.exceptions import (
                 CommitDoesNotExistError, EmptyRepositoryError)
             from rhodecode.model import BaseModel
             from rhodecode.model.changeset_status import ChangesetStatusModel
             from rhodecode.model.comment import CommentsModel
             from rhodecode.model.db import (
                 or_, PullRequest, PullRequestReviewers, ChangesetStatus,
                 PullRequestVersion, ChangesetComment, Repository, RepoReviewRule)
             from rhodecode.model.meta import Session
             from rhodecode.model.notification import NotificationModel, \
                 EmailNotificationModel
             from rhodecode.model.scm import ScmModel
             from rhodecode.model.settings import VcsSettingsModel
             log = logging.getLogger(__name__)
             # Data structure to hold the response data when updating commits during a pull
             # request update.
             UpdateResponse = collections.namedtuple('UpdateResponse', [
                 'executed', 'reason', 'new', 'old', 'changes',
                 'source_changed', 'target_changed'])
             class PullRequestModel(BaseModel):
                 cls = PullRequest
                 DIFF_CONTEXT = diffs.DEFAULT_CONTEXT
                 UPDATE_STATUS_MESSAGES = {
                     UpdateFailureReason.NONE: lazy_ugettext(
                         'Pull request update successful.'),
                     UpdateFailureReason.UNKNOWN: lazy_ugettext(
                         'Pull request update failed because of an unknown error.'),
                     UpdateFailureReason.NO_CHANGE: lazy_ugettext(
                         'No update needed because the source and target have not changed.'),
                     UpdateFailureReason.WRONG_REF_TYPE: lazy_ugettext(
                         'Pull request cannot be updated because the reference type is '
                         'not supported for an update. Only Branch, Tag or Bookmark is allowed.'),
                     UpdateFailureReason.MISSING_TARGET_REF: lazy_ugettext(
                         'This pull request cannot be updated because the target '
                         'reference is missing.'),
                     UpdateFailureReason.MISSING_SOURCE_REF: lazy_ugettext(
                         'This pull request cannot be updated because the source '
                         'reference is missing.'),
                 }
                 REF_TYPES = ['bookmark', 'book', 'tag', 'branch']
                 UPDATABLE_REF_TYPES = ['bookmark', 'book', 'branch']
                 def __get_pull_request(self, pull_request):
                     return self._get_instance((
                         PullRequest, PullRequestVersion), pull_request)
                 def _check_perms(self, perms, pull_request, user, api=False):
                     if not api:
                         return h.HasRepoPermissionAny(*perms)(
                             user=user, repo_name=pull_request.target_repo.repo_name)
                     else:
                         return h.HasRepoPermissionAnyApi(*perms)(
                             user=user, repo_name=pull_request.target_repo.repo_name)
                 def check_user_read(self, pull_request, user, api=False):
                     _perms = ('repository.admin', 'repository.write', 'repository.read',)
                     return self._check_perms(_perms, pull_request, user, api)
                 def check_user_merge(self, pull_request, user, api=False):
                     _perms = ('repository.admin', 'repository.write', 'hg.admin',)
                     return self._check_perms(_perms, pull_request, user, api)
                 def check_user_update(self, pull_request, user, api=False):
                     owner = user.user_id == pull_request.user_id
                     return self.check_user_merge(pull_request, user, api) or owner
                 def check_user_delete(self, pull_request, user):
                     owner = user.user_id == pull_request.user_id
                     _perms = ('repository.admin',)
                     return self._check_perms(_perms, pull_request, user) or owner
                 def check_user_change_status(self, pull_request, user, api=False):
                     reviewer = user.user_id in [x.user_id for x in
                                                 pull_request.reviewers]
                     return self.check_user_update(pull_request, user, api) or reviewer
                 def check_user_comment(self, pull_request, user):
                     owner = user.user_id == pull_request.user_id
                     return self.check_user_read(pull_request, user) or owner
                 def get(self, pull_request):
                     return self.__get_pull_request(pull_request)
                 def _prepare_get_all_query(self, repo_name, source=False, statuses=None,
                                            opened_by=None, order_by=None,
                                            order_dir='desc', only_created=False):
                     repo = None
                     if repo_name:
                         repo = self._get_repo(repo_name)
                     q = PullRequest.query()
                     # source or target
                     if repo and source:
                         q = q.filter(PullRequest.source_repo == repo)
                     elif repo:
                         q = q.filter(PullRequest.target_repo == repo)
                     # closed,opened
                     if statuses:
                         q = q.filter(PullRequest.status.in_(statuses))
                     # opened by filter
                     if opened_by:
                         q = q.filter(PullRequest.user_id.in_(opened_by))
                     # only get those that are in "created" state
                     if only_created:
                         q = q.filter(PullRequest.pull_request_state == PullRequest.STATE_CREATED)
                     if order_by:
                         order_map = {
                             'name_raw': PullRequest.pull_request_id,
                             'id': PullRequest.pull_request_id,
                             'title': PullRequest.title,
                             'updated_on_raw': PullRequest.updated_on,
                             'target_repo': PullRequest.target_repo_id
                         }
                         if order_dir == 'asc':
                             q = q.order_by(order_map[order_by].asc())
                         else:
                             q = q.order_by(order_map[order_by].desc())
                     return q
                 def count_all(self, repo_name, source=False, statuses=None,
                               opened_by=None):
                     """
                     Count the number of pull requests for a specific repository.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :returns: int number of pull requests
                     """
                     q = self._prepare_get_all_query(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by)
                     return q.count()
                 def get_all(self, repo_name, source=False, statuses=None, opened_by=None,
                             offset=0, length=None, order_by=None, order_dir='desc'):
                     """
                     Get all pull requests for a specific repository.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :param offset: pagination offset
                     :param length: length of returned list
                     :param order_by: order of the returned list
                     :param order_dir: 'asc' or 'desc' ordering direction
                     :returns: list of pull requests
                     """
                     q = self._prepare_get_all_query(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by,
                         order_by=order_by, order_dir=order_dir)
                     if length:
                         pull_requests = q.limit(length).offset(offset).all()
                     else:
                         pull_requests = q.all()
                     return pull_requests
                 def count_awaiting_review(self, repo_name, source=False, statuses=None,
                                           opened_by=None):
                     """
                     Count the number of pull requests for a specific repository that are
                     awaiting review.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :returns: int number of pull requests
                     """
                     pull_requests = self.get_awaiting_review(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by)
                     return len(pull_requests)
                 def get_awaiting_review(self, repo_name, source=False, statuses=None,
                                         opened_by=None, offset=0, length=None,
                                         order_by=None, order_dir='desc'):
                     """
                     Get all pull requests for a specific repository that are awaiting
                     review.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :param offset: pagination offset
                     :param length: length of returned list
                     :param order_by: order of the returned list
                     :param order_dir: 'asc' or 'desc' ordering direction
                     :returns: list of pull requests
                     """
                     pull_requests = self.get_all(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by,
                         order_by=order_by, order_dir=order_dir)
                     _filtered_pull_requests = []
                     for pr in pull_requests:
                         status = pr.calculated_review_status()
                         if status in [ChangesetStatus.STATUS_NOT_REVIEWED,
                                       ChangesetStatus.STATUS_UNDER_REVIEW]:
                             _filtered_pull_requests.append(pr)
                     if length:
                         return _filtered_pull_requests[offset:offset+length]
                     else:
                         return _filtered_pull_requests
                 def count_awaiting_my_review(self, repo_name, source=False, statuses=None,
                                              opened_by=None, user_id=None):
                     """
                     Count the number of pull requests for a specific repository that are
                     awaiting review from a specific user.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :param user_id: reviewer user of the pull request
                     :returns: int number of pull requests
                     """
                     pull_requests = self.get_awaiting_my_review(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by,
                         user_id=user_id)
                     return len(pull_requests)
                 def get_awaiting_my_review(self, repo_name, source=False, statuses=None,
                                            opened_by=None, user_id=None, offset=0,
                                            length=None, order_by=None, order_dir='desc'):
                     """
                     Get all pull requests for a specific repository that are awaiting
                     review from a specific user.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :param user_id: reviewer user of the pull request
                     :param offset: pagination offset
                     :param length: length of returned list
                     :param order_by: order of the returned list
                     :param order_dir: 'asc' or 'desc' ordering direction
                     :returns: list of pull requests
                     """
                     pull_requests = self.get_all(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by,
                         order_by=order_by, order_dir=order_dir)
                     _my = PullRequestModel().get_not_reviewed(user_id)
                     my_participation = []
                     for pr in pull_requests:
                         if pr in _my:
                             my_participation.append(pr)
                     _filtered_pull_requests = my_participation
                     if length:
                         return _filtered_pull_requests[offset:offset+length]
                     else:
                         return _filtered_pull_requests
                 def get_not_reviewed(self, user_id):
                     return [
                         x.pull_request for x in PullRequestReviewers.query().filter(
                             PullRequestReviewers.user_id == user_id).all()
                     ]
                 def _prepare_participating_query(self, user_id=None, statuses=None,
                                                  order_by=None, order_dir='desc'):
                     q = PullRequest.query()
                     if user_id:
                         reviewers_subquery = Session().query(
                             PullRequestReviewers.pull_request_id).filter(
                             PullRequestReviewers.user_id == user_id).subquery()
                         user_filter = or_(
                             PullRequest.user_id == user_id,
                             PullRequest.pull_request_id.in_(reviewers_subquery)
                         )
                         q = PullRequest.query().filter(user_filter)
                     # closed,opened
                     if statuses:
                         q = q.filter(PullRequest.status.in_(statuses))
                     if order_by:
                         order_map = {
                             'name_raw': PullRequest.pull_request_id,
                             'title': PullRequest.title,
                             'updated_on_raw': PullRequest.updated_on,
                             'target_repo': PullRequest.target_repo_id
                         }
                         if order_dir == 'asc':
                             q = q.order_by(order_map[order_by].asc())
                         else:
                             q = q.order_by(order_map[order_by].desc())
                     return q
                 def count_im_participating_in(self, user_id=None, statuses=None):
                     q = self._prepare_participating_query(user_id, statuses=statuses)
                     return q.count()
                 def get_im_participating_in(
                         self, user_id=None, statuses=None, offset=0,
                         length=None, order_by=None, order_dir='desc'):
                     """
                     Get all Pull requests that i'm participating in, or i have opened
                     """
                     q = self._prepare_participating_query(
                         user_id, statuses=statuses, order_by=order_by,
                         order_dir=order_dir)
                     if length:
                         pull_requests = q.limit(length).offset(offset).all()
                     else:
                         pull_requests = q.all()
                     return pull_requests
                 def get_versions(self, pull_request):
                     """
                     returns version of pull request sorted by ID descending
                     """
                     return PullRequestVersion.query()\
                         .filter(PullRequestVersion.pull_request == pull_request)\
                         .order_by(PullRequestVersion.pull_request_version_id.asc())\
                         .all()
                 def get_pr_version(self, pull_request_id, version=None):
                     at_version = None
                     if version and version == 'latest':
                         pull_request_ver = PullRequest.get(pull_request_id)
                         pull_request_obj = pull_request_ver
                         _org_pull_request_obj = pull_request_obj
                         at_version = 'latest'
                     elif version:
                         pull_request_ver = PullRequestVersion.get_or_404(version)
                         pull_request_obj = pull_request_ver
                         _org_pull_request_obj = pull_request_ver.pull_request
                         at_version = pull_request_ver.pull_request_version_id
                     else:
                         _org_pull_request_obj = pull_request_obj = PullRequest.get_or_404(
                             pull_request_id)
                     pull_request_display_obj = PullRequest.get_pr_display_object(
                         pull_request_obj, _org_pull_request_obj)
                     return _org_pull_request_obj, pull_request_obj, \
                            pull_request_display_obj, at_version
                 def create(self, created_by, source_repo, source_ref, target_repo,
                            target_ref, revisions, reviewers, title, description=None,
                            description_renderer=None,
                            reviewer_data=None, translator=None, auth_user=None):
                     translator = translator or get_current_request().translate
                     created_by_user = self._get_user(created_by)
                     auth_user = auth_user or created_by_user.AuthUser()
                     source_repo = self._get_repo(source_repo)
                     target_repo = self._get_repo(target_repo)
                     pull_request = PullRequest()
                     pull_request.source_repo = source_repo
                     pull_request.source_ref = source_ref
                     pull_request.target_repo = target_repo
                     pull_request.target_ref = target_ref
                     pull_request.revisions = revisions
                     pull_request.title = title
                     pull_request.description = description
                     pull_request.description_renderer = description_renderer
                     pull_request.author = created_by_user
                     pull_request.reviewer_data = reviewer_data
                     pull_request.pull_request_state = pull_request.STATE_CREATING
                     Session().add(pull_request)
                     Session().flush()
                     reviewer_ids = set()
                     # members / reviewers
                     for reviewer_object in reviewers:
                         user_id, reasons, mandatory, rules = reviewer_object
                         user = self._get_user(user_id)
                         # skip duplicates
                         if user.user_id in reviewer_ids:
                             continue
                         reviewer_ids.add(user.user_id)
                         reviewer = PullRequestReviewers()
                         reviewer.user = user
                         reviewer.pull_request = pull_request
                         reviewer.reasons = reasons
                         reviewer.mandatory = mandatory
                         # NOTE(marcink): pick only first rule for now
                         rule_id = list(rules)[0] if rules else None
                         rule = RepoReviewRule.get(rule_id) if rule_id else None
                         if rule:
                             review_group = rule.user_group_vote_rule(user_id)
                             # we check if this particular reviewer is member of a voting group
                             if review_group:
                                 # NOTE(marcink):
                                 # can be that user is member of more but we pick the first same,
                                 # same as default reviewers algo
                                 review_group = review_group[0]
                                 rule_data = {
                                     'rule_name':
                                         rule.review_rule_name,
                                     'rule_user_group_entry_id':
                                         review_group.repo_review_rule_users_group_id,
                                     'rule_user_group_name':
                                         review_group.users_group.users_group_name,
                                     'rule_user_group_members':
                                         [x.user.username for x in review_group.users_group.members],
                                     'rule_user_group_members_id':
                                         [x.user.user_id for x in review_group.users_group.members],
                                 }
                                 # e.g {'vote_rule': -1, 'mandatory': True}
                                 rule_data.update(review_group.rule_data())
                                 reviewer.rule_data = rule_data
                         Session().add(reviewer)
                         Session().flush()
                     # Set approval status to "Under Review" for all commits which are
                     # part of this pull request.
                     ChangesetStatusModel().set_status(
                         repo=target_repo,
                         status=ChangesetStatus.STATUS_UNDER_REVIEW,
                         user=created_by_user,
                         pull_request=pull_request
                     )
                     # we commit early at this point. This has to do with a fact
                     # that before queries do some row-locking. And because of that
                     # we need to commit and finish transaction before below validate call
                     # that for large repos could be long resulting in long row locks
                     Session().commit()
                     # prepare workspace, and run initial merge simulation. Set state during that
                     # operation
                     pull_request = PullRequest.get(pull_request.pull_request_id)
                     # set as merging, for merge simulation, and if finished to created so we mark
                     # simulation is working fine
                     with pull_request.set_state(PullRequest.STATE_MERGING,
                                                 final_state=PullRequest.STATE_CREATED) as state_obj:
                         MergeCheck.validate(
                             pull_request, auth_user=auth_user, translator=translator)
                     self.notify_reviewers(pull_request, reviewer_ids)
                     self.trigger_pull_request_hook(
                         pull_request, created_by_user, 'create')
                     creation_data = pull_request.get_api_data(with_merge_state=False)
                     self._log_audit_action(
                         'repo.pull_request.create', {'data': creation_data},
                         auth_user, pull_request)
                     return pull_request
                 def trigger_pull_request_hook(self, pull_request, user, action, data=None):
                     pull_request = self.__get_pull_request(pull_request)
                     target_scm = pull_request.target_repo.scm_instance()
                     if action == 'create':
                         trigger_hook = hooks_utils.trigger_log_create_pull_request_hook
                     elif action == 'merge':
                         trigger_hook = hooks_utils.trigger_log_merge_pull_request_hook
                     elif action == 'close':
                         trigger_hook = hooks_utils.trigger_log_close_pull_request_hook
                     elif action == 'review_status_change':
                         trigger_hook = hooks_utils.trigger_log_review_pull_request_hook
                     elif action == 'update':
                         trigger_hook = hooks_utils.trigger_log_update_pull_request_hook
                     elif action == 'comment':
                         # dummy hook ! for comment. We want this function to handle all cases
                         def trigger_hook(*args, **kwargs):
                             pass
                         comment = data['comment']
                         events.trigger(events.PullRequestCommentEvent(pull_request, comment))
                     else:
                         return
                     trigger_hook(
                         username=user.username,
                         repo_name=pull_request.target_repo.repo_name,
                         repo_alias=target_scm.alias,
                         pull_request=pull_request,
                         data=data)
                 def _get_commit_ids(self, pull_request):
                     """
                     Return the commit ids of the merged pull request.
                     This method is not dealing correctly yet with the lack of autoupdates
                     nor with the implicit target updates.
                     For example: if a commit in the source repo is already in the target it
                     will be reported anyways.
                     """
                     merge_rev = pull_request.merge_rev
                     if merge_rev is None:
                         raise ValueError('This pull request was not merged yet')
                     commit_ids = list(pull_request.revisions)
                     if merge_rev not in commit_ids:
                         commit_ids.append(merge_rev)
                     return commit_ids
                 def merge_repo(self, pull_request, user, extras):
                     log.debug("Merging pull request %s", pull_request.pull_request_id)
                     extras['user_agent'] = 'internal-merge'
                     merge_state = self._merge_pull_request(pull_request, user, extras)
                     if merge_state.executed:
                         log.debug("Merge was successful, updating the pull request comments.")
                         self._comment_and_close_pr(pull_request, user, merge_state)
                         self._log_audit_action(
                             'repo.pull_request.merge',
                             {'merge_state': merge_state.__dict__},
                             user, pull_request)
                     else:
                         log.warn("Merge failed, not updating the pull request.")
                     return merge_state
                 def _merge_pull_request(self, pull_request, user, extras, merge_msg=None):
                     target_vcs = pull_request.target_repo.scm_instance()
                     source_vcs = pull_request.source_repo.scm_instance()
                     message = safe_unicode(merge_msg or vcs_settings.MERGE_MESSAGE_TMPL).format(
                         pr_id=pull_request.pull_request_id,
                         pr_title=pull_request.title,
                         source_repo=source_vcs.name,
                         source_ref_name=pull_request.source_ref_parts.name,
                         target_repo=target_vcs.name,
                         target_ref_name=pull_request.target_ref_parts.name,
                     )
                     workspace_id = self._workspace_id(pull_request)
                     repo_id = pull_request.target_repo.repo_id
                     use_rebase = self._use_rebase_for_merging(pull_request)
                     close_branch = self._close_branch_before_merging(pull_request)
                     target_ref = self._refresh_reference(
                         pull_request.target_ref_parts, target_vcs)
                     callback_daemon, extras = prepare_callback_daemon(
                         extras, protocol=vcs_settings.HOOKS_PROTOCOL,
                         host=vcs_settings.HOOKS_HOST,
                         use_direct_calls=vcs_settings.HOOKS_DIRECT_CALLS)
                     with callback_daemon:
                         # TODO: johbo: Implement a clean way to run a config_override
                         # for a single call.
                         target_vcs.config.set(
                             'rhodecode', 'RC_SCM_DATA', json.dumps(extras))
                         user_name = user.short_contact
                         merge_state = target_vcs.merge(
                             repo_id, workspace_id, target_ref, source_vcs,
                             pull_request.source_ref_parts,
                             user_name=user_name, user_email=user.email,
                             message=message, use_rebase=use_rebase,
                             close_branch=close_branch)
                     return merge_state
                 def _comment_and_close_pr(self, pull_request, user, merge_state, close_msg=None):
                     pull_request.merge_rev = merge_state.merge_ref.commit_id
                     pull_request.updated_on = datetime.datetime.now()
                     close_msg = close_msg or 'Pull request merged and closed'
                     CommentsModel().create(
                         text=safe_unicode(close_msg),
                         repo=pull_request.target_repo.repo_id,
                         user=user.user_id,
                         pull_request=pull_request.pull_request_id,
                         f_path=None,
                         line_no=None,
                         closing_pr=True
                     )
                     Session().add(pull_request)
                     Session().flush()
                     # TODO: paris: replace invalidation with less radical solution
                     ScmModel().mark_for_invalidation(
                         pull_request.target_repo.repo_name)
                     self.trigger_pull_request_hook(pull_request, user, 'merge')
                 def has_valid_update_type(self, pull_request):
                     source_ref_type = pull_request.source_ref_parts.type
                     return source_ref_type in self.REF_TYPES
                 def update_commits(self, pull_request):
                     """
                     Get the updated list of commits for the pull request
                     and return the new pull request version and the list
                     of commits processed by this update action
                     """
                     pull_request = self.__get_pull_request(pull_request)
                     source_ref_type = pull_request.source_ref_parts.type
                     source_ref_name = pull_request.source_ref_parts.name
                     source_ref_id = pull_request.source_ref_parts.commit_id
                     target_ref_type = pull_request.target_ref_parts.type
                     target_ref_name = pull_request.target_ref_parts.name
                     target_ref_id = pull_request.target_ref_parts.commit_id
                     if not self.has_valid_update_type(pull_request):
                         log.debug("Skipping update of pull request %s due to ref type: %s",
                                   pull_request, source_ref_type)
                         return UpdateResponse(
                             executed=False,
                             reason=UpdateFailureReason.WRONG_REF_TYPE,
                             old=pull_request, new=None, changes=None,
                             source_changed=False, target_changed=False)
                     # source repo
                     source_repo = pull_request.source_repo.scm_instance()
                     try:
                         source_commit = source_repo.get_commit(commit_id=source_ref_name)
                     except CommitDoesNotExistError:
                         return UpdateResponse(
                             executed=False,
                             reason=UpdateFailureReason.MISSING_SOURCE_REF,
                             old=pull_request, new=None, changes=None,
                             source_changed=False, target_changed=False)
                     source_changed = source_ref_id != source_commit.raw_id
                     # target repo
                     target_repo = pull_request.target_repo.scm_instance()
                     try:
                         target_commit = target_repo.get_commit(commit_id=target_ref_name)
                     except CommitDoesNotExistError:
                         return UpdateResponse(
                             executed=False,
                             reason=UpdateFailureReason.MISSING_TARGET_REF,
                             old=pull_request, new=None, changes=None,
                             source_changed=False, target_changed=False)
                     target_changed = target_ref_id != target_commit.raw_id
                     if not (source_changed or target_changed):
                         log.debug("Nothing changed in pull request %s", pull_request)
                         return UpdateResponse(
                             executed=False,
                             reason=UpdateFailureReason.NO_CHANGE,
                             old=pull_request, new=None, changes=None,
                             source_changed=target_changed, target_changed=source_changed)
                     change_in_found = 'target repo' if target_changed else 'source repo'
                     log.debug('Updating pull request because of change in %s detected',
                               change_in_found)
                     # Finally there is a need for an update, in case of source change
                     # we create a new version, else just an update
                     if source_changed:
                         pull_request_version = self._create_version_from_snapshot(pull_request)
                         self._link_comments_to_version(pull_request_version)
                     else:
                         try:
                             ver = pull_request.versions[-1]
                         except IndexError:
                             ver = None
                         pull_request.pull_request_version_id = \
                             ver.pull_request_version_id if ver else None
                         pull_request_version = pull_request
                     try:
                         if target_ref_type in self.REF_TYPES:
                             target_commit = target_repo.get_commit(target_ref_name)
                         else:
                             target_commit = target_repo.get_commit(target_ref_id)
                     except CommitDoesNotExistError:
                         return UpdateResponse(
                             executed=False,
                             reason=UpdateFailureReason.MISSING_TARGET_REF,
                             old=pull_request, new=None, changes=None,
                             source_changed=source_changed, target_changed=target_changed)
                     # re-compute commit ids
                     old_commit_ids = pull_request.revisions
                     pre_load = ["author", "date", "message", "branch"]
                     commit_ranges = target_repo.compare(
                         target_commit.raw_id, source_commit.raw_id, source_repo, merge=True,
                         pre_load=pre_load)
                     ancestor = source_repo.get_common_ancestor(
                         source_commit.raw_id, target_commit.raw_id, target_repo)
                     pull_request.source_ref = '%s:%s:%s' % (
                         source_ref_type, source_ref_name, source_commit.raw_id)
                     pull_request.target_ref = '%s:%s:%s' % (
                         target_ref_type, target_ref_name, ancestor)
                     pull_request.revisions = [
                         commit.raw_id for commit in reversed(commit_ranges)]
                     pull_request.updated_on = datetime.datetime.now()
                     Session().add(pull_request)
                     new_commit_ids = pull_request.revisions
                     old_diff_data, new_diff_data = self._generate_update_diffs(
                         pull_request, pull_request_version)
                     # calculate commit and file changes
                     changes = self._calculate_commit_id_changes(
                         old_commit_ids, new_commit_ids)
                     file_changes = self._calculate_file_changes(
                         old_diff_data, new_diff_data)
                     # set comments as outdated if DIFFS changed
                     CommentsModel().outdate_comments(
                         pull_request, old_diff_data=old_diff_data,
                         new_diff_data=new_diff_data)
                     commit_changes = (changes.added or changes.removed)
                     file_node_changes = (
                         file_changes.added or file_changes.modified or file_changes.removed)
                     pr_has_changes = commit_changes or file_node_changes
                     # Add an automatic comment to the pull request, in case
                     # anything has changed
                     if pr_has_changes:
                         update_comment = CommentsModel().create(
                             text=self._render_update_message(changes, file_changes),
                             repo=pull_request.target_repo,
                             user=pull_request.author,
                             pull_request=pull_request,
                             send_email=False, renderer=DEFAULT_COMMENTS_RENDERER)
                         # Update status to "Under Review" for added commits
                         for commit_id in changes.added:
                             ChangesetStatusModel().set_status(
                                 repo=pull_request.source_repo,
                                 status=ChangesetStatus.STATUS_UNDER_REVIEW,
                                 comment=update_comment,
                                 user=pull_request.author,
                                 pull_request=pull_request,
                                 revision=commit_id)
                     log.debug(
                         'Updated pull request %s, added_ids: %s, common_ids: %s, '
                         'removed_ids: %s', pull_request.pull_request_id,
                         changes.added, changes.common, changes.removed)
                     log.debug(
                         'Updated pull request with the following file changes: %s',
                         file_changes)
                     log.info(
                         "Updated pull request %s from commit %s to commit %s, "
                         "stored new version %s of this pull request.",
                         pull_request.pull_request_id, source_ref_id,
                         pull_request.source_ref_parts.commit_id,
                         pull_request_version.pull_request_version_id)
                     Session().commit()
                     self.trigger_pull_request_hook(pull_request, pull_request.author, 'update')
                     return UpdateResponse(
                         executed=True, reason=UpdateFailureReason.NONE,
                         old=pull_request, new=pull_request_version, changes=changes,
                         source_changed=source_changed, target_changed=target_changed)
                 def _create_version_from_snapshot(self, pull_request):
                     version = PullRequestVersion()
                     version.title = pull_request.title
                     version.description = pull_request.description
                     version.status = pull_request.status
                     version.pull_request_state = pull_request.pull_request_state
                     version.created_on = datetime.datetime.now()
                     version.updated_on = pull_request.updated_on
                     version.user_id = pull_request.user_id
                     version.source_repo = pull_request.source_repo
                     version.source_ref = pull_request.source_ref
                     version.target_repo = pull_request.target_repo
                     version.target_ref = pull_request.target_ref
                     version._last_merge_source_rev = pull_request._last_merge_source_rev
                     version._last_merge_target_rev = pull_request._last_merge_target_rev
                     version.last_merge_status = pull_request.last_merge_status
                     version.shadow_merge_ref = pull_request.shadow_merge_ref
                     version.merge_rev = pull_request.merge_rev
                     version.reviewer_data = pull_request.reviewer_data
                     version.revisions = pull_request.revisions
                     version.pull_request = pull_request
                     Session().add(version)
                     Session().flush()
                     return version
                 def _generate_update_diffs(self, pull_request, pull_request_version):
                     diff_context = (
                         self.DIFF_CONTEXT +
                         CommentsModel.needed_extra_diff_context())
                     hide_whitespace_changes = False
                     source_repo = pull_request_version.source_repo
                     source_ref_id = pull_request_version.source_ref_parts.commit_id
                     target_ref_id = pull_request_version.target_ref_parts.commit_id
                     old_diff = self._get_diff_from_pr_or_version(
                         source_repo, source_ref_id, target_ref_id,
                         hide_whitespace_changes=hide_whitespace_changes, diff_context=diff_context)
                     source_repo = pull_request.source_repo
                     source_ref_id = pull_request.source_ref_parts.commit_id
                     target_ref_id = pull_request.target_ref_parts.commit_id
                     new_diff = self._get_diff_from_pr_or_version(
                         source_repo, source_ref_id, target_ref_id,
                         hide_whitespace_changes=hide_whitespace_changes, diff_context=diff_context)
                     old_diff_data = diffs.DiffProcessor(old_diff)
                     old_diff_data.prepare()
                     new_diff_data = diffs.DiffProcessor(new_diff)
                     new_diff_data.prepare()
                     return old_diff_data, new_diff_data
                 def _link_comments_to_version(self, pull_request_version):
                     """
                     Link all unlinked comments of this pull request to the given version.
                     :param pull_request_version: The `PullRequestVersion` to which
                         the comments shall be linked.
                     """
                     pull_request = pull_request_version.pull_request
                     comments = ChangesetComment.query()\
                         .filter(
                             # TODO: johbo: Should we query for the repo at all here?
                             # Pending decision on how comments of PRs are to be related
                             # to either the source repo, the target repo or no repo at all.
                             ChangesetComment.repo_id == pull_request.target_repo.repo_id,
                             ChangesetComment.pull_request == pull_request,
                             ChangesetComment.pull_request_version == None)\
                         .order_by(ChangesetComment.comment_id.asc())
                     # TODO: johbo: Find out why this breaks if it is done in a bulk
                     # operation.
                     for comment in comments:
                         comment.pull_request_version_id = (
                             pull_request_version.pull_request_version_id)
                         Session().add(comment)
                 def _calculate_commit_id_changes(self, old_ids, new_ids):
                     added = [x for x in new_ids if x not in old_ids]
                     common = [x for x in new_ids if x in old_ids]
                     removed = [x for x in old_ids if x not in new_ids]
                     total = new_ids
                     return ChangeTuple(added, common, removed, total)
                 def _calculate_file_changes(self, old_diff_data, new_diff_data):
                     old_files = OrderedDict()
                     for diff_data in old_diff_data.parsed_diff:
                         old_files[diff_data['filename']] = md5_safe(diff_data['raw_diff'])
                     added_files = []
                     modified_files = []
                     removed_files = []
                     for diff_data in new_diff_data.parsed_diff:
                         new_filename = diff_data['filename']
                         new_hash = md5_safe(diff_data['raw_diff'])
                         old_hash = old_files.get(new_filename)
                         if not old_hash:
                             # file is not present in old diff, means it's added
                             added_files.append(new_filename)
                         else:
                             if new_hash != old_hash:
                                 modified_files.append(new_filename)
                             # now remove a file from old, since we have seen it already
                             del old_files[new_filename]
                     # removed files is when there are present in old, but not in NEW,
                     # since we remove old files that are present in new diff, left-overs
                     # if any should be the removed files
                     removed_files.extend(old_files.keys())
                     return FileChangeTuple(added_files, modified_files, removed_files)
                 def _render_update_message(self, changes, file_changes):
                     """
                     render the message using DEFAULT_COMMENTS_RENDERER (RST renderer),
                     so it's always looking the same disregarding on which default
                     renderer system is using.
                     :param changes: changes named tuple
                     :param file_changes: file changes named tuple
                     """
                     new_status = ChangesetStatus.get_status_lbl(
                         ChangesetStatus.STATUS_UNDER_REVIEW)
                     changed_files = (
                         file_changes.added + file_changes.modified + file_changes.removed)
                     params = {
                         'under_review_label': new_status,
                         'added_commits': changes.added,
                         'removed_commits': changes.removed,
                         'changed_files': changed_files,
                         'added_files': file_changes.added,
                         'modified_files': file_changes.modified,
                         'removed_files': file_changes.removed,
                     }
                     renderer = RstTemplateRenderer()
                     return renderer.render('pull_request_update.mako', **params)
                 def edit(self, pull_request, title, description, description_renderer, user):
                     pull_request = self.__get_pull_request(pull_request)
                     old_data = pull_request.get_api_data(with_merge_state=False)
                     if pull_request.is_closed():
                         raise ValueError('This pull request is closed')
                     if title:
                         pull_request.title = title
                     pull_request.description = description
                     pull_request.updated_on = datetime.datetime.now()
                     pull_request.description_renderer = description_renderer
                     Session().add(pull_request)
                     self._log_audit_action(
                         'repo.pull_request.edit', {'old_data': old_data},
                         user, pull_request)
                 def update_reviewers(self, pull_request, reviewer_data, user):
                     """
                     Update the reviewers in the pull request
                     :param pull_request: the pr to update
                     :param reviewer_data: list of tuples
                         [(user, ['reason1', 'reason2'], mandatory_flag, [rules])]
                     """
                     pull_request = self.__get_pull_request(pull_request)
                     if pull_request.is_closed():
                         raise ValueError('This pull request is closed')
                     reviewers = {}
                     for user_id, reasons, mandatory, rules in reviewer_data:
                         if isinstance(user_id, (int, compat.string_types)):
                             user_id = self._get_user(user_id).user_id
                         reviewers[user_id] = {
                             'reasons': reasons, 'mandatory': mandatory}
                     reviewers_ids = set(reviewers.keys())
                     current_reviewers = PullRequestReviewers.query()\
                         .filter(PullRequestReviewers.pull_request ==
                                 pull_request).all()
                     current_reviewers_ids = set([x.user.user_id for x in current_reviewers])
                     ids_to_add = reviewers_ids.difference(current_reviewers_ids)
                     ids_to_remove = current_reviewers_ids.difference(reviewers_ids)
                     log.debug("Adding %s reviewers", ids_to_add)
                     log.debug("Removing %s reviewers", ids_to_remove)
                     changed = False
                     added_audit_reviewers = []
                     removed_audit_reviewers = []
                     for uid in ids_to_add:
                         changed = True
                         _usr = self._get_user(uid)
                         reviewer = PullRequestReviewers()
                         reviewer.user = _usr
                         reviewer.pull_request = pull_request
                         reviewer.reasons = reviewers[uid]['reasons']
                         # NOTE(marcink): mandatory shouldn't be changed now
                         # reviewer.mandatory = reviewers[uid]['reasons']
                         Session().add(reviewer)
                         added_audit_reviewers.append(reviewer.get_dict())
                     for uid in ids_to_remove:
                         changed = True
                         # NOTE(marcink): we fetch "ALL" reviewers using .all(). This is an edge case
                         # that prevents and fixes cases that we added the same reviewer twice.
                         # this CAN happen due to the lack of DB checks
                         reviewers = PullRequestReviewers.query()\
                             .filter(PullRequestReviewers.user_id == uid,
                                     PullRequestReviewers.pull_request == pull_request)\
                             .all()
                         for obj in reviewers:
                             added_audit_reviewers.append(obj.get_dict())
                             Session().delete(obj)
                     if changed:
                         Session().expire_all()
                         pull_request.updated_on = datetime.datetime.now()
                         Session().add(pull_request)
                     # finally store audit logs
                     for user_data in added_audit_reviewers:
                         self._log_audit_action(
                             'repo.pull_request.reviewer.add', {'data': user_data},
                             user, pull_request)
                     for user_data in removed_audit_reviewers:
                         self._log_audit_action(
                             'repo.pull_request.reviewer.delete', {'old_data': user_data},
                             user, pull_request)
                     self.notify_reviewers(pull_request, ids_to_add)
                     return ids_to_add, ids_to_remove
                 def get_url(self, pull_request, request=None, permalink=False):
                     if not request:
                         request = get_current_request()
                     if permalink:
                         return request.route_url(
                             'pull_requests_global',
                             pull_request_id=pull_request.pull_request_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,)
                 def get_shadow_clone_url(self, pull_request, request=None):
                     """
                     Returns qualified url pointing to the shadow repository. If this pull
                     request is closed there is no shadow repository and ``None`` will be
                     returned.
                     """
                     if pull_request.is_closed():
                         return None
                     else:
                         pr_url = urllib.unquote(self.get_url(pull_request, request=request))
                         return safe_unicode('{pr_url}/repository'.format(pr_url=pr_url))
                 def notify_reviewers(self, pull_request, reviewers_ids):
                     # notification to reviewers
                     if not reviewers_ids:
                         return
                     log.debug('Notify following reviewers about pull-request %s', reviewers_ids)
                     pull_request_obj = pull_request
                     # get the current participants of this pull request
                     recipients = reviewers_ids
                     notification_type = EmailNotificationModel.TYPE_PULL_REQUEST
                     pr_source_repo = pull_request_obj.source_repo
                     pr_target_repo = pull_request_obj.target_repo
                     pr_url = h.route_url('pullrequest_show',
-                        repo_name=pr_target_repo.repo_name,
+                                         repo_name=pr_target_repo.repo_name,
-                        pull_request_id=pull_request_obj.pull_request_id,)
+                                         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
                     pull_request_commits = [
                         (x.raw_id, x.message)
                         for x in map(pr_source_repo.get_commit, pull_request.revisions)]
                     kwargs = {
                         'user': pull_request.author,
                         'pull_request': pull_request_obj,
                         'pull_request_commits': pull_request_commits,
                         'pull_request_target_repo': pr_target_repo,
                         'pull_request_target_repo_url': pr_target_repo_url,
                         'pull_request_source_repo': pr_source_repo,
                         'pull_request_source_repo_url': pr_source_repo_url,
                         'pull_request_url': pr_url,
                     }
                     # 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=pull_request.author,
                         notification_subject=subject,
                         notification_body=body_plaintext,
                         notification_type=notification_type,
                         recipients=recipients,
                         email_kwargs=kwargs,
                     )
                 def delete(self, pull_request, user):
                     pull_request = self.__get_pull_request(pull_request)
                     old_data = pull_request.get_api_data(with_merge_state=False)
                     self._cleanup_merge_workspace(pull_request)
                     self._log_audit_action(
                         'repo.pull_request.delete', {'old_data': old_data},
                         user, pull_request)
                     Session().delete(pull_request)
                 def close_pull_request(self, pull_request, user):
                     pull_request = self.__get_pull_request(pull_request)
                     self._cleanup_merge_workspace(pull_request)
                     pull_request.status = PullRequest.STATUS_CLOSED
                     pull_request.updated_on = datetime.datetime.now()
                     Session().add(pull_request)
                     self.trigger_pull_request_hook(
                         pull_request, pull_request.author, 'close')
                     pr_data = pull_request.get_api_data(with_merge_state=False)
                     self._log_audit_action(
                         'repo.pull_request.close', {'data': pr_data}, user, pull_request)
                 def close_pull_request_with_comment(
                         self, pull_request, user, repo, message=None, auth_user=None):
                     pull_request_review_status = pull_request.calculated_review_status()
                     if pull_request_review_status == ChangesetStatus.STATUS_APPROVED:
                         # approved only if we have voting consent
                         status = ChangesetStatus.STATUS_APPROVED
                     else:
                         status = ChangesetStatus.STATUS_REJECTED
                     status_lbl = ChangesetStatus.get_status_lbl(status)
                     default_message = (
                         'Closing with status change {transition_icon} {status}.'
                     ).format(transition_icon='>', status=status_lbl)
                     text = message or default_message
                     # create a comment, and link it to new status
                     comment = CommentsModel().create(
                         text=text,
                         repo=repo.repo_id,
                         user=user.user_id,
                         pull_request=pull_request.pull_request_id,
                         status_change=status_lbl,
                         status_change_type=status,
                         closing_pr=True,
                         auth_user=auth_user,
                     )
                     # calculate old status before we change it
                     old_calculated_status = pull_request.calculated_review_status()
                     ChangesetStatusModel().set_status(
                         repo.repo_id,
                         status,
                         user.user_id,
                         comment=comment,
                         pull_request=pull_request.pull_request_id
                     )
                     Session().flush()
                     events.trigger(events.PullRequestCommentEvent(pull_request, comment))
                     # we now calculate the status of pull request again, and based on that
                     # calculation trigger status change. This might happen in cases
                     # that non-reviewer admin closes a pr, which means his vote doesn't
                     # change the status, while if he's a reviewer this might change it.
                     calculated_status = pull_request.calculated_review_status()
                     if old_calculated_status != calculated_status:
                         self.trigger_pull_request_hook(
                             pull_request, user, 'review_status_change',
                             data={'status': calculated_status})
                     # finally close the PR
                     PullRequestModel().close_pull_request(
                         pull_request.pull_request_id, user)
                     return comment, status
                 def merge_status(self, pull_request, translator=None,
                                  force_shadow_repo_refresh=False):
                     _ = translator or get_current_request().translate
                     if not self._is_merge_enabled(pull_request):
                         return False, _('Server-side pull request merging is disabled.')
                     if pull_request.is_closed():
                         return False, _('This pull request is closed.')
                     merge_possible, msg = self._check_repo_requirements(
                         target=pull_request.target_repo, source=pull_request.source_repo,
                         translator=_)
                     if not merge_possible:
                         return merge_possible, msg
                     try:
                         resp = self._try_merge(
                             pull_request,
                             force_shadow_repo_refresh=force_shadow_repo_refresh)
                         log.debug("Merge response: %s", resp)
                         status = resp.possible, resp.merge_status_message
                     except NotImplementedError:
                         status = False, _('Pull request merging is not supported.')
                     return status
                 def _check_repo_requirements(self, target, source, translator):
                     """
                     Check if `target` and `source` have compatible requirements.
                     Currently this is just checking for largefiles.
                     """
                     _ = translator
                     target_has_largefiles = self._has_largefiles(target)
                     source_has_largefiles = self._has_largefiles(source)
                     merge_possible = True
                     message = u''
                     if target_has_largefiles != source_has_largefiles:
                         merge_possible = False
                         if source_has_largefiles:
                             message = _(
                                 'Target repository large files support is disabled.')
                         else:
                             message = _(
                                 'Source repository large files support is disabled.')
                     return merge_possible, message
                 def _has_largefiles(self, repo):
                     largefiles_ui = VcsSettingsModel(repo=repo).get_ui_settings(
                         'extensions', 'largefiles')
                     return largefiles_ui and largefiles_ui[0].active
                 def _try_merge(self, pull_request, force_shadow_repo_refresh=False):
                     """
                     Try to merge the pull request and return the merge status.
                     """
                     log.debug(
                         "Trying out if the pull request %s can be merged. Force_refresh=%s",
                         pull_request.pull_request_id, force_shadow_repo_refresh)
                     target_vcs = pull_request.target_repo.scm_instance()
                     # Refresh the target reference.
                     try:
                         target_ref = self._refresh_reference(
                             pull_request.target_ref_parts, target_vcs)
                     except CommitDoesNotExistError:
                         merge_state = MergeResponse(
                             False, False, None, MergeFailureReason.MISSING_TARGET_REF,
                             metadata={'target_ref': pull_request.target_ref_parts})
                         return merge_state
                     target_locked = pull_request.target_repo.locked
                     if target_locked and target_locked[0]:
                         locked_by = 'user:{}'.format(target_locked[0])
                         log.debug("The target repository is locked by %s.", locked_by)
                         merge_state = MergeResponse(
                             False, False, None, MergeFailureReason.TARGET_IS_LOCKED,
                             metadata={'locked_by': locked_by})
                     elif force_shadow_repo_refresh or self._needs_merge_state_refresh(
                             pull_request, target_ref):
                         log.debug("Refreshing the merge status of the repository.")
                         merge_state = self._refresh_merge_state(
                             pull_request, target_vcs, target_ref)
                     else:
                         possible = pull_request.last_merge_status == MergeFailureReason.NONE
                         metadata = {
                             'target_ref': pull_request.target_ref_parts,
                             'source_ref': pull_request.source_ref_parts,
                         }
                         if not possible and target_ref.type == 'branch':
                             # NOTE(marcink): case for mercurial multiple heads on branch
                             heads = target_vcs._heads(target_ref.name)
                             if len(heads) != 1:
                                 heads = '\n,'.join(target_vcs._heads(target_ref.name))
                                 metadata.update({
                                     'heads': heads
                                 })
                         merge_state = MergeResponse(
                             possible, False, None, pull_request.last_merge_status, metadata=metadata)
                     return merge_state
                 def _refresh_reference(self, reference, vcs_repository):
                     if reference.type in self.UPDATABLE_REF_TYPES:
                         name_or_id = reference.name
                     else:
                         name_or_id = reference.commit_id
                     refreshed_commit = vcs_repository.get_commit(name_or_id)
                     refreshed_reference = Reference(
                         reference.type, reference.name, refreshed_commit.raw_id)
                     return refreshed_reference
                 def _needs_merge_state_refresh(self, pull_request, target_reference):
                     return not(
                         pull_request.revisions and
                         pull_request.revisions[0] == pull_request._last_merge_source_rev and
                         target_reference.commit_id == pull_request._last_merge_target_rev)
                 def _refresh_merge_state(self, pull_request, target_vcs, target_reference):
                     workspace_id = self._workspace_id(pull_request)
                     source_vcs = pull_request.source_repo.scm_instance()
                     repo_id = pull_request.target_repo.repo_id
                     use_rebase = self._use_rebase_for_merging(pull_request)
                     close_branch = self._close_branch_before_merging(pull_request)
                     merge_state = target_vcs.merge(
                         repo_id, workspace_id,
                         target_reference, source_vcs, pull_request.source_ref_parts,
                         dry_run=True, use_rebase=use_rebase,
                         close_branch=close_branch)
                     # Do not store the response if there was an unknown error.
                     if merge_state.failure_reason != MergeFailureReason.UNKNOWN:
                         pull_request._last_merge_source_rev = \
                             pull_request.source_ref_parts.commit_id
                         pull_request._last_merge_target_rev = target_reference.commit_id
                         pull_request.last_merge_status = merge_state.failure_reason
                         pull_request.shadow_merge_ref = merge_state.merge_ref
                         Session().add(pull_request)
                         Session().commit()
                     return merge_state
                 def _workspace_id(self, pull_request):
                     workspace_id = 'pr-%s' % pull_request.pull_request_id
                     return workspace_id
                 def generate_repo_data(self, repo, commit_id=None, branch=None,
                                        bookmark=None, translator=None):
                     from rhodecode.model.repo import RepoModel
                     all_refs, selected_ref = \
                         self._get_repo_pullrequest_sources(
                             repo.scm_instance(), commit_id=commit_id,
                             branch=branch, bookmark=bookmark, translator=translator)
                     refs_select2 = []
                     for element in all_refs:
                         children = [{'id': x[0], 'text': x[1]} for x in element[0]]
                         refs_select2.append({'text': element[1], 'children': children})
                     return {
                         'user': {
                             'user_id': repo.user.user_id,
                             'username': repo.user.username,
                             'firstname': repo.user.first_name,
                             'lastname': repo.user.last_name,
                             'gravatar_link': h.gravatar_url(repo.user.email, 14),
                         },
                         'name': repo.repo_name,
                         'link': RepoModel().get_url(repo),
                         'description': h.chop_at_smart(repo.description_safe, '\n'),
                         'refs': {
                             'all_refs': all_refs,
                             'selected_ref': selected_ref,
                             'select2_refs': refs_select2
                         }
                     }
                 def generate_pullrequest_title(self, source, source_ref, target):
                     return u'{source}#{at_ref} to {target}'.format(
                         source=source,
                         at_ref=source_ref,
                         target=target,
                     )
                 def _cleanup_merge_workspace(self, pull_request):
                     # Merging related cleanup
                     repo_id = pull_request.target_repo.repo_id
                     target_scm = pull_request.target_repo.scm_instance()
                     workspace_id = self._workspace_id(pull_request)
                     try:
                         target_scm.cleanup_merge_workspace(repo_id, workspace_id)
                     except NotImplementedError:
                         pass
                 def _get_repo_pullrequest_sources(
                         self, repo, commit_id=None, branch=None, bookmark=None,
                         translator=None):
                     """
                     Return a structure with repo's interesting commits, suitable for
                     the selectors in pullrequest controller
                     :param commit_id: a commit that must be in the list somehow
                         and selected by default
                     :param branch: a branch that must be in the list and selected
                         by default - even if closed
                     :param bookmark: a bookmark that must be in the list and selected
                     """
                     _ = translator or get_current_request().translate
                     commit_id = safe_str(commit_id) if commit_id else None
                     branch = safe_unicode(branch) if branch else None
                     bookmark = safe_unicode(bookmark) if bookmark else None
                     selected = None
                     # order matters: first source that has commit_id in it will be selected
                     sources = []
                     sources.append(('book', repo.bookmarks.items(), _('Bookmarks'), bookmark))
                     sources.append(('branch', repo.branches.items(), _('Branches'), branch))
                     if commit_id:
                         ref_commit = (h.short_id(commit_id), commit_id)
                         sources.append(('rev', [ref_commit], _('Commit IDs'), commit_id))
                     sources.append(
                         ('branch', repo.branches_closed.items(), _('Closed Branches'), branch),
                     )
                     groups = []
                     for group_key, ref_list, group_name, match in sources:
                         group_refs = []
                         for ref_name, ref_id in ref_list:
                             ref_key = u'{}:{}:{}'.format(group_key, ref_name, ref_id)
                             group_refs.append((ref_key, ref_name))
                             if not selected:
                                 if set([commit_id, match]) & set([ref_id, ref_name]):
                                     selected = ref_key
                         if group_refs:
                             groups.append((group_refs, group_name))
                     if not selected:
                         ref = commit_id or branch or bookmark
                         if ref:
                             raise CommitDoesNotExistError(
                                 u'No commit refs could be found matching: {}'.format(ref))
                         elif repo.DEFAULT_BRANCH_NAME in repo.branches:
                             selected = u'branch:{}:{}'.format(
                                 safe_unicode(repo.DEFAULT_BRANCH_NAME),
                                 safe_unicode(repo.branches[repo.DEFAULT_BRANCH_NAME])
                             )
                         elif repo.commit_ids:
                             # make the user select in this case
                             selected = None
                         else:
                             raise EmptyRepositoryError()
                     return groups, selected
                 def get_diff(self, source_repo, source_ref_id, target_ref_id,
                              hide_whitespace_changes, diff_context):
                     return self._get_diff_from_pr_or_version(
                         source_repo, source_ref_id, target_ref_id,
                         hide_whitespace_changes=hide_whitespace_changes, diff_context=diff_context)
                 def _get_diff_from_pr_or_version(
                         self, source_repo, source_ref_id, target_ref_id,
                         hide_whitespace_changes, diff_context):
                     target_commit = source_repo.get_commit(
                         commit_id=safe_str(target_ref_id))
                     source_commit = source_repo.get_commit(
                         commit_id=safe_str(source_ref_id))
                     if isinstance(source_repo, Repository):
                         vcs_repo = source_repo.scm_instance()
                     else:
                         vcs_repo = source_repo
                     # TODO: johbo: In the context of an update, we cannot reach
                     # the old commit anymore with our normal mechanisms. It needs
                     # some sort of special support in the vcs layer to avoid this
                     # workaround.
                     if (source_commit.raw_id == vcs_repo.EMPTY_COMMIT_ID and
                             vcs_repo.alias == 'git'):
                         source_commit.raw_id = safe_str(source_ref_id)
                     log.debug('calculating diff between '
                               'source_ref:%s and target_ref:%s for repo `%s`',
                               target_ref_id, source_ref_id,
                               safe_unicode(vcs_repo.path))
                     vcs_diff = vcs_repo.get_diff(
                         commit1=target_commit, commit2=source_commit,
                         ignore_whitespace=hide_whitespace_changes, context=diff_context)
                     return vcs_diff
                 def _is_merge_enabled(self, pull_request):
                     return self._get_general_setting(
                         pull_request, 'rhodecode_pr_merge_enabled')
                 def _use_rebase_for_merging(self, pull_request):
                     repo_type = pull_request.target_repo.repo_type
                     if repo_type == 'hg':
                         return self._get_general_setting(
                             pull_request, 'rhodecode_hg_use_rebase_for_merging')
                     elif repo_type == 'git':
                         return self._get_general_setting(
                             pull_request, 'rhodecode_git_use_rebase_for_merging')
                     return False
                 def _close_branch_before_merging(self, pull_request):
                     repo_type = pull_request.target_repo.repo_type
                     if repo_type == 'hg':
                         return self._get_general_setting(
                             pull_request, 'rhodecode_hg_close_branch_before_merging')
                     elif repo_type == 'git':
                         return self._get_general_setting(
                             pull_request, 'rhodecode_git_close_branch_before_merging')
                     return False
                 def _get_general_setting(self, pull_request, settings_key, default=False):
                     settings_model = VcsSettingsModel(repo=pull_request.target_repo)
                     settings = settings_model.get_general_settings()
                     return settings.get(settings_key, default)
                 def _log_audit_action(self, action, action_data, user, pull_request):
                     audit_logger.store(
                         action=action,
                         action_data=action_data,
                         user=user,
                         repo=pull_request.target_repo)
                 def get_reviewer_functions(self):
                     """
                     Fetches functions for validation and fetching default reviewers.
                     If available we use the EE package, else we fallback to CE
                     package functions
                     """
                     try:
                         from rc_reviewers.utils import get_default_reviewers_data
                         from rc_reviewers.utils import validate_default_reviewers
                     except ImportError:
                         from rhodecode.apps.repository.utils import get_default_reviewers_data
                         from rhodecode.apps.repository.utils import validate_default_reviewers
                     return get_default_reviewers_data, validate_default_reviewers
             class MergeCheck(object):
                 """
                 Perform Merge Checks and returns a check object which stores information
                 about merge errors, and merge conditions
                 """
                 TODO_CHECK = 'todo'
                 PERM_CHECK = 'perm'
                 REVIEW_CHECK = 'review'
                 MERGE_CHECK = 'merge'
                 def __init__(self):
                     self.review_status = None
                     self.merge_possible = None
                     self.merge_msg = ''
                     self.failed = None
                     self.errors = []
                     self.error_details = OrderedDict()
                 def push_error(self, error_type, message, error_key, details):
                     self.failed = True
                     self.errors.append([error_type, message])
                     self.error_details[error_key] = dict(
                         details=details,
                         error_type=error_type,
                         message=message
                     )
                 @classmethod
                 def validate(cls, pull_request, auth_user, translator, fail_early=False,
                              force_shadow_repo_refresh=False):
                     _ = translator
                     merge_check = cls()
                     # permissions to merge
                     user_allowed_to_merge = PullRequestModel().check_user_merge(
                         pull_request, auth_user)
                     if not user_allowed_to_merge:
                         log.debug("MergeCheck: cannot merge, approval is pending.")
                         msg = _('User `{}` not allowed to perform merge.').format(auth_user.username)
                         merge_check.push_error('error', msg, cls.PERM_CHECK, auth_user.username)
                         if fail_early:
                             return merge_check
                     # permission to merge into the target branch
                     target_commit_id = pull_request.target_ref_parts.commit_id
                     if pull_request.target_ref_parts.type == 'branch':
                         branch_name = pull_request.target_ref_parts.name
                     else:
                         # for mercurial we can always figure out the branch from the commit
                         # in case of bookmark
                         target_commit = pull_request.target_repo.get_commit(target_commit_id)
                         branch_name = target_commit.branch
                     rule, branch_perm = auth_user.get_rule_and_branch_permission(
                         pull_request.target_repo.repo_name, branch_name)
                     if branch_perm and branch_perm == 'branch.none':
                         msg = _('Target branch `{}` changes rejected by rule {}.').format(
                             branch_name, rule)
                         merge_check.push_error('error', msg, cls.PERM_CHECK, auth_user.username)
                         if fail_early:
                             return merge_check
                     # review status, must be always present
                     review_status = pull_request.calculated_review_status()
                     merge_check.review_status = review_status
                     status_approved = review_status == ChangesetStatus.STATUS_APPROVED
                     if not status_approved:
                         log.debug("MergeCheck: cannot merge, approval is pending.")
                         msg = _('Pull request reviewer approval is pending.')
                         merge_check.push_error('warning', msg, cls.REVIEW_CHECK, review_status)
                         if fail_early:
                             return merge_check
                     # left over TODOs
                     todos = CommentsModel().get_pull_request_unresolved_todos(pull_request)
                     if todos:
                         log.debug("MergeCheck: cannot merge, {} "
                                   "unresolved TODOs left.".format(len(todos)))
                         if len(todos) == 1:
                             msg = _('Cannot merge, {} TODO still not resolved.').format(
                                 len(todos))
                         else:
                             msg = _('Cannot merge, {} TODOs still not resolved.').format(
                                 len(todos))
                         merge_check.push_error('warning', msg, cls.TODO_CHECK, todos)
                         if fail_early:
                             return merge_check
                     # merge possible, here is the filesystem simulation + shadow repo
                     merge_status, msg = PullRequestModel().merge_status(
                         pull_request, translator=translator,
                         force_shadow_repo_refresh=force_shadow_repo_refresh)
                     merge_check.merge_possible = merge_status
                     merge_check.merge_msg = msg
                     if not merge_status:
                         log.debug("MergeCheck: cannot merge, pull request merge not possible.")
                         merge_check.push_error('warning', msg, cls.MERGE_CHECK, None)
                         if fail_early:
                             return merge_check
                     log.debug('MergeCheck: is failed: %s', merge_check.failed)
                     return merge_check
                 @classmethod
                 def get_merge_conditions(cls, pull_request, translator):
                     _ = translator
                     merge_details = {}
                     model = PullRequestModel()
                     use_rebase = model._use_rebase_for_merging(pull_request)
                     if use_rebase:
                         merge_details['merge_strategy'] = dict(
                             details={},
                             message=_('Merge strategy: rebase')
                         )
                     else:
                         merge_details['merge_strategy'] = dict(
                             details={},
                             message=_('Merge strategy: explicit merge commit')
                         )
                     close_branch = model._close_branch_before_merging(pull_request)
                     if close_branch:
                         repo_type = pull_request.target_repo.repo_type
                         close_msg = ''
                         if repo_type == 'hg':
                             close_msg = _('Source branch will be closed after merge.')
                         elif repo_type == 'git':
                             close_msg = _('Source branch will be deleted after merge.')
                         merge_details['close_branch'] = dict(
                             details={},
                             message=close_msg
                         )
                     return merge_details
             ChangeTuple = collections.namedtuple(
                 'ChangeTuple', ['added', 'common', 'removed', 'total'])
             FileChangeTuple = collections.namedtuple(
                 'FileChangeTuple', ['added', 'modified', 'removed'])

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 +437 -54

@@ -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	%>	12
13	<pre style="display:inline;border-radius:2px;font-size:12px;padding:.2em;${color_scheme.get(tag_type, color_scheme['default'])}">${text}</pre>	13	css_style = ';'.join([
		14	'display:inline',
		15	'border-radius:2px',
		16	'font-size:12px',
		17	'padding:.2em',
		18	])
		19
		20	%>
		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;
58	/* Prevent Webkit and Windows Mobile platforms from changing default font sizes.*/	94	}
59	.ExternalClass {width:100%;} /* Force Hotmail to display emails at full width */	95
60	.ExternalClass, .ExternalClass p, .ExternalClass span, .ExternalClass font, .ExternalClass td, .ExternalClass div {line-height: 100%;}	96	/* Force Outlook to provide a "view in browser" menu link. */
61	/* Forces Hotmail to display normal line spacing. More on that: http://www.emailonacid.com/forum/viewthread/43/ */	97	body {
62	#backgroundTable {margin:0; padding:0; line-height: 100% !important;}	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
		106	/* Prevent Webkit and Windows Mobile platforms from changing default font sizes.*/
		107	.ExternalClass {
		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
		116	/* Forces Hotmail to display normal line spacing. More on that: http://www.emailonacid.com/forum/viewthread/43/ */
		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	}
		162
		163	a:hover {
		164	color: #305b91;
		165	}
69		166
70	body {line-height:1.2em;}	167	h1 a, h2 a, h3 a, h4 a, h5 a, h6 a {
71	p {margin: 0 0 20px;}	168	color: #427cc9 !important;
72	h1, h2, h3, h4, h5, h6 {color:#323232!important;}	169	text-decoration: none !important;
73	a {color:#427cc9;text-decoration:none;outline:none;cursor:pointer;}	170	}
74	a:focus {outline:none;}	171
75	a:hover {color: #305b91;}	172	h1 a:active, h2 a:active, h3 a:active, h4 a:active, h5 a:active, h6 a:active {
76	h1 a, h2 a, h3 a, h4 a, h5 a, h6 a {color:#427cc9!important;text-decoration:none!important;}	173	color: #305b91 !important;
77	h1 a:active, h2 a:active, h3 a:active, h4 a:active, h5 a:active, h6 a:active {color: #305b91!important;}	174	}
78	h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited {color: #305b91!important;}	175
79	table {font-size:13px;border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;}	176	h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited {
80	table td {padding:.65em 1em .65em 0;border-collapse:collapse;vertical-align:top;text-align:left;}	177	color: #305b91 !important;
81	input {display:inline;border-radius:2px;border-style:solid;border: 1px solid #dbd9da;padding:.5em;}	178	}
82	input:focus {outline: 1px solid #979797}	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>
121	<a style="color:#eeeeee;text-decoration:none;" href="${instance_url}">	499	<td style="width:100%;padding:10px 15px;background-color:#202020" valign="top">
122	${_('RhodeCode')}	500	<a style="color:#eeeeee;text-decoration:none;" href="${instance_url}">
123	% if ~~rhodecode_instance_name~~:	501	${_('RhodeCode')}
124	- ${rhodecode_instance_name}	502	% if rhodecode_instance_name:
125	% endif	503	- ${rhodecode_instance_name}
126	</a>	504	% endif
127	</td~~></~~tr>	505	</a>
128	<tr><td style="padding:15px;" valign="top">${self.body()}</td></tr>	506	</td>
		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}">
139	</a>	521	${instance_url}
140	</p>	522	</a>
		523	</div>
141	</body>	524	</body>
142	</html>	525	</html>

rhodecode/templates/email_templates/commit_comment.mako

0 +87 -34

             ## -*- 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;">
-                % if comment_file:
+                    <h4 style="margin: 0">
-                    <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>
+                        <div style="margin-bottom: 4px; color:#7E7F7F">
-                % else:
+                            @${h.person(user.username)}
-                    <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>
+                        </div>
-                % endif
+                        ${_('left a')}
-                </td></tr>
+                        <a href="${commit_comment_url}" style="${base.link_css()}">
+                            % if comment_file:
+                                ${_('{comment_type} on file `{comment_file}` in commit.').format(**data)}
+                            % else:
+                                ${_('{comment_type} on commit.').format(**data) |n}
+                            % endif
+                        </a>
+                        <div style="margin-top: 10px"></div>
+                        ${_('Commit')} <code>${data['commit_id']}</code> ${_('of repository')}: ${data['repo_name']}
+                    </h4>
-                <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>
+                </td>
-                <tr><td style="padding-right:20px;">${_('Description')}</td><td style="white-space:pre-wrap">${h.urlify_commit_message(commit.message, repo_name)}</td></tr>
+                </tr>
+            </table>
+            <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 +123 -46

@@ -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
83	% if comment_file:	114	<h4 style="margin: 0">
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>	115	<div style="margin-bottom: 4px; color:#7E7F7F">
85	% else:	116	@${h.person(user.username)}
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>	117	</div>
87	% endif	118	${_('left a')}
		119	<a href="${pr_comment_url}" style="${base.link_css()}">
		120	% if comment_file:
		121	${_('{comment_type} on file `{comment_file}` in pull request.').format(**data)}
		122	% else:
		123	${_('{comment_type} on pull request.').format(**data) \|n}
		124	% endif
		125	</a>
		126	<div style="margin-top: 10px"></div>
		127	${_('Pull request')} <code>!${data['pr_id']}: ${data['pr_title']}</code>
		128	</h4>
88		129
89	</td></tr>	130	</td>
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>	131	</tr>
		132
		133	</table>
		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:
		144	<tr>
		145	<td style="padding-right:20px;">${_('Review Status')}:</td>
		146	<td>
		147	% if closing_pr:
		148	${_('Closed pull request with status')}: ${base.status_text(status_change, tag_type=status_change_type)}
		149	% else:
		150	${_('Submitted review status')}: ${base.status_text(status_change, tag_type=status_change_type)}
		151	% endif
		152	</td>
		153	</tr>
		154	% endif
		155
		156	<tr>
		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:
93	<tr>	173	<tr>
94	<td style="padding-right:20px;">${_('~~Status~~')}</td>	174	<td style="padding-right:20px;">${_('File')}:</td>
95	<td>	175	<td><a href="${pr_comment_url}" style="${base.link_css()}">${_('`{comment_file}` on line {comment_line}').format(**data)}</a></td>
96	% if closing_pr:
97	${_('Closed pull request with status')}: ${base.status_text(status_change, tag_type=status_change_type)}
98	% else:
99	${_('Submitted review status')}: ${base.status_text(status_change, tag_type=status_change_type)}
100	% endif
101	</td>
102	</tr>	176	</tr>
103	% endif	177	% endif
104	<tr>	178
105	<td style="padding-right:20px;">	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 +85 -26

             ## -*- 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.short_id(commit_id)}
-                      ${h.chop_at_smart(message, '\n', suffix_if_chopped='...')}
+                  ${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)}
-                        % for commit_id, message in pull_request_commits:
+                        </div>
-                        <li style="margin:0 0 1em;"><pre style="margin:0 0 .5em">${h.short_id(commit_id)}</pre>
+                        ${_('requested a')}
-                            ${h.chop_at_smart(message, '\n', suffix_if_chopped='...')}
+                        <a href="${pull_request_url}" style="${base.link_css()}">
-                        </li>
+                        ${_('pull request review.').format(**data) }
-                        % endfor
+                        </a>
-                    </ol></td>
+                        <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"><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>
                 </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