##// END OF EJS Templates
reviewers: added validation and default review rules via API calls....
dan -
r1795:4b1dac88 default
parent child Browse files
Show More
@@ -1,297 +1,297 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2010-2017 RhodeCode GmbH
3 # Copyright (C) 2010-2017 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 pytest
21 import pytest
22
22
23 from rhodecode.model.db import User
23 from rhodecode.model.db import User
24 from rhodecode.model.pull_request import PullRequestModel
24 from rhodecode.model.pull_request import PullRequestModel
25 from rhodecode.model.repo import RepoModel
25 from rhodecode.model.repo import RepoModel
26 from rhodecode.model.user import UserModel
26 from rhodecode.model.user import UserModel
27 from rhodecode.tests import TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN
27 from rhodecode.tests import TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN
28 from rhodecode.api.tests.utils import build_data, api_call, assert_error
28 from rhodecode.api.tests.utils import build_data, api_call, assert_error
29
29
30
30
31 @pytest.mark.usefixtures("testuser_api", "app")
31 @pytest.mark.usefixtures("testuser_api", "app")
32 class TestCreatePullRequestApi(object):
32 class TestCreatePullRequestApi(object):
33 finalizers = []
33 finalizers = []
34
34
35 def teardown_method(self, method):
35 def teardown_method(self, method):
36 if self.finalizers:
36 if self.finalizers:
37 for finalizer in self.finalizers:
37 for finalizer in self.finalizers:
38 finalizer()
38 finalizer()
39 self.finalizers = []
39 self.finalizers = []
40
40
41 def test_create_with_wrong_data(self):
41 def test_create_with_wrong_data(self):
42 required_data = {
42 required_data = {
43 'source_repo': 'tests/source_repo',
43 'source_repo': 'tests/source_repo',
44 'target_repo': 'tests/target_repo',
44 'target_repo': 'tests/target_repo',
45 'source_ref': 'branch:default:initial',
45 'source_ref': 'branch:default:initial',
46 'target_ref': 'branch:default:new-feature',
46 'target_ref': 'branch:default:new-feature',
47 'title': 'Test PR 1'
47 'title': 'Test PR 1'
48 }
48 }
49 for key in required_data:
49 for key in required_data:
50 data = required_data.copy()
50 data = required_data.copy()
51 data.pop(key)
51 data.pop(key)
52 id_, params = build_data(
52 id_, params = build_data(
53 self.apikey, 'create_pull_request', **data)
53 self.apikey, 'create_pull_request', **data)
54 response = api_call(self.app, params)
54 response = api_call(self.app, params)
55
55
56 expected = 'Missing non optional `{}` arg in JSON DATA'.format(key)
56 expected = 'Missing non optional `{}` arg in JSON DATA'.format(key)
57 assert_error(id_, expected, given=response.body)
57 assert_error(id_, expected, given=response.body)
58
58
59 @pytest.mark.backends("git", "hg")
59 @pytest.mark.backends("git", "hg")
60 def test_create_with_correct_data(self, backend):
60 def test_create_with_correct_data(self, backend):
61 data = self._prepare_data(backend)
61 data = self._prepare_data(backend)
62 RepoModel().revoke_user_permission(
62 RepoModel().revoke_user_permission(
63 self.source.repo_name, User.DEFAULT_USER)
63 self.source.repo_name, User.DEFAULT_USER)
64 id_, params = build_data(
64 id_, params = build_data(
65 self.apikey_regular, 'create_pull_request', **data)
65 self.apikey_regular, 'create_pull_request', **data)
66 response = api_call(self.app, params)
66 response = api_call(self.app, params)
67 expected_message = "Created new pull request `{title}`".format(
67 expected_message = "Created new pull request `{title}`".format(
68 title=data['title'])
68 title=data['title'])
69 result = response.json
69 result = response.json
70 assert result['result']['msg'] == expected_message
70 assert result['result']['msg'] == expected_message
71 pull_request_id = result['result']['pull_request_id']
71 pull_request_id = result['result']['pull_request_id']
72 pull_request = PullRequestModel().get(pull_request_id)
72 pull_request = PullRequestModel().get(pull_request_id)
73 assert pull_request.title == data['title']
73 assert pull_request.title == data['title']
74 assert pull_request.description == data['description']
74 assert pull_request.description == data['description']
75 assert pull_request.source_ref == data['source_ref']
75 assert pull_request.source_ref == data['source_ref']
76 assert pull_request.target_ref == data['target_ref']
76 assert pull_request.target_ref == data['target_ref']
77 assert pull_request.source_repo.repo_name == data['source_repo']
77 assert pull_request.source_repo.repo_name == data['source_repo']
78 assert pull_request.target_repo.repo_name == data['target_repo']
78 assert pull_request.target_repo.repo_name == data['target_repo']
79 assert pull_request.revisions == [self.commit_ids['change']]
79 assert pull_request.revisions == [self.commit_ids['change']]
80 assert pull_request.reviewers == []
80 assert len(pull_request.reviewers) == 1
81
81
82 @pytest.mark.backends("git", "hg")
82 @pytest.mark.backends("git", "hg")
83 def test_create_with_empty_description(self, backend):
83 def test_create_with_empty_description(self, backend):
84 data = self._prepare_data(backend)
84 data = self._prepare_data(backend)
85 data.pop('description')
85 data.pop('description')
86 id_, params = build_data(
86 id_, params = build_data(
87 self.apikey_regular, 'create_pull_request', **data)
87 self.apikey_regular, 'create_pull_request', **data)
88 response = api_call(self.app, params)
88 response = api_call(self.app, params)
89 expected_message = "Created new pull request `{title}`".format(
89 expected_message = "Created new pull request `{title}`".format(
90 title=data['title'])
90 title=data['title'])
91 result = response.json
91 result = response.json
92 assert result['result']['msg'] == expected_message
92 assert result['result']['msg'] == expected_message
93 pull_request_id = result['result']['pull_request_id']
93 pull_request_id = result['result']['pull_request_id']
94 pull_request = PullRequestModel().get(pull_request_id)
94 pull_request = PullRequestModel().get(pull_request_id)
95 assert pull_request.description == ''
95 assert pull_request.description == ''
96
96
97 @pytest.mark.backends("git", "hg")
97 @pytest.mark.backends("git", "hg")
98 def test_create_with_reviewers_specified_by_names(
98 def test_create_with_reviewers_specified_by_names(
99 self, backend, no_notifications):
99 self, backend, no_notifications):
100 data = self._prepare_data(backend)
100 data = self._prepare_data(backend)
101 reviewers = [
101 reviewers = [
102 {'username': TEST_USER_REGULAR_LOGIN,
102 {'username': TEST_USER_REGULAR_LOGIN,
103 'reasons': ['added manually']},
103 'reasons': ['added manually']},
104 {'username': TEST_USER_ADMIN_LOGIN,
104 {'username': TEST_USER_ADMIN_LOGIN,
105 'reasons': ['added manually']},
105 'reasons': ['added manually']},
106 ]
106 ]
107 data['reviewers'] = reviewers
107 data['reviewers'] = reviewers
108 id_, params = build_data(
108 id_, params = build_data(
109 self.apikey_regular, 'create_pull_request', **data)
109 self.apikey_regular, 'create_pull_request', **data)
110 response = api_call(self.app, params)
110 response = api_call(self.app, params)
111
111
112 expected_message = "Created new pull request `{title}`".format(
112 expected_message = "Created new pull request `{title}`".format(
113 title=data['title'])
113 title=data['title'])
114 result = response.json
114 result = response.json
115 assert result['result']['msg'] == expected_message
115 assert result['result']['msg'] == expected_message
116 pull_request_id = result['result']['pull_request_id']
116 pull_request_id = result['result']['pull_request_id']
117 pull_request = PullRequestModel().get(pull_request_id)
117 pull_request = PullRequestModel().get(pull_request_id)
118 actual_reviewers = [
118 actual_reviewers = [
119 {'username': r.user.username,
119 {'username': r.user.username,
120 'reasons': ['added manually'],
120 'reasons': ['added manually'],
121 } for r in pull_request.reviewers
121 } for r in pull_request.reviewers
122 ]
122 ]
123 assert sorted(actual_reviewers) == sorted(reviewers)
123 assert sorted(actual_reviewers) == sorted(reviewers)
124
124
125 @pytest.mark.backends("git", "hg")
125 @pytest.mark.backends("git", "hg")
126 def test_create_with_reviewers_specified_by_ids(
126 def test_create_with_reviewers_specified_by_ids(
127 self, backend, no_notifications):
127 self, backend, no_notifications):
128 data = self._prepare_data(backend)
128 data = self._prepare_data(backend)
129 reviewers = [
129 reviewers = [
130 {'username': UserModel().get_by_username(
130 {'username': UserModel().get_by_username(
131 TEST_USER_REGULAR_LOGIN).user_id,
131 TEST_USER_REGULAR_LOGIN).user_id,
132 'reasons': ['added manually']},
132 'reasons': ['added manually']},
133 {'username': UserModel().get_by_username(
133 {'username': UserModel().get_by_username(
134 TEST_USER_ADMIN_LOGIN).user_id,
134 TEST_USER_ADMIN_LOGIN).user_id,
135 'reasons': ['added manually']},
135 'reasons': ['added manually']},
136 ]
136 ]
137
137
138 data['reviewers'] = reviewers
138 data['reviewers'] = reviewers
139 id_, params = build_data(
139 id_, params = build_data(
140 self.apikey_regular, 'create_pull_request', **data)
140 self.apikey_regular, 'create_pull_request', **data)
141 response = api_call(self.app, params)
141 response = api_call(self.app, params)
142
142
143 expected_message = "Created new pull request `{title}`".format(
143 expected_message = "Created new pull request `{title}`".format(
144 title=data['title'])
144 title=data['title'])
145 result = response.json
145 result = response.json
146 assert result['result']['msg'] == expected_message
146 assert result['result']['msg'] == expected_message
147 pull_request_id = result['result']['pull_request_id']
147 pull_request_id = result['result']['pull_request_id']
148 pull_request = PullRequestModel().get(pull_request_id)
148 pull_request = PullRequestModel().get(pull_request_id)
149 actual_reviewers = [
149 actual_reviewers = [
150 {'username': r.user.user_id,
150 {'username': r.user.user_id,
151 'reasons': ['added manually'],
151 'reasons': ['added manually'],
152 } for r in pull_request.reviewers
152 } for r in pull_request.reviewers
153 ]
153 ]
154 assert sorted(actual_reviewers) == sorted(reviewers)
154 assert sorted(actual_reviewers) == sorted(reviewers)
155
155
156 @pytest.mark.backends("git", "hg")
156 @pytest.mark.backends("git", "hg")
157 def test_create_fails_when_the_reviewer_is_not_found(self, backend):
157 def test_create_fails_when_the_reviewer_is_not_found(self, backend):
158 data = self._prepare_data(backend)
158 data = self._prepare_data(backend)
159 data['reviewers'] = [{'username': 'somebody'}]
159 data['reviewers'] = [{'username': 'somebody'}]
160 id_, params = build_data(
160 id_, params = build_data(
161 self.apikey_regular, 'create_pull_request', **data)
161 self.apikey_regular, 'create_pull_request', **data)
162 response = api_call(self.app, params)
162 response = api_call(self.app, params)
163 expected_message = 'user `somebody` does not exist'
163 expected_message = 'user `somebody` does not exist'
164 assert_error(id_, expected_message, given=response.body)
164 assert_error(id_, expected_message, given=response.body)
165
165
166 @pytest.mark.backends("git", "hg")
166 @pytest.mark.backends("git", "hg")
167 def test_cannot_create_with_reviewers_in_wrong_format(self, backend):
167 def test_cannot_create_with_reviewers_in_wrong_format(self, backend):
168 data = self._prepare_data(backend)
168 data = self._prepare_data(backend)
169 reviewers = ','.join([TEST_USER_REGULAR_LOGIN, TEST_USER_ADMIN_LOGIN])
169 reviewers = ','.join([TEST_USER_REGULAR_LOGIN, TEST_USER_ADMIN_LOGIN])
170 data['reviewers'] = reviewers
170 data['reviewers'] = reviewers
171 id_, params = build_data(
171 id_, params = build_data(
172 self.apikey_regular, 'create_pull_request', **data)
172 self.apikey_regular, 'create_pull_request', **data)
173 response = api_call(self.app, params)
173 response = api_call(self.app, params)
174 expected_message = {u'': '"test_regular,test_admin" is not iterable'}
174 expected_message = {u'': '"test_regular,test_admin" is not iterable'}
175 assert_error(id_, expected_message, given=response.body)
175 assert_error(id_, expected_message, given=response.body)
176
176
177 @pytest.mark.backends("git", "hg")
177 @pytest.mark.backends("git", "hg")
178 def test_create_with_no_commit_hashes(self, backend):
178 def test_create_with_no_commit_hashes(self, backend):
179 data = self._prepare_data(backend)
179 data = self._prepare_data(backend)
180 expected_source_ref = data['source_ref']
180 expected_source_ref = data['source_ref']
181 expected_target_ref = data['target_ref']
181 expected_target_ref = data['target_ref']
182 data['source_ref'] = 'branch:{}'.format(backend.default_branch_name)
182 data['source_ref'] = 'branch:{}'.format(backend.default_branch_name)
183 data['target_ref'] = 'branch:{}'.format(backend.default_branch_name)
183 data['target_ref'] = 'branch:{}'.format(backend.default_branch_name)
184 id_, params = build_data(
184 id_, params = build_data(
185 self.apikey_regular, 'create_pull_request', **data)
185 self.apikey_regular, 'create_pull_request', **data)
186 response = api_call(self.app, params)
186 response = api_call(self.app, params)
187 expected_message = "Created new pull request `{title}`".format(
187 expected_message = "Created new pull request `{title}`".format(
188 title=data['title'])
188 title=data['title'])
189 result = response.json
189 result = response.json
190 assert result['result']['msg'] == expected_message
190 assert result['result']['msg'] == expected_message
191 pull_request_id = result['result']['pull_request_id']
191 pull_request_id = result['result']['pull_request_id']
192 pull_request = PullRequestModel().get(pull_request_id)
192 pull_request = PullRequestModel().get(pull_request_id)
193 assert pull_request.source_ref == expected_source_ref
193 assert pull_request.source_ref == expected_source_ref
194 assert pull_request.target_ref == expected_target_ref
194 assert pull_request.target_ref == expected_target_ref
195
195
196 @pytest.mark.backends("git", "hg")
196 @pytest.mark.backends("git", "hg")
197 @pytest.mark.parametrize("data_key", ["source_repo", "target_repo"])
197 @pytest.mark.parametrize("data_key", ["source_repo", "target_repo"])
198 def test_create_fails_with_wrong_repo(self, backend, data_key):
198 def test_create_fails_with_wrong_repo(self, backend, data_key):
199 repo_name = 'fake-repo'
199 repo_name = 'fake-repo'
200 data = self._prepare_data(backend)
200 data = self._prepare_data(backend)
201 data[data_key] = repo_name
201 data[data_key] = repo_name
202 id_, params = build_data(
202 id_, params = build_data(
203 self.apikey_regular, 'create_pull_request', **data)
203 self.apikey_regular, 'create_pull_request', **data)
204 response = api_call(self.app, params)
204 response = api_call(self.app, params)
205 expected_message = 'repository `{}` does not exist'.format(repo_name)
205 expected_message = 'repository `{}` does not exist'.format(repo_name)
206 assert_error(id_, expected_message, given=response.body)
206 assert_error(id_, expected_message, given=response.body)
207
207
208 @pytest.mark.backends("git", "hg")
208 @pytest.mark.backends("git", "hg")
209 @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
209 @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
210 def test_create_fails_with_non_existing_branch(self, backend, data_key):
210 def test_create_fails_with_non_existing_branch(self, backend, data_key):
211 branch_name = 'test-branch'
211 branch_name = 'test-branch'
212 data = self._prepare_data(backend)
212 data = self._prepare_data(backend)
213 data[data_key] = "branch:{}".format(branch_name)
213 data[data_key] = "branch:{}".format(branch_name)
214 id_, params = build_data(
214 id_, params = build_data(
215 self.apikey_regular, 'create_pull_request', **data)
215 self.apikey_regular, 'create_pull_request', **data)
216 response = api_call(self.app, params)
216 response = api_call(self.app, params)
217 expected_message = 'The specified branch `{}` does not exist'.format(
217 expected_message = 'The specified branch `{}` does not exist'.format(
218 branch_name)
218 branch_name)
219 assert_error(id_, expected_message, given=response.body)
219 assert_error(id_, expected_message, given=response.body)
220
220
221 @pytest.mark.backends("git", "hg")
221 @pytest.mark.backends("git", "hg")
222 @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
222 @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
223 def test_create_fails_with_ref_in_a_wrong_format(self, backend, data_key):
223 def test_create_fails_with_ref_in_a_wrong_format(self, backend, data_key):
224 data = self._prepare_data(backend)
224 data = self._prepare_data(backend)
225 ref = 'stange-ref'
225 ref = 'stange-ref'
226 data[data_key] = ref
226 data[data_key] = ref
227 id_, params = build_data(
227 id_, params = build_data(
228 self.apikey_regular, 'create_pull_request', **data)
228 self.apikey_regular, 'create_pull_request', **data)
229 response = api_call(self.app, params)
229 response = api_call(self.app, params)
230 expected_message = (
230 expected_message = (
231 'Ref `{ref}` given in a wrong format. Please check the API'
231 'Ref `{ref}` given in a wrong format. Please check the API'
232 ' documentation for more details'.format(ref=ref))
232 ' documentation for more details'.format(ref=ref))
233 assert_error(id_, expected_message, given=response.body)
233 assert_error(id_, expected_message, given=response.body)
234
234
235 @pytest.mark.backends("git", "hg")
235 @pytest.mark.backends("git", "hg")
236 @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
236 @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
237 def test_create_fails_with_non_existing_ref(self, backend, data_key):
237 def test_create_fails_with_non_existing_ref(self, backend, data_key):
238 commit_id = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa10'
238 commit_id = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa10'
239 ref = self._get_full_ref(backend, commit_id)
239 ref = self._get_full_ref(backend, commit_id)
240 data = self._prepare_data(backend)
240 data = self._prepare_data(backend)
241 data[data_key] = ref
241 data[data_key] = ref
242 id_, params = build_data(
242 id_, params = build_data(
243 self.apikey_regular, 'create_pull_request', **data)
243 self.apikey_regular, 'create_pull_request', **data)
244 response = api_call(self.app, params)
244 response = api_call(self.app, params)
245 expected_message = 'Ref `{}` does not exist'.format(ref)
245 expected_message = 'Ref `{}` does not exist'.format(ref)
246 assert_error(id_, expected_message, given=response.body)
246 assert_error(id_, expected_message, given=response.body)
247
247
248 @pytest.mark.backends("git", "hg")
248 @pytest.mark.backends("git", "hg")
249 def test_create_fails_when_no_revisions(self, backend):
249 def test_create_fails_when_no_revisions(self, backend):
250 data = self._prepare_data(backend, source_head='initial')
250 data = self._prepare_data(backend, source_head='initial')
251 id_, params = build_data(
251 id_, params = build_data(
252 self.apikey_regular, 'create_pull_request', **data)
252 self.apikey_regular, 'create_pull_request', **data)
253 response = api_call(self.app, params)
253 response = api_call(self.app, params)
254 expected_message = 'no commits found'
254 expected_message = 'no commits found'
255 assert_error(id_, expected_message, given=response.body)
255 assert_error(id_, expected_message, given=response.body)
256
256
257 @pytest.mark.backends("git", "hg")
257 @pytest.mark.backends("git", "hg")
258 def test_create_fails_when_no_permissions(self, backend):
258 def test_create_fails_when_no_permissions(self, backend):
259 data = self._prepare_data(backend)
259 data = self._prepare_data(backend)
260 RepoModel().revoke_user_permission(
260 RepoModel().revoke_user_permission(
261 self.source.repo_name, User.DEFAULT_USER)
261 self.source.repo_name, User.DEFAULT_USER)
262 RepoModel().revoke_user_permission(
262 RepoModel().revoke_user_permission(
263 self.source.repo_name, self.test_user)
263 self.source.repo_name, self.test_user)
264 id_, params = build_data(
264 id_, params = build_data(
265 self.apikey_regular, 'create_pull_request', **data)
265 self.apikey_regular, 'create_pull_request', **data)
266 response = api_call(self.app, params)
266 response = api_call(self.app, params)
267 expected_message = 'repository `{}` does not exist'.format(
267 expected_message = 'repository `{}` does not exist'.format(
268 self.source.repo_name)
268 self.source.repo_name)
269 assert_error(id_, expected_message, given=response.body)
269 assert_error(id_, expected_message, given=response.body)
270
270
271 def _prepare_data(
271 def _prepare_data(
272 self, backend, source_head='change', target_head='initial'):
272 self, backend, source_head='change', target_head='initial'):
273 commits = [
273 commits = [
274 {'message': 'initial'},
274 {'message': 'initial'},
275 {'message': 'change'},
275 {'message': 'change'},
276 {'message': 'new-feature', 'parents': ['initial']},
276 {'message': 'new-feature', 'parents': ['initial']},
277 ]
277 ]
278 self.commit_ids = backend.create_master_repo(commits)
278 self.commit_ids = backend.create_master_repo(commits)
279 self.source = backend.create_repo(heads=[source_head])
279 self.source = backend.create_repo(heads=[source_head])
280 self.target = backend.create_repo(heads=[target_head])
280 self.target = backend.create_repo(heads=[target_head])
281 data = {
281 data = {
282 'source_repo': self.source.repo_name,
282 'source_repo': self.source.repo_name,
283 'target_repo': self.target.repo_name,
283 'target_repo': self.target.repo_name,
284 'source_ref': self._get_full_ref(
284 'source_ref': self._get_full_ref(
285 backend, self.commit_ids[source_head]),
285 backend, self.commit_ids[source_head]),
286 'target_ref': self._get_full_ref(
286 'target_ref': self._get_full_ref(
287 backend, self.commit_ids[target_head]),
287 backend, self.commit_ids[target_head]),
288 'title': 'Test PR 1',
288 'title': 'Test PR 1',
289 'description': 'Test'
289 'description': 'Test'
290 }
290 }
291 RepoModel().grant_user_permission(
291 RepoModel().grant_user_permission(
292 self.source.repo_name, self.TEST_USER_LOGIN, 'repository.read')
292 self.source.repo_name, self.TEST_USER_LOGIN, 'repository.read')
293 return data
293 return data
294
294
295 def _get_full_ref(self, backend, commit_id):
295 def _get_full_ref(self, backend, commit_id):
296 return 'branch:{branch}:{commit_id}'.format(
296 return 'branch:{branch}:{commit_id}'.format(
297 branch=backend.default_branch_name, commit_id=commit_id)
297 branch=backend.default_branch_name, commit_id=commit_id)
@@ -1,748 +1,779 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2011-2017 RhodeCode GmbH
3 # Copyright (C) 2011-2017 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
21
22 import logging
22 import logging
23
23
24 from rhodecode import events
24 from rhodecode import events
25 from rhodecode.api import jsonrpc_method, JSONRPCError, JSONRPCValidationError
25 from rhodecode.api import jsonrpc_method, JSONRPCError, JSONRPCValidationError
26 from rhodecode.api.utils import (
26 from rhodecode.api.utils import (
27 has_superadmin_permission, Optional, OAttr, get_repo_or_error,
27 has_superadmin_permission, Optional, OAttr, get_repo_or_error,
28 get_pull_request_or_error, get_commit_or_error, get_user_or_error,
28 get_pull_request_or_error, get_commit_or_error, get_user_or_error,
29 validate_repo_permissions, resolve_ref_or_error)
29 validate_repo_permissions, resolve_ref_or_error)
30 from rhodecode.lib.auth import (HasRepoPermissionAnyApi)
30 from rhodecode.lib.auth import (HasRepoPermissionAnyApi)
31 from rhodecode.lib.base import vcs_operation_context
31 from rhodecode.lib.base import vcs_operation_context
32 from rhodecode.lib.utils2 import str2bool
32 from rhodecode.lib.utils2 import str2bool
33 from rhodecode.model.changeset_status import ChangesetStatusModel
33 from rhodecode.model.changeset_status import ChangesetStatusModel
34 from rhodecode.model.comment import CommentsModel
34 from rhodecode.model.comment import CommentsModel
35 from rhodecode.model.db import Session, ChangesetStatus, ChangesetComment
35 from rhodecode.model.db import Session, ChangesetStatus, ChangesetComment
36 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
36 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
37 from rhodecode.model.settings import SettingsModel
37 from rhodecode.model.settings import SettingsModel
38 from rhodecode.model.validation_schema import Invalid
38 from rhodecode.model.validation_schema import Invalid
39 from rhodecode.model.validation_schema.schemas.reviewer_schema import(
39 from rhodecode.model.validation_schema.schemas.reviewer_schema import(
40 ReviewerListSchema)
40 ReviewerListSchema)
41
41
42 log = logging.getLogger(__name__)
42 log = logging.getLogger(__name__)
43
43
44
44
45 @jsonrpc_method()
45 @jsonrpc_method()
46 def get_pull_request(request, apiuser, repoid, pullrequestid):
46 def get_pull_request(request, apiuser, repoid, pullrequestid):
47 """
47 """
48 Get a pull request based on the given ID.
48 Get a pull request based on the given ID.
49
49
50 :param apiuser: This is filled automatically from the |authtoken|.
50 :param apiuser: This is filled automatically from the |authtoken|.
51 :type apiuser: AuthUser
51 :type apiuser: AuthUser
52 :param repoid: Repository name or repository ID from where the pull
52 :param repoid: Repository name or repository ID from where the pull
53 request was opened.
53 request was opened.
54 :type repoid: str or int
54 :type repoid: str or int
55 :param pullrequestid: ID of the requested pull request.
55 :param pullrequestid: ID of the requested pull request.
56 :type pullrequestid: int
56 :type pullrequestid: int
57
57
58 Example output:
58 Example output:
59
59
60 .. code-block:: bash
60 .. code-block:: bash
61
61
62 "id": <id_given_in_input>,
62 "id": <id_given_in_input>,
63 "result":
63 "result":
64 {
64 {
65 "pull_request_id": "<pull_request_id>",
65 "pull_request_id": "<pull_request_id>",
66 "url": "<url>",
66 "url": "<url>",
67 "title": "<title>",
67 "title": "<title>",
68 "description": "<description>",
68 "description": "<description>",
69 "status" : "<status>",
69 "status" : "<status>",
70 "created_on": "<date_time_created>",
70 "created_on": "<date_time_created>",
71 "updated_on": "<date_time_updated>",
71 "updated_on": "<date_time_updated>",
72 "commit_ids": [
72 "commit_ids": [
73 ...
73 ...
74 "<commit_id>",
74 "<commit_id>",
75 "<commit_id>",
75 "<commit_id>",
76 ...
76 ...
77 ],
77 ],
78 "review_status": "<review_status>",
78 "review_status": "<review_status>",
79 "mergeable": {
79 "mergeable": {
80 "status": "<bool>",
80 "status": "<bool>",
81 "message": "<message>",
81 "message": "<message>",
82 },
82 },
83 "source": {
83 "source": {
84 "clone_url": "<clone_url>",
84 "clone_url": "<clone_url>",
85 "repository": "<repository_name>",
85 "repository": "<repository_name>",
86 "reference":
86 "reference":
87 {
87 {
88 "name": "<name>",
88 "name": "<name>",
89 "type": "<type>",
89 "type": "<type>",
90 "commit_id": "<commit_id>",
90 "commit_id": "<commit_id>",
91 }
91 }
92 },
92 },
93 "target": {
93 "target": {
94 "clone_url": "<clone_url>",
94 "clone_url": "<clone_url>",
95 "repository": "<repository_name>",
95 "repository": "<repository_name>",
96 "reference":
96 "reference":
97 {
97 {
98 "name": "<name>",
98 "name": "<name>",
99 "type": "<type>",
99 "type": "<type>",
100 "commit_id": "<commit_id>",
100 "commit_id": "<commit_id>",
101 }
101 }
102 },
102 },
103 "merge": {
103 "merge": {
104 "clone_url": "<clone_url>",
104 "clone_url": "<clone_url>",
105 "reference":
105 "reference":
106 {
106 {
107 "name": "<name>",
107 "name": "<name>",
108 "type": "<type>",
108 "type": "<type>",
109 "commit_id": "<commit_id>",
109 "commit_id": "<commit_id>",
110 }
110 }
111 },
111 },
112 "author": <user_obj>,
112 "author": <user_obj>,
113 "reviewers": [
113 "reviewers": [
114 ...
114 ...
115 {
115 {
116 "user": "<user_obj>",
116 "user": "<user_obj>",
117 "review_status": "<review_status>",
117 "review_status": "<review_status>",
118 }
118 }
119 ...
119 ...
120 ]
120 ]
121 },
121 },
122 "error": null
122 "error": null
123 """
123 """
124 get_repo_or_error(repoid)
124 get_repo_or_error(repoid)
125 pull_request = get_pull_request_or_error(pullrequestid)
125 pull_request = get_pull_request_or_error(pullrequestid)
126 if not PullRequestModel().check_user_read(
126 if not PullRequestModel().check_user_read(
127 pull_request, apiuser, api=True):
127 pull_request, apiuser, api=True):
128 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
128 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
129 data = pull_request.get_api_data()
129 data = pull_request.get_api_data()
130 return data
130 return data
131
131
132
132
133 @jsonrpc_method()
133 @jsonrpc_method()
134 def get_pull_requests(request, apiuser, repoid, status=Optional('new')):
134 def get_pull_requests(request, apiuser, repoid, status=Optional('new')):
135 """
135 """
136 Get all pull requests from the repository specified in `repoid`.
136 Get all pull requests from the repository specified in `repoid`.
137
137
138 :param apiuser: This is filled automatically from the |authtoken|.
138 :param apiuser: This is filled automatically from the |authtoken|.
139 :type apiuser: AuthUser
139 :type apiuser: AuthUser
140 :param repoid: Repository name or repository ID.
140 :param repoid: Repository name or repository ID.
141 :type repoid: str or int
141 :type repoid: str or int
142 :param status: Only return pull requests with the specified status.
142 :param status: Only return pull requests with the specified status.
143 Valid options are.
143 Valid options are.
144 * ``new`` (default)
144 * ``new`` (default)
145 * ``open``
145 * ``open``
146 * ``closed``
146 * ``closed``
147 :type status: str
147 :type status: str
148
148
149 Example output:
149 Example output:
150
150
151 .. code-block:: bash
151 .. code-block:: bash
152
152
153 "id": <id_given_in_input>,
153 "id": <id_given_in_input>,
154 "result":
154 "result":
155 [
155 [
156 ...
156 ...
157 {
157 {
158 "pull_request_id": "<pull_request_id>",
158 "pull_request_id": "<pull_request_id>",
159 "url": "<url>",
159 "url": "<url>",
160 "title" : "<title>",
160 "title" : "<title>",
161 "description": "<description>",
161 "description": "<description>",
162 "status": "<status>",
162 "status": "<status>",
163 "created_on": "<date_time_created>",
163 "created_on": "<date_time_created>",
164 "updated_on": "<date_time_updated>",
164 "updated_on": "<date_time_updated>",
165 "commit_ids": [
165 "commit_ids": [
166 ...
166 ...
167 "<commit_id>",
167 "<commit_id>",
168 "<commit_id>",
168 "<commit_id>",
169 ...
169 ...
170 ],
170 ],
171 "review_status": "<review_status>",
171 "review_status": "<review_status>",
172 "mergeable": {
172 "mergeable": {
173 "status": "<bool>",
173 "status": "<bool>",
174 "message: "<message>",
174 "message: "<message>",
175 },
175 },
176 "source": {
176 "source": {
177 "clone_url": "<clone_url>",
177 "clone_url": "<clone_url>",
178 "reference":
178 "reference":
179 {
179 {
180 "name": "<name>",
180 "name": "<name>",
181 "type": "<type>",
181 "type": "<type>",
182 "commit_id": "<commit_id>",
182 "commit_id": "<commit_id>",
183 }
183 }
184 },
184 },
185 "target": {
185 "target": {
186 "clone_url": "<clone_url>",
186 "clone_url": "<clone_url>",
187 "reference":
187 "reference":
188 {
188 {
189 "name": "<name>",
189 "name": "<name>",
190 "type": "<type>",
190 "type": "<type>",
191 "commit_id": "<commit_id>",
191 "commit_id": "<commit_id>",
192 }
192 }
193 },
193 },
194 "merge": {
194 "merge": {
195 "clone_url": "<clone_url>",
195 "clone_url": "<clone_url>",
196 "reference":
196 "reference":
197 {
197 {
198 "name": "<name>",
198 "name": "<name>",
199 "type": "<type>",
199 "type": "<type>",
200 "commit_id": "<commit_id>",
200 "commit_id": "<commit_id>",
201 }
201 }
202 },
202 },
203 "author": <user_obj>,
203 "author": <user_obj>,
204 "reviewers": [
204 "reviewers": [
205 ...
205 ...
206 {
206 {
207 "user": "<user_obj>",
207 "user": "<user_obj>",
208 "review_status": "<review_status>",
208 "review_status": "<review_status>",
209 }
209 }
210 ...
210 ...
211 ]
211 ]
212 }
212 }
213 ...
213 ...
214 ],
214 ],
215 "error": null
215 "error": null
216
216
217 """
217 """
218 repo = get_repo_or_error(repoid)
218 repo = get_repo_or_error(repoid)
219 if not has_superadmin_permission(apiuser):
219 if not has_superadmin_permission(apiuser):
220 _perms = (
220 _perms = (
221 'repository.admin', 'repository.write', 'repository.read',)
221 'repository.admin', 'repository.write', 'repository.read',)
222 validate_repo_permissions(apiuser, repoid, repo, _perms)
222 validate_repo_permissions(apiuser, repoid, repo, _perms)
223
223
224 status = Optional.extract(status)
224 status = Optional.extract(status)
225 pull_requests = PullRequestModel().get_all(repo, statuses=[status])
225 pull_requests = PullRequestModel().get_all(repo, statuses=[status])
226 data = [pr.get_api_data() for pr in pull_requests]
226 data = [pr.get_api_data() for pr in pull_requests]
227 return data
227 return data
228
228
229
229
230 @jsonrpc_method()
230 @jsonrpc_method()
231 def merge_pull_request(
231 def merge_pull_request(
232 request, apiuser, repoid, pullrequestid,
232 request, apiuser, repoid, pullrequestid,
233 userid=Optional(OAttr('apiuser'))):
233 userid=Optional(OAttr('apiuser'))):
234 """
234 """
235 Merge the pull request specified by `pullrequestid` into its target
235 Merge the pull request specified by `pullrequestid` into its target
236 repository.
236 repository.
237
237
238 :param apiuser: This is filled automatically from the |authtoken|.
238 :param apiuser: This is filled automatically from the |authtoken|.
239 :type apiuser: AuthUser
239 :type apiuser: AuthUser
240 :param repoid: The Repository name or repository ID of the
240 :param repoid: The Repository name or repository ID of the
241 target repository to which the |pr| is to be merged.
241 target repository to which the |pr| is to be merged.
242 :type repoid: str or int
242 :type repoid: str or int
243 :param pullrequestid: ID of the pull request which shall be merged.
243 :param pullrequestid: ID of the pull request which shall be merged.
244 :type pullrequestid: int
244 :type pullrequestid: int
245 :param userid: Merge the pull request as this user.
245 :param userid: Merge the pull request as this user.
246 :type userid: Optional(str or int)
246 :type userid: Optional(str or int)
247
247
248 Example output:
248 Example output:
249
249
250 .. code-block:: bash
250 .. code-block:: bash
251
251
252 "id": <id_given_in_input>,
252 "id": <id_given_in_input>,
253 "result": {
253 "result": {
254 "executed": "<bool>",
254 "executed": "<bool>",
255 "failure_reason": "<int>",
255 "failure_reason": "<int>",
256 "merge_commit_id": "<merge_commit_id>",
256 "merge_commit_id": "<merge_commit_id>",
257 "possible": "<bool>",
257 "possible": "<bool>",
258 "merge_ref": {
258 "merge_ref": {
259 "commit_id": "<commit_id>",
259 "commit_id": "<commit_id>",
260 "type": "<type>",
260 "type": "<type>",
261 "name": "<name>"
261 "name": "<name>"
262 }
262 }
263 },
263 },
264 "error": null
264 "error": null
265 """
265 """
266 repo = get_repo_or_error(repoid)
266 repo = get_repo_or_error(repoid)
267 if not isinstance(userid, Optional):
267 if not isinstance(userid, Optional):
268 if (has_superadmin_permission(apiuser) or
268 if (has_superadmin_permission(apiuser) or
269 HasRepoPermissionAnyApi('repository.admin')(
269 HasRepoPermissionAnyApi('repository.admin')(
270 user=apiuser, repo_name=repo.repo_name)):
270 user=apiuser, repo_name=repo.repo_name)):
271 apiuser = get_user_or_error(userid)
271 apiuser = get_user_or_error(userid)
272 else:
272 else:
273 raise JSONRPCError('userid is not the same as your user')
273 raise JSONRPCError('userid is not the same as your user')
274
274
275 pull_request = get_pull_request_or_error(pullrequestid)
275 pull_request = get_pull_request_or_error(pullrequestid)
276
276
277 check = MergeCheck.validate(pull_request, user=apiuser)
277 check = MergeCheck.validate(pull_request, user=apiuser)
278 merge_possible = not check.failed
278 merge_possible = not check.failed
279
279
280 if not merge_possible:
280 if not merge_possible:
281 error_messages = []
281 error_messages = []
282 for err_type, error_msg in check.errors:
282 for err_type, error_msg in check.errors:
283 error_msg = request.translate(error_msg)
283 error_msg = request.translate(error_msg)
284 error_messages.append(error_msg)
284 error_messages.append(error_msg)
285
285
286 reasons = ','.join(error_messages)
286 reasons = ','.join(error_messages)
287 raise JSONRPCError(
287 raise JSONRPCError(
288 'merge not possible for following reasons: {}'.format(reasons))
288 'merge not possible for following reasons: {}'.format(reasons))
289
289
290 target_repo = pull_request.target_repo
290 target_repo = pull_request.target_repo
291 extras = vcs_operation_context(
291 extras = vcs_operation_context(
292 request.environ, repo_name=target_repo.repo_name,
292 request.environ, repo_name=target_repo.repo_name,
293 username=apiuser.username, action='push',
293 username=apiuser.username, action='push',
294 scm=target_repo.repo_type)
294 scm=target_repo.repo_type)
295 merge_response = PullRequestModel().merge(
295 merge_response = PullRequestModel().merge(
296 pull_request, apiuser, extras=extras)
296 pull_request, apiuser, extras=extras)
297 if merge_response.executed:
297 if merge_response.executed:
298 PullRequestModel().close_pull_request(
298 PullRequestModel().close_pull_request(
299 pull_request.pull_request_id, apiuser)
299 pull_request.pull_request_id, apiuser)
300
300
301 Session().commit()
301 Session().commit()
302
302
303 # In previous versions the merge response directly contained the merge
303 # In previous versions the merge response directly contained the merge
304 # commit id. It is now contained in the merge reference object. To be
304 # commit id. It is now contained in the merge reference object. To be
305 # backwards compatible we have to extract it again.
305 # backwards compatible we have to extract it again.
306 merge_response = merge_response._asdict()
306 merge_response = merge_response._asdict()
307 merge_response['merge_commit_id'] = merge_response['merge_ref'].commit_id
307 merge_response['merge_commit_id'] = merge_response['merge_ref'].commit_id
308
308
309 return merge_response
309 return merge_response
310
310
311
311
312 @jsonrpc_method()
312 @jsonrpc_method()
313 def comment_pull_request(
313 def comment_pull_request(
314 request, apiuser, repoid, pullrequestid, message=Optional(None),
314 request, apiuser, repoid, pullrequestid, message=Optional(None),
315 commit_id=Optional(None), status=Optional(None),
315 commit_id=Optional(None), status=Optional(None),
316 comment_type=Optional(ChangesetComment.COMMENT_TYPE_NOTE),
316 comment_type=Optional(ChangesetComment.COMMENT_TYPE_NOTE),
317 resolves_comment_id=Optional(None),
317 resolves_comment_id=Optional(None),
318 userid=Optional(OAttr('apiuser'))):
318 userid=Optional(OAttr('apiuser'))):
319 """
319 """
320 Comment on the pull request specified with the `pullrequestid`,
320 Comment on the pull request specified with the `pullrequestid`,
321 in the |repo| specified by the `repoid`, and optionally change the
321 in the |repo| specified by the `repoid`, and optionally change the
322 review status.
322 review status.
323
323
324 :param apiuser: This is filled automatically from the |authtoken|.
324 :param apiuser: This is filled automatically from the |authtoken|.
325 :type apiuser: AuthUser
325 :type apiuser: AuthUser
326 :param repoid: The repository name or repository ID.
326 :param repoid: The repository name or repository ID.
327 :type repoid: str or int
327 :type repoid: str or int
328 :param pullrequestid: The pull request ID.
328 :param pullrequestid: The pull request ID.
329 :type pullrequestid: int
329 :type pullrequestid: int
330 :param commit_id: Specify the commit_id for which to set a comment. If
330 :param commit_id: Specify the commit_id for which to set a comment. If
331 given commit_id is different than latest in the PR status
331 given commit_id is different than latest in the PR status
332 change won't be performed.
332 change won't be performed.
333 :type commit_id: str
333 :type commit_id: str
334 :param message: The text content of the comment.
334 :param message: The text content of the comment.
335 :type message: str
335 :type message: str
336 :param status: (**Optional**) Set the approval status of the pull
336 :param status: (**Optional**) Set the approval status of the pull
337 request. One of: 'not_reviewed', 'approved', 'rejected',
337 request. One of: 'not_reviewed', 'approved', 'rejected',
338 'under_review'
338 'under_review'
339 :type status: str
339 :type status: str
340 :param comment_type: Comment type, one of: 'note', 'todo'
340 :param comment_type: Comment type, one of: 'note', 'todo'
341 :type comment_type: Optional(str), default: 'note'
341 :type comment_type: Optional(str), default: 'note'
342 :param userid: Comment on the pull request as this user
342 :param userid: Comment on the pull request as this user
343 :type userid: Optional(str or int)
343 :type userid: Optional(str or int)
344
344
345 Example output:
345 Example output:
346
346
347 .. code-block:: bash
347 .. code-block:: bash
348
348
349 id : <id_given_in_input>
349 id : <id_given_in_input>
350 result : {
350 result : {
351 "pull_request_id": "<Integer>",
351 "pull_request_id": "<Integer>",
352 "comment_id": "<Integer>",
352 "comment_id": "<Integer>",
353 "status": {"given": <given_status>,
353 "status": {"given": <given_status>,
354 "was_changed": <bool status_was_actually_changed> },
354 "was_changed": <bool status_was_actually_changed> },
355 },
355 },
356 error : null
356 error : null
357 """
357 """
358 repo = get_repo_or_error(repoid)
358 repo = get_repo_or_error(repoid)
359 if not isinstance(userid, Optional):
359 if not isinstance(userid, Optional):
360 if (has_superadmin_permission(apiuser) or
360 if (has_superadmin_permission(apiuser) or
361 HasRepoPermissionAnyApi('repository.admin')(
361 HasRepoPermissionAnyApi('repository.admin')(
362 user=apiuser, repo_name=repo.repo_name)):
362 user=apiuser, repo_name=repo.repo_name)):
363 apiuser = get_user_or_error(userid)
363 apiuser = get_user_or_error(userid)
364 else:
364 else:
365 raise JSONRPCError('userid is not the same as your user')
365 raise JSONRPCError('userid is not the same as your user')
366
366
367 pull_request = get_pull_request_or_error(pullrequestid)
367 pull_request = get_pull_request_or_error(pullrequestid)
368 if not PullRequestModel().check_user_read(
368 if not PullRequestModel().check_user_read(
369 pull_request, apiuser, api=True):
369 pull_request, apiuser, api=True):
370 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
370 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
371 message = Optional.extract(message)
371 message = Optional.extract(message)
372 status = Optional.extract(status)
372 status = Optional.extract(status)
373 commit_id = Optional.extract(commit_id)
373 commit_id = Optional.extract(commit_id)
374 comment_type = Optional.extract(comment_type)
374 comment_type = Optional.extract(comment_type)
375 resolves_comment_id = Optional.extract(resolves_comment_id)
375 resolves_comment_id = Optional.extract(resolves_comment_id)
376
376
377 if not message and not status:
377 if not message and not status:
378 raise JSONRPCError(
378 raise JSONRPCError(
379 'Both message and status parameters are missing. '
379 'Both message and status parameters are missing. '
380 'At least one is required.')
380 'At least one is required.')
381
381
382 if (status not in (st[0] for st in ChangesetStatus.STATUSES) and
382 if (status not in (st[0] for st in ChangesetStatus.STATUSES) and
383 status is not None):
383 status is not None):
384 raise JSONRPCError('Unknown comment status: `%s`' % status)
384 raise JSONRPCError('Unknown comment status: `%s`' % status)
385
385
386 if commit_id and commit_id not in pull_request.revisions:
386 if commit_id and commit_id not in pull_request.revisions:
387 raise JSONRPCError(
387 raise JSONRPCError(
388 'Invalid commit_id `%s` for this pull request.' % commit_id)
388 'Invalid commit_id `%s` for this pull request.' % commit_id)
389
389
390 allowed_to_change_status = PullRequestModel().check_user_change_status(
390 allowed_to_change_status = PullRequestModel().check_user_change_status(
391 pull_request, apiuser)
391 pull_request, apiuser)
392
392
393 # if commit_id is passed re-validated if user is allowed to change status
393 # if commit_id is passed re-validated if user is allowed to change status
394 # based on latest commit_id from the PR
394 # based on latest commit_id from the PR
395 if commit_id:
395 if commit_id:
396 commit_idx = pull_request.revisions.index(commit_id)
396 commit_idx = pull_request.revisions.index(commit_id)
397 if commit_idx != 0:
397 if commit_idx != 0:
398 allowed_to_change_status = False
398 allowed_to_change_status = False
399
399
400 if resolves_comment_id:
400 if resolves_comment_id:
401 comment = ChangesetComment.get(resolves_comment_id)
401 comment = ChangesetComment.get(resolves_comment_id)
402 if not comment:
402 if not comment:
403 raise JSONRPCError(
403 raise JSONRPCError(
404 'Invalid resolves_comment_id `%s` for this pull request.'
404 'Invalid resolves_comment_id `%s` for this pull request.'
405 % resolves_comment_id)
405 % resolves_comment_id)
406 if comment.comment_type != ChangesetComment.COMMENT_TYPE_TODO:
406 if comment.comment_type != ChangesetComment.COMMENT_TYPE_TODO:
407 raise JSONRPCError(
407 raise JSONRPCError(
408 'Comment `%s` is wrong type for setting status to resolved.'
408 'Comment `%s` is wrong type for setting status to resolved.'
409 % resolves_comment_id)
409 % resolves_comment_id)
410
410
411 text = message
411 text = message
412 status_label = ChangesetStatus.get_status_lbl(status)
412 status_label = ChangesetStatus.get_status_lbl(status)
413 if status and allowed_to_change_status:
413 if status and allowed_to_change_status:
414 st_message = ('Status change %(transition_icon)s %(status)s'
414 st_message = ('Status change %(transition_icon)s %(status)s'
415 % {'transition_icon': '>', 'status': status_label})
415 % {'transition_icon': '>', 'status': status_label})
416 text = message or st_message
416 text = message or st_message
417
417
418 rc_config = SettingsModel().get_all_settings()
418 rc_config = SettingsModel().get_all_settings()
419 renderer = rc_config.get('rhodecode_markup_renderer', 'rst')
419 renderer = rc_config.get('rhodecode_markup_renderer', 'rst')
420
420
421 status_change = status and allowed_to_change_status
421 status_change = status and allowed_to_change_status
422 comment = CommentsModel().create(
422 comment = CommentsModel().create(
423 text=text,
423 text=text,
424 repo=pull_request.target_repo.repo_id,
424 repo=pull_request.target_repo.repo_id,
425 user=apiuser.user_id,
425 user=apiuser.user_id,
426 pull_request=pull_request.pull_request_id,
426 pull_request=pull_request.pull_request_id,
427 f_path=None,
427 f_path=None,
428 line_no=None,
428 line_no=None,
429 status_change=(status_label if status_change else None),
429 status_change=(status_label if status_change else None),
430 status_change_type=(status if status_change else None),
430 status_change_type=(status if status_change else None),
431 closing_pr=False,
431 closing_pr=False,
432 renderer=renderer,
432 renderer=renderer,
433 comment_type=comment_type,
433 comment_type=comment_type,
434 resolves_comment_id=resolves_comment_id
434 resolves_comment_id=resolves_comment_id
435 )
435 )
436
436
437 if allowed_to_change_status and status:
437 if allowed_to_change_status and status:
438 ChangesetStatusModel().set_status(
438 ChangesetStatusModel().set_status(
439 pull_request.target_repo.repo_id,
439 pull_request.target_repo.repo_id,
440 status,
440 status,
441 apiuser.user_id,
441 apiuser.user_id,
442 comment,
442 comment,
443 pull_request=pull_request.pull_request_id
443 pull_request=pull_request.pull_request_id
444 )
444 )
445 Session().flush()
445 Session().flush()
446
446
447 Session().commit()
447 Session().commit()
448 data = {
448 data = {
449 'pull_request_id': pull_request.pull_request_id,
449 'pull_request_id': pull_request.pull_request_id,
450 'comment_id': comment.comment_id if comment else None,
450 'comment_id': comment.comment_id if comment else None,
451 'status': {'given': status, 'was_changed': status_change},
451 'status': {'given': status, 'was_changed': status_change},
452 }
452 }
453 return data
453 return data
454
454
455
455
456 @jsonrpc_method()
456 @jsonrpc_method()
457 def create_pull_request(
457 def create_pull_request(
458 request, apiuser, source_repo, target_repo, source_ref, target_ref,
458 request, apiuser, source_repo, target_repo, source_ref, target_ref,
459 title, description=Optional(''), reviewers=Optional(None)):
459 title, description=Optional(''), reviewers=Optional(None)):
460 """
460 """
461 Creates a new pull request.
461 Creates a new pull request.
462
462
463 Accepts refs in the following formats:
463 Accepts refs in the following formats:
464
464
465 * branch:<branch_name>:<sha>
465 * branch:<branch_name>:<sha>
466 * branch:<branch_name>
466 * branch:<branch_name>
467 * bookmark:<bookmark_name>:<sha> (Mercurial only)
467 * bookmark:<bookmark_name>:<sha> (Mercurial only)
468 * bookmark:<bookmark_name> (Mercurial only)
468 * bookmark:<bookmark_name> (Mercurial only)
469
469
470 :param apiuser: This is filled automatically from the |authtoken|.
470 :param apiuser: This is filled automatically from the |authtoken|.
471 :type apiuser: AuthUser
471 :type apiuser: AuthUser
472 :param source_repo: Set the source repository name.
472 :param source_repo: Set the source repository name.
473 :type source_repo: str
473 :type source_repo: str
474 :param target_repo: Set the target repository name.
474 :param target_repo: Set the target repository name.
475 :type target_repo: str
475 :type target_repo: str
476 :param source_ref: Set the source ref name.
476 :param source_ref: Set the source ref name.
477 :type source_ref: str
477 :type source_ref: str
478 :param target_ref: Set the target ref name.
478 :param target_ref: Set the target ref name.
479 :type target_ref: str
479 :type target_ref: str
480 :param title: Set the pull request title.
480 :param title: Set the pull request title.
481 :type title: str
481 :type title: str
482 :param description: Set the pull request description.
482 :param description: Set the pull request description.
483 :type description: Optional(str)
483 :type description: Optional(str)
484 :param reviewers: Set the new pull request reviewers list.
484 :param reviewers: Set the new pull request reviewers list.
485 Reviewer defined by review rules will be added automatically to the
486 defined list.
485 :type reviewers: Optional(list)
487 :type reviewers: Optional(list)
486 Accepts username strings or objects of the format:
488 Accepts username strings or objects of the format:
487
489
488 {'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}
490 [{'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}]
489 """
491 """
490
492
491 source = get_repo_or_error(source_repo)
493 source_db_repo = get_repo_or_error(source_repo)
492 target = get_repo_or_error(target_repo)
494 target_db_repo = get_repo_or_error(target_repo)
493 if not has_superadmin_permission(apiuser):
495 if not has_superadmin_permission(apiuser):
494 _perms = ('repository.admin', 'repository.write', 'repository.read',)
496 _perms = ('repository.admin', 'repository.write', 'repository.read',)
495 validate_repo_permissions(apiuser, source_repo, source, _perms)
497 validate_repo_permissions(apiuser, source_repo, source_db_repo, _perms)
496
498
497 full_source_ref = resolve_ref_or_error(source_ref, source)
499 full_source_ref = resolve_ref_or_error(source_ref, source_db_repo)
498 full_target_ref = resolve_ref_or_error(target_ref, target)
500 full_target_ref = resolve_ref_or_error(target_ref, target_db_repo)
499 source_commit = get_commit_or_error(full_source_ref, source)
501 source_commit = get_commit_or_error(full_source_ref, source_db_repo)
500 target_commit = get_commit_or_error(full_target_ref, target)
502 target_commit = get_commit_or_error(full_target_ref, target_db_repo)
501 source_scm = source.scm_instance()
503 source_scm = source_db_repo.scm_instance()
502 target_scm = target.scm_instance()
504 target_scm = target_db_repo.scm_instance()
503
505
504 commit_ranges = target_scm.compare(
506 commit_ranges = target_scm.compare(
505 target_commit.raw_id, source_commit.raw_id, source_scm,
507 target_commit.raw_id, source_commit.raw_id, source_scm,
506 merge=True, pre_load=[])
508 merge=True, pre_load=[])
507
509
508 ancestor = target_scm.get_common_ancestor(
510 ancestor = target_scm.get_common_ancestor(
509 target_commit.raw_id, source_commit.raw_id, source_scm)
511 target_commit.raw_id, source_commit.raw_id, source_scm)
510
512
511 if not commit_ranges:
513 if not commit_ranges:
512 raise JSONRPCError('no commits found')
514 raise JSONRPCError('no commits found')
513
515
514 if not ancestor:
516 if not ancestor:
515 raise JSONRPCError('no common ancestor found')
517 raise JSONRPCError('no common ancestor found')
516
518
517 reviewer_objects = Optional.extract(reviewers) or []
519 reviewer_objects = Optional.extract(reviewers) or []
520
518 if reviewer_objects:
521 if reviewer_objects:
519 schema = ReviewerListSchema()
522 schema = ReviewerListSchema()
520 try:
523 try:
521 reviewer_objects = schema.deserialize(reviewer_objects)
524 reviewer_objects = schema.deserialize(reviewer_objects)
522 except Invalid as err:
525 except Invalid as err:
523 raise JSONRPCValidationError(colander_exc=err)
526 raise JSONRPCValidationError(colander_exc=err)
524
527
525 reviewers = []
528 # validate users
526 for reviewer_object in reviewer_objects:
529 for reviewer_object in reviewer_objects:
527 user = get_user_or_error(reviewer_object['username'])
530 user = get_user_or_error(reviewer_object['username'])
528 reasons = reviewer_object['reasons']
531 reviewer_object['user_id'] = user.user_id
529 mandatory = reviewer_object['mandatory']
532
530 reviewers.append((user.user_id, reasons, mandatory))
533 get_default_reviewers_data, get_validated_reviewers = \
534 PullRequestModel().get_reviewer_functions()
535
536 reviewer_rules = get_default_reviewers_data(
537 apiuser.get_instance(), source_db_repo,
538 source_commit, target_db_repo, target_commit)
539
540 # specified rules are later re-validated, thus we can assume users will
541 # eventually provide those that meet the reviewer criteria.
542 if not reviewer_objects:
543 reviewer_objects = reviewer_rules['reviewers']
544
545 try:
546 reviewers = get_validated_reviewers(
547 reviewer_objects, reviewer_rules)
548 except ValueError as e:
549 raise JSONRPCError('Reviewers Validation: {}'.format(e))
531
550
532 pull_request_model = PullRequestModel()
551 pull_request_model = PullRequestModel()
533 pull_request = pull_request_model.create(
552 pull_request = pull_request_model.create(
534 created_by=apiuser.user_id,
553 created_by=apiuser.user_id,
535 source_repo=source_repo,
554 source_repo=source_repo,
536 source_ref=full_source_ref,
555 source_ref=full_source_ref,
537 target_repo=target_repo,
556 target_repo=target_repo,
538 target_ref=full_target_ref,
557 target_ref=full_target_ref,
539 revisions=reversed(
558 revisions=reversed(
540 [commit.raw_id for commit in reversed(commit_ranges)]),
559 [commit.raw_id for commit in reversed(commit_ranges)]),
541 reviewers=reviewers,
560 reviewers=reviewers,
542 title=title,
561 title=title,
543 description=Optional.extract(description)
562 description=Optional.extract(description)
544 )
563 )
545
564
546 Session().commit()
565 Session().commit()
547 data = {
566 data = {
548 'msg': 'Created new pull request `{}`'.format(title),
567 'msg': 'Created new pull request `{}`'.format(title),
549 'pull_request_id': pull_request.pull_request_id,
568 'pull_request_id': pull_request.pull_request_id,
550 }
569 }
551 return data
570 return data
552
571
553
572
554 @jsonrpc_method()
573 @jsonrpc_method()
555 def update_pull_request(
574 def update_pull_request(
556 request, apiuser, repoid, pullrequestid, title=Optional(''),
575 request, apiuser, repoid, pullrequestid, title=Optional(''),
557 description=Optional(''), reviewers=Optional(None),
576 description=Optional(''), reviewers=Optional(None),
558 update_commits=Optional(None)):
577 update_commits=Optional(None)):
559 """
578 """
560 Updates a pull request.
579 Updates a pull request.
561
580
562 :param apiuser: This is filled automatically from the |authtoken|.
581 :param apiuser: This is filled automatically from the |authtoken|.
563 :type apiuser: AuthUser
582 :type apiuser: AuthUser
564 :param repoid: The repository name or repository ID.
583 :param repoid: The repository name or repository ID.
565 :type repoid: str or int
584 :type repoid: str or int
566 :param pullrequestid: The pull request ID.
585 :param pullrequestid: The pull request ID.
567 :type pullrequestid: int
586 :type pullrequestid: int
568 :param title: Set the pull request title.
587 :param title: Set the pull request title.
569 :type title: str
588 :type title: str
570 :param description: Update pull request description.
589 :param description: Update pull request description.
571 :type description: Optional(str)
590 :type description: Optional(str)
572 :param reviewers: Update pull request reviewers list with new value.
591 :param reviewers: Update pull request reviewers list with new value.
573 :type reviewers: Optional(list)
592 :type reviewers: Optional(list)
574 Accepts username strings or objects of the format:
593 Accepts username strings or objects of the format:
575
594
576 {'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}
595 [{'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}]
577
596
578 :param update_commits: Trigger update of commits for this pull request
597 :param update_commits: Trigger update of commits for this pull request
579 :type: update_commits: Optional(bool)
598 :type: update_commits: Optional(bool)
580
599
581 Example output:
600 Example output:
582
601
583 .. code-block:: bash
602 .. code-block:: bash
584
603
585 id : <id_given_in_input>
604 id : <id_given_in_input>
586 result : {
605 result : {
587 "msg": "Updated pull request `63`",
606 "msg": "Updated pull request `63`",
588 "pull_request": <pull_request_object>,
607 "pull_request": <pull_request_object>,
589 "updated_reviewers": {
608 "updated_reviewers": {
590 "added": [
609 "added": [
591 "username"
610 "username"
592 ],
611 ],
593 "removed": []
612 "removed": []
594 },
613 },
595 "updated_commits": {
614 "updated_commits": {
596 "added": [
615 "added": [
597 "<sha1_hash>"
616 "<sha1_hash>"
598 ],
617 ],
599 "common": [
618 "common": [
600 "<sha1_hash>",
619 "<sha1_hash>",
601 "<sha1_hash>",
620 "<sha1_hash>",
602 ],
621 ],
603 "removed": []
622 "removed": []
604 }
623 }
605 }
624 }
606 error : null
625 error : null
607 """
626 """
608
627
609 repo = get_repo_or_error(repoid)
628 repo = get_repo_or_error(repoid)
610 pull_request = get_pull_request_or_error(pullrequestid)
629 pull_request = get_pull_request_or_error(pullrequestid)
611 if not PullRequestModel().check_user_update(
630 if not PullRequestModel().check_user_update(
612 pull_request, apiuser, api=True):
631 pull_request, apiuser, api=True):
613 raise JSONRPCError(
632 raise JSONRPCError(
614 'pull request `%s` update failed, no permission to update.' % (
633 'pull request `%s` update failed, no permission to update.' % (
615 pullrequestid,))
634 pullrequestid,))
616 if pull_request.is_closed():
635 if pull_request.is_closed():
617 raise JSONRPCError(
636 raise JSONRPCError(
618 'pull request `%s` update failed, pull request is closed' % (
637 'pull request `%s` update failed, pull request is closed' % (
619 pullrequestid,))
638 pullrequestid,))
620
639
621 reviewer_objects = Optional.extract(reviewers) or []
640 reviewer_objects = Optional.extract(reviewers) or []
641
622 if reviewer_objects:
642 if reviewer_objects:
623 schema = ReviewerListSchema()
643 schema = ReviewerListSchema()
624 try:
644 try:
625 reviewer_objects = schema.deserialize(reviewer_objects)
645 reviewer_objects = schema.deserialize(reviewer_objects)
626 except Invalid as err:
646 except Invalid as err:
627 raise JSONRPCValidationError(colander_exc=err)
647 raise JSONRPCValidationError(colander_exc=err)
628
648
629 reviewers = []
649 # validate users
630 for reviewer_object in reviewer_objects:
650 for reviewer_object in reviewer_objects:
631 user = get_user_or_error(reviewer_object['username'])
651 user = get_user_or_error(reviewer_object['username'])
632 reasons = reviewer_object['reasons']
652 reviewer_object['user_id'] = user.user_id
633 mandatory = reviewer_object['mandatory']
653
634 reviewers.append((user.user_id, reasons, mandatory))
654 get_default_reviewers_data, get_validated_reviewers = \
655 PullRequestModel().get_reviewer_functions()
656
657 # re-use stored rules
658 reviewer_rules = pull_request.reviewer_data
659 try:
660 reviewers = get_validated_reviewers(
661 reviewer_objects, reviewer_rules)
662 except ValueError as e:
663 raise JSONRPCError('Reviewers Validation: {}'.format(e))
664 else:
665 reviewers = []
635
666
636 title = Optional.extract(title)
667 title = Optional.extract(title)
637 description = Optional.extract(description)
668 description = Optional.extract(description)
638 if title or description:
669 if title or description:
639 PullRequestModel().edit(
670 PullRequestModel().edit(
640 pull_request, title or pull_request.title,
671 pull_request, title or pull_request.title,
641 description or pull_request.description)
672 description or pull_request.description)
642 Session().commit()
673 Session().commit()
643
674
644 commit_changes = {"added": [], "common": [], "removed": []}
675 commit_changes = {"added": [], "common": [], "removed": []}
645 if str2bool(Optional.extract(update_commits)):
676 if str2bool(Optional.extract(update_commits)):
646 if PullRequestModel().has_valid_update_type(pull_request):
677 if PullRequestModel().has_valid_update_type(pull_request):
647 update_response = PullRequestModel().update_commits(
678 update_response = PullRequestModel().update_commits(
648 pull_request)
679 pull_request)
649 commit_changes = update_response.changes or commit_changes
680 commit_changes = update_response.changes or commit_changes
650 Session().commit()
681 Session().commit()
651
682
652 reviewers_changes = {"added": [], "removed": []}
683 reviewers_changes = {"added": [], "removed": []}
653 if reviewers:
684 if reviewers:
654 added_reviewers, removed_reviewers = \
685 added_reviewers, removed_reviewers = \
655 PullRequestModel().update_reviewers(pull_request, reviewers)
686 PullRequestModel().update_reviewers(pull_request, reviewers)
656
687
657 reviewers_changes['added'] = sorted(
688 reviewers_changes['added'] = sorted(
658 [get_user_or_error(n).username for n in added_reviewers])
689 [get_user_or_error(n).username for n in added_reviewers])
659 reviewers_changes['removed'] = sorted(
690 reviewers_changes['removed'] = sorted(
660 [get_user_or_error(n).username for n in removed_reviewers])
691 [get_user_or_error(n).username for n in removed_reviewers])
661 Session().commit()
692 Session().commit()
662
693
663 data = {
694 data = {
664 'msg': 'Updated pull request `{}`'.format(
695 'msg': 'Updated pull request `{}`'.format(
665 pull_request.pull_request_id),
696 pull_request.pull_request_id),
666 'pull_request': pull_request.get_api_data(),
697 'pull_request': pull_request.get_api_data(),
667 'updated_commits': commit_changes,
698 'updated_commits': commit_changes,
668 'updated_reviewers': reviewers_changes
699 'updated_reviewers': reviewers_changes
669 }
700 }
670
701
671 return data
702 return data
672
703
673
704
674 @jsonrpc_method()
705 @jsonrpc_method()
675 def close_pull_request(
706 def close_pull_request(
676 request, apiuser, repoid, pullrequestid,
707 request, apiuser, repoid, pullrequestid,
677 userid=Optional(OAttr('apiuser')), message=Optional('')):
708 userid=Optional(OAttr('apiuser')), message=Optional('')):
678 """
709 """
679 Close the pull request specified by `pullrequestid`.
710 Close the pull request specified by `pullrequestid`.
680
711
681 :param apiuser: This is filled automatically from the |authtoken|.
712 :param apiuser: This is filled automatically from the |authtoken|.
682 :type apiuser: AuthUser
713 :type apiuser: AuthUser
683 :param repoid: Repository name or repository ID to which the pull
714 :param repoid: Repository name or repository ID to which the pull
684 request belongs.
715 request belongs.
685 :type repoid: str or int
716 :type repoid: str or int
686 :param pullrequestid: ID of the pull request to be closed.
717 :param pullrequestid: ID of the pull request to be closed.
687 :type pullrequestid: int
718 :type pullrequestid: int
688 :param userid: Close the pull request as this user.
719 :param userid: Close the pull request as this user.
689 :type userid: Optional(str or int)
720 :type userid: Optional(str or int)
690 :param message: Optional message to close the Pull Request with. If not
721 :param message: Optional message to close the Pull Request with. If not
691 specified it will be generated automatically.
722 specified it will be generated automatically.
692 :type message: Optional(str)
723 :type message: Optional(str)
693
724
694 Example output:
725 Example output:
695
726
696 .. code-block:: bash
727 .. code-block:: bash
697
728
698 "id": <id_given_in_input>,
729 "id": <id_given_in_input>,
699 "result": {
730 "result": {
700 "pull_request_id": "<int>",
731 "pull_request_id": "<int>",
701 "close_status": "<str:status_lbl>,
732 "close_status": "<str:status_lbl>,
702 "closed": "<bool>"
733 "closed": "<bool>"
703 },
734 },
704 "error": null
735 "error": null
705
736
706 """
737 """
707 _ = request.translate
738 _ = request.translate
708
739
709 repo = get_repo_or_error(repoid)
740 repo = get_repo_or_error(repoid)
710 if not isinstance(userid, Optional):
741 if not isinstance(userid, Optional):
711 if (has_superadmin_permission(apiuser) or
742 if (has_superadmin_permission(apiuser) or
712 HasRepoPermissionAnyApi('repository.admin')(
743 HasRepoPermissionAnyApi('repository.admin')(
713 user=apiuser, repo_name=repo.repo_name)):
744 user=apiuser, repo_name=repo.repo_name)):
714 apiuser = get_user_or_error(userid)
745 apiuser = get_user_or_error(userid)
715 else:
746 else:
716 raise JSONRPCError('userid is not the same as your user')
747 raise JSONRPCError('userid is not the same as your user')
717
748
718 pull_request = get_pull_request_or_error(pullrequestid)
749 pull_request = get_pull_request_or_error(pullrequestid)
719
750
720 if pull_request.is_closed():
751 if pull_request.is_closed():
721 raise JSONRPCError(
752 raise JSONRPCError(
722 'pull request `%s` is already closed' % (pullrequestid,))
753 'pull request `%s` is already closed' % (pullrequestid,))
723
754
724 # only owner or admin or person with write permissions
755 # only owner or admin or person with write permissions
725 allowed_to_close = PullRequestModel().check_user_update(
756 allowed_to_close = PullRequestModel().check_user_update(
726 pull_request, apiuser, api=True)
757 pull_request, apiuser, api=True)
727
758
728 if not allowed_to_close:
759 if not allowed_to_close:
729 raise JSONRPCError(
760 raise JSONRPCError(
730 'pull request `%s` close failed, no permission to close.' % (
761 'pull request `%s` close failed, no permission to close.' % (
731 pullrequestid,))
762 pullrequestid,))
732
763
733 # message we're using to close the PR, else it's automatically generated
764 # message we're using to close the PR, else it's automatically generated
734 message = Optional.extract(message)
765 message = Optional.extract(message)
735
766
736 # finally close the PR, with proper message comment
767 # finally close the PR, with proper message comment
737 comment, status = PullRequestModel().close_pull_request_with_comment(
768 comment, status = PullRequestModel().close_pull_request_with_comment(
738 pull_request, apiuser, repo, message=message)
769 pull_request, apiuser, repo, message=message)
739 status_lbl = ChangesetStatus.get_status_lbl(status)
770 status_lbl = ChangesetStatus.get_status_lbl(status)
740
771
741 Session().commit()
772 Session().commit()
742
773
743 data = {
774 data = {
744 'pull_request_id': pull_request.pull_request_id,
775 'pull_request_id': pull_request.pull_request_id,
745 'close_status': status_lbl,
776 'close_status': status_lbl,
746 'closed': True,
777 'closed': True,
747 }
778 }
748 return data
779 return data
@@ -1,1008 +1,1008 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2012-2017 RhodeCode GmbH
3 # Copyright (C) 2012-2017 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 """
21 """
22 pull requests controller for rhodecode for initializing pull requests
22 pull requests controller for rhodecode for initializing pull requests
23 """
23 """
24 import types
24 import types
25
25
26 import peppercorn
26 import peppercorn
27 import formencode
27 import formencode
28 import logging
28 import logging
29 import collections
29 import collections
30
30
31 from webob.exc import HTTPNotFound, HTTPForbidden, HTTPBadRequest
31 from webob.exc import HTTPNotFound, HTTPForbidden, HTTPBadRequest
32 from pylons import request, tmpl_context as c, url
32 from pylons import request, tmpl_context as c, url
33 from pylons.controllers.util import redirect
33 from pylons.controllers.util import redirect
34 from pylons.i18n.translation import _
34 from pylons.i18n.translation import _
35 from pyramid.threadlocal import get_current_registry
35 from pyramid.threadlocal import get_current_registry
36 from sqlalchemy.sql import func
36 from sqlalchemy.sql import func
37 from sqlalchemy.sql.expression import or_
37 from sqlalchemy.sql.expression import or_
38
38
39 from rhodecode import events
39 from rhodecode import events
40 from rhodecode.lib import auth, diffs, helpers as h, codeblocks
40 from rhodecode.lib import auth, diffs, helpers as h, codeblocks
41 from rhodecode.lib.ext_json import json
41 from rhodecode.lib.ext_json import json
42 from rhodecode.lib.base import (
42 from rhodecode.lib.base import (
43 BaseRepoController, render, vcs_operation_context)
43 BaseRepoController, render, vcs_operation_context)
44 from rhodecode.lib.auth import (
44 from rhodecode.lib.auth import (
45 LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
45 LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
46 HasAcceptedRepoType, XHRRequired)
46 HasAcceptedRepoType, XHRRequired)
47 from rhodecode.lib.channelstream import channelstream_request
47 from rhodecode.lib.channelstream import channelstream_request
48 from rhodecode.lib.utils import jsonify
48 from rhodecode.lib.utils import jsonify
49 from rhodecode.lib.utils2 import (
49 from rhodecode.lib.utils2 import (
50 safe_int, safe_str, str2bool, safe_unicode)
50 safe_int, safe_str, str2bool, safe_unicode)
51 from rhodecode.lib.vcs.backends.base import (
51 from rhodecode.lib.vcs.backends.base import (
52 EmptyCommit, UpdateFailureReason, EmptyRepository)
52 EmptyCommit, UpdateFailureReason, EmptyRepository)
53 from rhodecode.lib.vcs.exceptions import (
53 from rhodecode.lib.vcs.exceptions import (
54 EmptyRepositoryError, CommitDoesNotExistError, RepositoryRequirementError,
54 EmptyRepositoryError, CommitDoesNotExistError, RepositoryRequirementError,
55 NodeDoesNotExistError)
55 NodeDoesNotExistError)
56
56
57 from rhodecode.model.changeset_status import ChangesetStatusModel
57 from rhodecode.model.changeset_status import ChangesetStatusModel
58 from rhodecode.model.comment import CommentsModel
58 from rhodecode.model.comment import CommentsModel
59 from rhodecode.model.db import (PullRequest, ChangesetStatus, ChangesetComment,
59 from rhodecode.model.db import (PullRequest, ChangesetStatus, ChangesetComment,
60 Repository, PullRequestVersion)
60 Repository, PullRequestVersion)
61 from rhodecode.model.forms import PullRequestForm
61 from rhodecode.model.forms import PullRequestForm
62 from rhodecode.model.meta import Session
62 from rhodecode.model.meta import Session
63 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
63 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
64
64
65 log = logging.getLogger(__name__)
65 log = logging.getLogger(__name__)
66
66
67
67
68 class PullrequestsController(BaseRepoController):
68 class PullrequestsController(BaseRepoController):
69
69
70 def __before__(self):
70 def __before__(self):
71 super(PullrequestsController, self).__before__()
71 super(PullrequestsController, self).__before__()
72 c.REVIEW_STATUS_APPROVED = ChangesetStatus.STATUS_APPROVED
72 c.REVIEW_STATUS_APPROVED = ChangesetStatus.STATUS_APPROVED
73 c.REVIEW_STATUS_REJECTED = ChangesetStatus.STATUS_REJECTED
73 c.REVIEW_STATUS_REJECTED = ChangesetStatus.STATUS_REJECTED
74
74
75 @LoginRequired()
75 @LoginRequired()
76 @NotAnonymous()
76 @NotAnonymous()
77 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
77 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
78 'repository.admin')
78 'repository.admin')
79 @HasAcceptedRepoType('git', 'hg')
79 @HasAcceptedRepoType('git', 'hg')
80 def index(self):
80 def index(self):
81 source_repo = c.rhodecode_db_repo
81 source_repo = c.rhodecode_db_repo
82
82
83 try:
83 try:
84 source_repo.scm_instance().get_commit()
84 source_repo.scm_instance().get_commit()
85 except EmptyRepositoryError:
85 except EmptyRepositoryError:
86 h.flash(h.literal(_('There are no commits yet')),
86 h.flash(h.literal(_('There are no commits yet')),
87 category='warning')
87 category='warning')
88 redirect(h.route_path('repo_summary', repo_name=source_repo.repo_name))
88 redirect(h.route_path('repo_summary', repo_name=source_repo.repo_name))
89
89
90 commit_id = request.GET.get('commit')
90 commit_id = request.GET.get('commit')
91 branch_ref = request.GET.get('branch')
91 branch_ref = request.GET.get('branch')
92 bookmark_ref = request.GET.get('bookmark')
92 bookmark_ref = request.GET.get('bookmark')
93
93
94 try:
94 try:
95 source_repo_data = PullRequestModel().generate_repo_data(
95 source_repo_data = PullRequestModel().generate_repo_data(
96 source_repo, commit_id=commit_id,
96 source_repo, commit_id=commit_id,
97 branch=branch_ref, bookmark=bookmark_ref)
97 branch=branch_ref, bookmark=bookmark_ref)
98 except CommitDoesNotExistError as e:
98 except CommitDoesNotExistError as e:
99 log.exception(e)
99 log.exception(e)
100 h.flash(_('Commit does not exist'), 'error')
100 h.flash(_('Commit does not exist'), 'error')
101 redirect(url('pullrequest_home', repo_name=source_repo.repo_name))
101 redirect(url('pullrequest_home', repo_name=source_repo.repo_name))
102
102
103 default_target_repo = source_repo
103 default_target_repo = source_repo
104
104
105 if source_repo.parent:
105 if source_repo.parent:
106 parent_vcs_obj = source_repo.parent.scm_instance()
106 parent_vcs_obj = source_repo.parent.scm_instance()
107 if parent_vcs_obj and not parent_vcs_obj.is_empty():
107 if parent_vcs_obj and not parent_vcs_obj.is_empty():
108 # change default if we have a parent repo
108 # change default if we have a parent repo
109 default_target_repo = source_repo.parent
109 default_target_repo = source_repo.parent
110
110
111 target_repo_data = PullRequestModel().generate_repo_data(
111 target_repo_data = PullRequestModel().generate_repo_data(
112 default_target_repo)
112 default_target_repo)
113
113
114 selected_source_ref = source_repo_data['refs']['selected_ref']
114 selected_source_ref = source_repo_data['refs']['selected_ref']
115
115
116 title_source_ref = selected_source_ref.split(':', 2)[1]
116 title_source_ref = selected_source_ref.split(':', 2)[1]
117 c.default_title = PullRequestModel().generate_pullrequest_title(
117 c.default_title = PullRequestModel().generate_pullrequest_title(
118 source=source_repo.repo_name,
118 source=source_repo.repo_name,
119 source_ref=title_source_ref,
119 source_ref=title_source_ref,
120 target=default_target_repo.repo_name
120 target=default_target_repo.repo_name
121 )
121 )
122
122
123 c.default_repo_data = {
123 c.default_repo_data = {
124 'source_repo_name': source_repo.repo_name,
124 'source_repo_name': source_repo.repo_name,
125 'source_refs_json': json.dumps(source_repo_data),
125 'source_refs_json': json.dumps(source_repo_data),
126 'target_repo_name': default_target_repo.repo_name,
126 'target_repo_name': default_target_repo.repo_name,
127 'target_refs_json': json.dumps(target_repo_data),
127 'target_refs_json': json.dumps(target_repo_data),
128 }
128 }
129 c.default_source_ref = selected_source_ref
129 c.default_source_ref = selected_source_ref
130
130
131 return render('/pullrequests/pullrequest.mako')
131 return render('/pullrequests/pullrequest.mako')
132
132
133 @LoginRequired()
133 @LoginRequired()
134 @NotAnonymous()
134 @NotAnonymous()
135 @XHRRequired()
135 @XHRRequired()
136 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
136 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
137 'repository.admin')
137 'repository.admin')
138 @jsonify
138 @jsonify
139 def get_repo_refs(self, repo_name, target_repo_name):
139 def get_repo_refs(self, repo_name, target_repo_name):
140 repo = Repository.get_by_repo_name(target_repo_name)
140 repo = Repository.get_by_repo_name(target_repo_name)
141 if not repo:
141 if not repo:
142 raise HTTPNotFound
142 raise HTTPNotFound
143 return PullRequestModel().generate_repo_data(repo)
143 return PullRequestModel().generate_repo_data(repo)
144
144
145 @LoginRequired()
145 @LoginRequired()
146 @NotAnonymous()
146 @NotAnonymous()
147 @XHRRequired()
147 @XHRRequired()
148 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
148 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
149 'repository.admin')
149 'repository.admin')
150 @jsonify
150 @jsonify
151 def get_repo_destinations(self, repo_name):
151 def get_repo_destinations(self, repo_name):
152 repo = Repository.get_by_repo_name(repo_name)
152 repo = Repository.get_by_repo_name(repo_name)
153 if not repo:
153 if not repo:
154 raise HTTPNotFound
154 raise HTTPNotFound
155 filter_query = request.GET.get('query')
155 filter_query = request.GET.get('query')
156
156
157 query = Repository.query() \
157 query = Repository.query() \
158 .order_by(func.length(Repository.repo_name)) \
158 .order_by(func.length(Repository.repo_name)) \
159 .filter(or_(
159 .filter(or_(
160 Repository.repo_name == repo.repo_name,
160 Repository.repo_name == repo.repo_name,
161 Repository.fork_id == repo.repo_id))
161 Repository.fork_id == repo.repo_id))
162
162
163 if filter_query:
163 if filter_query:
164 ilike_expression = u'%{}%'.format(safe_unicode(filter_query))
164 ilike_expression = u'%{}%'.format(safe_unicode(filter_query))
165 query = query.filter(
165 query = query.filter(
166 Repository.repo_name.ilike(ilike_expression))
166 Repository.repo_name.ilike(ilike_expression))
167
167
168 add_parent = False
168 add_parent = False
169 if repo.parent:
169 if repo.parent:
170 if filter_query in repo.parent.repo_name:
170 if filter_query in repo.parent.repo_name:
171 parent_vcs_obj = repo.parent.scm_instance()
171 parent_vcs_obj = repo.parent.scm_instance()
172 if parent_vcs_obj and not parent_vcs_obj.is_empty():
172 if parent_vcs_obj and not parent_vcs_obj.is_empty():
173 add_parent = True
173 add_parent = True
174
174
175 limit = 20 - 1 if add_parent else 20
175 limit = 20 - 1 if add_parent else 20
176 all_repos = query.limit(limit).all()
176 all_repos = query.limit(limit).all()
177 if add_parent:
177 if add_parent:
178 all_repos += [repo.parent]
178 all_repos += [repo.parent]
179
179
180 repos = []
180 repos = []
181 for obj in self.scm_model.get_repos(all_repos):
181 for obj in self.scm_model.get_repos(all_repos):
182 repos.append({
182 repos.append({
183 'id': obj['name'],
183 'id': obj['name'],
184 'text': obj['name'],
184 'text': obj['name'],
185 'type': 'repo',
185 'type': 'repo',
186 'obj': obj['dbrepo']
186 'obj': obj['dbrepo']
187 })
187 })
188
188
189 data = {
189 data = {
190 'more': False,
190 'more': False,
191 'results': [{
191 'results': [{
192 'text': _('Repositories'),
192 'text': _('Repositories'),
193 'children': repos
193 'children': repos
194 }] if repos else []
194 }] if repos else []
195 }
195 }
196 return data
196 return data
197
197
198 @LoginRequired()
198 @LoginRequired()
199 @NotAnonymous()
199 @NotAnonymous()
200 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
200 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
201 'repository.admin')
201 'repository.admin')
202 @HasAcceptedRepoType('git', 'hg')
202 @HasAcceptedRepoType('git', 'hg')
203 @auth.CSRFRequired()
203 @auth.CSRFRequired()
204 def create(self, repo_name):
204 def create(self, repo_name):
205 repo = Repository.get_by_repo_name(repo_name)
205 repo = Repository.get_by_repo_name(repo_name)
206 if not repo:
206 if not repo:
207 raise HTTPNotFound
207 raise HTTPNotFound
208
208
209 controls = peppercorn.parse(request.POST.items())
209 controls = peppercorn.parse(request.POST.items())
210
210
211 try:
211 try:
212 _form = PullRequestForm(repo.repo_id)().to_python(controls)
212 _form = PullRequestForm(repo.repo_id)().to_python(controls)
213 except formencode.Invalid as errors:
213 except formencode.Invalid as errors:
214 if errors.error_dict.get('revisions'):
214 if errors.error_dict.get('revisions'):
215 msg = 'Revisions: %s' % errors.error_dict['revisions']
215 msg = 'Revisions: %s' % errors.error_dict['revisions']
216 elif errors.error_dict.get('pullrequest_title'):
216 elif errors.error_dict.get('pullrequest_title'):
217 msg = _('Pull request requires a title with min. 3 chars')
217 msg = _('Pull request requires a title with min. 3 chars')
218 else:
218 else:
219 msg = _('Error creating pull request: {}').format(errors)
219 msg = _('Error creating pull request: {}').format(errors)
220 log.exception(msg)
220 log.exception(msg)
221 h.flash(msg, 'error')
221 h.flash(msg, 'error')
222
222
223 # would rather just go back to form ...
223 # would rather just go back to form ...
224 return redirect(url('pullrequest_home', repo_name=repo_name))
224 return redirect(url('pullrequest_home', repo_name=repo_name))
225
225
226 source_repo = _form['source_repo']
226 source_repo = _form['source_repo']
227 source_ref = _form['source_ref']
227 source_ref = _form['source_ref']
228 target_repo = _form['target_repo']
228 target_repo = _form['target_repo']
229 target_ref = _form['target_ref']
229 target_ref = _form['target_ref']
230 commit_ids = _form['revisions'][::-1]
230 commit_ids = _form['revisions'][::-1]
231
231
232 # find the ancestor for this pr
232 # find the ancestor for this pr
233 source_db_repo = Repository.get_by_repo_name(_form['source_repo'])
233 source_db_repo = Repository.get_by_repo_name(_form['source_repo'])
234 target_db_repo = Repository.get_by_repo_name(_form['target_repo'])
234 target_db_repo = Repository.get_by_repo_name(_form['target_repo'])
235
235
236 source_scm = source_db_repo.scm_instance()
236 source_scm = source_db_repo.scm_instance()
237 target_scm = target_db_repo.scm_instance()
237 target_scm = target_db_repo.scm_instance()
238
238
239 source_commit = source_scm.get_commit(source_ref.split(':')[-1])
239 source_commit = source_scm.get_commit(source_ref.split(':')[-1])
240 target_commit = target_scm.get_commit(target_ref.split(':')[-1])
240 target_commit = target_scm.get_commit(target_ref.split(':')[-1])
241
241
242 ancestor = source_scm.get_common_ancestor(
242 ancestor = source_scm.get_common_ancestor(
243 source_commit.raw_id, target_commit.raw_id, target_scm)
243 source_commit.raw_id, target_commit.raw_id, target_scm)
244
244
245 target_ref_type, target_ref_name, __ = _form['target_ref'].split(':')
245 target_ref_type, target_ref_name, __ = _form['target_ref'].split(':')
246 target_ref = ':'.join((target_ref_type, target_ref_name, ancestor))
246 target_ref = ':'.join((target_ref_type, target_ref_name, ancestor))
247
247
248 pullrequest_title = _form['pullrequest_title']
248 pullrequest_title = _form['pullrequest_title']
249 title_source_ref = source_ref.split(':', 2)[1]
249 title_source_ref = source_ref.split(':', 2)[1]
250 if not pullrequest_title:
250 if not pullrequest_title:
251 pullrequest_title = PullRequestModel().generate_pullrequest_title(
251 pullrequest_title = PullRequestModel().generate_pullrequest_title(
252 source=source_repo,
252 source=source_repo,
253 source_ref=title_source_ref,
253 source_ref=title_source_ref,
254 target=target_repo
254 target=target_repo
255 )
255 )
256
256
257 description = _form['pullrequest_desc']
257 description = _form['pullrequest_desc']
258
258
259 get_default_reviewers_data, validate_default_reviewers = \
259 get_default_reviewers_data, validate_default_reviewers = \
260 PullRequestModel().get_reviewer_functions()
260 PullRequestModel().get_reviewer_functions()
261
261
262 # recalculate reviewers logic, to make sure we can validate this
262 # recalculate reviewers logic, to make sure we can validate this
263 reviewer_rules = get_default_reviewers_data(
263 reviewer_rules = get_default_reviewers_data(
264 c.rhodecode_user.get_instance(), source_db_repo,
264 c.rhodecode_user.get_instance(), source_db_repo,
265 source_commit, target_db_repo, target_commit)
265 source_commit, target_db_repo, target_commit)
266
266
267 reviewers = validate_default_reviewers(
267 given_reviewers = _form['review_members']
268 _form['review_members'], reviewer_rules)
268 reviewers = validate_default_reviewers(given_reviewers, reviewer_rules)
269
269
270 try:
270 try:
271 pull_request = PullRequestModel().create(
271 pull_request = PullRequestModel().create(
272 c.rhodecode_user.user_id, source_repo, source_ref, target_repo,
272 c.rhodecode_user.user_id, source_repo, source_ref, target_repo,
273 target_ref, commit_ids, reviewers, pullrequest_title,
273 target_ref, commit_ids, reviewers, pullrequest_title,
274 description, reviewer_rules
274 description, reviewer_rules
275 )
275 )
276 Session().commit()
276 Session().commit()
277 h.flash(_('Successfully opened new pull request'),
277 h.flash(_('Successfully opened new pull request'),
278 category='success')
278 category='success')
279 except Exception as e:
279 except Exception as e:
280 msg = _('Error occurred during creation of this pull request.')
280 msg = _('Error occurred during creation of this pull request.')
281 log.exception(msg)
281 log.exception(msg)
282 h.flash(msg, category='error')
282 h.flash(msg, category='error')
283 return redirect(url('pullrequest_home', repo_name=repo_name))
283 return redirect(url('pullrequest_home', repo_name=repo_name))
284
284
285 return redirect(url('pullrequest_show', repo_name=target_repo,
285 return redirect(url('pullrequest_show', repo_name=target_repo,
286 pull_request_id=pull_request.pull_request_id))
286 pull_request_id=pull_request.pull_request_id))
287
287
288 @LoginRequired()
288 @LoginRequired()
289 @NotAnonymous()
289 @NotAnonymous()
290 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
290 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
291 'repository.admin')
291 'repository.admin')
292 @auth.CSRFRequired()
292 @auth.CSRFRequired()
293 @jsonify
293 @jsonify
294 def update(self, repo_name, pull_request_id):
294 def update(self, repo_name, pull_request_id):
295 pull_request_id = safe_int(pull_request_id)
295 pull_request_id = safe_int(pull_request_id)
296 pull_request = PullRequest.get_or_404(pull_request_id)
296 pull_request = PullRequest.get_or_404(pull_request_id)
297 # only owner or admin can update it
297 # only owner or admin can update it
298 allowed_to_update = PullRequestModel().check_user_update(
298 allowed_to_update = PullRequestModel().check_user_update(
299 pull_request, c.rhodecode_user)
299 pull_request, c.rhodecode_user)
300 if allowed_to_update:
300 if allowed_to_update:
301 controls = peppercorn.parse(request.POST.items())
301 controls = peppercorn.parse(request.POST.items())
302
302
303 if 'review_members' in controls:
303 if 'review_members' in controls:
304 self._update_reviewers(
304 self._update_reviewers(
305 pull_request_id, controls['review_members'],
305 pull_request_id, controls['review_members'],
306 pull_request.reviewer_data)
306 pull_request.reviewer_data)
307 elif str2bool(request.POST.get('update_commits', 'false')):
307 elif str2bool(request.POST.get('update_commits', 'false')):
308 self._update_commits(pull_request)
308 self._update_commits(pull_request)
309 elif str2bool(request.POST.get('edit_pull_request', 'false')):
309 elif str2bool(request.POST.get('edit_pull_request', 'false')):
310 self._edit_pull_request(pull_request)
310 self._edit_pull_request(pull_request)
311 else:
311 else:
312 raise HTTPBadRequest()
312 raise HTTPBadRequest()
313 return True
313 return True
314 raise HTTPForbidden()
314 raise HTTPForbidden()
315
315
316 def _edit_pull_request(self, pull_request):
316 def _edit_pull_request(self, pull_request):
317 try:
317 try:
318 PullRequestModel().edit(
318 PullRequestModel().edit(
319 pull_request, request.POST.get('title'),
319 pull_request, request.POST.get('title'),
320 request.POST.get('description'))
320 request.POST.get('description'))
321 except ValueError:
321 except ValueError:
322 msg = _(u'Cannot update closed pull requests.')
322 msg = _(u'Cannot update closed pull requests.')
323 h.flash(msg, category='error')
323 h.flash(msg, category='error')
324 return
324 return
325 else:
325 else:
326 Session().commit()
326 Session().commit()
327
327
328 msg = _(u'Pull request title & description updated.')
328 msg = _(u'Pull request title & description updated.')
329 h.flash(msg, category='success')
329 h.flash(msg, category='success')
330 return
330 return
331
331
332 def _update_commits(self, pull_request):
332 def _update_commits(self, pull_request):
333 resp = PullRequestModel().update_commits(pull_request)
333 resp = PullRequestModel().update_commits(pull_request)
334
334
335 if resp.executed:
335 if resp.executed:
336
336
337 if resp.target_changed and resp.source_changed:
337 if resp.target_changed and resp.source_changed:
338 changed = 'target and source repositories'
338 changed = 'target and source repositories'
339 elif resp.target_changed and not resp.source_changed:
339 elif resp.target_changed and not resp.source_changed:
340 changed = 'target repository'
340 changed = 'target repository'
341 elif not resp.target_changed and resp.source_changed:
341 elif not resp.target_changed and resp.source_changed:
342 changed = 'source repository'
342 changed = 'source repository'
343 else:
343 else:
344 changed = 'nothing'
344 changed = 'nothing'
345
345
346 msg = _(
346 msg = _(
347 u'Pull request updated to "{source_commit_id}" with '
347 u'Pull request updated to "{source_commit_id}" with '
348 u'{count_added} added, {count_removed} removed commits. '
348 u'{count_added} added, {count_removed} removed commits. '
349 u'Source of changes: {change_source}')
349 u'Source of changes: {change_source}')
350 msg = msg.format(
350 msg = msg.format(
351 source_commit_id=pull_request.source_ref_parts.commit_id,
351 source_commit_id=pull_request.source_ref_parts.commit_id,
352 count_added=len(resp.changes.added),
352 count_added=len(resp.changes.added),
353 count_removed=len(resp.changes.removed),
353 count_removed=len(resp.changes.removed),
354 change_source=changed)
354 change_source=changed)
355 h.flash(msg, category='success')
355 h.flash(msg, category='success')
356
356
357 registry = get_current_registry()
357 registry = get_current_registry()
358 rhodecode_plugins = getattr(registry, 'rhodecode_plugins', {})
358 rhodecode_plugins = getattr(registry, 'rhodecode_plugins', {})
359 channelstream_config = rhodecode_plugins.get('channelstream', {})
359 channelstream_config = rhodecode_plugins.get('channelstream', {})
360 if channelstream_config.get('enabled'):
360 if channelstream_config.get('enabled'):
361 message = msg + (
361 message = msg + (
362 ' - <a onclick="window.location.reload()">'
362 ' - <a onclick="window.location.reload()">'
363 '<strong>{}</strong></a>'.format(_('Reload page')))
363 '<strong>{}</strong></a>'.format(_('Reload page')))
364 channel = '/repo${}$/pr/{}'.format(
364 channel = '/repo${}$/pr/{}'.format(
365 pull_request.target_repo.repo_name,
365 pull_request.target_repo.repo_name,
366 pull_request.pull_request_id
366 pull_request.pull_request_id
367 )
367 )
368 payload = {
368 payload = {
369 'type': 'message',
369 'type': 'message',
370 'user': 'system',
370 'user': 'system',
371 'exclude_users': [request.user.username],
371 'exclude_users': [request.user.username],
372 'channel': channel,
372 'channel': channel,
373 'message': {
373 'message': {
374 'message': message,
374 'message': message,
375 'level': 'success',
375 'level': 'success',
376 'topic': '/notifications'
376 'topic': '/notifications'
377 }
377 }
378 }
378 }
379 channelstream_request(
379 channelstream_request(
380 channelstream_config, [payload], '/message',
380 channelstream_config, [payload], '/message',
381 raise_exc=False)
381 raise_exc=False)
382 else:
382 else:
383 msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason]
383 msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason]
384 warning_reasons = [
384 warning_reasons = [
385 UpdateFailureReason.NO_CHANGE,
385 UpdateFailureReason.NO_CHANGE,
386 UpdateFailureReason.WRONG_REF_TYPE,
386 UpdateFailureReason.WRONG_REF_TYPE,
387 ]
387 ]
388 category = 'warning' if resp.reason in warning_reasons else 'error'
388 category = 'warning' if resp.reason in warning_reasons else 'error'
389 h.flash(msg, category=category)
389 h.flash(msg, category=category)
390
390
391 @auth.CSRFRequired()
391 @auth.CSRFRequired()
392 @LoginRequired()
392 @LoginRequired()
393 @NotAnonymous()
393 @NotAnonymous()
394 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
394 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
395 'repository.admin')
395 'repository.admin')
396 def merge(self, repo_name, pull_request_id):
396 def merge(self, repo_name, pull_request_id):
397 """
397 """
398 POST /{repo_name}/pull-request/{pull_request_id}
398 POST /{repo_name}/pull-request/{pull_request_id}
399
399
400 Merge will perform a server-side merge of the specified
400 Merge will perform a server-side merge of the specified
401 pull request, if the pull request is approved and mergeable.
401 pull request, if the pull request is approved and mergeable.
402 After successful merging, the pull request is automatically
402 After successful merging, the pull request is automatically
403 closed, with a relevant comment.
403 closed, with a relevant comment.
404 """
404 """
405 pull_request_id = safe_int(pull_request_id)
405 pull_request_id = safe_int(pull_request_id)
406 pull_request = PullRequest.get_or_404(pull_request_id)
406 pull_request = PullRequest.get_or_404(pull_request_id)
407 user = c.rhodecode_user
407 user = c.rhodecode_user
408
408
409 check = MergeCheck.validate(pull_request, user)
409 check = MergeCheck.validate(pull_request, user)
410 merge_possible = not check.failed
410 merge_possible = not check.failed
411
411
412 for err_type, error_msg in check.errors:
412 for err_type, error_msg in check.errors:
413 h.flash(error_msg, category=err_type)
413 h.flash(error_msg, category=err_type)
414
414
415 if merge_possible:
415 if merge_possible:
416 log.debug("Pre-conditions checked, trying to merge.")
416 log.debug("Pre-conditions checked, trying to merge.")
417 extras = vcs_operation_context(
417 extras = vcs_operation_context(
418 request.environ, repo_name=pull_request.target_repo.repo_name,
418 request.environ, repo_name=pull_request.target_repo.repo_name,
419 username=user.username, action='push',
419 username=user.username, action='push',
420 scm=pull_request.target_repo.repo_type)
420 scm=pull_request.target_repo.repo_type)
421 self._merge_pull_request(pull_request, user, extras)
421 self._merge_pull_request(pull_request, user, extras)
422
422
423 return redirect(url(
423 return redirect(url(
424 'pullrequest_show',
424 'pullrequest_show',
425 repo_name=pull_request.target_repo.repo_name,
425 repo_name=pull_request.target_repo.repo_name,
426 pull_request_id=pull_request.pull_request_id))
426 pull_request_id=pull_request.pull_request_id))
427
427
428 def _merge_pull_request(self, pull_request, user, extras):
428 def _merge_pull_request(self, pull_request, user, extras):
429 merge_resp = PullRequestModel().merge(
429 merge_resp = PullRequestModel().merge(
430 pull_request, user, extras=extras)
430 pull_request, user, extras=extras)
431
431
432 if merge_resp.executed:
432 if merge_resp.executed:
433 log.debug("The merge was successful, closing the pull request.")
433 log.debug("The merge was successful, closing the pull request.")
434 PullRequestModel().close_pull_request(
434 PullRequestModel().close_pull_request(
435 pull_request.pull_request_id, user)
435 pull_request.pull_request_id, user)
436 Session().commit()
436 Session().commit()
437 msg = _('Pull request was successfully merged and closed.')
437 msg = _('Pull request was successfully merged and closed.')
438 h.flash(msg, category='success')
438 h.flash(msg, category='success')
439 else:
439 else:
440 log.debug(
440 log.debug(
441 "The merge was not successful. Merge response: %s",
441 "The merge was not successful. Merge response: %s",
442 merge_resp)
442 merge_resp)
443 msg = PullRequestModel().merge_status_message(
443 msg = PullRequestModel().merge_status_message(
444 merge_resp.failure_reason)
444 merge_resp.failure_reason)
445 h.flash(msg, category='error')
445 h.flash(msg, category='error')
446
446
447 def _update_reviewers(self, pull_request_id, review_members, reviewer_rules):
447 def _update_reviewers(self, pull_request_id, review_members, reviewer_rules):
448
448
449 get_default_reviewers_data, validate_default_reviewers = \
449 get_default_reviewers_data, validate_default_reviewers = \
450 PullRequestModel().get_reviewer_functions()
450 PullRequestModel().get_reviewer_functions()
451
451
452 try:
452 try:
453 reviewers = validate_default_reviewers(review_members, reviewer_rules)
453 reviewers = validate_default_reviewers(review_members, reviewer_rules)
454 except ValueError as e:
454 except ValueError as e:
455 log.error('Reviewers Validation:{}'.format(e))
455 log.error('Reviewers Validation: {}'.format(e))
456 h.flash(e, category='error')
456 h.flash(e, category='error')
457 return
457 return
458
458
459 PullRequestModel().update_reviewers(pull_request_id, reviewers)
459 PullRequestModel().update_reviewers(pull_request_id, reviewers)
460 h.flash(_('Pull request reviewers updated.'), category='success')
460 h.flash(_('Pull request reviewers updated.'), category='success')
461 Session().commit()
461 Session().commit()
462
462
463 @LoginRequired()
463 @LoginRequired()
464 @NotAnonymous()
464 @NotAnonymous()
465 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
465 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
466 'repository.admin')
466 'repository.admin')
467 @auth.CSRFRequired()
467 @auth.CSRFRequired()
468 @jsonify
468 @jsonify
469 def delete(self, repo_name, pull_request_id):
469 def delete(self, repo_name, pull_request_id):
470 pull_request_id = safe_int(pull_request_id)
470 pull_request_id = safe_int(pull_request_id)
471 pull_request = PullRequest.get_or_404(pull_request_id)
471 pull_request = PullRequest.get_or_404(pull_request_id)
472
472
473 pr_closed = pull_request.is_closed()
473 pr_closed = pull_request.is_closed()
474 allowed_to_delete = PullRequestModel().check_user_delete(
474 allowed_to_delete = PullRequestModel().check_user_delete(
475 pull_request, c.rhodecode_user) and not pr_closed
475 pull_request, c.rhodecode_user) and not pr_closed
476
476
477 # only owner can delete it !
477 # only owner can delete it !
478 if allowed_to_delete:
478 if allowed_to_delete:
479 PullRequestModel().delete(pull_request)
479 PullRequestModel().delete(pull_request)
480 Session().commit()
480 Session().commit()
481 h.flash(_('Successfully deleted pull request'),
481 h.flash(_('Successfully deleted pull request'),
482 category='success')
482 category='success')
483 return redirect(url('my_account_pullrequests'))
483 return redirect(url('my_account_pullrequests'))
484
484
485 h.flash(_('Your are not allowed to delete this pull request'),
485 h.flash(_('Your are not allowed to delete this pull request'),
486 category='error')
486 category='error')
487 raise HTTPForbidden()
487 raise HTTPForbidden()
488
488
489 def _get_pr_version(self, pull_request_id, version=None):
489 def _get_pr_version(self, pull_request_id, version=None):
490 pull_request_id = safe_int(pull_request_id)
490 pull_request_id = safe_int(pull_request_id)
491 at_version = None
491 at_version = None
492
492
493 if version and version == 'latest':
493 if version and version == 'latest':
494 pull_request_ver = PullRequest.get(pull_request_id)
494 pull_request_ver = PullRequest.get(pull_request_id)
495 pull_request_obj = pull_request_ver
495 pull_request_obj = pull_request_ver
496 _org_pull_request_obj = pull_request_obj
496 _org_pull_request_obj = pull_request_obj
497 at_version = 'latest'
497 at_version = 'latest'
498 elif version:
498 elif version:
499 pull_request_ver = PullRequestVersion.get_or_404(version)
499 pull_request_ver = PullRequestVersion.get_or_404(version)
500 pull_request_obj = pull_request_ver
500 pull_request_obj = pull_request_ver
501 _org_pull_request_obj = pull_request_ver.pull_request
501 _org_pull_request_obj = pull_request_ver.pull_request
502 at_version = pull_request_ver.pull_request_version_id
502 at_version = pull_request_ver.pull_request_version_id
503 else:
503 else:
504 _org_pull_request_obj = pull_request_obj = PullRequest.get_or_404(
504 _org_pull_request_obj = pull_request_obj = PullRequest.get_or_404(
505 pull_request_id)
505 pull_request_id)
506
506
507 pull_request_display_obj = PullRequest.get_pr_display_object(
507 pull_request_display_obj = PullRequest.get_pr_display_object(
508 pull_request_obj, _org_pull_request_obj)
508 pull_request_obj, _org_pull_request_obj)
509
509
510 return _org_pull_request_obj, pull_request_obj, \
510 return _org_pull_request_obj, pull_request_obj, \
511 pull_request_display_obj, at_version
511 pull_request_display_obj, at_version
512
512
513 def _get_diffset(
513 def _get_diffset(
514 self, source_repo, source_ref_id, target_ref_id, target_commit,
514 self, source_repo, source_ref_id, target_ref_id, target_commit,
515 source_commit, diff_limit, file_limit, display_inline_comments):
515 source_commit, diff_limit, file_limit, display_inline_comments):
516 vcs_diff = PullRequestModel().get_diff(
516 vcs_diff = PullRequestModel().get_diff(
517 source_repo, source_ref_id, target_ref_id)
517 source_repo, source_ref_id, target_ref_id)
518
518
519 diff_processor = diffs.DiffProcessor(
519 diff_processor = diffs.DiffProcessor(
520 vcs_diff, format='newdiff', diff_limit=diff_limit,
520 vcs_diff, format='newdiff', diff_limit=diff_limit,
521 file_limit=file_limit, show_full_diff=c.fulldiff)
521 file_limit=file_limit, show_full_diff=c.fulldiff)
522
522
523 _parsed = diff_processor.prepare()
523 _parsed = diff_processor.prepare()
524
524
525 def _node_getter(commit):
525 def _node_getter(commit):
526 def get_node(fname):
526 def get_node(fname):
527 try:
527 try:
528 return commit.get_node(fname)
528 return commit.get_node(fname)
529 except NodeDoesNotExistError:
529 except NodeDoesNotExistError:
530 return None
530 return None
531
531
532 return get_node
532 return get_node
533
533
534 diffset = codeblocks.DiffSet(
534 diffset = codeblocks.DiffSet(
535 repo_name=c.repo_name,
535 repo_name=c.repo_name,
536 source_repo_name=c.source_repo.repo_name,
536 source_repo_name=c.source_repo.repo_name,
537 source_node_getter=_node_getter(target_commit),
537 source_node_getter=_node_getter(target_commit),
538 target_node_getter=_node_getter(source_commit),
538 target_node_getter=_node_getter(source_commit),
539 comments=display_inline_comments
539 comments=display_inline_comments
540 )
540 )
541 diffset = diffset.render_patchset(
541 diffset = diffset.render_patchset(
542 _parsed, target_commit.raw_id, source_commit.raw_id)
542 _parsed, target_commit.raw_id, source_commit.raw_id)
543
543
544 return diffset
544 return diffset
545
545
546 @LoginRequired()
546 @LoginRequired()
547 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
547 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
548 'repository.admin')
548 'repository.admin')
549 def show(self, repo_name, pull_request_id):
549 def show(self, repo_name, pull_request_id):
550 pull_request_id = safe_int(pull_request_id)
550 pull_request_id = safe_int(pull_request_id)
551 version = request.GET.get('version')
551 version = request.GET.get('version')
552 from_version = request.GET.get('from_version') or version
552 from_version = request.GET.get('from_version') or version
553 merge_checks = request.GET.get('merge_checks')
553 merge_checks = request.GET.get('merge_checks')
554 c.fulldiff = str2bool(request.GET.get('fulldiff'))
554 c.fulldiff = str2bool(request.GET.get('fulldiff'))
555
555
556 (pull_request_latest,
556 (pull_request_latest,
557 pull_request_at_ver,
557 pull_request_at_ver,
558 pull_request_display_obj,
558 pull_request_display_obj,
559 at_version) = self._get_pr_version(
559 at_version) = self._get_pr_version(
560 pull_request_id, version=version)
560 pull_request_id, version=version)
561 pr_closed = pull_request_latest.is_closed()
561 pr_closed = pull_request_latest.is_closed()
562
562
563 if pr_closed and (version or from_version):
563 if pr_closed and (version or from_version):
564 # not allow to browse versions
564 # not allow to browse versions
565 return redirect(h.url('pullrequest_show', repo_name=repo_name,
565 return redirect(h.url('pullrequest_show', repo_name=repo_name,
566 pull_request_id=pull_request_id))
566 pull_request_id=pull_request_id))
567
567
568 versions = pull_request_display_obj.versions()
568 versions = pull_request_display_obj.versions()
569
569
570 c.at_version = at_version
570 c.at_version = at_version
571 c.at_version_num = (at_version
571 c.at_version_num = (at_version
572 if at_version and at_version != 'latest'
572 if at_version and at_version != 'latest'
573 else None)
573 else None)
574 c.at_version_pos = ChangesetComment.get_index_from_version(
574 c.at_version_pos = ChangesetComment.get_index_from_version(
575 c.at_version_num, versions)
575 c.at_version_num, versions)
576
576
577 (prev_pull_request_latest,
577 (prev_pull_request_latest,
578 prev_pull_request_at_ver,
578 prev_pull_request_at_ver,
579 prev_pull_request_display_obj,
579 prev_pull_request_display_obj,
580 prev_at_version) = self._get_pr_version(
580 prev_at_version) = self._get_pr_version(
581 pull_request_id, version=from_version)
581 pull_request_id, version=from_version)
582
582
583 c.from_version = prev_at_version
583 c.from_version = prev_at_version
584 c.from_version_num = (prev_at_version
584 c.from_version_num = (prev_at_version
585 if prev_at_version and prev_at_version != 'latest'
585 if prev_at_version and prev_at_version != 'latest'
586 else None)
586 else None)
587 c.from_version_pos = ChangesetComment.get_index_from_version(
587 c.from_version_pos = ChangesetComment.get_index_from_version(
588 c.from_version_num, versions)
588 c.from_version_num, versions)
589
589
590 # define if we're in COMPARE mode or VIEW at version mode
590 # define if we're in COMPARE mode or VIEW at version mode
591 compare = at_version != prev_at_version
591 compare = at_version != prev_at_version
592
592
593 # pull_requests repo_name we opened it against
593 # pull_requests repo_name we opened it against
594 # ie. target_repo must match
594 # ie. target_repo must match
595 if repo_name != pull_request_at_ver.target_repo.repo_name:
595 if repo_name != pull_request_at_ver.target_repo.repo_name:
596 raise HTTPNotFound
596 raise HTTPNotFound
597
597
598 c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(
598 c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(
599 pull_request_at_ver)
599 pull_request_at_ver)
600
600
601 c.pull_request = pull_request_display_obj
601 c.pull_request = pull_request_display_obj
602 c.pull_request_latest = pull_request_latest
602 c.pull_request_latest = pull_request_latest
603
603
604 if compare or (at_version and not at_version == 'latest'):
604 if compare or (at_version and not at_version == 'latest'):
605 c.allowed_to_change_status = False
605 c.allowed_to_change_status = False
606 c.allowed_to_update = False
606 c.allowed_to_update = False
607 c.allowed_to_merge = False
607 c.allowed_to_merge = False
608 c.allowed_to_delete = False
608 c.allowed_to_delete = False
609 c.allowed_to_comment = False
609 c.allowed_to_comment = False
610 c.allowed_to_close = False
610 c.allowed_to_close = False
611 else:
611 else:
612 can_change_status = PullRequestModel().check_user_change_status(
612 can_change_status = PullRequestModel().check_user_change_status(
613 pull_request_at_ver, c.rhodecode_user)
613 pull_request_at_ver, c.rhodecode_user)
614 c.allowed_to_change_status = can_change_status and not pr_closed
614 c.allowed_to_change_status = can_change_status and not pr_closed
615
615
616 c.allowed_to_update = PullRequestModel().check_user_update(
616 c.allowed_to_update = PullRequestModel().check_user_update(
617 pull_request_latest, c.rhodecode_user) and not pr_closed
617 pull_request_latest, c.rhodecode_user) and not pr_closed
618 c.allowed_to_merge = PullRequestModel().check_user_merge(
618 c.allowed_to_merge = PullRequestModel().check_user_merge(
619 pull_request_latest, c.rhodecode_user) and not pr_closed
619 pull_request_latest, c.rhodecode_user) and not pr_closed
620 c.allowed_to_delete = PullRequestModel().check_user_delete(
620 c.allowed_to_delete = PullRequestModel().check_user_delete(
621 pull_request_latest, c.rhodecode_user) and not pr_closed
621 pull_request_latest, c.rhodecode_user) and not pr_closed
622 c.allowed_to_comment = not pr_closed
622 c.allowed_to_comment = not pr_closed
623 c.allowed_to_close = c.allowed_to_merge and not pr_closed
623 c.allowed_to_close = c.allowed_to_merge and not pr_closed
624
624
625 c.forbid_adding_reviewers = False
625 c.forbid_adding_reviewers = False
626 c.forbid_author_to_review = False
626 c.forbid_author_to_review = False
627 c.forbid_commit_author_to_review = False
627 c.forbid_commit_author_to_review = False
628
628
629 if pull_request_latest.reviewer_data and \
629 if pull_request_latest.reviewer_data and \
630 'rules' in pull_request_latest.reviewer_data:
630 'rules' in pull_request_latest.reviewer_data:
631 rules = pull_request_latest.reviewer_data['rules'] or {}
631 rules = pull_request_latest.reviewer_data['rules'] or {}
632 try:
632 try:
633 c.forbid_adding_reviewers = rules.get(
633 c.forbid_adding_reviewers = rules.get(
634 'forbid_adding_reviewers')
634 'forbid_adding_reviewers')
635 c.forbid_author_to_review = rules.get(
635 c.forbid_author_to_review = rules.get(
636 'forbid_author_to_review')
636 'forbid_author_to_review')
637 c.forbid_commit_author_to_review = rules.get(
637 c.forbid_commit_author_to_review = rules.get(
638 'forbid_commit_author_to_review')
638 'forbid_commit_author_to_review')
639 except Exception:
639 except Exception:
640 pass
640 pass
641
641
642 # check merge capabilities
642 # check merge capabilities
643 _merge_check = MergeCheck.validate(
643 _merge_check = MergeCheck.validate(
644 pull_request_latest, user=c.rhodecode_user)
644 pull_request_latest, user=c.rhodecode_user)
645 c.pr_merge_errors = _merge_check.error_details
645 c.pr_merge_errors = _merge_check.error_details
646 c.pr_merge_possible = not _merge_check.failed
646 c.pr_merge_possible = not _merge_check.failed
647 c.pr_merge_message = _merge_check.merge_msg
647 c.pr_merge_message = _merge_check.merge_msg
648
648
649 c.pull_request_review_status = _merge_check.review_status
649 c.pull_request_review_status = _merge_check.review_status
650 if merge_checks:
650 if merge_checks:
651 return render('/pullrequests/pullrequest_merge_checks.mako')
651 return render('/pullrequests/pullrequest_merge_checks.mako')
652
652
653 comments_model = CommentsModel()
653 comments_model = CommentsModel()
654
654
655 # reviewers and statuses
655 # reviewers and statuses
656 c.pull_request_reviewers = pull_request_at_ver.reviewers_statuses()
656 c.pull_request_reviewers = pull_request_at_ver.reviewers_statuses()
657 allowed_reviewers = [x[0].user_id for x in c.pull_request_reviewers]
657 allowed_reviewers = [x[0].user_id for x in c.pull_request_reviewers]
658
658
659 # GENERAL COMMENTS with versions #
659 # GENERAL COMMENTS with versions #
660 q = comments_model._all_general_comments_of_pull_request(pull_request_latest)
660 q = comments_model._all_general_comments_of_pull_request(pull_request_latest)
661 q = q.order_by(ChangesetComment.comment_id.asc())
661 q = q.order_by(ChangesetComment.comment_id.asc())
662 general_comments = q
662 general_comments = q
663
663
664 # pick comments we want to render at current version
664 # pick comments we want to render at current version
665 c.comment_versions = comments_model.aggregate_comments(
665 c.comment_versions = comments_model.aggregate_comments(
666 general_comments, versions, c.at_version_num)
666 general_comments, versions, c.at_version_num)
667 c.comments = c.comment_versions[c.at_version_num]['until']
667 c.comments = c.comment_versions[c.at_version_num]['until']
668
668
669 # INLINE COMMENTS with versions #
669 # INLINE COMMENTS with versions #
670 q = comments_model._all_inline_comments_of_pull_request(pull_request_latest)
670 q = comments_model._all_inline_comments_of_pull_request(pull_request_latest)
671 q = q.order_by(ChangesetComment.comment_id.asc())
671 q = q.order_by(ChangesetComment.comment_id.asc())
672 inline_comments = q
672 inline_comments = q
673
673
674 c.inline_versions = comments_model.aggregate_comments(
674 c.inline_versions = comments_model.aggregate_comments(
675 inline_comments, versions, c.at_version_num, inline=True)
675 inline_comments, versions, c.at_version_num, inline=True)
676
676
677 # inject latest version
677 # inject latest version
678 latest_ver = PullRequest.get_pr_display_object(
678 latest_ver = PullRequest.get_pr_display_object(
679 pull_request_latest, pull_request_latest)
679 pull_request_latest, pull_request_latest)
680
680
681 c.versions = versions + [latest_ver]
681 c.versions = versions + [latest_ver]
682
682
683 # if we use version, then do not show later comments
683 # if we use version, then do not show later comments
684 # than current version
684 # than current version
685 display_inline_comments = collections.defaultdict(
685 display_inline_comments = collections.defaultdict(
686 lambda: collections.defaultdict(list))
686 lambda: collections.defaultdict(list))
687 for co in inline_comments:
687 for co in inline_comments:
688 if c.at_version_num:
688 if c.at_version_num:
689 # pick comments that are at least UPTO given version, so we
689 # pick comments that are at least UPTO given version, so we
690 # don't render comments for higher version
690 # don't render comments for higher version
691 should_render = co.pull_request_version_id and \
691 should_render = co.pull_request_version_id and \
692 co.pull_request_version_id <= c.at_version_num
692 co.pull_request_version_id <= c.at_version_num
693 else:
693 else:
694 # showing all, for 'latest'
694 # showing all, for 'latest'
695 should_render = True
695 should_render = True
696
696
697 if should_render:
697 if should_render:
698 display_inline_comments[co.f_path][co.line_no].append(co)
698 display_inline_comments[co.f_path][co.line_no].append(co)
699
699
700 # load diff data into template context, if we use compare mode then
700 # load diff data into template context, if we use compare mode then
701 # diff is calculated based on changes between versions of PR
701 # diff is calculated based on changes between versions of PR
702
702
703 source_repo = pull_request_at_ver.source_repo
703 source_repo = pull_request_at_ver.source_repo
704 source_ref_id = pull_request_at_ver.source_ref_parts.commit_id
704 source_ref_id = pull_request_at_ver.source_ref_parts.commit_id
705
705
706 target_repo = pull_request_at_ver.target_repo
706 target_repo = pull_request_at_ver.target_repo
707 target_ref_id = pull_request_at_ver.target_ref_parts.commit_id
707 target_ref_id = pull_request_at_ver.target_ref_parts.commit_id
708
708
709 if compare:
709 if compare:
710 # in compare switch the diff base to latest commit from prev version
710 # in compare switch the diff base to latest commit from prev version
711 target_ref_id = prev_pull_request_display_obj.revisions[0]
711 target_ref_id = prev_pull_request_display_obj.revisions[0]
712
712
713 # despite opening commits for bookmarks/branches/tags, we always
713 # despite opening commits for bookmarks/branches/tags, we always
714 # convert this to rev to prevent changes after bookmark or branch change
714 # convert this to rev to prevent changes after bookmark or branch change
715 c.source_ref_type = 'rev'
715 c.source_ref_type = 'rev'
716 c.source_ref = source_ref_id
716 c.source_ref = source_ref_id
717
717
718 c.target_ref_type = 'rev'
718 c.target_ref_type = 'rev'
719 c.target_ref = target_ref_id
719 c.target_ref = target_ref_id
720
720
721 c.source_repo = source_repo
721 c.source_repo = source_repo
722 c.target_repo = target_repo
722 c.target_repo = target_repo
723
723
724 # diff_limit is the old behavior, will cut off the whole diff
724 # diff_limit is the old behavior, will cut off the whole diff
725 # if the limit is applied otherwise will just hide the
725 # if the limit is applied otherwise will just hide the
726 # big files from the front-end
726 # big files from the front-end
727 diff_limit = self.cut_off_limit_diff
727 diff_limit = self.cut_off_limit_diff
728 file_limit = self.cut_off_limit_file
728 file_limit = self.cut_off_limit_file
729
729
730 c.commit_ranges = []
730 c.commit_ranges = []
731 source_commit = EmptyCommit()
731 source_commit = EmptyCommit()
732 target_commit = EmptyCommit()
732 target_commit = EmptyCommit()
733 c.missing_requirements = False
733 c.missing_requirements = False
734
734
735 source_scm = source_repo.scm_instance()
735 source_scm = source_repo.scm_instance()
736 target_scm = target_repo.scm_instance()
736 target_scm = target_repo.scm_instance()
737
737
738 # try first shadow repo, fallback to regular repo
738 # try first shadow repo, fallback to regular repo
739 try:
739 try:
740 commits_source_repo = pull_request_latest.get_shadow_repo()
740 commits_source_repo = pull_request_latest.get_shadow_repo()
741 except Exception:
741 except Exception:
742 log.debug('Failed to get shadow repo', exc_info=True)
742 log.debug('Failed to get shadow repo', exc_info=True)
743 commits_source_repo = source_scm
743 commits_source_repo = source_scm
744
744
745 c.commits_source_repo = commits_source_repo
745 c.commits_source_repo = commits_source_repo
746 commit_cache = {}
746 commit_cache = {}
747 try:
747 try:
748 pre_load = ["author", "branch", "date", "message"]
748 pre_load = ["author", "branch", "date", "message"]
749 show_revs = pull_request_at_ver.revisions
749 show_revs = pull_request_at_ver.revisions
750 for rev in show_revs:
750 for rev in show_revs:
751 comm = commits_source_repo.get_commit(
751 comm = commits_source_repo.get_commit(
752 commit_id=rev, pre_load=pre_load)
752 commit_id=rev, pre_load=pre_load)
753 c.commit_ranges.append(comm)
753 c.commit_ranges.append(comm)
754 commit_cache[comm.raw_id] = comm
754 commit_cache[comm.raw_id] = comm
755
755
756 # Order here matters, we first need to get target, and then
756 # Order here matters, we first need to get target, and then
757 # the source
757 # the source
758 target_commit = commits_source_repo.get_commit(
758 target_commit = commits_source_repo.get_commit(
759 commit_id=safe_str(target_ref_id))
759 commit_id=safe_str(target_ref_id))
760
760
761 source_commit = commits_source_repo.get_commit(
761 source_commit = commits_source_repo.get_commit(
762 commit_id=safe_str(source_ref_id))
762 commit_id=safe_str(source_ref_id))
763
763
764 except CommitDoesNotExistError:
764 except CommitDoesNotExistError:
765 log.warning(
765 log.warning(
766 'Failed to get commit from `{}` repo'.format(
766 'Failed to get commit from `{}` repo'.format(
767 commits_source_repo), exc_info=True)
767 commits_source_repo), exc_info=True)
768 except RepositoryRequirementError:
768 except RepositoryRequirementError:
769 log.warning(
769 log.warning(
770 'Failed to get all required data from repo', exc_info=True)
770 'Failed to get all required data from repo', exc_info=True)
771 c.missing_requirements = True
771 c.missing_requirements = True
772
772
773 c.ancestor = None # set it to None, to hide it from PR view
773 c.ancestor = None # set it to None, to hide it from PR view
774
774
775 try:
775 try:
776 ancestor_id = source_scm.get_common_ancestor(
776 ancestor_id = source_scm.get_common_ancestor(
777 source_commit.raw_id, target_commit.raw_id, target_scm)
777 source_commit.raw_id, target_commit.raw_id, target_scm)
778 c.ancestor_commit = source_scm.get_commit(ancestor_id)
778 c.ancestor_commit = source_scm.get_commit(ancestor_id)
779 except Exception:
779 except Exception:
780 c.ancestor_commit = None
780 c.ancestor_commit = None
781
781
782 c.statuses = source_repo.statuses(
782 c.statuses = source_repo.statuses(
783 [x.raw_id for x in c.commit_ranges])
783 [x.raw_id for x in c.commit_ranges])
784
784
785 # auto collapse if we have more than limit
785 # auto collapse if we have more than limit
786 collapse_limit = diffs.DiffProcessor._collapse_commits_over
786 collapse_limit = diffs.DiffProcessor._collapse_commits_over
787 c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
787 c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
788 c.compare_mode = compare
788 c.compare_mode = compare
789
789
790 c.missing_commits = False
790 c.missing_commits = False
791 if (c.missing_requirements or isinstance(source_commit, EmptyCommit)
791 if (c.missing_requirements or isinstance(source_commit, EmptyCommit)
792 or source_commit == target_commit):
792 or source_commit == target_commit):
793
793
794 c.missing_commits = True
794 c.missing_commits = True
795 else:
795 else:
796
796
797 c.diffset = self._get_diffset(
797 c.diffset = self._get_diffset(
798 commits_source_repo, source_ref_id, target_ref_id,
798 commits_source_repo, source_ref_id, target_ref_id,
799 target_commit, source_commit,
799 target_commit, source_commit,
800 diff_limit, file_limit, display_inline_comments)
800 diff_limit, file_limit, display_inline_comments)
801
801
802 c.limited_diff = c.diffset.limited_diff
802 c.limited_diff = c.diffset.limited_diff
803
803
804 # calculate removed files that are bound to comments
804 # calculate removed files that are bound to comments
805 comment_deleted_files = [
805 comment_deleted_files = [
806 fname for fname in display_inline_comments
806 fname for fname in display_inline_comments
807 if fname not in c.diffset.file_stats]
807 if fname not in c.diffset.file_stats]
808
808
809 c.deleted_files_comments = collections.defaultdict(dict)
809 c.deleted_files_comments = collections.defaultdict(dict)
810 for fname, per_line_comments in display_inline_comments.items():
810 for fname, per_line_comments in display_inline_comments.items():
811 if fname in comment_deleted_files:
811 if fname in comment_deleted_files:
812 c.deleted_files_comments[fname]['stats'] = 0
812 c.deleted_files_comments[fname]['stats'] = 0
813 c.deleted_files_comments[fname]['comments'] = list()
813 c.deleted_files_comments[fname]['comments'] = list()
814 for lno, comments in per_line_comments.items():
814 for lno, comments in per_line_comments.items():
815 c.deleted_files_comments[fname]['comments'].extend(
815 c.deleted_files_comments[fname]['comments'].extend(
816 comments)
816 comments)
817
817
818 # this is a hack to properly display links, when creating PR, the
818 # this is a hack to properly display links, when creating PR, the
819 # compare view and others uses different notation, and
819 # compare view and others uses different notation, and
820 # compare_commits.mako renders links based on the target_repo.
820 # compare_commits.mako renders links based on the target_repo.
821 # We need to swap that here to generate it properly on the html side
821 # We need to swap that here to generate it properly on the html side
822 c.target_repo = c.source_repo
822 c.target_repo = c.source_repo
823
823
824 c.commit_statuses = ChangesetStatus.STATUSES
824 c.commit_statuses = ChangesetStatus.STATUSES
825
825
826 c.show_version_changes = not pr_closed
826 c.show_version_changes = not pr_closed
827 if c.show_version_changes:
827 if c.show_version_changes:
828 cur_obj = pull_request_at_ver
828 cur_obj = pull_request_at_ver
829 prev_obj = prev_pull_request_at_ver
829 prev_obj = prev_pull_request_at_ver
830
830
831 old_commit_ids = prev_obj.revisions
831 old_commit_ids = prev_obj.revisions
832 new_commit_ids = cur_obj.revisions
832 new_commit_ids = cur_obj.revisions
833 commit_changes = PullRequestModel()._calculate_commit_id_changes(
833 commit_changes = PullRequestModel()._calculate_commit_id_changes(
834 old_commit_ids, new_commit_ids)
834 old_commit_ids, new_commit_ids)
835 c.commit_changes_summary = commit_changes
835 c.commit_changes_summary = commit_changes
836
836
837 # calculate the diff for commits between versions
837 # calculate the diff for commits between versions
838 c.commit_changes = []
838 c.commit_changes = []
839 mark = lambda cs, fw: list(
839 mark = lambda cs, fw: list(
840 h.itertools.izip_longest([], cs, fillvalue=fw))
840 h.itertools.izip_longest([], cs, fillvalue=fw))
841 for c_type, raw_id in mark(commit_changes.added, 'a') \
841 for c_type, raw_id in mark(commit_changes.added, 'a') \
842 + mark(commit_changes.removed, 'r') \
842 + mark(commit_changes.removed, 'r') \
843 + mark(commit_changes.common, 'c'):
843 + mark(commit_changes.common, 'c'):
844
844
845 if raw_id in commit_cache:
845 if raw_id in commit_cache:
846 commit = commit_cache[raw_id]
846 commit = commit_cache[raw_id]
847 else:
847 else:
848 try:
848 try:
849 commit = commits_source_repo.get_commit(raw_id)
849 commit = commits_source_repo.get_commit(raw_id)
850 except CommitDoesNotExistError:
850 except CommitDoesNotExistError:
851 # in case we fail extracting still use "dummy" commit
851 # in case we fail extracting still use "dummy" commit
852 # for display in commit diff
852 # for display in commit diff
853 commit = h.AttributeDict(
853 commit = h.AttributeDict(
854 {'raw_id': raw_id,
854 {'raw_id': raw_id,
855 'message': 'EMPTY or MISSING COMMIT'})
855 'message': 'EMPTY or MISSING COMMIT'})
856 c.commit_changes.append([c_type, commit])
856 c.commit_changes.append([c_type, commit])
857
857
858 # current user review statuses for each version
858 # current user review statuses for each version
859 c.review_versions = {}
859 c.review_versions = {}
860 if c.rhodecode_user.user_id in allowed_reviewers:
860 if c.rhodecode_user.user_id in allowed_reviewers:
861 for co in general_comments:
861 for co in general_comments:
862 if co.author.user_id == c.rhodecode_user.user_id:
862 if co.author.user_id == c.rhodecode_user.user_id:
863 # each comment has a status change
863 # each comment has a status change
864 status = co.status_change
864 status = co.status_change
865 if status:
865 if status:
866 _ver_pr = status[0].comment.pull_request_version_id
866 _ver_pr = status[0].comment.pull_request_version_id
867 c.review_versions[_ver_pr] = status[0]
867 c.review_versions[_ver_pr] = status[0]
868
868
869 return render('/pullrequests/pullrequest_show.mako')
869 return render('/pullrequests/pullrequest_show.mako')
870
870
871 @LoginRequired()
871 @LoginRequired()
872 @NotAnonymous()
872 @NotAnonymous()
873 @HasRepoPermissionAnyDecorator(
873 @HasRepoPermissionAnyDecorator(
874 'repository.read', 'repository.write', 'repository.admin')
874 'repository.read', 'repository.write', 'repository.admin')
875 @auth.CSRFRequired()
875 @auth.CSRFRequired()
876 @jsonify
876 @jsonify
877 def comment(self, repo_name, pull_request_id):
877 def comment(self, repo_name, pull_request_id):
878 pull_request_id = safe_int(pull_request_id)
878 pull_request_id = safe_int(pull_request_id)
879 pull_request = PullRequest.get_or_404(pull_request_id)
879 pull_request = PullRequest.get_or_404(pull_request_id)
880 if pull_request.is_closed():
880 if pull_request.is_closed():
881 log.debug('comment: forbidden because pull request is closed')
881 log.debug('comment: forbidden because pull request is closed')
882 raise HTTPForbidden()
882 raise HTTPForbidden()
883
883
884 status = request.POST.get('changeset_status', None)
884 status = request.POST.get('changeset_status', None)
885 text = request.POST.get('text')
885 text = request.POST.get('text')
886 comment_type = request.POST.get('comment_type')
886 comment_type = request.POST.get('comment_type')
887 resolves_comment_id = request.POST.get('resolves_comment_id', None)
887 resolves_comment_id = request.POST.get('resolves_comment_id', None)
888 close_pull_request = request.POST.get('close_pull_request')
888 close_pull_request = request.POST.get('close_pull_request')
889
889
890 # the logic here should work like following, if we submit close
890 # the logic here should work like following, if we submit close
891 # pr comment, use `close_pull_request_with_comment` function
891 # pr comment, use `close_pull_request_with_comment` function
892 # else handle regular comment logic
892 # else handle regular comment logic
893 user = c.rhodecode_user
893 user = c.rhodecode_user
894 repo = c.rhodecode_db_repo
894 repo = c.rhodecode_db_repo
895
895
896 if close_pull_request:
896 if close_pull_request:
897 # only owner or admin or person with write permissions
897 # only owner or admin or person with write permissions
898 allowed_to_close = PullRequestModel().check_user_update(
898 allowed_to_close = PullRequestModel().check_user_update(
899 pull_request, c.rhodecode_user)
899 pull_request, c.rhodecode_user)
900 if not allowed_to_close:
900 if not allowed_to_close:
901 log.debug('comment: forbidden because not allowed to close '
901 log.debug('comment: forbidden because not allowed to close '
902 'pull request %s', pull_request_id)
902 'pull request %s', pull_request_id)
903 raise HTTPForbidden()
903 raise HTTPForbidden()
904 comment, status = PullRequestModel().close_pull_request_with_comment(
904 comment, status = PullRequestModel().close_pull_request_with_comment(
905 pull_request, user, repo, message=text)
905 pull_request, user, repo, message=text)
906 Session().flush()
906 Session().flush()
907 events.trigger(
907 events.trigger(
908 events.PullRequestCommentEvent(pull_request, comment))
908 events.PullRequestCommentEvent(pull_request, comment))
909
909
910 else:
910 else:
911 # regular comment case, could be inline, or one with status.
911 # regular comment case, could be inline, or one with status.
912 # for that one we check also permissions
912 # for that one we check also permissions
913
913
914 allowed_to_change_status = PullRequestModel().check_user_change_status(
914 allowed_to_change_status = PullRequestModel().check_user_change_status(
915 pull_request, c.rhodecode_user)
915 pull_request, c.rhodecode_user)
916
916
917 if status and allowed_to_change_status:
917 if status and allowed_to_change_status:
918 message = (_('Status change %(transition_icon)s %(status)s')
918 message = (_('Status change %(transition_icon)s %(status)s')
919 % {'transition_icon': '>',
919 % {'transition_icon': '>',
920 'status': ChangesetStatus.get_status_lbl(status)})
920 'status': ChangesetStatus.get_status_lbl(status)})
921 text = text or message
921 text = text or message
922
922
923 comment = CommentsModel().create(
923 comment = CommentsModel().create(
924 text=text,
924 text=text,
925 repo=c.rhodecode_db_repo.repo_id,
925 repo=c.rhodecode_db_repo.repo_id,
926 user=c.rhodecode_user.user_id,
926 user=c.rhodecode_user.user_id,
927 pull_request=pull_request_id,
927 pull_request=pull_request_id,
928 f_path=request.POST.get('f_path'),
928 f_path=request.POST.get('f_path'),
929 line_no=request.POST.get('line'),
929 line_no=request.POST.get('line'),
930 status_change=(ChangesetStatus.get_status_lbl(status)
930 status_change=(ChangesetStatus.get_status_lbl(status)
931 if status and allowed_to_change_status else None),
931 if status and allowed_to_change_status else None),
932 status_change_type=(status
932 status_change_type=(status
933 if status and allowed_to_change_status else None),
933 if status and allowed_to_change_status else None),
934 comment_type=comment_type,
934 comment_type=comment_type,
935 resolves_comment_id=resolves_comment_id
935 resolves_comment_id=resolves_comment_id
936 )
936 )
937
937
938 if allowed_to_change_status:
938 if allowed_to_change_status:
939 # calculate old status before we change it
939 # calculate old status before we change it
940 old_calculated_status = pull_request.calculated_review_status()
940 old_calculated_status = pull_request.calculated_review_status()
941
941
942 # get status if set !
942 # get status if set !
943 if status:
943 if status:
944 ChangesetStatusModel().set_status(
944 ChangesetStatusModel().set_status(
945 c.rhodecode_db_repo.repo_id,
945 c.rhodecode_db_repo.repo_id,
946 status,
946 status,
947 c.rhodecode_user.user_id,
947 c.rhodecode_user.user_id,
948 comment,
948 comment,
949 pull_request=pull_request_id
949 pull_request=pull_request_id
950 )
950 )
951
951
952 Session().flush()
952 Session().flush()
953 events.trigger(
953 events.trigger(
954 events.PullRequestCommentEvent(pull_request, comment))
954 events.PullRequestCommentEvent(pull_request, comment))
955
955
956 # we now calculate the status of pull request, and based on that
956 # we now calculate the status of pull request, and based on that
957 # calculation we set the commits status
957 # calculation we set the commits status
958 calculated_status = pull_request.calculated_review_status()
958 calculated_status = pull_request.calculated_review_status()
959 if old_calculated_status != calculated_status:
959 if old_calculated_status != calculated_status:
960 PullRequestModel()._trigger_pull_request_hook(
960 PullRequestModel()._trigger_pull_request_hook(
961 pull_request, c.rhodecode_user, 'review_status_change')
961 pull_request, c.rhodecode_user, 'review_status_change')
962
962
963 Session().commit()
963 Session().commit()
964
964
965 if not request.is_xhr:
965 if not request.is_xhr:
966 return redirect(h.url('pullrequest_show', repo_name=repo_name,
966 return redirect(h.url('pullrequest_show', repo_name=repo_name,
967 pull_request_id=pull_request_id))
967 pull_request_id=pull_request_id))
968
968
969 data = {
969 data = {
970 'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),
970 'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),
971 }
971 }
972 if comment:
972 if comment:
973 c.co = comment
973 c.co = comment
974 rendered_comment = render('changeset/changeset_comment_block.mako')
974 rendered_comment = render('changeset/changeset_comment_block.mako')
975 data.update(comment.get_dict())
975 data.update(comment.get_dict())
976 data.update({'rendered_text': rendered_comment})
976 data.update({'rendered_text': rendered_comment})
977
977
978 return data
978 return data
979
979
980 @LoginRequired()
980 @LoginRequired()
981 @NotAnonymous()
981 @NotAnonymous()
982 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
982 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
983 'repository.admin')
983 'repository.admin')
984 @auth.CSRFRequired()
984 @auth.CSRFRequired()
985 @jsonify
985 @jsonify
986 def delete_comment(self, repo_name, comment_id):
986 def delete_comment(self, repo_name, comment_id):
987 return self._delete_comment(comment_id)
987 return self._delete_comment(comment_id)
988
988
989 def _delete_comment(self, comment_id):
989 def _delete_comment(self, comment_id):
990 comment_id = safe_int(comment_id)
990 comment_id = safe_int(comment_id)
991 co = ChangesetComment.get_or_404(comment_id)
991 co = ChangesetComment.get_or_404(comment_id)
992 if co.pull_request.is_closed():
992 if co.pull_request.is_closed():
993 # don't allow deleting comments on closed pull request
993 # don't allow deleting comments on closed pull request
994 raise HTTPForbidden()
994 raise HTTPForbidden()
995
995
996 is_owner = co.author.user_id == c.rhodecode_user.user_id
996 is_owner = co.author.user_id == c.rhodecode_user.user_id
997 is_repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)
997 is_repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)
998 if h.HasPermissionAny('hg.admin')() or is_repo_admin or is_owner:
998 if h.HasPermissionAny('hg.admin')() or is_repo_admin or is_owner:
999 old_calculated_status = co.pull_request.calculated_review_status()
999 old_calculated_status = co.pull_request.calculated_review_status()
1000 CommentsModel().delete(comment=co)
1000 CommentsModel().delete(comment=co)
1001 Session().commit()
1001 Session().commit()
1002 calculated_status = co.pull_request.calculated_review_status()
1002 calculated_status = co.pull_request.calculated_review_status()
1003 if old_calculated_status != calculated_status:
1003 if old_calculated_status != calculated_status:
1004 PullRequestModel()._trigger_pull_request_hook(
1004 PullRequestModel()._trigger_pull_request_hook(
1005 co.pull_request, c.rhodecode_user, 'review_status_change')
1005 co.pull_request, c.rhodecode_user, 'review_status_change')
1006 return True
1006 return True
1007 else:
1007 else:
1008 raise HTTPForbidden()
1008 raise HTTPForbidden()
@@ -1,2028 +1,2035 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2010-2017 RhodeCode GmbH
3 # Copyright (C) 2010-2017 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 """
21 """
22 Helper functions
22 Helper functions
23
23
24 Consists of functions to typically be used within templates, but also
24 Consists of functions to typically be used within templates, but also
25 available to Controllers. This module is available to both as 'h'.
25 available to Controllers. This module is available to both as 'h'.
26 """
26 """
27
27
28 import random
28 import random
29 import hashlib
29 import hashlib
30 import StringIO
30 import StringIO
31 import urllib
31 import urllib
32 import math
32 import math
33 import logging
33 import logging
34 import re
34 import re
35 import urlparse
35 import urlparse
36 import time
36 import time
37 import string
37 import string
38 import hashlib
38 import hashlib
39 from collections import OrderedDict
39 from collections import OrderedDict
40
40
41 import pygments
41 import pygments
42 import itertools
42 import itertools
43 import fnmatch
43 import fnmatch
44
44
45 from datetime import datetime
45 from datetime import datetime
46 from functools import partial
46 from functools import partial
47 from pygments.formatters.html import HtmlFormatter
47 from pygments.formatters.html import HtmlFormatter
48 from pygments import highlight as code_highlight
48 from pygments import highlight as code_highlight
49 from pygments.lexers import (
49 from pygments.lexers import (
50 get_lexer_by_name, get_lexer_for_filename, get_lexer_for_mimetype)
50 get_lexer_by_name, get_lexer_for_filename, get_lexer_for_mimetype)
51 from pylons import url as pylons_url
51 from pylons import url as pylons_url
52 from pylons.i18n.translation import _, ungettext
52 from pylons.i18n.translation import _, ungettext
53 from pyramid.threadlocal import get_current_request
53 from pyramid.threadlocal import get_current_request
54
54
55 from webhelpers.html import literal, HTML, escape
55 from webhelpers.html import literal, HTML, escape
56 from webhelpers.html.tools import *
56 from webhelpers.html.tools import *
57 from webhelpers.html.builder import make_tag
57 from webhelpers.html.builder import make_tag
58 from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \
58 from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \
59 end_form, file, form as wh_form, hidden, image, javascript_link, link_to, \
59 end_form, file, form as wh_form, hidden, image, javascript_link, link_to, \
60 link_to_if, link_to_unless, ol, required_legend, select, stylesheet_link, \
60 link_to_if, link_to_unless, ol, required_legend, select, stylesheet_link, \
61 submit, text, password, textarea, title, ul, xml_declaration, radio
61 submit, text, password, textarea, title, ul, xml_declaration, radio
62 from webhelpers.html.tools import auto_link, button_to, highlight, \
62 from webhelpers.html.tools import auto_link, button_to, highlight, \
63 js_obfuscate, mail_to, strip_links, strip_tags, tag_re
63 js_obfuscate, mail_to, strip_links, strip_tags, tag_re
64 from webhelpers.pylonslib import Flash as _Flash
64 from webhelpers.pylonslib import Flash as _Flash
65 from webhelpers.text import chop_at, collapse, convert_accented_entities, \
65 from webhelpers.text import chop_at, collapse, convert_accented_entities, \
66 convert_misc_entities, lchop, plural, rchop, remove_formatting, \
66 convert_misc_entities, lchop, plural, rchop, remove_formatting, \
67 replace_whitespace, urlify, truncate, wrap_paragraphs
67 replace_whitespace, urlify, truncate, wrap_paragraphs
68 from webhelpers.date import time_ago_in_words
68 from webhelpers.date import time_ago_in_words
69 from webhelpers.paginate import Page as _Page
69 from webhelpers.paginate import Page as _Page
70 from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \
70 from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \
71 convert_boolean_attrs, NotGiven, _make_safe_id_component
71 convert_boolean_attrs, NotGiven, _make_safe_id_component
72 from webhelpers2.number import format_byte_size
72 from webhelpers2.number import format_byte_size
73
73
74 from rhodecode.lib.action_parser import action_parser
74 from rhodecode.lib.action_parser import action_parser
75 from rhodecode.lib.ext_json import json
75 from rhodecode.lib.ext_json import json
76 from rhodecode.lib.utils import repo_name_slug, get_custom_lexer
76 from rhodecode.lib.utils import repo_name_slug, get_custom_lexer
77 from rhodecode.lib.utils2 import str2bool, safe_unicode, safe_str, \
77 from rhodecode.lib.utils2 import str2bool, safe_unicode, safe_str, \
78 get_commit_safe, datetime_to_time, time_to_datetime, time_to_utcdatetime, \
78 get_commit_safe, datetime_to_time, time_to_datetime, time_to_utcdatetime, \
79 AttributeDict, safe_int, md5, md5_safe
79 AttributeDict, safe_int, md5, md5_safe
80 from rhodecode.lib.markup_renderer import MarkupRenderer, relative_links
80 from rhodecode.lib.markup_renderer import MarkupRenderer, relative_links
81 from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
81 from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
82 from rhodecode.lib.vcs.backends.base import BaseChangeset, EmptyCommit
82 from rhodecode.lib.vcs.backends.base import BaseChangeset, EmptyCommit
83 from rhodecode.config.conf import DATE_FORMAT, DATETIME_FORMAT
83 from rhodecode.config.conf import DATE_FORMAT, DATETIME_FORMAT
84 from rhodecode.model.changeset_status import ChangesetStatusModel
84 from rhodecode.model.changeset_status import ChangesetStatusModel
85 from rhodecode.model.db import Permission, User, Repository
85 from rhodecode.model.db import Permission, User, Repository
86 from rhodecode.model.repo_group import RepoGroupModel
86 from rhodecode.model.repo_group import RepoGroupModel
87 from rhodecode.model.settings import IssueTrackerSettingsModel
87 from rhodecode.model.settings import IssueTrackerSettingsModel
88
88
89 log = logging.getLogger(__name__)
89 log = logging.getLogger(__name__)
90
90
91
91
92 DEFAULT_USER = User.DEFAULT_USER
92 DEFAULT_USER = User.DEFAULT_USER
93 DEFAULT_USER_EMAIL = User.DEFAULT_USER_EMAIL
93 DEFAULT_USER_EMAIL = User.DEFAULT_USER_EMAIL
94
94
95
95
96 def url(*args, **kw):
96 def url(*args, **kw):
97 return pylons_url(*args, **kw)
97 return pylons_url(*args, **kw)
98
98
99
99
100 def pylons_url_current(*args, **kw):
100 def pylons_url_current(*args, **kw):
101 """
101 """
102 This function overrides pylons.url.current() which returns the current
102 This function overrides pylons.url.current() which returns the current
103 path so that it will also work from a pyramid only context. This
103 path so that it will also work from a pyramid only context. This
104 should be removed once port to pyramid is complete.
104 should be removed once port to pyramid is complete.
105 """
105 """
106 if not args and not kw:
106 if not args and not kw:
107 request = get_current_request()
107 request = get_current_request()
108 return request.path
108 return request.path
109 return pylons_url.current(*args, **kw)
109 return pylons_url.current(*args, **kw)
110
110
111 url.current = pylons_url_current
111 url.current = pylons_url_current
112
112
113
113
114 def url_replace(**qargs):
114 def url_replace(**qargs):
115 """ Returns the current request url while replacing query string args """
115 """ Returns the current request url while replacing query string args """
116
116
117 request = get_current_request()
117 request = get_current_request()
118 new_args = request.GET.mixed()
118 new_args = request.GET.mixed()
119 new_args.update(qargs)
119 new_args.update(qargs)
120 return url('', **new_args)
120 return url('', **new_args)
121
121
122
122
123 def asset(path, ver=None, **kwargs):
123 def asset(path, ver=None, **kwargs):
124 """
124 """
125 Helper to generate a static asset file path for rhodecode assets
125 Helper to generate a static asset file path for rhodecode assets
126
126
127 eg. h.asset('images/image.png', ver='3923')
127 eg. h.asset('images/image.png', ver='3923')
128
128
129 :param path: path of asset
129 :param path: path of asset
130 :param ver: optional version query param to append as ?ver=
130 :param ver: optional version query param to append as ?ver=
131 """
131 """
132 request = get_current_request()
132 request = get_current_request()
133 query = {}
133 query = {}
134 query.update(kwargs)
134 query.update(kwargs)
135 if ver:
135 if ver:
136 query = {'ver': ver}
136 query = {'ver': ver}
137 return request.static_path(
137 return request.static_path(
138 'rhodecode:public/{}'.format(path), _query=query)
138 'rhodecode:public/{}'.format(path), _query=query)
139
139
140
140
141 default_html_escape_table = {
141 default_html_escape_table = {
142 ord('&'): u'&amp;',
142 ord('&'): u'&amp;',
143 ord('<'): u'&lt;',
143 ord('<'): u'&lt;',
144 ord('>'): u'&gt;',
144 ord('>'): u'&gt;',
145 ord('"'): u'&quot;',
145 ord('"'): u'&quot;',
146 ord("'"): u'&#39;',
146 ord("'"): u'&#39;',
147 }
147 }
148
148
149
149
150 def html_escape(text, html_escape_table=default_html_escape_table):
150 def html_escape(text, html_escape_table=default_html_escape_table):
151 """Produce entities within text."""
151 """Produce entities within text."""
152 return text.translate(html_escape_table)
152 return text.translate(html_escape_table)
153
153
154
154
155 def chop_at_smart(s, sub, inclusive=False, suffix_if_chopped=None):
155 def chop_at_smart(s, sub, inclusive=False, suffix_if_chopped=None):
156 """
156 """
157 Truncate string ``s`` at the first occurrence of ``sub``.
157 Truncate string ``s`` at the first occurrence of ``sub``.
158
158
159 If ``inclusive`` is true, truncate just after ``sub`` rather than at it.
159 If ``inclusive`` is true, truncate just after ``sub`` rather than at it.
160 """
160 """
161 suffix_if_chopped = suffix_if_chopped or ''
161 suffix_if_chopped = suffix_if_chopped or ''
162 pos = s.find(sub)
162 pos = s.find(sub)
163 if pos == -1:
163 if pos == -1:
164 return s
164 return s
165
165
166 if inclusive:
166 if inclusive:
167 pos += len(sub)
167 pos += len(sub)
168
168
169 chopped = s[:pos]
169 chopped = s[:pos]
170 left = s[pos:].strip()
170 left = s[pos:].strip()
171
171
172 if left and suffix_if_chopped:
172 if left and suffix_if_chopped:
173 chopped += suffix_if_chopped
173 chopped += suffix_if_chopped
174
174
175 return chopped
175 return chopped
176
176
177
177
178 def shorter(text, size=20):
178 def shorter(text, size=20):
179 postfix = '...'
179 postfix = '...'
180 if len(text) > size:
180 if len(text) > size:
181 return text[:size - len(postfix)] + postfix
181 return text[:size - len(postfix)] + postfix
182 return text
182 return text
183
183
184
184
185 def _reset(name, value=None, id=NotGiven, type="reset", **attrs):
185 def _reset(name, value=None, id=NotGiven, type="reset", **attrs):
186 """
186 """
187 Reset button
187 Reset button
188 """
188 """
189 _set_input_attrs(attrs, type, name, value)
189 _set_input_attrs(attrs, type, name, value)
190 _set_id_attr(attrs, id, name)
190 _set_id_attr(attrs, id, name)
191 convert_boolean_attrs(attrs, ["disabled"])
191 convert_boolean_attrs(attrs, ["disabled"])
192 return HTML.input(**attrs)
192 return HTML.input(**attrs)
193
193
194 reset = _reset
194 reset = _reset
195 safeid = _make_safe_id_component
195 safeid = _make_safe_id_component
196
196
197
197
198 def branding(name, length=40):
198 def branding(name, length=40):
199 return truncate(name, length, indicator="")
199 return truncate(name, length, indicator="")
200
200
201
201
202 def FID(raw_id, path):
202 def FID(raw_id, path):
203 """
203 """
204 Creates a unique ID for filenode based on it's hash of path and commit
204 Creates a unique ID for filenode based on it's hash of path and commit
205 it's safe to use in urls
205 it's safe to use in urls
206
206
207 :param raw_id:
207 :param raw_id:
208 :param path:
208 :param path:
209 """
209 """
210
210
211 return 'c-%s-%s' % (short_id(raw_id), md5_safe(path)[:12])
211 return 'c-%s-%s' % (short_id(raw_id), md5_safe(path)[:12])
212
212
213
213
214 class _GetError(object):
214 class _GetError(object):
215 """Get error from form_errors, and represent it as span wrapped error
215 """Get error from form_errors, and represent it as span wrapped error
216 message
216 message
217
217
218 :param field_name: field to fetch errors for
218 :param field_name: field to fetch errors for
219 :param form_errors: form errors dict
219 :param form_errors: form errors dict
220 """
220 """
221
221
222 def __call__(self, field_name, form_errors):
222 def __call__(self, field_name, form_errors):
223 tmpl = """<span class="error_msg">%s</span>"""
223 tmpl = """<span class="error_msg">%s</span>"""
224 if form_errors and field_name in form_errors:
224 if form_errors and field_name in form_errors:
225 return literal(tmpl % form_errors.get(field_name))
225 return literal(tmpl % form_errors.get(field_name))
226
226
227 get_error = _GetError()
227 get_error = _GetError()
228
228
229
229
230 class _ToolTip(object):
230 class _ToolTip(object):
231
231
232 def __call__(self, tooltip_title, trim_at=50):
232 def __call__(self, tooltip_title, trim_at=50):
233 """
233 """
234 Special function just to wrap our text into nice formatted
234 Special function just to wrap our text into nice formatted
235 autowrapped text
235 autowrapped text
236
236
237 :param tooltip_title:
237 :param tooltip_title:
238 """
238 """
239 tooltip_title = escape(tooltip_title)
239 tooltip_title = escape(tooltip_title)
240 tooltip_title = tooltip_title.replace('<', '&lt;').replace('>', '&gt;')
240 tooltip_title = tooltip_title.replace('<', '&lt;').replace('>', '&gt;')
241 return tooltip_title
241 return tooltip_title
242 tooltip = _ToolTip()
242 tooltip = _ToolTip()
243
243
244
244
245 def files_breadcrumbs(repo_name, commit_id, file_path):
245 def files_breadcrumbs(repo_name, commit_id, file_path):
246 if isinstance(file_path, str):
246 if isinstance(file_path, str):
247 file_path = safe_unicode(file_path)
247 file_path = safe_unicode(file_path)
248
248
249 # TODO: johbo: Is this always a url like path, or is this operating
249 # TODO: johbo: Is this always a url like path, or is this operating
250 # system dependent?
250 # system dependent?
251 path_segments = file_path.split('/')
251 path_segments = file_path.split('/')
252
252
253 repo_name_html = escape(repo_name)
253 repo_name_html = escape(repo_name)
254 if len(path_segments) == 1 and path_segments[0] == '':
254 if len(path_segments) == 1 and path_segments[0] == '':
255 url_segments = [repo_name_html]
255 url_segments = [repo_name_html]
256 else:
256 else:
257 url_segments = [
257 url_segments = [
258 link_to(
258 link_to(
259 repo_name_html,
259 repo_name_html,
260 url('files_home',
260 url('files_home',
261 repo_name=repo_name,
261 repo_name=repo_name,
262 revision=commit_id,
262 revision=commit_id,
263 f_path=''),
263 f_path=''),
264 class_='pjax-link')]
264 class_='pjax-link')]
265
265
266 last_cnt = len(path_segments) - 1
266 last_cnt = len(path_segments) - 1
267 for cnt, segment in enumerate(path_segments):
267 for cnt, segment in enumerate(path_segments):
268 if not segment:
268 if not segment:
269 continue
269 continue
270 segment_html = escape(segment)
270 segment_html = escape(segment)
271
271
272 if cnt != last_cnt:
272 if cnt != last_cnt:
273 url_segments.append(
273 url_segments.append(
274 link_to(
274 link_to(
275 segment_html,
275 segment_html,
276 url('files_home',
276 url('files_home',
277 repo_name=repo_name,
277 repo_name=repo_name,
278 revision=commit_id,
278 revision=commit_id,
279 f_path='/'.join(path_segments[:cnt + 1])),
279 f_path='/'.join(path_segments[:cnt + 1])),
280 class_='pjax-link'))
280 class_='pjax-link'))
281 else:
281 else:
282 url_segments.append(segment_html)
282 url_segments.append(segment_html)
283
283
284 return literal('/'.join(url_segments))
284 return literal('/'.join(url_segments))
285
285
286
286
287 class CodeHtmlFormatter(HtmlFormatter):
287 class CodeHtmlFormatter(HtmlFormatter):
288 """
288 """
289 My code Html Formatter for source codes
289 My code Html Formatter for source codes
290 """
290 """
291
291
292 def wrap(self, source, outfile):
292 def wrap(self, source, outfile):
293 return self._wrap_div(self._wrap_pre(self._wrap_code(source)))
293 return self._wrap_div(self._wrap_pre(self._wrap_code(source)))
294
294
295 def _wrap_code(self, source):
295 def _wrap_code(self, source):
296 for cnt, it in enumerate(source):
296 for cnt, it in enumerate(source):
297 i, t = it
297 i, t = it
298 t = '<div id="L%s">%s</div>' % (cnt + 1, t)
298 t = '<div id="L%s">%s</div>' % (cnt + 1, t)
299 yield i, t
299 yield i, t
300
300
301 def _wrap_tablelinenos(self, inner):
301 def _wrap_tablelinenos(self, inner):
302 dummyoutfile = StringIO.StringIO()
302 dummyoutfile = StringIO.StringIO()
303 lncount = 0
303 lncount = 0
304 for t, line in inner:
304 for t, line in inner:
305 if t:
305 if t:
306 lncount += 1
306 lncount += 1
307 dummyoutfile.write(line)
307 dummyoutfile.write(line)
308
308
309 fl = self.linenostart
309 fl = self.linenostart
310 mw = len(str(lncount + fl - 1))
310 mw = len(str(lncount + fl - 1))
311 sp = self.linenospecial
311 sp = self.linenospecial
312 st = self.linenostep
312 st = self.linenostep
313 la = self.lineanchors
313 la = self.lineanchors
314 aln = self.anchorlinenos
314 aln = self.anchorlinenos
315 nocls = self.noclasses
315 nocls = self.noclasses
316 if sp:
316 if sp:
317 lines = []
317 lines = []
318
318
319 for i in range(fl, fl + lncount):
319 for i in range(fl, fl + lncount):
320 if i % st == 0:
320 if i % st == 0:
321 if i % sp == 0:
321 if i % sp == 0:
322 if aln:
322 if aln:
323 lines.append('<a href="#%s%d" class="special">%*d</a>' %
323 lines.append('<a href="#%s%d" class="special">%*d</a>' %
324 (la, i, mw, i))
324 (la, i, mw, i))
325 else:
325 else:
326 lines.append('<span class="special">%*d</span>' % (mw, i))
326 lines.append('<span class="special">%*d</span>' % (mw, i))
327 else:
327 else:
328 if aln:
328 if aln:
329 lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
329 lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
330 else:
330 else:
331 lines.append('%*d' % (mw, i))
331 lines.append('%*d' % (mw, i))
332 else:
332 else:
333 lines.append('')
333 lines.append('')
334 ls = '\n'.join(lines)
334 ls = '\n'.join(lines)
335 else:
335 else:
336 lines = []
336 lines = []
337 for i in range(fl, fl + lncount):
337 for i in range(fl, fl + lncount):
338 if i % st == 0:
338 if i % st == 0:
339 if aln:
339 if aln:
340 lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
340 lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
341 else:
341 else:
342 lines.append('%*d' % (mw, i))
342 lines.append('%*d' % (mw, i))
343 else:
343 else:
344 lines.append('')
344 lines.append('')
345 ls = '\n'.join(lines)
345 ls = '\n'.join(lines)
346
346
347 # in case you wonder about the seemingly redundant <div> here: since the
347 # in case you wonder about the seemingly redundant <div> here: since the
348 # content in the other cell also is wrapped in a div, some browsers in
348 # content in the other cell also is wrapped in a div, some browsers in
349 # some configurations seem to mess up the formatting...
349 # some configurations seem to mess up the formatting...
350 if nocls:
350 if nocls:
351 yield 0, ('<table class="%stable">' % self.cssclass +
351 yield 0, ('<table class="%stable">' % self.cssclass +
352 '<tr><td><div class="linenodiv" '
352 '<tr><td><div class="linenodiv" '
353 'style="background-color: #f0f0f0; padding-right: 10px">'
353 'style="background-color: #f0f0f0; padding-right: 10px">'
354 '<pre style="line-height: 125%">' +
354 '<pre style="line-height: 125%">' +
355 ls + '</pre></div></td><td id="hlcode" class="code">')
355 ls + '</pre></div></td><td id="hlcode" class="code">')
356 else:
356 else:
357 yield 0, ('<table class="%stable">' % self.cssclass +
357 yield 0, ('<table class="%stable">' % self.cssclass +
358 '<tr><td class="linenos"><div class="linenodiv"><pre>' +
358 '<tr><td class="linenos"><div class="linenodiv"><pre>' +
359 ls + '</pre></div></td><td id="hlcode" class="code">')
359 ls + '</pre></div></td><td id="hlcode" class="code">')
360 yield 0, dummyoutfile.getvalue()
360 yield 0, dummyoutfile.getvalue()
361 yield 0, '</td></tr></table>'
361 yield 0, '</td></tr></table>'
362
362
363
363
364 class SearchContentCodeHtmlFormatter(CodeHtmlFormatter):
364 class SearchContentCodeHtmlFormatter(CodeHtmlFormatter):
365 def __init__(self, **kw):
365 def __init__(self, **kw):
366 # only show these line numbers if set
366 # only show these line numbers if set
367 self.only_lines = kw.pop('only_line_numbers', [])
367 self.only_lines = kw.pop('only_line_numbers', [])
368 self.query_terms = kw.pop('query_terms', [])
368 self.query_terms = kw.pop('query_terms', [])
369 self.max_lines = kw.pop('max_lines', 5)
369 self.max_lines = kw.pop('max_lines', 5)
370 self.line_context = kw.pop('line_context', 3)
370 self.line_context = kw.pop('line_context', 3)
371 self.url = kw.pop('url', None)
371 self.url = kw.pop('url', None)
372
372
373 super(CodeHtmlFormatter, self).__init__(**kw)
373 super(CodeHtmlFormatter, self).__init__(**kw)
374
374
375 def _wrap_code(self, source):
375 def _wrap_code(self, source):
376 for cnt, it in enumerate(source):
376 for cnt, it in enumerate(source):
377 i, t = it
377 i, t = it
378 t = '<pre>%s</pre>' % t
378 t = '<pre>%s</pre>' % t
379 yield i, t
379 yield i, t
380
380
381 def _wrap_tablelinenos(self, inner):
381 def _wrap_tablelinenos(self, inner):
382 yield 0, '<table class="code-highlight %stable">' % self.cssclass
382 yield 0, '<table class="code-highlight %stable">' % self.cssclass
383
383
384 last_shown_line_number = 0
384 last_shown_line_number = 0
385 current_line_number = 1
385 current_line_number = 1
386
386
387 for t, line in inner:
387 for t, line in inner:
388 if not t:
388 if not t:
389 yield t, line
389 yield t, line
390 continue
390 continue
391
391
392 if current_line_number in self.only_lines:
392 if current_line_number in self.only_lines:
393 if last_shown_line_number + 1 != current_line_number:
393 if last_shown_line_number + 1 != current_line_number:
394 yield 0, '<tr>'
394 yield 0, '<tr>'
395 yield 0, '<td class="line">...</td>'
395 yield 0, '<td class="line">...</td>'
396 yield 0, '<td id="hlcode" class="code"></td>'
396 yield 0, '<td id="hlcode" class="code"></td>'
397 yield 0, '</tr>'
397 yield 0, '</tr>'
398
398
399 yield 0, '<tr>'
399 yield 0, '<tr>'
400 if self.url:
400 if self.url:
401 yield 0, '<td class="line"><a href="%s#L%i">%i</a></td>' % (
401 yield 0, '<td class="line"><a href="%s#L%i">%i</a></td>' % (
402 self.url, current_line_number, current_line_number)
402 self.url, current_line_number, current_line_number)
403 else:
403 else:
404 yield 0, '<td class="line"><a href="">%i</a></td>' % (
404 yield 0, '<td class="line"><a href="">%i</a></td>' % (
405 current_line_number)
405 current_line_number)
406 yield 0, '<td id="hlcode" class="code">' + line + '</td>'
406 yield 0, '<td id="hlcode" class="code">' + line + '</td>'
407 yield 0, '</tr>'
407 yield 0, '</tr>'
408
408
409 last_shown_line_number = current_line_number
409 last_shown_line_number = current_line_number
410
410
411 current_line_number += 1
411 current_line_number += 1
412
412
413
413
414 yield 0, '</table>'
414 yield 0, '</table>'
415
415
416
416
417 def extract_phrases(text_query):
417 def extract_phrases(text_query):
418 """
418 """
419 Extracts phrases from search term string making sure phrases
419 Extracts phrases from search term string making sure phrases
420 contained in double quotes are kept together - and discarding empty values
420 contained in double quotes are kept together - and discarding empty values
421 or fully whitespace values eg.
421 or fully whitespace values eg.
422
422
423 'some text "a phrase" more' => ['some', 'text', 'a phrase', 'more']
423 'some text "a phrase" more' => ['some', 'text', 'a phrase', 'more']
424
424
425 """
425 """
426
426
427 in_phrase = False
427 in_phrase = False
428 buf = ''
428 buf = ''
429 phrases = []
429 phrases = []
430 for char in text_query:
430 for char in text_query:
431 if in_phrase:
431 if in_phrase:
432 if char == '"': # end phrase
432 if char == '"': # end phrase
433 phrases.append(buf)
433 phrases.append(buf)
434 buf = ''
434 buf = ''
435 in_phrase = False
435 in_phrase = False
436 continue
436 continue
437 else:
437 else:
438 buf += char
438 buf += char
439 continue
439 continue
440 else:
440 else:
441 if char == '"': # start phrase
441 if char == '"': # start phrase
442 in_phrase = True
442 in_phrase = True
443 phrases.append(buf)
443 phrases.append(buf)
444 buf = ''
444 buf = ''
445 continue
445 continue
446 elif char == ' ':
446 elif char == ' ':
447 phrases.append(buf)
447 phrases.append(buf)
448 buf = ''
448 buf = ''
449 continue
449 continue
450 else:
450 else:
451 buf += char
451 buf += char
452
452
453 phrases.append(buf)
453 phrases.append(buf)
454 phrases = [phrase.strip() for phrase in phrases if phrase.strip()]
454 phrases = [phrase.strip() for phrase in phrases if phrase.strip()]
455 return phrases
455 return phrases
456
456
457
457
458 def get_matching_offsets(text, phrases):
458 def get_matching_offsets(text, phrases):
459 """
459 """
460 Returns a list of string offsets in `text` that the list of `terms` match
460 Returns a list of string offsets in `text` that the list of `terms` match
461
461
462 >>> get_matching_offsets('some text here', ['some', 'here'])
462 >>> get_matching_offsets('some text here', ['some', 'here'])
463 [(0, 4), (10, 14)]
463 [(0, 4), (10, 14)]
464
464
465 """
465 """
466 offsets = []
466 offsets = []
467 for phrase in phrases:
467 for phrase in phrases:
468 for match in re.finditer(phrase, text):
468 for match in re.finditer(phrase, text):
469 offsets.append((match.start(), match.end()))
469 offsets.append((match.start(), match.end()))
470
470
471 return offsets
471 return offsets
472
472
473
473
474 def normalize_text_for_matching(x):
474 def normalize_text_for_matching(x):
475 """
475 """
476 Replaces all non alnum characters to spaces and lower cases the string,
476 Replaces all non alnum characters to spaces and lower cases the string,
477 useful for comparing two text strings without punctuation
477 useful for comparing two text strings without punctuation
478 """
478 """
479 return re.sub(r'[^\w]', ' ', x.lower())
479 return re.sub(r'[^\w]', ' ', x.lower())
480
480
481
481
482 def get_matching_line_offsets(lines, terms):
482 def get_matching_line_offsets(lines, terms):
483 """ Return a set of `lines` indices (starting from 1) matching a
483 """ Return a set of `lines` indices (starting from 1) matching a
484 text search query, along with `context` lines above/below matching lines
484 text search query, along with `context` lines above/below matching lines
485
485
486 :param lines: list of strings representing lines
486 :param lines: list of strings representing lines
487 :param terms: search term string to match in lines eg. 'some text'
487 :param terms: search term string to match in lines eg. 'some text'
488 :param context: number of lines above/below a matching line to add to result
488 :param context: number of lines above/below a matching line to add to result
489 :param max_lines: cut off for lines of interest
489 :param max_lines: cut off for lines of interest
490 eg.
490 eg.
491
491
492 text = '''
492 text = '''
493 words words words
493 words words words
494 words words words
494 words words words
495 some text some
495 some text some
496 words words words
496 words words words
497 words words words
497 words words words
498 text here what
498 text here what
499 '''
499 '''
500 get_matching_line_offsets(text, 'text', context=1)
500 get_matching_line_offsets(text, 'text', context=1)
501 {3: [(5, 9)], 6: [(0, 4)]]
501 {3: [(5, 9)], 6: [(0, 4)]]
502
502
503 """
503 """
504 matching_lines = {}
504 matching_lines = {}
505 phrases = [normalize_text_for_matching(phrase)
505 phrases = [normalize_text_for_matching(phrase)
506 for phrase in extract_phrases(terms)]
506 for phrase in extract_phrases(terms)]
507
507
508 for line_index, line in enumerate(lines, start=1):
508 for line_index, line in enumerate(lines, start=1):
509 match_offsets = get_matching_offsets(
509 match_offsets = get_matching_offsets(
510 normalize_text_for_matching(line), phrases)
510 normalize_text_for_matching(line), phrases)
511 if match_offsets:
511 if match_offsets:
512 matching_lines[line_index] = match_offsets
512 matching_lines[line_index] = match_offsets
513
513
514 return matching_lines
514 return matching_lines
515
515
516
516
517 def hsv_to_rgb(h, s, v):
517 def hsv_to_rgb(h, s, v):
518 """ Convert hsv color values to rgb """
518 """ Convert hsv color values to rgb """
519
519
520 if s == 0.0:
520 if s == 0.0:
521 return v, v, v
521 return v, v, v
522 i = int(h * 6.0) # XXX assume int() truncates!
522 i = int(h * 6.0) # XXX assume int() truncates!
523 f = (h * 6.0) - i
523 f = (h * 6.0) - i
524 p = v * (1.0 - s)
524 p = v * (1.0 - s)
525 q = v * (1.0 - s * f)
525 q = v * (1.0 - s * f)
526 t = v * (1.0 - s * (1.0 - f))
526 t = v * (1.0 - s * (1.0 - f))
527 i = i % 6
527 i = i % 6
528 if i == 0:
528 if i == 0:
529 return v, t, p
529 return v, t, p
530 if i == 1:
530 if i == 1:
531 return q, v, p
531 return q, v, p
532 if i == 2:
532 if i == 2:
533 return p, v, t
533 return p, v, t
534 if i == 3:
534 if i == 3:
535 return p, q, v
535 return p, q, v
536 if i == 4:
536 if i == 4:
537 return t, p, v
537 return t, p, v
538 if i == 5:
538 if i == 5:
539 return v, p, q
539 return v, p, q
540
540
541
541
542 def unique_color_generator(n=10000, saturation=0.10, lightness=0.95):
542 def unique_color_generator(n=10000, saturation=0.10, lightness=0.95):
543 """
543 """
544 Generator for getting n of evenly distributed colors using
544 Generator for getting n of evenly distributed colors using
545 hsv color and golden ratio. It always return same order of colors
545 hsv color and golden ratio. It always return same order of colors
546
546
547 :param n: number of colors to generate
547 :param n: number of colors to generate
548 :param saturation: saturation of returned colors
548 :param saturation: saturation of returned colors
549 :param lightness: lightness of returned colors
549 :param lightness: lightness of returned colors
550 :returns: RGB tuple
550 :returns: RGB tuple
551 """
551 """
552
552
553 golden_ratio = 0.618033988749895
553 golden_ratio = 0.618033988749895
554 h = 0.22717784590367374
554 h = 0.22717784590367374
555
555
556 for _ in xrange(n):
556 for _ in xrange(n):
557 h += golden_ratio
557 h += golden_ratio
558 h %= 1
558 h %= 1
559 HSV_tuple = [h, saturation, lightness]
559 HSV_tuple = [h, saturation, lightness]
560 RGB_tuple = hsv_to_rgb(*HSV_tuple)
560 RGB_tuple = hsv_to_rgb(*HSV_tuple)
561 yield map(lambda x: str(int(x * 256)), RGB_tuple)
561 yield map(lambda x: str(int(x * 256)), RGB_tuple)
562
562
563
563
564 def color_hasher(n=10000, saturation=0.10, lightness=0.95):
564 def color_hasher(n=10000, saturation=0.10, lightness=0.95):
565 """
565 """
566 Returns a function which when called with an argument returns a unique
566 Returns a function which when called with an argument returns a unique
567 color for that argument, eg.
567 color for that argument, eg.
568
568
569 :param n: number of colors to generate
569 :param n: number of colors to generate
570 :param saturation: saturation of returned colors
570 :param saturation: saturation of returned colors
571 :param lightness: lightness of returned colors
571 :param lightness: lightness of returned colors
572 :returns: css RGB string
572 :returns: css RGB string
573
573
574 >>> color_hash = color_hasher()
574 >>> color_hash = color_hasher()
575 >>> color_hash('hello')
575 >>> color_hash('hello')
576 'rgb(34, 12, 59)'
576 'rgb(34, 12, 59)'
577 >>> color_hash('hello')
577 >>> color_hash('hello')
578 'rgb(34, 12, 59)'
578 'rgb(34, 12, 59)'
579 >>> color_hash('other')
579 >>> color_hash('other')
580 'rgb(90, 224, 159)'
580 'rgb(90, 224, 159)'
581 """
581 """
582
582
583 color_dict = {}
583 color_dict = {}
584 cgenerator = unique_color_generator(
584 cgenerator = unique_color_generator(
585 saturation=saturation, lightness=lightness)
585 saturation=saturation, lightness=lightness)
586
586
587 def get_color_string(thing):
587 def get_color_string(thing):
588 if thing in color_dict:
588 if thing in color_dict:
589 col = color_dict[thing]
589 col = color_dict[thing]
590 else:
590 else:
591 col = color_dict[thing] = cgenerator.next()
591 col = color_dict[thing] = cgenerator.next()
592 return "rgb(%s)" % (', '.join(col))
592 return "rgb(%s)" % (', '.join(col))
593
593
594 return get_color_string
594 return get_color_string
595
595
596
596
597 def get_lexer_safe(mimetype=None, filepath=None):
597 def get_lexer_safe(mimetype=None, filepath=None):
598 """
598 """
599 Tries to return a relevant pygments lexer using mimetype/filepath name,
599 Tries to return a relevant pygments lexer using mimetype/filepath name,
600 defaulting to plain text if none could be found
600 defaulting to plain text if none could be found
601 """
601 """
602 lexer = None
602 lexer = None
603 try:
603 try:
604 if mimetype:
604 if mimetype:
605 lexer = get_lexer_for_mimetype(mimetype)
605 lexer = get_lexer_for_mimetype(mimetype)
606 if not lexer:
606 if not lexer:
607 lexer = get_lexer_for_filename(filepath)
607 lexer = get_lexer_for_filename(filepath)
608 except pygments.util.ClassNotFound:
608 except pygments.util.ClassNotFound:
609 pass
609 pass
610
610
611 if not lexer:
611 if not lexer:
612 lexer = get_lexer_by_name('text')
612 lexer = get_lexer_by_name('text')
613
613
614 return lexer
614 return lexer
615
615
616
616
617 def get_lexer_for_filenode(filenode):
617 def get_lexer_for_filenode(filenode):
618 lexer = get_custom_lexer(filenode.extension) or filenode.lexer
618 lexer = get_custom_lexer(filenode.extension) or filenode.lexer
619 return lexer
619 return lexer
620
620
621
621
622 def pygmentize(filenode, **kwargs):
622 def pygmentize(filenode, **kwargs):
623 """
623 """
624 pygmentize function using pygments
624 pygmentize function using pygments
625
625
626 :param filenode:
626 :param filenode:
627 """
627 """
628 lexer = get_lexer_for_filenode(filenode)
628 lexer = get_lexer_for_filenode(filenode)
629 return literal(code_highlight(filenode.content, lexer,
629 return literal(code_highlight(filenode.content, lexer,
630 CodeHtmlFormatter(**kwargs)))
630 CodeHtmlFormatter(**kwargs)))
631
631
632
632
633 def is_following_repo(repo_name, user_id):
633 def is_following_repo(repo_name, user_id):
634 from rhodecode.model.scm import ScmModel
634 from rhodecode.model.scm import ScmModel
635 return ScmModel().is_following_repo(repo_name, user_id)
635 return ScmModel().is_following_repo(repo_name, user_id)
636
636
637
637
638 class _Message(object):
638 class _Message(object):
639 """A message returned by ``Flash.pop_messages()``.
639 """A message returned by ``Flash.pop_messages()``.
640
640
641 Converting the message to a string returns the message text. Instances
641 Converting the message to a string returns the message text. Instances
642 also have the following attributes:
642 also have the following attributes:
643
643
644 * ``message``: the message text.
644 * ``message``: the message text.
645 * ``category``: the category specified when the message was created.
645 * ``category``: the category specified when the message was created.
646 """
646 """
647
647
648 def __init__(self, category, message):
648 def __init__(self, category, message):
649 self.category = category
649 self.category = category
650 self.message = message
650 self.message = message
651
651
652 def __str__(self):
652 def __str__(self):
653 return self.message
653 return self.message
654
654
655 __unicode__ = __str__
655 __unicode__ = __str__
656
656
657 def __html__(self):
657 def __html__(self):
658 return escape(safe_unicode(self.message))
658 return escape(safe_unicode(self.message))
659
659
660
660
661 class Flash(_Flash):
661 class Flash(_Flash):
662
662
663 def pop_messages(self):
663 def pop_messages(self):
664 """Return all accumulated messages and delete them from the session.
664 """Return all accumulated messages and delete them from the session.
665
665
666 The return value is a list of ``Message`` objects.
666 The return value is a list of ``Message`` objects.
667 """
667 """
668 from pylons import session
668 from pylons import session
669
669
670 messages = []
670 messages = []
671
671
672 # Pop the 'old' pylons flash messages. They are tuples of the form
672 # Pop the 'old' pylons flash messages. They are tuples of the form
673 # (category, message)
673 # (category, message)
674 for cat, msg in session.pop(self.session_key, []):
674 for cat, msg in session.pop(self.session_key, []):
675 messages.append(_Message(cat, msg))
675 messages.append(_Message(cat, msg))
676
676
677 # Pop the 'new' pyramid flash messages for each category as list
677 # Pop the 'new' pyramid flash messages for each category as list
678 # of strings.
678 # of strings.
679 for cat in self.categories:
679 for cat in self.categories:
680 for msg in session.pop_flash(queue=cat):
680 for msg in session.pop_flash(queue=cat):
681 messages.append(_Message(cat, msg))
681 messages.append(_Message(cat, msg))
682 # Map messages from the default queue to the 'notice' category.
682 # Map messages from the default queue to the 'notice' category.
683 for msg in session.pop_flash():
683 for msg in session.pop_flash():
684 messages.append(_Message('notice', msg))
684 messages.append(_Message('notice', msg))
685
685
686 session.save()
686 session.save()
687 return messages
687 return messages
688
688
689 def json_alerts(self):
689 def json_alerts(self):
690 payloads = []
690 payloads = []
691 messages = flash.pop_messages()
691 messages = flash.pop_messages()
692 if messages:
692 if messages:
693 for message in messages:
693 for message in messages:
694 subdata = {}
694 subdata = {}
695 if hasattr(message.message, 'rsplit'):
695 if hasattr(message.message, 'rsplit'):
696 flash_data = message.message.rsplit('|DELIM|', 1)
696 flash_data = message.message.rsplit('|DELIM|', 1)
697 org_message = flash_data[0]
697 org_message = flash_data[0]
698 if len(flash_data) > 1:
698 if len(flash_data) > 1:
699 subdata = json.loads(flash_data[1])
699 subdata = json.loads(flash_data[1])
700 else:
700 else:
701 org_message = message.message
701 org_message = message.message
702 payloads.append({
702 payloads.append({
703 'message': {
703 'message': {
704 'message': u'{}'.format(org_message),
704 'message': u'{}'.format(org_message),
705 'level': message.category,
705 'level': message.category,
706 'force': True,
706 'force': True,
707 'subdata': subdata
707 'subdata': subdata
708 }
708 }
709 })
709 })
710 return json.dumps(payloads)
710 return json.dumps(payloads)
711
711
712 flash = Flash()
712 flash = Flash()
713
713
714 #==============================================================================
714 #==============================================================================
715 # SCM FILTERS available via h.
715 # SCM FILTERS available via h.
716 #==============================================================================
716 #==============================================================================
717 from rhodecode.lib.vcs.utils import author_name, author_email
717 from rhodecode.lib.vcs.utils import author_name, author_email
718 from rhodecode.lib.utils2 import credentials_filter, age as _age
718 from rhodecode.lib.utils2 import credentials_filter, age as _age
719 from rhodecode.model.db import User, ChangesetStatus
719 from rhodecode.model.db import User, ChangesetStatus
720
720
721 age = _age
721 age = _age
722 capitalize = lambda x: x.capitalize()
722 capitalize = lambda x: x.capitalize()
723 email = author_email
723 email = author_email
724 short_id = lambda x: x[:12]
724 short_id = lambda x: x[:12]
725 hide_credentials = lambda x: ''.join(credentials_filter(x))
725 hide_credentials = lambda x: ''.join(credentials_filter(x))
726
726
727
727
728 def age_component(datetime_iso, value=None, time_is_local=False):
728 def age_component(datetime_iso, value=None, time_is_local=False):
729 title = value or format_date(datetime_iso)
729 title = value or format_date(datetime_iso)
730 tzinfo = '+00:00'
730 tzinfo = '+00:00'
731
731
732 # detect if we have a timezone info, otherwise, add it
732 # detect if we have a timezone info, otherwise, add it
733 if isinstance(datetime_iso, datetime) and not datetime_iso.tzinfo:
733 if isinstance(datetime_iso, datetime) and not datetime_iso.tzinfo:
734 if time_is_local:
734 if time_is_local:
735 tzinfo = time.strftime("+%H:%M",
735 tzinfo = time.strftime("+%H:%M",
736 time.gmtime(
736 time.gmtime(
737 (datetime.now() - datetime.utcnow()).seconds + 1
737 (datetime.now() - datetime.utcnow()).seconds + 1
738 )
738 )
739 )
739 )
740
740
741 return literal(
741 return literal(
742 '<time class="timeago tooltip" '
742 '<time class="timeago tooltip" '
743 'title="{1}{2}" datetime="{0}{2}">{1}</time>'.format(
743 'title="{1}{2}" datetime="{0}{2}">{1}</time>'.format(
744 datetime_iso, title, tzinfo))
744 datetime_iso, title, tzinfo))
745
745
746
746
747 def _shorten_commit_id(commit_id):
747 def _shorten_commit_id(commit_id):
748 from rhodecode import CONFIG
748 from rhodecode import CONFIG
749 def_len = safe_int(CONFIG.get('rhodecode_show_sha_length', 12))
749 def_len = safe_int(CONFIG.get('rhodecode_show_sha_length', 12))
750 return commit_id[:def_len]
750 return commit_id[:def_len]
751
751
752
752
753 def show_id(commit):
753 def show_id(commit):
754 """
754 """
755 Configurable function that shows ID
755 Configurable function that shows ID
756 by default it's r123:fffeeefffeee
756 by default it's r123:fffeeefffeee
757
757
758 :param commit: commit instance
758 :param commit: commit instance
759 """
759 """
760 from rhodecode import CONFIG
760 from rhodecode import CONFIG
761 show_idx = str2bool(CONFIG.get('rhodecode_show_revision_number', True))
761 show_idx = str2bool(CONFIG.get('rhodecode_show_revision_number', True))
762
762
763 raw_id = _shorten_commit_id(commit.raw_id)
763 raw_id = _shorten_commit_id(commit.raw_id)
764 if show_idx:
764 if show_idx:
765 return 'r%s:%s' % (commit.idx, raw_id)
765 return 'r%s:%s' % (commit.idx, raw_id)
766 else:
766 else:
767 return '%s' % (raw_id, )
767 return '%s' % (raw_id, )
768
768
769
769
770 def format_date(date):
770 def format_date(date):
771 """
771 """
772 use a standardized formatting for dates used in RhodeCode
772 use a standardized formatting for dates used in RhodeCode
773
773
774 :param date: date/datetime object
774 :param date: date/datetime object
775 :return: formatted date
775 :return: formatted date
776 """
776 """
777
777
778 if date:
778 if date:
779 _fmt = "%a, %d %b %Y %H:%M:%S"
779 _fmt = "%a, %d %b %Y %H:%M:%S"
780 return safe_unicode(date.strftime(_fmt))
780 return safe_unicode(date.strftime(_fmt))
781
781
782 return u""
782 return u""
783
783
784
784
785 class _RepoChecker(object):
785 class _RepoChecker(object):
786
786
787 def __init__(self, backend_alias):
787 def __init__(self, backend_alias):
788 self._backend_alias = backend_alias
788 self._backend_alias = backend_alias
789
789
790 def __call__(self, repository):
790 def __call__(self, repository):
791 if hasattr(repository, 'alias'):
791 if hasattr(repository, 'alias'):
792 _type = repository.alias
792 _type = repository.alias
793 elif hasattr(repository, 'repo_type'):
793 elif hasattr(repository, 'repo_type'):
794 _type = repository.repo_type
794 _type = repository.repo_type
795 else:
795 else:
796 _type = repository
796 _type = repository
797 return _type == self._backend_alias
797 return _type == self._backend_alias
798
798
799 is_git = _RepoChecker('git')
799 is_git = _RepoChecker('git')
800 is_hg = _RepoChecker('hg')
800 is_hg = _RepoChecker('hg')
801 is_svn = _RepoChecker('svn')
801 is_svn = _RepoChecker('svn')
802
802
803
803
804 def get_repo_type_by_name(repo_name):
804 def get_repo_type_by_name(repo_name):
805 repo = Repository.get_by_repo_name(repo_name)
805 repo = Repository.get_by_repo_name(repo_name)
806 return repo.repo_type
806 return repo.repo_type
807
807
808
808
809 def is_svn_without_proxy(repository):
809 def is_svn_without_proxy(repository):
810 if is_svn(repository):
810 if is_svn(repository):
811 from rhodecode.model.settings import VcsSettingsModel
811 from rhodecode.model.settings import VcsSettingsModel
812 conf = VcsSettingsModel().get_ui_settings_as_config_obj()
812 conf = VcsSettingsModel().get_ui_settings_as_config_obj()
813 return not str2bool(conf.get('vcs_svn_proxy', 'http_requests_enabled'))
813 return not str2bool(conf.get('vcs_svn_proxy', 'http_requests_enabled'))
814 return False
814 return False
815
815
816
816
817 def discover_user(author):
817 def discover_user(author):
818 """
818 """
819 Tries to discover RhodeCode User based on the autho string. Author string
819 Tries to discover RhodeCode User based on the autho string. Author string
820 is typically `FirstName LastName <email@address.com>`
820 is typically `FirstName LastName <email@address.com>`
821 """
821 """
822
822
823 # if author is already an instance use it for extraction
823 # if author is already an instance use it for extraction
824 if isinstance(author, User):
824 if isinstance(author, User):
825 return author
825 return author
826
826
827 # Valid email in the attribute passed, see if they're in the system
827 # Valid email in the attribute passed, see if they're in the system
828 _email = author_email(author)
828 _email = author_email(author)
829 if _email != '':
829 if _email != '':
830 user = User.get_by_email(_email, case_insensitive=True, cache=True)
830 user = User.get_by_email(_email, case_insensitive=True, cache=True)
831 if user is not None:
831 if user is not None:
832 return user
832 return user
833
833
834 # Maybe it's a username, we try to extract it and fetch by username ?
834 # Maybe it's a username, we try to extract it and fetch by username ?
835 _author = author_name(author)
835 _author = author_name(author)
836 user = User.get_by_username(_author, case_insensitive=True, cache=True)
836 user = User.get_by_username(_author, case_insensitive=True, cache=True)
837 if user is not None:
837 if user is not None:
838 return user
838 return user
839
839
840 return None
840 return None
841
841
842
842
843 def email_or_none(author):
843 def email_or_none(author):
844 # extract email from the commit string
844 # extract email from the commit string
845 _email = author_email(author)
845 _email = author_email(author)
846
846
847 # If we have an email, use it, otherwise
847 # If we have an email, use it, otherwise
848 # see if it contains a username we can get an email from
848 # see if it contains a username we can get an email from
849 if _email != '':
849 if _email != '':
850 return _email
850 return _email
851 else:
851 else:
852 user = User.get_by_username(
852 user = User.get_by_username(
853 author_name(author), case_insensitive=True, cache=True)
853 author_name(author), case_insensitive=True, cache=True)
854
854
855 if user is not None:
855 if user is not None:
856 return user.email
856 return user.email
857
857
858 # No valid email, not a valid user in the system, none!
858 # No valid email, not a valid user in the system, none!
859 return None
859 return None
860
860
861
861
862 def link_to_user(author, length=0, **kwargs):
862 def link_to_user(author, length=0, **kwargs):
863 user = discover_user(author)
863 user = discover_user(author)
864 # user can be None, but if we have it already it means we can re-use it
864 # user can be None, but if we have it already it means we can re-use it
865 # in the person() function, so we save 1 intensive-query
865 # in the person() function, so we save 1 intensive-query
866 if user:
866 if user:
867 author = user
867 author = user
868
868
869 display_person = person(author, 'username_or_name_or_email')
869 display_person = person(author, 'username_or_name_or_email')
870 if length:
870 if length:
871 display_person = shorter(display_person, length)
871 display_person = shorter(display_person, length)
872
872
873 if user:
873 if user:
874 return link_to(
874 return link_to(
875 escape(display_person),
875 escape(display_person),
876 route_path('user_profile', username=user.username),
876 route_path('user_profile', username=user.username),
877 **kwargs)
877 **kwargs)
878 else:
878 else:
879 return escape(display_person)
879 return escape(display_person)
880
880
881
881
882 def person(author, show_attr="username_and_name"):
882 def person(author, show_attr="username_and_name"):
883 user = discover_user(author)
883 user = discover_user(author)
884 if user:
884 if user:
885 return getattr(user, show_attr)
885 return getattr(user, show_attr)
886 else:
886 else:
887 _author = author_name(author)
887 _author = author_name(author)
888 _email = email(author)
888 _email = email(author)
889 return _author or _email
889 return _author or _email
890
890
891
891
892 def author_string(email):
892 def author_string(email):
893 if email:
893 if email:
894 user = User.get_by_email(email, case_insensitive=True, cache=True)
894 user = User.get_by_email(email, case_insensitive=True, cache=True)
895 if user:
895 if user:
896 if user.firstname or user.lastname:
896 if user.firstname or user.lastname:
897 return '%s %s &lt;%s&gt;' % (
897 return '%s %s &lt;%s&gt;' % (
898 escape(user.firstname), escape(user.lastname), email)
898 escape(user.firstname), escape(user.lastname), email)
899 else:
899 else:
900 return email
900 return email
901 else:
901 else:
902 return email
902 return email
903 else:
903 else:
904 return None
904 return None
905
905
906
906
907 def person_by_id(id_, show_attr="username_and_name"):
907 def person_by_id(id_, show_attr="username_and_name"):
908 # attr to return from fetched user
908 # attr to return from fetched user
909 person_getter = lambda usr: getattr(usr, show_attr)
909 person_getter = lambda usr: getattr(usr, show_attr)
910
910
911 #maybe it's an ID ?
911 #maybe it's an ID ?
912 if str(id_).isdigit() or isinstance(id_, int):
912 if str(id_).isdigit() or isinstance(id_, int):
913 id_ = int(id_)
913 id_ = int(id_)
914 user = User.get(id_)
914 user = User.get(id_)
915 if user is not None:
915 if user is not None:
916 return person_getter(user)
916 return person_getter(user)
917 return id_
917 return id_
918
918
919
919
920 def gravatar_with_user(author, show_disabled=False):
920 def gravatar_with_user(author, show_disabled=False):
921 from rhodecode.lib.utils import PartialRenderer
921 from rhodecode.lib.utils import PartialRenderer
922 _render = PartialRenderer('base/base.mako')
922 _render = PartialRenderer('base/base.mako')
923 return _render('gravatar_with_user', author, show_disabled=show_disabled)
923 return _render('gravatar_with_user', author, show_disabled=show_disabled)
924
924
925
925
926 def desc_stylize(value):
926 def desc_stylize(value):
927 """
927 """
928 converts tags from value into html equivalent
928 converts tags from value into html equivalent
929
929
930 :param value:
930 :param value:
931 """
931 """
932 if not value:
932 if not value:
933 return ''
933 return ''
934
934
935 value = re.sub(r'\[see\ \=\>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',
935 value = re.sub(r'\[see\ \=\>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',
936 '<div class="metatag" tag="see">see =&gt; \\1 </div>', value)
936 '<div class="metatag" tag="see">see =&gt; \\1 </div>', value)
937 value = re.sub(r'\[license\ \=\>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',
937 value = re.sub(r'\[license\ \=\>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',
938 '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>', value)
938 '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>', value)
939 value = re.sub(r'\[(requires|recommends|conflicts|base)\ \=\>\ *([a-zA-Z0-9\-\/]*)\]',
939 value = re.sub(r'\[(requires|recommends|conflicts|base)\ \=\>\ *([a-zA-Z0-9\-\/]*)\]',
940 '<div class="metatag" tag="\\1">\\1 =&gt; <a href="/\\2">\\2</a></div>', value)
940 '<div class="metatag" tag="\\1">\\1 =&gt; <a href="/\\2">\\2</a></div>', value)
941 value = re.sub(r'\[(lang|language)\ \=\>\ *([a-zA-Z\-\/\#\+]*)\]',
941 value = re.sub(r'\[(lang|language)\ \=\>\ *([a-zA-Z\-\/\#\+]*)\]',
942 '<div class="metatag" tag="lang">\\2</div>', value)
942 '<div class="metatag" tag="lang">\\2</div>', value)
943 value = re.sub(r'\[([a-z]+)\]',
943 value = re.sub(r'\[([a-z]+)\]',
944 '<div class="metatag" tag="\\1">\\1</div>', value)
944 '<div class="metatag" tag="\\1">\\1</div>', value)
945
945
946 return value
946 return value
947
947
948
948
949 def escaped_stylize(value):
949 def escaped_stylize(value):
950 """
950 """
951 converts tags from value into html equivalent, but escaping its value first
951 converts tags from value into html equivalent, but escaping its value first
952 """
952 """
953 if not value:
953 if not value:
954 return ''
954 return ''
955
955
956 # Using default webhelper escape method, but has to force it as a
956 # Using default webhelper escape method, but has to force it as a
957 # plain unicode instead of a markup tag to be used in regex expressions
957 # plain unicode instead of a markup tag to be used in regex expressions
958 value = unicode(escape(safe_unicode(value)))
958 value = unicode(escape(safe_unicode(value)))
959
959
960 value = re.sub(r'\[see\ \=\&gt;\ *([a-zA-Z0-9\/\=\?\&amp;\ \:\/\.\-]*)\]',
960 value = re.sub(r'\[see\ \=\&gt;\ *([a-zA-Z0-9\/\=\?\&amp;\ \:\/\.\-]*)\]',
961 '<div class="metatag" tag="see">see =&gt; \\1 </div>', value)
961 '<div class="metatag" tag="see">see =&gt; \\1 </div>', value)
962 value = re.sub(r'\[license\ \=\&gt;\ *([a-zA-Z0-9\/\=\?\&amp;\ \:\/\.\-]*)\]',
962 value = re.sub(r'\[license\ \=\&gt;\ *([a-zA-Z0-9\/\=\?\&amp;\ \:\/\.\-]*)\]',
963 '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>', value)
963 '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>', value)
964 value = re.sub(r'\[(requires|recommends|conflicts|base)\ \=\&gt;\ *([a-zA-Z0-9\-\/]*)\]',
964 value = re.sub(r'\[(requires|recommends|conflicts|base)\ \=\&gt;\ *([a-zA-Z0-9\-\/]*)\]',
965 '<div class="metatag" tag="\\1">\\1 =&gt; <a href="/\\2">\\2</a></div>', value)
965 '<div class="metatag" tag="\\1">\\1 =&gt; <a href="/\\2">\\2</a></div>', value)
966 value = re.sub(r'\[(lang|language)\ \=\&gt;\ *([a-zA-Z\-\/\#\+]*)\]',
966 value = re.sub(r'\[(lang|language)\ \=\&gt;\ *([a-zA-Z\-\/\#\+]*)\]',
967 '<div class="metatag" tag="lang">\\2</div>', value)
967 '<div class="metatag" tag="lang">\\2</div>', value)
968 value = re.sub(r'\[([a-z]+)\]',
968 value = re.sub(r'\[([a-z]+)\]',
969 '<div class="metatag" tag="\\1">\\1</div>', value)
969 '<div class="metatag" tag="\\1">\\1</div>', value)
970
970
971 return value
971 return value
972
972
973
973
974 def bool2icon(value):
974 def bool2icon(value):
975 """
975 """
976 Returns boolean value of a given value, represented as html element with
976 Returns boolean value of a given value, represented as html element with
977 classes that will represent icons
977 classes that will represent icons
978
978
979 :param value: given value to convert to html node
979 :param value: given value to convert to html node
980 """
980 """
981
981
982 if value: # does bool conversion
982 if value: # does bool conversion
983 return HTML.tag('i', class_="icon-true")
983 return HTML.tag('i', class_="icon-true")
984 else: # not true as bool
984 else: # not true as bool
985 return HTML.tag('i', class_="icon-false")
985 return HTML.tag('i', class_="icon-false")
986
986
987
987
988 #==============================================================================
988 #==============================================================================
989 # PERMS
989 # PERMS
990 #==============================================================================
990 #==============================================================================
991 from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \
991 from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \
992 HasRepoPermissionAny, HasRepoPermissionAll, HasRepoGroupPermissionAll, \
992 HasRepoPermissionAny, HasRepoPermissionAll, HasRepoGroupPermissionAll, \
993 HasRepoGroupPermissionAny, HasRepoPermissionAnyApi, get_csrf_token, \
993 HasRepoGroupPermissionAny, HasRepoPermissionAnyApi, get_csrf_token, \
994 csrf_token_key
994 csrf_token_key
995
995
996
996
997 #==============================================================================
997 #==============================================================================
998 # GRAVATAR URL
998 # GRAVATAR URL
999 #==============================================================================
999 #==============================================================================
1000 class InitialsGravatar(object):
1000 class InitialsGravatar(object):
1001 def __init__(self, email_address, first_name, last_name, size=30,
1001 def __init__(self, email_address, first_name, last_name, size=30,
1002 background=None, text_color='#fff'):
1002 background=None, text_color='#fff'):
1003 self.size = size
1003 self.size = size
1004 self.first_name = first_name
1004 self.first_name = first_name
1005 self.last_name = last_name
1005 self.last_name = last_name
1006 self.email_address = email_address
1006 self.email_address = email_address
1007 self.background = background or self.str2color(email_address)
1007 self.background = background or self.str2color(email_address)
1008 self.text_color = text_color
1008 self.text_color = text_color
1009
1009
1010 def get_color_bank(self):
1010 def get_color_bank(self):
1011 """
1011 """
1012 returns a predefined list of colors that gravatars can use.
1012 returns a predefined list of colors that gravatars can use.
1013 Those are randomized distinct colors that guarantee readability and
1013 Those are randomized distinct colors that guarantee readability and
1014 uniqueness.
1014 uniqueness.
1015
1015
1016 generated with: http://phrogz.net/css/distinct-colors.html
1016 generated with: http://phrogz.net/css/distinct-colors.html
1017 """
1017 """
1018 return [
1018 return [
1019 '#bf3030', '#a67f53', '#00ff00', '#5989b3', '#392040', '#d90000',
1019 '#bf3030', '#a67f53', '#00ff00', '#5989b3', '#392040', '#d90000',
1020 '#402910', '#204020', '#79baf2', '#a700b3', '#bf6060', '#7f5320',
1020 '#402910', '#204020', '#79baf2', '#a700b3', '#bf6060', '#7f5320',
1021 '#008000', '#003059', '#ee00ff', '#ff0000', '#8c4b00', '#007300',
1021 '#008000', '#003059', '#ee00ff', '#ff0000', '#8c4b00', '#007300',
1022 '#005fb3', '#de73e6', '#ff4040', '#ffaa00', '#3df255', '#203140',
1022 '#005fb3', '#de73e6', '#ff4040', '#ffaa00', '#3df255', '#203140',
1023 '#47004d', '#591616', '#664400', '#59b365', '#0d2133', '#83008c',
1023 '#47004d', '#591616', '#664400', '#59b365', '#0d2133', '#83008c',
1024 '#592d2d', '#bf9f60', '#73e682', '#1d3f73', '#73006b', '#402020',
1024 '#592d2d', '#bf9f60', '#73e682', '#1d3f73', '#73006b', '#402020',
1025 '#b2862d', '#397341', '#597db3', '#e600d6', '#a60000', '#736039',
1025 '#b2862d', '#397341', '#597db3', '#e600d6', '#a60000', '#736039',
1026 '#00b318', '#79aaf2', '#330d30', '#ff8080', '#403010', '#16591f',
1026 '#00b318', '#79aaf2', '#330d30', '#ff8080', '#403010', '#16591f',
1027 '#002459', '#8c4688', '#e50000', '#ffbf40', '#00732e', '#102340',
1027 '#002459', '#8c4688', '#e50000', '#ffbf40', '#00732e', '#102340',
1028 '#bf60ac', '#8c4646', '#cc8800', '#00a642', '#1d3473', '#b32d98',
1028 '#bf60ac', '#8c4646', '#cc8800', '#00a642', '#1d3473', '#b32d98',
1029 '#660e00', '#ffd580', '#80ffb2', '#7391e6', '#733967', '#d97b6c',
1029 '#660e00', '#ffd580', '#80ffb2', '#7391e6', '#733967', '#d97b6c',
1030 '#8c5e00', '#59b389', '#3967e6', '#590047', '#73281d', '#665200',
1030 '#8c5e00', '#59b389', '#3967e6', '#590047', '#73281d', '#665200',
1031 '#00e67a', '#2d50b3', '#8c2377', '#734139', '#b2982d', '#16593a',
1031 '#00e67a', '#2d50b3', '#8c2377', '#734139', '#b2982d', '#16593a',
1032 '#001859', '#ff00aa', '#a65e53', '#ffcc00', '#0d3321', '#2d3959',
1032 '#001859', '#ff00aa', '#a65e53', '#ffcc00', '#0d3321', '#2d3959',
1033 '#731d56', '#401610', '#4c3d00', '#468c6c', '#002ca6', '#d936a3',
1033 '#731d56', '#401610', '#4c3d00', '#468c6c', '#002ca6', '#d936a3',
1034 '#d94c36', '#403920', '#36d9a3', '#0d1733', '#592d4a', '#993626',
1034 '#d94c36', '#403920', '#36d9a3', '#0d1733', '#592d4a', '#993626',
1035 '#cca300', '#00734d', '#46598c', '#8c005e', '#7f1100', '#8c7000',
1035 '#cca300', '#00734d', '#46598c', '#8c005e', '#7f1100', '#8c7000',
1036 '#00a66f', '#7382e6', '#b32d74', '#d9896c', '#ffe680', '#1d7362',
1036 '#00a66f', '#7382e6', '#b32d74', '#d9896c', '#ffe680', '#1d7362',
1037 '#364cd9', '#73003d', '#d93a00', '#998a4d', '#59b3a1', '#5965b3',
1037 '#364cd9', '#73003d', '#d93a00', '#998a4d', '#59b3a1', '#5965b3',
1038 '#e5007a', '#73341d', '#665f00', '#00b38f', '#0018b3', '#59163a',
1038 '#e5007a', '#73341d', '#665f00', '#00b38f', '#0018b3', '#59163a',
1039 '#b2502d', '#bfb960', '#00ffcc', '#23318c', '#a6537f', '#734939',
1039 '#b2502d', '#bfb960', '#00ffcc', '#23318c', '#a6537f', '#734939',
1040 '#b2a700', '#104036', '#3d3df2', '#402031', '#e56739', '#736f39',
1040 '#b2a700', '#104036', '#3d3df2', '#402031', '#e56739', '#736f39',
1041 '#79f2ea', '#000059', '#401029', '#4c1400', '#ffee00', '#005953',
1041 '#79f2ea', '#000059', '#401029', '#4c1400', '#ffee00', '#005953',
1042 '#101040', '#990052', '#402820', '#403d10', '#00ffee', '#0000d9',
1042 '#101040', '#990052', '#402820', '#403d10', '#00ffee', '#0000d9',
1043 '#ff80c4', '#a66953', '#eeff00', '#00ccbe', '#8080ff', '#e673a1',
1043 '#ff80c4', '#a66953', '#eeff00', '#00ccbe', '#8080ff', '#e673a1',
1044 '#a62c00', '#474d00', '#1a3331', '#46468c', '#733950', '#662900',
1044 '#a62c00', '#474d00', '#1a3331', '#46468c', '#733950', '#662900',
1045 '#858c23', '#238c85', '#0f0073', '#b20047', '#d9986c', '#becc00',
1045 '#858c23', '#238c85', '#0f0073', '#b20047', '#d9986c', '#becc00',
1046 '#396f73', '#281d73', '#ff0066', '#ff6600', '#dee673', '#59adb3',
1046 '#396f73', '#281d73', '#ff0066', '#ff6600', '#dee673', '#59adb3',
1047 '#6559b3', '#590024', '#b2622d', '#98b32d', '#36ced9', '#332d59',
1047 '#6559b3', '#590024', '#b2622d', '#98b32d', '#36ced9', '#332d59',
1048 '#40001a', '#733f1d', '#526600', '#005359', '#242040', '#bf6079',
1048 '#40001a', '#733f1d', '#526600', '#005359', '#242040', '#bf6079',
1049 '#735039', '#cef23d', '#007780', '#5630bf', '#66001b', '#b24700',
1049 '#735039', '#cef23d', '#007780', '#5630bf', '#66001b', '#b24700',
1050 '#acbf60', '#1d6273', '#25008c', '#731d34', '#a67453', '#50592d',
1050 '#acbf60', '#1d6273', '#25008c', '#731d34', '#a67453', '#50592d',
1051 '#00ccff', '#6600ff', '#ff0044', '#4c1f00', '#8a994d', '#79daf2',
1051 '#00ccff', '#6600ff', '#ff0044', '#4c1f00', '#8a994d', '#79daf2',
1052 '#a173e6', '#d93662', '#402310', '#aaff00', '#2d98b3', '#8c40ff',
1052 '#a173e6', '#d93662', '#402310', '#aaff00', '#2d98b3', '#8c40ff',
1053 '#592d39', '#ff8c40', '#354020', '#103640', '#1a0040', '#331a20',
1053 '#592d39', '#ff8c40', '#354020', '#103640', '#1a0040', '#331a20',
1054 '#331400', '#334d00', '#1d5673', '#583973', '#7f0022', '#4c3626',
1054 '#331400', '#334d00', '#1d5673', '#583973', '#7f0022', '#4c3626',
1055 '#88cc00', '#36a3d9', '#3d0073', '#d9364c', '#33241a', '#698c23',
1055 '#88cc00', '#36a3d9', '#3d0073', '#d9364c', '#33241a', '#698c23',
1056 '#5995b3', '#300059', '#e57382', '#7f3300', '#366600', '#00aaff',
1056 '#5995b3', '#300059', '#e57382', '#7f3300', '#366600', '#00aaff',
1057 '#3a1659', '#733941', '#663600', '#74b32d', '#003c59', '#7f53a6',
1057 '#3a1659', '#733941', '#663600', '#74b32d', '#003c59', '#7f53a6',
1058 '#73000f', '#ff8800', '#baf279', '#79caf2', '#291040', '#a6293a',
1058 '#73000f', '#ff8800', '#baf279', '#79caf2', '#291040', '#a6293a',
1059 '#b2742d', '#587339', '#0077b3', '#632699', '#400009', '#d9a66c',
1059 '#b2742d', '#587339', '#0077b3', '#632699', '#400009', '#d9a66c',
1060 '#294010', '#2d4a59', '#aa00ff', '#4c131b', '#b25f00', '#5ce600',
1060 '#294010', '#2d4a59', '#aa00ff', '#4c131b', '#b25f00', '#5ce600',
1061 '#267399', '#a336d9', '#990014', '#664e33', '#86bf60', '#0088ff',
1061 '#267399', '#a336d9', '#990014', '#664e33', '#86bf60', '#0088ff',
1062 '#7700b3', '#593a16', '#073300', '#1d4b73', '#ac60bf', '#e59539',
1062 '#7700b3', '#593a16', '#073300', '#1d4b73', '#ac60bf', '#e59539',
1063 '#4f8c46', '#368dd9', '#5c0073'
1063 '#4f8c46', '#368dd9', '#5c0073'
1064 ]
1064 ]
1065
1065
1066 def rgb_to_hex_color(self, rgb_tuple):
1066 def rgb_to_hex_color(self, rgb_tuple):
1067 """
1067 """
1068 Converts an rgb_tuple passed to an hex color.
1068 Converts an rgb_tuple passed to an hex color.
1069
1069
1070 :param rgb_tuple: tuple with 3 ints represents rgb color space
1070 :param rgb_tuple: tuple with 3 ints represents rgb color space
1071 """
1071 """
1072 return '#' + ("".join(map(chr, rgb_tuple)).encode('hex'))
1072 return '#' + ("".join(map(chr, rgb_tuple)).encode('hex'))
1073
1073
1074 def email_to_int_list(self, email_str):
1074 def email_to_int_list(self, email_str):
1075 """
1075 """
1076 Get every byte of the hex digest value of email and turn it to integer.
1076 Get every byte of the hex digest value of email and turn it to integer.
1077 It's going to be always between 0-255
1077 It's going to be always between 0-255
1078 """
1078 """
1079 digest = md5_safe(email_str.lower())
1079 digest = md5_safe(email_str.lower())
1080 return [int(digest[i * 2:i * 2 + 2], 16) for i in range(16)]
1080 return [int(digest[i * 2:i * 2 + 2], 16) for i in range(16)]
1081
1081
1082 def pick_color_bank_index(self, email_str, color_bank):
1082 def pick_color_bank_index(self, email_str, color_bank):
1083 return self.email_to_int_list(email_str)[0] % len(color_bank)
1083 return self.email_to_int_list(email_str)[0] % len(color_bank)
1084
1084
1085 def str2color(self, email_str):
1085 def str2color(self, email_str):
1086 """
1086 """
1087 Tries to map in a stable algorithm an email to color
1087 Tries to map in a stable algorithm an email to color
1088
1088
1089 :param email_str:
1089 :param email_str:
1090 """
1090 """
1091 color_bank = self.get_color_bank()
1091 color_bank = self.get_color_bank()
1092 # pick position (module it's length so we always find it in the
1092 # pick position (module it's length so we always find it in the
1093 # bank even if it's smaller than 256 values
1093 # bank even if it's smaller than 256 values
1094 pos = self.pick_color_bank_index(email_str, color_bank)
1094 pos = self.pick_color_bank_index(email_str, color_bank)
1095 return color_bank[pos]
1095 return color_bank[pos]
1096
1096
1097 def normalize_email(self, email_address):
1097 def normalize_email(self, email_address):
1098 import unicodedata
1098 import unicodedata
1099 # default host used to fill in the fake/missing email
1099 # default host used to fill in the fake/missing email
1100 default_host = u'localhost'
1100 default_host = u'localhost'
1101
1101
1102 if not email_address:
1102 if not email_address:
1103 email_address = u'%s@%s' % (User.DEFAULT_USER, default_host)
1103 email_address = u'%s@%s' % (User.DEFAULT_USER, default_host)
1104
1104
1105 email_address = safe_unicode(email_address)
1105 email_address = safe_unicode(email_address)
1106
1106
1107 if u'@' not in email_address:
1107 if u'@' not in email_address:
1108 email_address = u'%s@%s' % (email_address, default_host)
1108 email_address = u'%s@%s' % (email_address, default_host)
1109
1109
1110 if email_address.endswith(u'@'):
1110 if email_address.endswith(u'@'):
1111 email_address = u'%s%s' % (email_address, default_host)
1111 email_address = u'%s%s' % (email_address, default_host)
1112
1112
1113 email_address = unicodedata.normalize('NFKD', email_address)\
1113 email_address = unicodedata.normalize('NFKD', email_address)\
1114 .encode('ascii', 'ignore')
1114 .encode('ascii', 'ignore')
1115 return email_address
1115 return email_address
1116
1116
1117 def get_initials(self):
1117 def get_initials(self):
1118 """
1118 """
1119 Returns 2 letter initials calculated based on the input.
1119 Returns 2 letter initials calculated based on the input.
1120 The algorithm picks first given email address, and takes first letter
1120 The algorithm picks first given email address, and takes first letter
1121 of part before @, and then the first letter of server name. In case
1121 of part before @, and then the first letter of server name. In case
1122 the part before @ is in a format of `somestring.somestring2` it replaces
1122 the part before @ is in a format of `somestring.somestring2` it replaces
1123 the server letter with first letter of somestring2
1123 the server letter with first letter of somestring2
1124
1124
1125 In case function was initialized with both first and lastname, this
1125 In case function was initialized with both first and lastname, this
1126 overrides the extraction from email by first letter of the first and
1126 overrides the extraction from email by first letter of the first and
1127 last name. We add special logic to that functionality, In case Full name
1127 last name. We add special logic to that functionality, In case Full name
1128 is compound, like Guido Von Rossum, we use last part of the last name
1128 is compound, like Guido Von Rossum, we use last part of the last name
1129 (Von Rossum) picking `R`.
1129 (Von Rossum) picking `R`.
1130
1130
1131 Function also normalizes the non-ascii characters to they ascii
1131 Function also normalizes the non-ascii characters to they ascii
1132 representation, eg Δ„ => A
1132 representation, eg Δ„ => A
1133 """
1133 """
1134 import unicodedata
1134 import unicodedata
1135 # replace non-ascii to ascii
1135 # replace non-ascii to ascii
1136 first_name = unicodedata.normalize(
1136 first_name = unicodedata.normalize(
1137 'NFKD', safe_unicode(self.first_name)).encode('ascii', 'ignore')
1137 'NFKD', safe_unicode(self.first_name)).encode('ascii', 'ignore')
1138 last_name = unicodedata.normalize(
1138 last_name = unicodedata.normalize(
1139 'NFKD', safe_unicode(self.last_name)).encode('ascii', 'ignore')
1139 'NFKD', safe_unicode(self.last_name)).encode('ascii', 'ignore')
1140
1140
1141 # do NFKD encoding, and also make sure email has proper format
1141 # do NFKD encoding, and also make sure email has proper format
1142 email_address = self.normalize_email(self.email_address)
1142 email_address = self.normalize_email(self.email_address)
1143
1143
1144 # first push the email initials
1144 # first push the email initials
1145 prefix, server = email_address.split('@', 1)
1145 prefix, server = email_address.split('@', 1)
1146
1146
1147 # check if prefix is maybe a 'firstname.lastname' syntax
1147 # check if prefix is maybe a 'firstname.lastname' syntax
1148 _dot_split = prefix.rsplit('.', 1)
1148 _dot_split = prefix.rsplit('.', 1)
1149 if len(_dot_split) == 2:
1149 if len(_dot_split) == 2:
1150 initials = [_dot_split[0][0], _dot_split[1][0]]
1150 initials = [_dot_split[0][0], _dot_split[1][0]]
1151 else:
1151 else:
1152 initials = [prefix[0], server[0]]
1152 initials = [prefix[0], server[0]]
1153
1153
1154 # then try to replace either firtname or lastname
1154 # then try to replace either firtname or lastname
1155 fn_letter = (first_name or " ")[0].strip()
1155 fn_letter = (first_name or " ")[0].strip()
1156 ln_letter = (last_name.split(' ', 1)[-1] or " ")[0].strip()
1156 ln_letter = (last_name.split(' ', 1)[-1] or " ")[0].strip()
1157
1157
1158 if fn_letter:
1158 if fn_letter:
1159 initials[0] = fn_letter
1159 initials[0] = fn_letter
1160
1160
1161 if ln_letter:
1161 if ln_letter:
1162 initials[1] = ln_letter
1162 initials[1] = ln_letter
1163
1163
1164 return ''.join(initials).upper()
1164 return ''.join(initials).upper()
1165
1165
1166 def get_img_data_by_type(self, font_family, img_type):
1166 def get_img_data_by_type(self, font_family, img_type):
1167 default_user = """
1167 default_user = """
1168 <svg xmlns="http://www.w3.org/2000/svg"
1168 <svg xmlns="http://www.w3.org/2000/svg"
1169 version="1.1" x="0px" y="0px" width="{size}" height="{size}"
1169 version="1.1" x="0px" y="0px" width="{size}" height="{size}"
1170 viewBox="-15 -10 439.165 429.164"
1170 viewBox="-15 -10 439.165 429.164"
1171
1171
1172 xml:space="preserve"
1172 xml:space="preserve"
1173 style="background:{background};" >
1173 style="background:{background};" >
1174
1174
1175 <path d="M204.583,216.671c50.664,0,91.74-48.075,
1175 <path d="M204.583,216.671c50.664,0,91.74-48.075,
1176 91.74-107.378c0-82.237-41.074-107.377-91.74-107.377
1176 91.74-107.378c0-82.237-41.074-107.377-91.74-107.377
1177 c-50.668,0-91.74,25.14-91.74,107.377C112.844,
1177 c-50.668,0-91.74,25.14-91.74,107.377C112.844,
1178 168.596,153.916,216.671,
1178 168.596,153.916,216.671,
1179 204.583,216.671z" fill="{text_color}"/>
1179 204.583,216.671z" fill="{text_color}"/>
1180 <path d="M407.164,374.717L360.88,
1180 <path d="M407.164,374.717L360.88,
1181 270.454c-2.117-4.771-5.836-8.728-10.465-11.138l-71.83-37.392
1181 270.454c-2.117-4.771-5.836-8.728-10.465-11.138l-71.83-37.392
1182 c-1.584-0.823-3.502-0.663-4.926,0.415c-20.316,
1182 c-1.584-0.823-3.502-0.663-4.926,0.415c-20.316,
1183 15.366-44.203,23.488-69.076,23.488c-24.877,
1183 15.366-44.203,23.488-69.076,23.488c-24.877,
1184 0-48.762-8.122-69.078-23.488
1184 0-48.762-8.122-69.078-23.488
1185 c-1.428-1.078-3.346-1.238-4.93-0.415L58.75,
1185 c-1.428-1.078-3.346-1.238-4.93-0.415L58.75,
1186 259.316c-4.631,2.41-8.346,6.365-10.465,11.138L2.001,374.717
1186 259.316c-4.631,2.41-8.346,6.365-10.465,11.138L2.001,374.717
1187 c-3.191,7.188-2.537,15.412,1.75,22.005c4.285,
1187 c-3.191,7.188-2.537,15.412,1.75,22.005c4.285,
1188 6.592,11.537,10.526,19.4,10.526h362.861c7.863,0,15.117-3.936,
1188 6.592,11.537,10.526,19.4,10.526h362.861c7.863,0,15.117-3.936,
1189 19.402-10.527 C409.699,390.129,
1189 19.402-10.527 C409.699,390.129,
1190 410.355,381.902,407.164,374.717z" fill="{text_color}"/>
1190 410.355,381.902,407.164,374.717z" fill="{text_color}"/>
1191 </svg>""".format(
1191 </svg>""".format(
1192 size=self.size,
1192 size=self.size,
1193 background='#979797', # @grey4
1193 background='#979797', # @grey4
1194 text_color=self.text_color,
1194 text_color=self.text_color,
1195 font_family=font_family)
1195 font_family=font_family)
1196
1196
1197 return {
1197 return {
1198 "default_user": default_user
1198 "default_user": default_user
1199 }[img_type]
1199 }[img_type]
1200
1200
1201 def get_img_data(self, svg_type=None):
1201 def get_img_data(self, svg_type=None):
1202 """
1202 """
1203 generates the svg metadata for image
1203 generates the svg metadata for image
1204 """
1204 """
1205
1205
1206 font_family = ','.join([
1206 font_family = ','.join([
1207 'proximanovaregular',
1207 'proximanovaregular',
1208 'Proxima Nova Regular',
1208 'Proxima Nova Regular',
1209 'Proxima Nova',
1209 'Proxima Nova',
1210 'Arial',
1210 'Arial',
1211 'Lucida Grande',
1211 'Lucida Grande',
1212 'sans-serif'
1212 'sans-serif'
1213 ])
1213 ])
1214 if svg_type:
1214 if svg_type:
1215 return self.get_img_data_by_type(font_family, svg_type)
1215 return self.get_img_data_by_type(font_family, svg_type)
1216
1216
1217 initials = self.get_initials()
1217 initials = self.get_initials()
1218 img_data = """
1218 img_data = """
1219 <svg xmlns="http://www.w3.org/2000/svg" pointer-events="none"
1219 <svg xmlns="http://www.w3.org/2000/svg" pointer-events="none"
1220 width="{size}" height="{size}"
1220 width="{size}" height="{size}"
1221 style="width: 100%; height: 100%; background-color: {background}"
1221 style="width: 100%; height: 100%; background-color: {background}"
1222 viewBox="0 0 {size} {size}">
1222 viewBox="0 0 {size} {size}">
1223 <text text-anchor="middle" y="50%" x="50%" dy="0.35em"
1223 <text text-anchor="middle" y="50%" x="50%" dy="0.35em"
1224 pointer-events="auto" fill="{text_color}"
1224 pointer-events="auto" fill="{text_color}"
1225 font-family="{font_family}"
1225 font-family="{font_family}"
1226 style="font-weight: 400; font-size: {f_size}px;">{text}
1226 style="font-weight: 400; font-size: {f_size}px;">{text}
1227 </text>
1227 </text>
1228 </svg>""".format(
1228 </svg>""".format(
1229 size=self.size,
1229 size=self.size,
1230 f_size=self.size/1.85, # scale the text inside the box nicely
1230 f_size=self.size/1.85, # scale the text inside the box nicely
1231 background=self.background,
1231 background=self.background,
1232 text_color=self.text_color,
1232 text_color=self.text_color,
1233 text=initials.upper(),
1233 text=initials.upper(),
1234 font_family=font_family)
1234 font_family=font_family)
1235
1235
1236 return img_data
1236 return img_data
1237
1237
1238 def generate_svg(self, svg_type=None):
1238 def generate_svg(self, svg_type=None):
1239 img_data = self.get_img_data(svg_type)
1239 img_data = self.get_img_data(svg_type)
1240 return "data:image/svg+xml;base64,%s" % img_data.encode('base64')
1240 return "data:image/svg+xml;base64,%s" % img_data.encode('base64')
1241
1241
1242
1242
1243 def initials_gravatar(email_address, first_name, last_name, size=30):
1243 def initials_gravatar(email_address, first_name, last_name, size=30):
1244 svg_type = None
1244 svg_type = None
1245 if email_address == User.DEFAULT_USER_EMAIL:
1245 if email_address == User.DEFAULT_USER_EMAIL:
1246 svg_type = 'default_user'
1246 svg_type = 'default_user'
1247 klass = InitialsGravatar(email_address, first_name, last_name, size)
1247 klass = InitialsGravatar(email_address, first_name, last_name, size)
1248 return klass.generate_svg(svg_type=svg_type)
1248 return klass.generate_svg(svg_type=svg_type)
1249
1249
1250
1250
1251 def gravatar_url(email_address, size=30):
1251 def gravatar_url(email_address, size=30, request=None):
1252 request = get_current_request()
1253 if request and hasattr(request, 'call_context'):
1254 _use_gravatar = request.call_context.visual.use_gravatar
1255 _gravatar_url = request.call_context.visual.gravatar_url
1256 else:
1252 # doh, we need to re-import those to mock it later
1257 # doh, we need to re-import those to mock it later
1253 from pylons import tmpl_context as c
1258 from pylons import tmpl_context as c
1254
1259
1255 _use_gravatar = c.visual.use_gravatar
1260 _use_gravatar = c.visual.use_gravatar
1256 _gravatar_url = c.visual.gravatar_url or User.DEFAULT_GRAVATAR_URL
1261 _gravatar_url = c.visual.gravatar_url
1262
1263 _gravatar_url = _gravatar_url or User.DEFAULT_GRAVATAR_URL
1257
1264
1258 email_address = email_address or User.DEFAULT_USER_EMAIL
1265 email_address = email_address or User.DEFAULT_USER_EMAIL
1259 if isinstance(email_address, unicode):
1266 if isinstance(email_address, unicode):
1260 # hashlib crashes on unicode items
1267 # hashlib crashes on unicode items
1261 email_address = safe_str(email_address)
1268 email_address = safe_str(email_address)
1262
1269
1263 # empty email or default user
1270 # empty email or default user
1264 if not email_address or email_address == User.DEFAULT_USER_EMAIL:
1271 if not email_address or email_address == User.DEFAULT_USER_EMAIL:
1265 return initials_gravatar(User.DEFAULT_USER_EMAIL, '', '', size=size)
1272 return initials_gravatar(User.DEFAULT_USER_EMAIL, '', '', size=size)
1266
1273
1267 if _use_gravatar:
1274 if _use_gravatar:
1268 # TODO: Disuse pyramid thread locals. Think about another solution to
1275 # TODO: Disuse pyramid thread locals. Think about another solution to
1269 # get the host and schema here.
1276 # get the host and schema here.
1270 request = get_current_request()
1277 request = get_current_request()
1271 tmpl = safe_str(_gravatar_url)
1278 tmpl = safe_str(_gravatar_url)
1272 tmpl = tmpl.replace('{email}', email_address)\
1279 tmpl = tmpl.replace('{email}', email_address)\
1273 .replace('{md5email}', md5_safe(email_address.lower())) \
1280 .replace('{md5email}', md5_safe(email_address.lower())) \
1274 .replace('{netloc}', request.host)\
1281 .replace('{netloc}', request.host)\
1275 .replace('{scheme}', request.scheme)\
1282 .replace('{scheme}', request.scheme)\
1276 .replace('{size}', safe_str(size))
1283 .replace('{size}', safe_str(size))
1277 return tmpl
1284 return tmpl
1278 else:
1285 else:
1279 return initials_gravatar(email_address, '', '', size=size)
1286 return initials_gravatar(email_address, '', '', size=size)
1280
1287
1281
1288
1282 class Page(_Page):
1289 class Page(_Page):
1283 """
1290 """
1284 Custom pager to match rendering style with paginator
1291 Custom pager to match rendering style with paginator
1285 """
1292 """
1286
1293
1287 def _get_pos(self, cur_page, max_page, items):
1294 def _get_pos(self, cur_page, max_page, items):
1288 edge = (items / 2) + 1
1295 edge = (items / 2) + 1
1289 if (cur_page <= edge):
1296 if (cur_page <= edge):
1290 radius = max(items / 2, items - cur_page)
1297 radius = max(items / 2, items - cur_page)
1291 elif (max_page - cur_page) < edge:
1298 elif (max_page - cur_page) < edge:
1292 radius = (items - 1) - (max_page - cur_page)
1299 radius = (items - 1) - (max_page - cur_page)
1293 else:
1300 else:
1294 radius = items / 2
1301 radius = items / 2
1295
1302
1296 left = max(1, (cur_page - (radius)))
1303 left = max(1, (cur_page - (radius)))
1297 right = min(max_page, cur_page + (radius))
1304 right = min(max_page, cur_page + (radius))
1298 return left, cur_page, right
1305 return left, cur_page, right
1299
1306
1300 def _range(self, regexp_match):
1307 def _range(self, regexp_match):
1301 """
1308 """
1302 Return range of linked pages (e.g. '1 2 [3] 4 5 6 7 8').
1309 Return range of linked pages (e.g. '1 2 [3] 4 5 6 7 8').
1303
1310
1304 Arguments:
1311 Arguments:
1305
1312
1306 regexp_match
1313 regexp_match
1307 A "re" (regular expressions) match object containing the
1314 A "re" (regular expressions) match object containing the
1308 radius of linked pages around the current page in
1315 radius of linked pages around the current page in
1309 regexp_match.group(1) as a string
1316 regexp_match.group(1) as a string
1310
1317
1311 This function is supposed to be called as a callable in
1318 This function is supposed to be called as a callable in
1312 re.sub.
1319 re.sub.
1313
1320
1314 """
1321 """
1315 radius = int(regexp_match.group(1))
1322 radius = int(regexp_match.group(1))
1316
1323
1317 # Compute the first and last page number within the radius
1324 # Compute the first and last page number within the radius
1318 # e.g. '1 .. 5 6 [7] 8 9 .. 12'
1325 # e.g. '1 .. 5 6 [7] 8 9 .. 12'
1319 # -> leftmost_page = 5
1326 # -> leftmost_page = 5
1320 # -> rightmost_page = 9
1327 # -> rightmost_page = 9
1321 leftmost_page, _cur, rightmost_page = self._get_pos(self.page,
1328 leftmost_page, _cur, rightmost_page = self._get_pos(self.page,
1322 self.last_page,
1329 self.last_page,
1323 (radius * 2) + 1)
1330 (radius * 2) + 1)
1324 nav_items = []
1331 nav_items = []
1325
1332
1326 # Create a link to the first page (unless we are on the first page
1333 # Create a link to the first page (unless we are on the first page
1327 # or there would be no need to insert '..' spacers)
1334 # or there would be no need to insert '..' spacers)
1328 if self.page != self.first_page and self.first_page < leftmost_page:
1335 if self.page != self.first_page and self.first_page < leftmost_page:
1329 nav_items.append(self._pagerlink(self.first_page, self.first_page))
1336 nav_items.append(self._pagerlink(self.first_page, self.first_page))
1330
1337
1331 # Insert dots if there are pages between the first page
1338 # Insert dots if there are pages between the first page
1332 # and the currently displayed page range
1339 # and the currently displayed page range
1333 if leftmost_page - self.first_page > 1:
1340 if leftmost_page - self.first_page > 1:
1334 # Wrap in a SPAN tag if nolink_attr is set
1341 # Wrap in a SPAN tag if nolink_attr is set
1335 text = '..'
1342 text = '..'
1336 if self.dotdot_attr:
1343 if self.dotdot_attr:
1337 text = HTML.span(c=text, **self.dotdot_attr)
1344 text = HTML.span(c=text, **self.dotdot_attr)
1338 nav_items.append(text)
1345 nav_items.append(text)
1339
1346
1340 for thispage in xrange(leftmost_page, rightmost_page + 1):
1347 for thispage in xrange(leftmost_page, rightmost_page + 1):
1341 # Hilight the current page number and do not use a link
1348 # Hilight the current page number and do not use a link
1342 if thispage == self.page:
1349 if thispage == self.page:
1343 text = '%s' % (thispage,)
1350 text = '%s' % (thispage,)
1344 # Wrap in a SPAN tag if nolink_attr is set
1351 # Wrap in a SPAN tag if nolink_attr is set
1345 if self.curpage_attr:
1352 if self.curpage_attr:
1346 text = HTML.span(c=text, **self.curpage_attr)
1353 text = HTML.span(c=text, **self.curpage_attr)
1347 nav_items.append(text)
1354 nav_items.append(text)
1348 # Otherwise create just a link to that page
1355 # Otherwise create just a link to that page
1349 else:
1356 else:
1350 text = '%s' % (thispage,)
1357 text = '%s' % (thispage,)
1351 nav_items.append(self._pagerlink(thispage, text))
1358 nav_items.append(self._pagerlink(thispage, text))
1352
1359
1353 # Insert dots if there are pages between the displayed
1360 # Insert dots if there are pages between the displayed
1354 # page numbers and the end of the page range
1361 # page numbers and the end of the page range
1355 if self.last_page - rightmost_page > 1:
1362 if self.last_page - rightmost_page > 1:
1356 text = '..'
1363 text = '..'
1357 # Wrap in a SPAN tag if nolink_attr is set
1364 # Wrap in a SPAN tag if nolink_attr is set
1358 if self.dotdot_attr:
1365 if self.dotdot_attr:
1359 text = HTML.span(c=text, **self.dotdot_attr)
1366 text = HTML.span(c=text, **self.dotdot_attr)
1360 nav_items.append(text)
1367 nav_items.append(text)
1361
1368
1362 # Create a link to the very last page (unless we are on the last
1369 # Create a link to the very last page (unless we are on the last
1363 # page or there would be no need to insert '..' spacers)
1370 # page or there would be no need to insert '..' spacers)
1364 if self.page != self.last_page and rightmost_page < self.last_page:
1371 if self.page != self.last_page and rightmost_page < self.last_page:
1365 nav_items.append(self._pagerlink(self.last_page, self.last_page))
1372 nav_items.append(self._pagerlink(self.last_page, self.last_page))
1366
1373
1367 ## prerender links
1374 ## prerender links
1368 #_page_link = url.current()
1375 #_page_link = url.current()
1369 #nav_items.append(literal('<link rel="prerender" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))
1376 #nav_items.append(literal('<link rel="prerender" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))
1370 #nav_items.append(literal('<link rel="prefetch" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))
1377 #nav_items.append(literal('<link rel="prefetch" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))
1371 return self.separator.join(nav_items)
1378 return self.separator.join(nav_items)
1372
1379
1373 def pager(self, format='~2~', page_param='page', partial_param='partial',
1380 def pager(self, format='~2~', page_param='page', partial_param='partial',
1374 show_if_single_page=False, separator=' ', onclick=None,
1381 show_if_single_page=False, separator=' ', onclick=None,
1375 symbol_first='<<', symbol_last='>>',
1382 symbol_first='<<', symbol_last='>>',
1376 symbol_previous='<', symbol_next='>',
1383 symbol_previous='<', symbol_next='>',
1377 link_attr={'class': 'pager_link', 'rel': 'prerender'},
1384 link_attr={'class': 'pager_link', 'rel': 'prerender'},
1378 curpage_attr={'class': 'pager_curpage'},
1385 curpage_attr={'class': 'pager_curpage'},
1379 dotdot_attr={'class': 'pager_dotdot'}, **kwargs):
1386 dotdot_attr={'class': 'pager_dotdot'}, **kwargs):
1380
1387
1381 self.curpage_attr = curpage_attr
1388 self.curpage_attr = curpage_attr
1382 self.separator = separator
1389 self.separator = separator
1383 self.pager_kwargs = kwargs
1390 self.pager_kwargs = kwargs
1384 self.page_param = page_param
1391 self.page_param = page_param
1385 self.partial_param = partial_param
1392 self.partial_param = partial_param
1386 self.onclick = onclick
1393 self.onclick = onclick
1387 self.link_attr = link_attr
1394 self.link_attr = link_attr
1388 self.dotdot_attr = dotdot_attr
1395 self.dotdot_attr = dotdot_attr
1389
1396
1390 # Don't show navigator if there is no more than one page
1397 # Don't show navigator if there is no more than one page
1391 if self.page_count == 0 or (self.page_count == 1 and not show_if_single_page):
1398 if self.page_count == 0 or (self.page_count == 1 and not show_if_single_page):
1392 return ''
1399 return ''
1393
1400
1394 from string import Template
1401 from string import Template
1395 # Replace ~...~ in token format by range of pages
1402 # Replace ~...~ in token format by range of pages
1396 result = re.sub(r'~(\d+)~', self._range, format)
1403 result = re.sub(r'~(\d+)~', self._range, format)
1397
1404
1398 # Interpolate '%' variables
1405 # Interpolate '%' variables
1399 result = Template(result).safe_substitute({
1406 result = Template(result).safe_substitute({
1400 'first_page': self.first_page,
1407 'first_page': self.first_page,
1401 'last_page': self.last_page,
1408 'last_page': self.last_page,
1402 'page': self.page,
1409 'page': self.page,
1403 'page_count': self.page_count,
1410 'page_count': self.page_count,
1404 'items_per_page': self.items_per_page,
1411 'items_per_page': self.items_per_page,
1405 'first_item': self.first_item,
1412 'first_item': self.first_item,
1406 'last_item': self.last_item,
1413 'last_item': self.last_item,
1407 'item_count': self.item_count,
1414 'item_count': self.item_count,
1408 'link_first': self.page > self.first_page and \
1415 'link_first': self.page > self.first_page and \
1409 self._pagerlink(self.first_page, symbol_first) or '',
1416 self._pagerlink(self.first_page, symbol_first) or '',
1410 'link_last': self.page < self.last_page and \
1417 'link_last': self.page < self.last_page and \
1411 self._pagerlink(self.last_page, symbol_last) or '',
1418 self._pagerlink(self.last_page, symbol_last) or '',
1412 'link_previous': self.previous_page and \
1419 'link_previous': self.previous_page and \
1413 self._pagerlink(self.previous_page, symbol_previous) \
1420 self._pagerlink(self.previous_page, symbol_previous) \
1414 or HTML.span(symbol_previous, class_="pg-previous disabled"),
1421 or HTML.span(symbol_previous, class_="pg-previous disabled"),
1415 'link_next': self.next_page and \
1422 'link_next': self.next_page and \
1416 self._pagerlink(self.next_page, symbol_next) \
1423 self._pagerlink(self.next_page, symbol_next) \
1417 or HTML.span(symbol_next, class_="pg-next disabled")
1424 or HTML.span(symbol_next, class_="pg-next disabled")
1418 })
1425 })
1419
1426
1420 return literal(result)
1427 return literal(result)
1421
1428
1422
1429
1423 #==============================================================================
1430 #==============================================================================
1424 # REPO PAGER, PAGER FOR REPOSITORY
1431 # REPO PAGER, PAGER FOR REPOSITORY
1425 #==============================================================================
1432 #==============================================================================
1426 class RepoPage(Page):
1433 class RepoPage(Page):
1427
1434
1428 def __init__(self, collection, page=1, items_per_page=20,
1435 def __init__(self, collection, page=1, items_per_page=20,
1429 item_count=None, url=None, **kwargs):
1436 item_count=None, url=None, **kwargs):
1430
1437
1431 """Create a "RepoPage" instance. special pager for paging
1438 """Create a "RepoPage" instance. special pager for paging
1432 repository
1439 repository
1433 """
1440 """
1434 self._url_generator = url
1441 self._url_generator = url
1435
1442
1436 # Safe the kwargs class-wide so they can be used in the pager() method
1443 # Safe the kwargs class-wide so they can be used in the pager() method
1437 self.kwargs = kwargs
1444 self.kwargs = kwargs
1438
1445
1439 # Save a reference to the collection
1446 # Save a reference to the collection
1440 self.original_collection = collection
1447 self.original_collection = collection
1441
1448
1442 self.collection = collection
1449 self.collection = collection
1443
1450
1444 # The self.page is the number of the current page.
1451 # The self.page is the number of the current page.
1445 # The first page has the number 1!
1452 # The first page has the number 1!
1446 try:
1453 try:
1447 self.page = int(page) # make it int() if we get it as a string
1454 self.page = int(page) # make it int() if we get it as a string
1448 except (ValueError, TypeError):
1455 except (ValueError, TypeError):
1449 self.page = 1
1456 self.page = 1
1450
1457
1451 self.items_per_page = items_per_page
1458 self.items_per_page = items_per_page
1452
1459
1453 # Unless the user tells us how many items the collections has
1460 # Unless the user tells us how many items the collections has
1454 # we calculate that ourselves.
1461 # we calculate that ourselves.
1455 if item_count is not None:
1462 if item_count is not None:
1456 self.item_count = item_count
1463 self.item_count = item_count
1457 else:
1464 else:
1458 self.item_count = len(self.collection)
1465 self.item_count = len(self.collection)
1459
1466
1460 # Compute the number of the first and last available page
1467 # Compute the number of the first and last available page
1461 if self.item_count > 0:
1468 if self.item_count > 0:
1462 self.first_page = 1
1469 self.first_page = 1
1463 self.page_count = int(math.ceil(float(self.item_count) /
1470 self.page_count = int(math.ceil(float(self.item_count) /
1464 self.items_per_page))
1471 self.items_per_page))
1465 self.last_page = self.first_page + self.page_count - 1
1472 self.last_page = self.first_page + self.page_count - 1
1466
1473
1467 # Make sure that the requested page number is the range of
1474 # Make sure that the requested page number is the range of
1468 # valid pages
1475 # valid pages
1469 if self.page > self.last_page:
1476 if self.page > self.last_page:
1470 self.page = self.last_page
1477 self.page = self.last_page
1471 elif self.page < self.first_page:
1478 elif self.page < self.first_page:
1472 self.page = self.first_page
1479 self.page = self.first_page
1473
1480
1474 # Note: the number of items on this page can be less than
1481 # Note: the number of items on this page can be less than
1475 # items_per_page if the last page is not full
1482 # items_per_page if the last page is not full
1476 self.first_item = max(0, (self.item_count) - (self.page *
1483 self.first_item = max(0, (self.item_count) - (self.page *
1477 items_per_page))
1484 items_per_page))
1478 self.last_item = ((self.item_count - 1) - items_per_page *
1485 self.last_item = ((self.item_count - 1) - items_per_page *
1479 (self.page - 1))
1486 (self.page - 1))
1480
1487
1481 self.items = list(self.collection[self.first_item:self.last_item + 1])
1488 self.items = list(self.collection[self.first_item:self.last_item + 1])
1482
1489
1483 # Links to previous and next page
1490 # Links to previous and next page
1484 if self.page > self.first_page:
1491 if self.page > self.first_page:
1485 self.previous_page = self.page - 1
1492 self.previous_page = self.page - 1
1486 else:
1493 else:
1487 self.previous_page = None
1494 self.previous_page = None
1488
1495
1489 if self.page < self.last_page:
1496 if self.page < self.last_page:
1490 self.next_page = self.page + 1
1497 self.next_page = self.page + 1
1491 else:
1498 else:
1492 self.next_page = None
1499 self.next_page = None
1493
1500
1494 # No items available
1501 # No items available
1495 else:
1502 else:
1496 self.first_page = None
1503 self.first_page = None
1497 self.page_count = 0
1504 self.page_count = 0
1498 self.last_page = None
1505 self.last_page = None
1499 self.first_item = None
1506 self.first_item = None
1500 self.last_item = None
1507 self.last_item = None
1501 self.previous_page = None
1508 self.previous_page = None
1502 self.next_page = None
1509 self.next_page = None
1503 self.items = []
1510 self.items = []
1504
1511
1505 # This is a subclass of the 'list' type. Initialise the list now.
1512 # This is a subclass of the 'list' type. Initialise the list now.
1506 list.__init__(self, reversed(self.items))
1513 list.__init__(self, reversed(self.items))
1507
1514
1508
1515
1509 def changed_tooltip(nodes):
1516 def changed_tooltip(nodes):
1510 """
1517 """
1511 Generates a html string for changed nodes in commit page.
1518 Generates a html string for changed nodes in commit page.
1512 It limits the output to 30 entries
1519 It limits the output to 30 entries
1513
1520
1514 :param nodes: LazyNodesGenerator
1521 :param nodes: LazyNodesGenerator
1515 """
1522 """
1516 if nodes:
1523 if nodes:
1517 pref = ': <br/> '
1524 pref = ': <br/> '
1518 suf = ''
1525 suf = ''
1519 if len(nodes) > 30:
1526 if len(nodes) > 30:
1520 suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)
1527 suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)
1521 return literal(pref + '<br/> '.join([safe_unicode(x.path)
1528 return literal(pref + '<br/> '.join([safe_unicode(x.path)
1522 for x in nodes[:30]]) + suf)
1529 for x in nodes[:30]]) + suf)
1523 else:
1530 else:
1524 return ': ' + _('No Files')
1531 return ': ' + _('No Files')
1525
1532
1526
1533
1527 def breadcrumb_repo_link(repo):
1534 def breadcrumb_repo_link(repo):
1528 """
1535 """
1529 Makes a breadcrumbs path link to repo
1536 Makes a breadcrumbs path link to repo
1530
1537
1531 ex::
1538 ex::
1532 group >> subgroup >> repo
1539 group >> subgroup >> repo
1533
1540
1534 :param repo: a Repository instance
1541 :param repo: a Repository instance
1535 """
1542 """
1536
1543
1537 path = [
1544 path = [
1538 link_to(group.name, route_path('repo_group_home', repo_group_name=group.group_name))
1545 link_to(group.name, route_path('repo_group_home', repo_group_name=group.group_name))
1539 for group in repo.groups_with_parents
1546 for group in repo.groups_with_parents
1540 ] + [
1547 ] + [
1541 link_to(repo.just_name, route_path('repo_summary', repo_name=repo.repo_name))
1548 link_to(repo.just_name, route_path('repo_summary', repo_name=repo.repo_name))
1542 ]
1549 ]
1543
1550
1544 return literal(' &raquo; '.join(path))
1551 return literal(' &raquo; '.join(path))
1545
1552
1546
1553
1547 def format_byte_size_binary(file_size):
1554 def format_byte_size_binary(file_size):
1548 """
1555 """
1549 Formats file/folder sizes to standard.
1556 Formats file/folder sizes to standard.
1550 """
1557 """
1551 formatted_size = format_byte_size(file_size, binary=True)
1558 formatted_size = format_byte_size(file_size, binary=True)
1552 return formatted_size
1559 return formatted_size
1553
1560
1554
1561
1555 def urlify_text(text_, safe=True):
1562 def urlify_text(text_, safe=True):
1556 """
1563 """
1557 Extrac urls from text and make html links out of them
1564 Extrac urls from text and make html links out of them
1558
1565
1559 :param text_:
1566 :param text_:
1560 """
1567 """
1561
1568
1562 url_pat = re.compile(r'''(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@#.&+]'''
1569 url_pat = re.compile(r'''(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@#.&+]'''
1563 '''|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)''')
1570 '''|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)''')
1564
1571
1565 def url_func(match_obj):
1572 def url_func(match_obj):
1566 url_full = match_obj.groups()[0]
1573 url_full = match_obj.groups()[0]
1567 return '<a href="%(url)s">%(url)s</a>' % ({'url': url_full})
1574 return '<a href="%(url)s">%(url)s</a>' % ({'url': url_full})
1568 _newtext = url_pat.sub(url_func, text_)
1575 _newtext = url_pat.sub(url_func, text_)
1569 if safe:
1576 if safe:
1570 return literal(_newtext)
1577 return literal(_newtext)
1571 return _newtext
1578 return _newtext
1572
1579
1573
1580
1574 def urlify_commits(text_, repository):
1581 def urlify_commits(text_, repository):
1575 """
1582 """
1576 Extract commit ids from text and make link from them
1583 Extract commit ids from text and make link from them
1577
1584
1578 :param text_:
1585 :param text_:
1579 :param repository: repo name to build the URL with
1586 :param repository: repo name to build the URL with
1580 """
1587 """
1581 from pylons import url # doh, we need to re-import url to mock it later
1588 from pylons import url # doh, we need to re-import url to mock it later
1582 URL_PAT = re.compile(r'(^|\s)([0-9a-fA-F]{12,40})($|\s)')
1589 URL_PAT = re.compile(r'(^|\s)([0-9a-fA-F]{12,40})($|\s)')
1583
1590
1584 def url_func(match_obj):
1591 def url_func(match_obj):
1585 commit_id = match_obj.groups()[1]
1592 commit_id = match_obj.groups()[1]
1586 pref = match_obj.groups()[0]
1593 pref = match_obj.groups()[0]
1587 suf = match_obj.groups()[2]
1594 suf = match_obj.groups()[2]
1588
1595
1589 tmpl = (
1596 tmpl = (
1590 '%(pref)s<a class="%(cls)s" href="%(url)s">'
1597 '%(pref)s<a class="%(cls)s" href="%(url)s">'
1591 '%(commit_id)s</a>%(suf)s'
1598 '%(commit_id)s</a>%(suf)s'
1592 )
1599 )
1593 return tmpl % {
1600 return tmpl % {
1594 'pref': pref,
1601 'pref': pref,
1595 'cls': 'revision-link',
1602 'cls': 'revision-link',
1596 'url': url('changeset_home', repo_name=repository,
1603 'url': url('changeset_home', repo_name=repository,
1597 revision=commit_id, qualified=True),
1604 revision=commit_id, qualified=True),
1598 'commit_id': commit_id,
1605 'commit_id': commit_id,
1599 'suf': suf
1606 'suf': suf
1600 }
1607 }
1601
1608
1602 newtext = URL_PAT.sub(url_func, text_)
1609 newtext = URL_PAT.sub(url_func, text_)
1603
1610
1604 return newtext
1611 return newtext
1605
1612
1606
1613
1607 def _process_url_func(match_obj, repo_name, uid, entry,
1614 def _process_url_func(match_obj, repo_name, uid, entry,
1608 return_raw_data=False, link_format='html'):
1615 return_raw_data=False, link_format='html'):
1609 pref = ''
1616 pref = ''
1610 if match_obj.group().startswith(' '):
1617 if match_obj.group().startswith(' '):
1611 pref = ' '
1618 pref = ' '
1612
1619
1613 issue_id = ''.join(match_obj.groups())
1620 issue_id = ''.join(match_obj.groups())
1614
1621
1615 if link_format == 'html':
1622 if link_format == 'html':
1616 tmpl = (
1623 tmpl = (
1617 '%(pref)s<a class="%(cls)s" href="%(url)s">'
1624 '%(pref)s<a class="%(cls)s" href="%(url)s">'
1618 '%(issue-prefix)s%(id-repr)s'
1625 '%(issue-prefix)s%(id-repr)s'
1619 '</a>')
1626 '</a>')
1620 elif link_format == 'rst':
1627 elif link_format == 'rst':
1621 tmpl = '`%(issue-prefix)s%(id-repr)s <%(url)s>`_'
1628 tmpl = '`%(issue-prefix)s%(id-repr)s <%(url)s>`_'
1622 elif link_format == 'markdown':
1629 elif link_format == 'markdown':
1623 tmpl = '[%(issue-prefix)s%(id-repr)s](%(url)s)'
1630 tmpl = '[%(issue-prefix)s%(id-repr)s](%(url)s)'
1624 else:
1631 else:
1625 raise ValueError('Bad link_format:{}'.format(link_format))
1632 raise ValueError('Bad link_format:{}'.format(link_format))
1626
1633
1627 (repo_name_cleaned,
1634 (repo_name_cleaned,
1628 parent_group_name) = RepoGroupModel().\
1635 parent_group_name) = RepoGroupModel().\
1629 _get_group_name_and_parent(repo_name)
1636 _get_group_name_and_parent(repo_name)
1630
1637
1631 # variables replacement
1638 # variables replacement
1632 named_vars = {
1639 named_vars = {
1633 'id': issue_id,
1640 'id': issue_id,
1634 'repo': repo_name,
1641 'repo': repo_name,
1635 'repo_name': repo_name_cleaned,
1642 'repo_name': repo_name_cleaned,
1636 'group_name': parent_group_name
1643 'group_name': parent_group_name
1637 }
1644 }
1638 # named regex variables
1645 # named regex variables
1639 named_vars.update(match_obj.groupdict())
1646 named_vars.update(match_obj.groupdict())
1640 _url = string.Template(entry['url']).safe_substitute(**named_vars)
1647 _url = string.Template(entry['url']).safe_substitute(**named_vars)
1641
1648
1642 data = {
1649 data = {
1643 'pref': pref,
1650 'pref': pref,
1644 'cls': 'issue-tracker-link',
1651 'cls': 'issue-tracker-link',
1645 'url': _url,
1652 'url': _url,
1646 'id-repr': issue_id,
1653 'id-repr': issue_id,
1647 'issue-prefix': entry['pref'],
1654 'issue-prefix': entry['pref'],
1648 'serv': entry['url'],
1655 'serv': entry['url'],
1649 }
1656 }
1650 if return_raw_data:
1657 if return_raw_data:
1651 return {
1658 return {
1652 'id': issue_id,
1659 'id': issue_id,
1653 'url': _url
1660 'url': _url
1654 }
1661 }
1655 return tmpl % data
1662 return tmpl % data
1656
1663
1657
1664
1658 def process_patterns(text_string, repo_name, link_format='html'):
1665 def process_patterns(text_string, repo_name, link_format='html'):
1659 allowed_formats = ['html', 'rst', 'markdown']
1666 allowed_formats = ['html', 'rst', 'markdown']
1660 if link_format not in allowed_formats:
1667 if link_format not in allowed_formats:
1661 raise ValueError('Link format can be only one of:{} got {}'.format(
1668 raise ValueError('Link format can be only one of:{} got {}'.format(
1662 allowed_formats, link_format))
1669 allowed_formats, link_format))
1663
1670
1664 repo = None
1671 repo = None
1665 if repo_name:
1672 if repo_name:
1666 # Retrieving repo_name to avoid invalid repo_name to explode on
1673 # Retrieving repo_name to avoid invalid repo_name to explode on
1667 # IssueTrackerSettingsModel but still passing invalid name further down
1674 # IssueTrackerSettingsModel but still passing invalid name further down
1668 repo = Repository.get_by_repo_name(repo_name, cache=True)
1675 repo = Repository.get_by_repo_name(repo_name, cache=True)
1669
1676
1670 settings_model = IssueTrackerSettingsModel(repo=repo)
1677 settings_model = IssueTrackerSettingsModel(repo=repo)
1671 active_entries = settings_model.get_settings(cache=True)
1678 active_entries = settings_model.get_settings(cache=True)
1672
1679
1673 issues_data = []
1680 issues_data = []
1674 newtext = text_string
1681 newtext = text_string
1675
1682
1676 for uid, entry in active_entries.items():
1683 for uid, entry in active_entries.items():
1677 log.debug('found issue tracker entry with uid %s' % (uid,))
1684 log.debug('found issue tracker entry with uid %s' % (uid,))
1678
1685
1679 if not (entry['pat'] and entry['url']):
1686 if not (entry['pat'] and entry['url']):
1680 log.debug('skipping due to missing data')
1687 log.debug('skipping due to missing data')
1681 continue
1688 continue
1682
1689
1683 log.debug('issue tracker entry: uid: `%s` PAT:%s URL:%s PREFIX:%s'
1690 log.debug('issue tracker entry: uid: `%s` PAT:%s URL:%s PREFIX:%s'
1684 % (uid, entry['pat'], entry['url'], entry['pref']))
1691 % (uid, entry['pat'], entry['url'], entry['pref']))
1685
1692
1686 try:
1693 try:
1687 pattern = re.compile(r'%s' % entry['pat'])
1694 pattern = re.compile(r'%s' % entry['pat'])
1688 except re.error:
1695 except re.error:
1689 log.exception(
1696 log.exception(
1690 'issue tracker pattern: `%s` failed to compile',
1697 'issue tracker pattern: `%s` failed to compile',
1691 entry['pat'])
1698 entry['pat'])
1692 continue
1699 continue
1693
1700
1694 data_func = partial(
1701 data_func = partial(
1695 _process_url_func, repo_name=repo_name, entry=entry, uid=uid,
1702 _process_url_func, repo_name=repo_name, entry=entry, uid=uid,
1696 return_raw_data=True)
1703 return_raw_data=True)
1697
1704
1698 for match_obj in pattern.finditer(text_string):
1705 for match_obj in pattern.finditer(text_string):
1699 issues_data.append(data_func(match_obj))
1706 issues_data.append(data_func(match_obj))
1700
1707
1701 url_func = partial(
1708 url_func = partial(
1702 _process_url_func, repo_name=repo_name, entry=entry, uid=uid,
1709 _process_url_func, repo_name=repo_name, entry=entry, uid=uid,
1703 link_format=link_format)
1710 link_format=link_format)
1704
1711
1705 newtext = pattern.sub(url_func, newtext)
1712 newtext = pattern.sub(url_func, newtext)
1706 log.debug('processed prefix:uid `%s`' % (uid,))
1713 log.debug('processed prefix:uid `%s`' % (uid,))
1707
1714
1708 return newtext, issues_data
1715 return newtext, issues_data
1709
1716
1710
1717
1711 def urlify_commit_message(commit_text, repository=None):
1718 def urlify_commit_message(commit_text, repository=None):
1712 """
1719 """
1713 Parses given text message and makes proper links.
1720 Parses given text message and makes proper links.
1714 issues are linked to given issue-server, and rest is a commit link
1721 issues are linked to given issue-server, and rest is a commit link
1715
1722
1716 :param commit_text:
1723 :param commit_text:
1717 :param repository:
1724 :param repository:
1718 """
1725 """
1719 from pylons import url # doh, we need to re-import url to mock it later
1726 from pylons import url # doh, we need to re-import url to mock it later
1720
1727
1721 def escaper(string):
1728 def escaper(string):
1722 return string.replace('<', '&lt;').replace('>', '&gt;')
1729 return string.replace('<', '&lt;').replace('>', '&gt;')
1723
1730
1724 newtext = escaper(commit_text)
1731 newtext = escaper(commit_text)
1725
1732
1726 # extract http/https links and make them real urls
1733 # extract http/https links and make them real urls
1727 newtext = urlify_text(newtext, safe=False)
1734 newtext = urlify_text(newtext, safe=False)
1728
1735
1729 # urlify commits - extract commit ids and make link out of them, if we have
1736 # urlify commits - extract commit ids and make link out of them, if we have
1730 # the scope of repository present.
1737 # the scope of repository present.
1731 if repository:
1738 if repository:
1732 newtext = urlify_commits(newtext, repository)
1739 newtext = urlify_commits(newtext, repository)
1733
1740
1734 # process issue tracker patterns
1741 # process issue tracker patterns
1735 newtext, issues = process_patterns(newtext, repository or '')
1742 newtext, issues = process_patterns(newtext, repository or '')
1736
1743
1737 return literal(newtext)
1744 return literal(newtext)
1738
1745
1739
1746
1740 def render_binary(repo_name, file_obj):
1747 def render_binary(repo_name, file_obj):
1741 """
1748 """
1742 Choose how to render a binary file
1749 Choose how to render a binary file
1743 """
1750 """
1744 filename = file_obj.name
1751 filename = file_obj.name
1745
1752
1746 # images
1753 # images
1747 for ext in ['*.png', '*.jpg', '*.ico', '*.gif']:
1754 for ext in ['*.png', '*.jpg', '*.ico', '*.gif']:
1748 if fnmatch.fnmatch(filename, pat=ext):
1755 if fnmatch.fnmatch(filename, pat=ext):
1749 alt = filename
1756 alt = filename
1750 src = url('files_raw_home', repo_name=repo_name,
1757 src = url('files_raw_home', repo_name=repo_name,
1751 revision=file_obj.commit.raw_id, f_path=file_obj.path)
1758 revision=file_obj.commit.raw_id, f_path=file_obj.path)
1752 return literal('<img class="rendered-binary" alt="{}" src="{}">'.format(alt, src))
1759 return literal('<img class="rendered-binary" alt="{}" src="{}">'.format(alt, src))
1753
1760
1754
1761
1755 def renderer_from_filename(filename, exclude=None):
1762 def renderer_from_filename(filename, exclude=None):
1756 """
1763 """
1757 choose a renderer based on filename, this works only for text based files
1764 choose a renderer based on filename, this works only for text based files
1758 """
1765 """
1759
1766
1760 # ipython
1767 # ipython
1761 for ext in ['*.ipynb']:
1768 for ext in ['*.ipynb']:
1762 if fnmatch.fnmatch(filename, pat=ext):
1769 if fnmatch.fnmatch(filename, pat=ext):
1763 return 'jupyter'
1770 return 'jupyter'
1764
1771
1765 is_markup = MarkupRenderer.renderer_from_filename(filename, exclude=exclude)
1772 is_markup = MarkupRenderer.renderer_from_filename(filename, exclude=exclude)
1766 if is_markup:
1773 if is_markup:
1767 return is_markup
1774 return is_markup
1768 return None
1775 return None
1769
1776
1770
1777
1771 def render(source, renderer='rst', mentions=False, relative_url=None,
1778 def render(source, renderer='rst', mentions=False, relative_url=None,
1772 repo_name=None):
1779 repo_name=None):
1773
1780
1774 def maybe_convert_relative_links(html_source):
1781 def maybe_convert_relative_links(html_source):
1775 if relative_url:
1782 if relative_url:
1776 return relative_links(html_source, relative_url)
1783 return relative_links(html_source, relative_url)
1777 return html_source
1784 return html_source
1778
1785
1779 if renderer == 'rst':
1786 if renderer == 'rst':
1780 if repo_name:
1787 if repo_name:
1781 # process patterns on comments if we pass in repo name
1788 # process patterns on comments if we pass in repo name
1782 source, issues = process_patterns(
1789 source, issues = process_patterns(
1783 source, repo_name, link_format='rst')
1790 source, repo_name, link_format='rst')
1784
1791
1785 return literal(
1792 return literal(
1786 '<div class="rst-block">%s</div>' %
1793 '<div class="rst-block">%s</div>' %
1787 maybe_convert_relative_links(
1794 maybe_convert_relative_links(
1788 MarkupRenderer.rst(source, mentions=mentions)))
1795 MarkupRenderer.rst(source, mentions=mentions)))
1789 elif renderer == 'markdown':
1796 elif renderer == 'markdown':
1790 if repo_name:
1797 if repo_name:
1791 # process patterns on comments if we pass in repo name
1798 # process patterns on comments if we pass in repo name
1792 source, issues = process_patterns(
1799 source, issues = process_patterns(
1793 source, repo_name, link_format='markdown')
1800 source, repo_name, link_format='markdown')
1794
1801
1795 return literal(
1802 return literal(
1796 '<div class="markdown-block">%s</div>' %
1803 '<div class="markdown-block">%s</div>' %
1797 maybe_convert_relative_links(
1804 maybe_convert_relative_links(
1798 MarkupRenderer.markdown(source, flavored=True,
1805 MarkupRenderer.markdown(source, flavored=True,
1799 mentions=mentions)))
1806 mentions=mentions)))
1800 elif renderer == 'jupyter':
1807 elif renderer == 'jupyter':
1801 return literal(
1808 return literal(
1802 '<div class="ipynb">%s</div>' %
1809 '<div class="ipynb">%s</div>' %
1803 maybe_convert_relative_links(
1810 maybe_convert_relative_links(
1804 MarkupRenderer.jupyter(source)))
1811 MarkupRenderer.jupyter(source)))
1805
1812
1806 # None means just show the file-source
1813 # None means just show the file-source
1807 return None
1814 return None
1808
1815
1809
1816
1810 def commit_status(repo, commit_id):
1817 def commit_status(repo, commit_id):
1811 return ChangesetStatusModel().get_status(repo, commit_id)
1818 return ChangesetStatusModel().get_status(repo, commit_id)
1812
1819
1813
1820
1814 def commit_status_lbl(commit_status):
1821 def commit_status_lbl(commit_status):
1815 return dict(ChangesetStatus.STATUSES).get(commit_status)
1822 return dict(ChangesetStatus.STATUSES).get(commit_status)
1816
1823
1817
1824
1818 def commit_time(repo_name, commit_id):
1825 def commit_time(repo_name, commit_id):
1819 repo = Repository.get_by_repo_name(repo_name)
1826 repo = Repository.get_by_repo_name(repo_name)
1820 commit = repo.get_commit(commit_id=commit_id)
1827 commit = repo.get_commit(commit_id=commit_id)
1821 return commit.date
1828 return commit.date
1822
1829
1823
1830
1824 def get_permission_name(key):
1831 def get_permission_name(key):
1825 return dict(Permission.PERMS).get(key)
1832 return dict(Permission.PERMS).get(key)
1826
1833
1827
1834
1828 def journal_filter_help():
1835 def journal_filter_help():
1829 return _(
1836 return _(
1830 'Example filter terms:\n' +
1837 'Example filter terms:\n' +
1831 ' repository:vcs\n' +
1838 ' repository:vcs\n' +
1832 ' username:marcin\n' +
1839 ' username:marcin\n' +
1833 ' action:*push*\n' +
1840 ' action:*push*\n' +
1834 ' ip:127.0.0.1\n' +
1841 ' ip:127.0.0.1\n' +
1835 ' date:20120101\n' +
1842 ' date:20120101\n' +
1836 ' date:[20120101100000 TO 20120102]\n' +
1843 ' date:[20120101100000 TO 20120102]\n' +
1837 '\n' +
1844 '\n' +
1838 'Generate wildcards using \'*\' character:\n' +
1845 'Generate wildcards using \'*\' character:\n' +
1839 ' "repository:vcs*" - search everything starting with \'vcs\'\n' +
1846 ' "repository:vcs*" - search everything starting with \'vcs\'\n' +
1840 ' "repository:*vcs*" - search for repository containing \'vcs\'\n' +
1847 ' "repository:*vcs*" - search for repository containing \'vcs\'\n' +
1841 '\n' +
1848 '\n' +
1842 'Optional AND / OR operators in queries\n' +
1849 'Optional AND / OR operators in queries\n' +
1843 ' "repository:vcs OR repository:test"\n' +
1850 ' "repository:vcs OR repository:test"\n' +
1844 ' "username:test AND repository:test*"\n'
1851 ' "username:test AND repository:test*"\n'
1845 )
1852 )
1846
1853
1847
1854
1848 def search_filter_help(searcher):
1855 def search_filter_help(searcher):
1849
1856
1850 terms = ''
1857 terms = ''
1851 return _(
1858 return _(
1852 'Example filter terms for `{searcher}` search:\n' +
1859 'Example filter terms for `{searcher}` search:\n' +
1853 '{terms}\n' +
1860 '{terms}\n' +
1854 'Generate wildcards using \'*\' character:\n' +
1861 'Generate wildcards using \'*\' character:\n' +
1855 ' "repo_name:vcs*" - search everything starting with \'vcs\'\n' +
1862 ' "repo_name:vcs*" - search everything starting with \'vcs\'\n' +
1856 ' "repo_name:*vcs*" - search for repository containing \'vcs\'\n' +
1863 ' "repo_name:*vcs*" - search for repository containing \'vcs\'\n' +
1857 '\n' +
1864 '\n' +
1858 'Optional AND / OR operators in queries\n' +
1865 'Optional AND / OR operators in queries\n' +
1859 ' "repo_name:vcs OR repo_name:test"\n' +
1866 ' "repo_name:vcs OR repo_name:test"\n' +
1860 ' "owner:test AND repo_name:test*"\n' +
1867 ' "owner:test AND repo_name:test*"\n' +
1861 'More: {search_doc}'
1868 'More: {search_doc}'
1862 ).format(searcher=searcher.name,
1869 ).format(searcher=searcher.name,
1863 terms=terms, search_doc=searcher.query_lang_doc)
1870 terms=terms, search_doc=searcher.query_lang_doc)
1864
1871
1865
1872
1866 def not_mapped_error(repo_name):
1873 def not_mapped_error(repo_name):
1867 flash(_('%s repository is not mapped to db perhaps'
1874 flash(_('%s repository is not mapped to db perhaps'
1868 ' it was created or renamed from the filesystem'
1875 ' it was created or renamed from the filesystem'
1869 ' please run the application again'
1876 ' please run the application again'
1870 ' in order to rescan repositories') % repo_name, category='error')
1877 ' in order to rescan repositories') % repo_name, category='error')
1871
1878
1872
1879
1873 def ip_range(ip_addr):
1880 def ip_range(ip_addr):
1874 from rhodecode.model.db import UserIpMap
1881 from rhodecode.model.db import UserIpMap
1875 s, e = UserIpMap._get_ip_range(ip_addr)
1882 s, e = UserIpMap._get_ip_range(ip_addr)
1876 return '%s - %s' % (s, e)
1883 return '%s - %s' % (s, e)
1877
1884
1878
1885
1879 def form(url, method='post', needs_csrf_token=True, **attrs):
1886 def form(url, method='post', needs_csrf_token=True, **attrs):
1880 """Wrapper around webhelpers.tags.form to prevent CSRF attacks."""
1887 """Wrapper around webhelpers.tags.form to prevent CSRF attacks."""
1881 if method.lower() != 'get' and needs_csrf_token:
1888 if method.lower() != 'get' and needs_csrf_token:
1882 raise Exception(
1889 raise Exception(
1883 'Forms to POST/PUT/DELETE endpoints should have (in general) a ' +
1890 'Forms to POST/PUT/DELETE endpoints should have (in general) a ' +
1884 'CSRF token. If the endpoint does not require such token you can ' +
1891 'CSRF token. If the endpoint does not require such token you can ' +
1885 'explicitly set the parameter needs_csrf_token to false.')
1892 'explicitly set the parameter needs_csrf_token to false.')
1886
1893
1887 return wh_form(url, method=method, **attrs)
1894 return wh_form(url, method=method, **attrs)
1888
1895
1889
1896
1890 def secure_form(url, method="POST", multipart=False, **attrs):
1897 def secure_form(url, method="POST", multipart=False, **attrs):
1891 """Start a form tag that points the action to an url. This
1898 """Start a form tag that points the action to an url. This
1892 form tag will also include the hidden field containing
1899 form tag will also include the hidden field containing
1893 the auth token.
1900 the auth token.
1894
1901
1895 The url options should be given either as a string, or as a
1902 The url options should be given either as a string, or as a
1896 ``url()`` function. The method for the form defaults to POST.
1903 ``url()`` function. The method for the form defaults to POST.
1897
1904
1898 Options:
1905 Options:
1899
1906
1900 ``multipart``
1907 ``multipart``
1901 If set to True, the enctype is set to "multipart/form-data".
1908 If set to True, the enctype is set to "multipart/form-data".
1902 ``method``
1909 ``method``
1903 The method to use when submitting the form, usually either
1910 The method to use when submitting the form, usually either
1904 "GET" or "POST". If "PUT", "DELETE", or another verb is used, a
1911 "GET" or "POST". If "PUT", "DELETE", or another verb is used, a
1905 hidden input with name _method is added to simulate the verb
1912 hidden input with name _method is added to simulate the verb
1906 over POST.
1913 over POST.
1907
1914
1908 """
1915 """
1909 from webhelpers.pylonslib.secure_form import insecure_form
1916 from webhelpers.pylonslib.secure_form import insecure_form
1910 form = insecure_form(url, method, multipart, **attrs)
1917 form = insecure_form(url, method, multipart, **attrs)
1911 token = csrf_input()
1918 token = csrf_input()
1912 return literal("%s\n%s" % (form, token))
1919 return literal("%s\n%s" % (form, token))
1913
1920
1914 def csrf_input():
1921 def csrf_input():
1915 return literal(
1922 return literal(
1916 '<input type="hidden" id="{}" name="{}" value="{}">'.format(
1923 '<input type="hidden" id="{}" name="{}" value="{}">'.format(
1917 csrf_token_key, csrf_token_key, get_csrf_token()))
1924 csrf_token_key, csrf_token_key, get_csrf_token()))
1918
1925
1919 def dropdownmenu(name, selected, options, enable_filter=False, **attrs):
1926 def dropdownmenu(name, selected, options, enable_filter=False, **attrs):
1920 select_html = select(name, selected, options, **attrs)
1927 select_html = select(name, selected, options, **attrs)
1921 select2 = """
1928 select2 = """
1922 <script>
1929 <script>
1923 $(document).ready(function() {
1930 $(document).ready(function() {
1924 $('#%s').select2({
1931 $('#%s').select2({
1925 containerCssClass: 'drop-menu',
1932 containerCssClass: 'drop-menu',
1926 dropdownCssClass: 'drop-menu-dropdown',
1933 dropdownCssClass: 'drop-menu-dropdown',
1927 dropdownAutoWidth: true%s
1934 dropdownAutoWidth: true%s
1928 });
1935 });
1929 });
1936 });
1930 </script>
1937 </script>
1931 """
1938 """
1932 filter_option = """,
1939 filter_option = """,
1933 minimumResultsForSearch: -1
1940 minimumResultsForSearch: -1
1934 """
1941 """
1935 input_id = attrs.get('id') or name
1942 input_id = attrs.get('id') or name
1936 filter_enabled = "" if enable_filter else filter_option
1943 filter_enabled = "" if enable_filter else filter_option
1937 select_script = literal(select2 % (input_id, filter_enabled))
1944 select_script = literal(select2 % (input_id, filter_enabled))
1938
1945
1939 return literal(select_html+select_script)
1946 return literal(select_html+select_script)
1940
1947
1941
1948
1942 def get_visual_attr(tmpl_context_var, attr_name):
1949 def get_visual_attr(tmpl_context_var, attr_name):
1943 """
1950 """
1944 A safe way to get a variable from visual variable of template context
1951 A safe way to get a variable from visual variable of template context
1945
1952
1946 :param tmpl_context_var: instance of tmpl_context, usually present as `c`
1953 :param tmpl_context_var: instance of tmpl_context, usually present as `c`
1947 :param attr_name: name of the attribute we fetch from the c.visual
1954 :param attr_name: name of the attribute we fetch from the c.visual
1948 """
1955 """
1949 visual = getattr(tmpl_context_var, 'visual', None)
1956 visual = getattr(tmpl_context_var, 'visual', None)
1950 if not visual:
1957 if not visual:
1951 return
1958 return
1952 else:
1959 else:
1953 return getattr(visual, attr_name, None)
1960 return getattr(visual, attr_name, None)
1954
1961
1955
1962
1956 def get_last_path_part(file_node):
1963 def get_last_path_part(file_node):
1957 if not file_node.path:
1964 if not file_node.path:
1958 return u''
1965 return u''
1959
1966
1960 path = safe_unicode(file_node.path.split('/')[-1])
1967 path = safe_unicode(file_node.path.split('/')[-1])
1961 return u'../' + path
1968 return u'../' + path
1962
1969
1963
1970
1964 def route_url(*args, **kwargs):
1971 def route_url(*args, **kwargs):
1965 """
1972 """
1966 Wrapper around pyramids `route_url` (fully qualified url) function.
1973 Wrapper around pyramids `route_url` (fully qualified url) function.
1967 It is used to generate URLs from within pylons views or templates.
1974 It is used to generate URLs from within pylons views or templates.
1968 This will be removed when pyramid migration if finished.
1975 This will be removed when pyramid migration if finished.
1969 """
1976 """
1970 req = get_current_request()
1977 req = get_current_request()
1971 return req.route_url(*args, **kwargs)
1978 return req.route_url(*args, **kwargs)
1972
1979
1973
1980
1974 def route_path(*args, **kwargs):
1981 def route_path(*args, **kwargs):
1975 """
1982 """
1976 Wrapper around pyramids `route_path` function. It is used to generate
1983 Wrapper around pyramids `route_path` function. It is used to generate
1977 URLs from within pylons views or templates. This will be removed when
1984 URLs from within pylons views or templates. This will be removed when
1978 pyramid migration if finished.
1985 pyramid migration if finished.
1979 """
1986 """
1980 req = get_current_request()
1987 req = get_current_request()
1981 return req.route_path(*args, **kwargs)
1988 return req.route_path(*args, **kwargs)
1982
1989
1983
1990
1984 def route_path_or_none(*args, **kwargs):
1991 def route_path_or_none(*args, **kwargs):
1985 try:
1992 try:
1986 return route_path(*args, **kwargs)
1993 return route_path(*args, **kwargs)
1987 except KeyError:
1994 except KeyError:
1988 return None
1995 return None
1989
1996
1990
1997
1991 def static_url(*args, **kwds):
1998 def static_url(*args, **kwds):
1992 """
1999 """
1993 Wrapper around pyramids `route_path` function. It is used to generate
2000 Wrapper around pyramids `route_path` function. It is used to generate
1994 URLs from within pylons views or templates. This will be removed when
2001 URLs from within pylons views or templates. This will be removed when
1995 pyramid migration if finished.
2002 pyramid migration if finished.
1996 """
2003 """
1997 req = get_current_request()
2004 req = get_current_request()
1998 return req.static_url(*args, **kwds)
2005 return req.static_url(*args, **kwds)
1999
2006
2000
2007
2001 def resource_path(*args, **kwds):
2008 def resource_path(*args, **kwds):
2002 """
2009 """
2003 Wrapper around pyramids `route_path` function. It is used to generate
2010 Wrapper around pyramids `route_path` function. It is used to generate
2004 URLs from within pylons views or templates. This will be removed when
2011 URLs from within pylons views or templates. This will be removed when
2005 pyramid migration if finished.
2012 pyramid migration if finished.
2006 """
2013 """
2007 req = get_current_request()
2014 req = get_current_request()
2008 return req.resource_path(*args, **kwds)
2015 return req.resource_path(*args, **kwds)
2009
2016
2010
2017
2011 def api_call_example(method, args):
2018 def api_call_example(method, args):
2012 """
2019 """
2013 Generates an API call example via CURL
2020 Generates an API call example via CURL
2014 """
2021 """
2015 args_json = json.dumps(OrderedDict([
2022 args_json = json.dumps(OrderedDict([
2016 ('id', 1),
2023 ('id', 1),
2017 ('auth_token', 'SECRET'),
2024 ('auth_token', 'SECRET'),
2018 ('method', method),
2025 ('method', method),
2019 ('args', args)
2026 ('args', args)
2020 ]))
2027 ]))
2021 return literal(
2028 return literal(
2022 "curl {api_url} -X POST -H 'content-type:text/plain' --data-binary '{data}'"
2029 "curl {api_url} -X POST -H 'content-type:text/plain' --data-binary '{data}'"
2023 "<br/><br/>SECRET can be found in <a href=\"{token_url}\">auth-tokens</a> page, "
2030 "<br/><br/>SECRET can be found in <a href=\"{token_url}\">auth-tokens</a> page, "
2024 "and needs to be of `api calls` role."
2031 "and needs to be of `api calls` role."
2025 .format(
2032 .format(
2026 api_url=route_url('apiv2'),
2033 api_url=route_url('apiv2'),
2027 token_url=route_url('my_account_auth_tokens'),
2034 token_url=route_url('my_account_auth_tokens'),
2028 data=args_json))
2035 data=args_json))
@@ -1,34 +1,34 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2016-2017 RhodeCode GmbH
3 # Copyright (C) 2016-2017 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 colander
21 import colander
22 from rhodecode.model.validation_schema import validators, preparers, types
22 from rhodecode.model.validation_schema import validators, preparers, types
23
23
24
24
25 class ReviewerSchema(colander.MappingSchema):
25 class ReviewerSchema(colander.MappingSchema):
26 username = colander.SchemaNode(types.StrOrIntType())
26 username = colander.SchemaNode(types.StrOrIntType())
27 reasons = colander.SchemaNode(colander.List(), missing=[])
27 reasons = colander.SchemaNode(colander.List(), missing=['no reason specified'])
28 mandatory = colander.SchemaNode(colander.Boolean(), missing=False)
28 mandatory = colander.SchemaNode(colander.Boolean(), missing=False)
29
29
30
30
31 class ReviewerListSchema(colander.SequenceSchema):
31 class ReviewerListSchema(colander.SequenceSchema):
32 reviewers = ReviewerSchema()
32 reviewers = ReviewerSchema()
33
33
34
34
General Comments 0
You need to be logged in to leave comments. Login now