##// END OF EJS Templates
comments: properly show version of pull request into added comments....
marcink -
r1286:e783fdd1 default
parent child Browse files
Show More
@@ -1,468 +1,470 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2010-2017 RhodeCode GmbH
4 4 #
5 5 # This program is free software: you can redistribute it and/or modify
6 6 # it under the terms of the GNU Affero General Public License, version 3
7 7 # (only), as published by the Free Software Foundation.
8 8 #
9 9 # This program is distributed in the hope that it will be useful,
10 10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 # GNU General Public License for more details.
13 13 #
14 14 # You should have received a copy of the GNU Affero General Public License
15 15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
16 16 #
17 17 # This program is dual-licensed. If you wish to learn more about the
18 18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20 20
21 21 """
22 22 commit controller for RhodeCode showing changes between commits
23 23 """
24 24
25 25 import logging
26 26
27 27 from collections import defaultdict
28 28 from webob.exc import HTTPForbidden, HTTPBadRequest, HTTPNotFound
29 29
30 30 from pylons import tmpl_context as c, request, response
31 31 from pylons.i18n.translation import _
32 32 from pylons.controllers.util import redirect
33 33
34 34 from rhodecode.lib import auth
35 35 from rhodecode.lib import diffs, codeblocks
36 36 from rhodecode.lib.auth import (
37 37 LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous)
38 38 from rhodecode.lib.base import BaseRepoController, render
39 39 from rhodecode.lib.compat import OrderedDict
40 40 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
41 41 import rhodecode.lib.helpers as h
42 42 from rhodecode.lib.utils import action_logger, jsonify
43 43 from rhodecode.lib.utils2 import safe_unicode
44 44 from rhodecode.lib.vcs.backends.base import EmptyCommit
45 45 from rhodecode.lib.vcs.exceptions import (
46 46 RepositoryError, CommitDoesNotExistError, NodeDoesNotExistError)
47 47 from rhodecode.model.db import ChangesetComment, ChangesetStatus
48 48 from rhodecode.model.changeset_status import ChangesetStatusModel
49 49 from rhodecode.model.comment import ChangesetCommentsModel
50 50 from rhodecode.model.meta import Session
51 51 from rhodecode.model.repo import RepoModel
52 52
53 53
54 54 log = logging.getLogger(__name__)
55 55
56 56
57 57 def _update_with_GET(params, GET):
58 58 for k in ['diff1', 'diff2', 'diff']:
59 59 params[k] += GET.getall(k)
60 60
61 61
62 62 def get_ignore_ws(fid, GET):
63 63 ig_ws_global = GET.get('ignorews')
64 64 ig_ws = filter(lambda k: k.startswith('WS'), GET.getall(fid))
65 65 if ig_ws:
66 66 try:
67 67 return int(ig_ws[0].split(':')[-1])
68 68 except Exception:
69 69 pass
70 70 return ig_ws_global
71 71
72 72
73 73 def _ignorews_url(GET, fileid=None):
74 74 fileid = str(fileid) if fileid else None
75 75 params = defaultdict(list)
76 76 _update_with_GET(params, GET)
77 77 label = _('Show whitespace')
78 78 tooltiplbl = _('Show whitespace for all diffs')
79 79 ig_ws = get_ignore_ws(fileid, GET)
80 80 ln_ctx = get_line_ctx(fileid, GET)
81 81
82 82 if ig_ws is None:
83 83 params['ignorews'] += [1]
84 84 label = _('Ignore whitespace')
85 85 tooltiplbl = _('Ignore whitespace for all diffs')
86 86 ctx_key = 'context'
87 87 ctx_val = ln_ctx
88 88
89 89 # if we have passed in ln_ctx pass it along to our params
90 90 if ln_ctx:
91 91 params[ctx_key] += [ctx_val]
92 92
93 93 if fileid:
94 94 params['anchor'] = 'a_' + fileid
95 95 return h.link_to(label, h.url.current(**params), title=tooltiplbl, class_='tooltip')
96 96
97 97
98 98 def get_line_ctx(fid, GET):
99 99 ln_ctx_global = GET.get('context')
100 100 if fid:
101 101 ln_ctx = filter(lambda k: k.startswith('C'), GET.getall(fid))
102 102 else:
103 103 _ln_ctx = filter(lambda k: k.startswith('C'), GET)
104 104 ln_ctx = GET.get(_ln_ctx[0]) if _ln_ctx else ln_ctx_global
105 105 if ln_ctx:
106 106 ln_ctx = [ln_ctx]
107 107
108 108 if ln_ctx:
109 109 retval = ln_ctx[0].split(':')[-1]
110 110 else:
111 111 retval = ln_ctx_global
112 112
113 113 try:
114 114 return int(retval)
115 115 except Exception:
116 116 return 3
117 117
118 118
119 119 def _context_url(GET, fileid=None):
120 120 """
121 121 Generates a url for context lines.
122 122
123 123 :param fileid:
124 124 """
125 125
126 126 fileid = str(fileid) if fileid else None
127 127 ig_ws = get_ignore_ws(fileid, GET)
128 128 ln_ctx = (get_line_ctx(fileid, GET) or 3) * 2
129 129
130 130 params = defaultdict(list)
131 131 _update_with_GET(params, GET)
132 132
133 133 if ln_ctx > 0:
134 134 params['context'] += [ln_ctx]
135 135
136 136 if ig_ws:
137 137 ig_ws_key = 'ignorews'
138 138 ig_ws_val = 1
139 139 params[ig_ws_key] += [ig_ws_val]
140 140
141 141 lbl = _('Increase context')
142 142 tooltiplbl = _('Increase context for all diffs')
143 143
144 144 if fileid:
145 145 params['anchor'] = 'a_' + fileid
146 146 return h.link_to(lbl, h.url.current(**params), title=tooltiplbl, class_='tooltip')
147 147
148 148
149 149 class ChangesetController(BaseRepoController):
150 150
151 151 def __before__(self):
152 152 super(ChangesetController, self).__before__()
153 153 c.affected_files_cut_off = 60
154 154
155 155 def _index(self, commit_id_range, method):
156 156 c.ignorews_url = _ignorews_url
157 157 c.context_url = _context_url
158 158 c.fulldiff = fulldiff = request.GET.get('fulldiff')
159 159
160 160 # fetch global flags of ignore ws or context lines
161 161 context_lcl = get_line_ctx('', request.GET)
162 162 ign_whitespace_lcl = get_ignore_ws('', request.GET)
163 163
164 164 # diff_limit will cut off the whole diff if the limit is applied
165 165 # otherwise it will just hide the big files from the front-end
166 166 diff_limit = self.cut_off_limit_diff
167 167 file_limit = self.cut_off_limit_file
168 168
169 169 # get ranges of commit ids if preset
170 170 commit_range = commit_id_range.split('...')[:2]
171 171
172 172 try:
173 173 pre_load = ['affected_files', 'author', 'branch', 'date',
174 174 'message', 'parents']
175 175
176 176 if len(commit_range) == 2:
177 177 commits = c.rhodecode_repo.get_commits(
178 178 start_id=commit_range[0], end_id=commit_range[1],
179 179 pre_load=pre_load)
180 180 commits = list(commits)
181 181 else:
182 182 commits = [c.rhodecode_repo.get_commit(
183 183 commit_id=commit_id_range, pre_load=pre_load)]
184 184
185 185 c.commit_ranges = commits
186 186 if not c.commit_ranges:
187 187 raise RepositoryError(
188 188 'The commit range returned an empty result')
189 189 except CommitDoesNotExistError:
190 190 msg = _('No such commit exists for this repository')
191 191 h.flash(msg, category='error')
192 192 raise HTTPNotFound()
193 193 except Exception:
194 194 log.exception("General failure")
195 195 raise HTTPNotFound()
196 196
197 197 c.changes = OrderedDict()
198 198 c.lines_added = 0
199 199 c.lines_deleted = 0
200 200
201 201 # auto collapse if we have more than limit
202 202 collapse_limit = diffs.DiffProcessor._collapse_commits_over
203 203 c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
204 204
205 205 c.commit_statuses = ChangesetStatus.STATUSES
206 206 c.inline_comments = []
207 207 c.files = []
208 208
209 209 c.statuses = []
210 210 c.comments = []
211 211 if len(c.commit_ranges) == 1:
212 212 commit = c.commit_ranges[0]
213 213 c.comments = ChangesetCommentsModel().get_comments(
214 214 c.rhodecode_db_repo.repo_id,
215 215 revision=commit.raw_id)
216 216 c.statuses.append(ChangesetStatusModel().get_status(
217 217 c.rhodecode_db_repo.repo_id, commit.raw_id))
218 218 # comments from PR
219 219 statuses = ChangesetStatusModel().get_statuses(
220 220 c.rhodecode_db_repo.repo_id, commit.raw_id,
221 221 with_revisions=True)
222 222 prs = set(st.pull_request for st in statuses
223 223 if st.pull_request is not None)
224 224 # from associated statuses, check the pull requests, and
225 225 # show comments from them
226 226 for pr in prs:
227 227 c.comments.extend(pr.comments)
228 228
229 229 # Iterate over ranges (default commit view is always one commit)
230 230 for commit in c.commit_ranges:
231 231 c.changes[commit.raw_id] = []
232 232
233 233 commit2 = commit
234 234 commit1 = commit.parents[0] if commit.parents else EmptyCommit()
235 235
236 236 _diff = c.rhodecode_repo.get_diff(
237 237 commit1, commit2,
238 238 ignore_whitespace=ign_whitespace_lcl, context=context_lcl)
239 239 diff_processor = diffs.DiffProcessor(
240 240 _diff, format='newdiff', diff_limit=diff_limit,
241 241 file_limit=file_limit, show_full_diff=fulldiff)
242 242
243 243 commit_changes = OrderedDict()
244 244 if method == 'show':
245 245 _parsed = diff_processor.prepare()
246 246 c.limited_diff = isinstance(_parsed, diffs.LimitedDiffContainer)
247 247
248 248 _parsed = diff_processor.prepare()
249 249
250 250 def _node_getter(commit):
251 251 def get_node(fname):
252 252 try:
253 253 return commit.get_node(fname)
254 254 except NodeDoesNotExistError:
255 255 return None
256 256 return get_node
257 257
258 258 inline_comments = ChangesetCommentsModel().get_inline_comments(
259 259 c.rhodecode_db_repo.repo_id, revision=commit.raw_id)
260 260 c.inline_cnt = ChangesetCommentsModel().get_inline_comments_count(
261 261 inline_comments)
262 262
263 263 diffset = codeblocks.DiffSet(
264 264 repo_name=c.repo_name,
265 265 source_node_getter=_node_getter(commit1),
266 266 target_node_getter=_node_getter(commit2),
267 267 comments=inline_comments
268 268 ).render_patchset(_parsed, commit1.raw_id, commit2.raw_id)
269 269 c.changes[commit.raw_id] = diffset
270 270 else:
271 271 # downloads/raw we only need RAW diff nothing else
272 272 diff = diff_processor.as_raw()
273 273 c.changes[commit.raw_id] = [None, None, None, None, diff, None, None]
274 274
275 275 # sort comments by how they were generated
276 276 c.comments = sorted(c.comments, key=lambda x: x.comment_id)
277 277
278 278
279 279 if len(c.commit_ranges) == 1:
280 280 c.commit = c.commit_ranges[0]
281 281 c.parent_tmpl = ''.join(
282 282 '# Parent %s\n' % x.raw_id for x in c.commit.parents)
283 283 if method == 'download':
284 284 response.content_type = 'text/plain'
285 285 response.content_disposition = (
286 286 'attachment; filename=%s.diff' % commit_id_range[:12])
287 287 return diff
288 288 elif method == 'patch':
289 289 response.content_type = 'text/plain'
290 290 c.diff = safe_unicode(diff)
291 291 return render('changeset/patch_changeset.mako')
292 292 elif method == 'raw':
293 293 response.content_type = 'text/plain'
294 294 return diff
295 295 elif method == 'show':
296 296 if len(c.commit_ranges) == 1:
297 297 return render('changeset/changeset.mako')
298 298 else:
299 299 c.ancestor = None
300 300 c.target_repo = c.rhodecode_db_repo
301 301 return render('changeset/changeset_range.mako')
302 302
303 303 @LoginRequired()
304 304 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
305 305 'repository.admin')
306 306 def index(self, revision, method='show'):
307 307 return self._index(revision, method=method)
308 308
309 309 @LoginRequired()
310 310 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
311 311 'repository.admin')
312 312 def changeset_raw(self, revision):
313 313 return self._index(revision, method='raw')
314 314
315 315 @LoginRequired()
316 316 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
317 317 'repository.admin')
318 318 def changeset_patch(self, revision):
319 319 return self._index(revision, method='patch')
320 320
321 321 @LoginRequired()
322 322 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
323 323 'repository.admin')
324 324 def changeset_download(self, revision):
325 325 return self._index(revision, method='download')
326 326
327 327 @LoginRequired()
328 328 @NotAnonymous()
329 329 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
330 330 'repository.admin')
331 331 @auth.CSRFRequired()
332 332 @jsonify
333 333 def comment(self, repo_name, revision):
334 334 commit_id = revision
335 335 status = request.POST.get('changeset_status', None)
336 336 text = request.POST.get('text')
337 337 if status:
338 338 text = text or (_('Status change %(transition_icon)s %(status)s')
339 339 % {'transition_icon': '>',
340 340 'status': ChangesetStatus.get_status_lbl(status)})
341 341
342 342 multi_commit_ids = filter(
343 343 lambda s: s not in ['', None],
344 344 request.POST.get('commit_ids', '').split(','),)
345 345
346 346 commit_ids = multi_commit_ids or [commit_id]
347 347 comment = None
348 348 for current_id in filter(None, commit_ids):
349 349 c.co = comment = ChangesetCommentsModel().create(
350 350 text=text,
351 351 repo=c.rhodecode_db_repo.repo_id,
352 352 user=c.rhodecode_user.user_id,
353 353 revision=current_id,
354 354 f_path=request.POST.get('f_path'),
355 355 line_no=request.POST.get('line'),
356 356 status_change=(ChangesetStatus.get_status_lbl(status)
357 357 if status else None),
358 358 status_change_type=status
359 359 )
360 c.inline_comment = True if comment.line_no else False
361
360 362 # get status if set !
361 363 if status:
362 364 # if latest status was from pull request and it's closed
363 365 # disallow changing status !
364 366 # dont_allow_on_closed_pull_request = True !
365 367
366 368 try:
367 369 ChangesetStatusModel().set_status(
368 370 c.rhodecode_db_repo.repo_id,
369 371 status,
370 372 c.rhodecode_user.user_id,
371 373 comment,
372 374 revision=current_id,
373 375 dont_allow_on_closed_pull_request=True
374 376 )
375 377 except StatusChangeOnClosedPullRequestError:
376 378 msg = _('Changing the status of a commit associated with '
377 379 'a closed pull request is not allowed')
378 380 log.exception(msg)
379 381 h.flash(msg, category='warning')
380 382 return redirect(h.url(
381 383 'changeset_home', repo_name=repo_name,
382 384 revision=current_id))
383 385
384 386 # finalize, commit and redirect
385 387 Session().commit()
386 388
387 389 data = {
388 390 'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),
389 391 }
390 392 if comment:
391 393 data.update(comment.get_dict())
392 394 data.update({'rendered_text':
393 395 render('changeset/changeset_comment_block.mako')})
394 396
395 397 return data
396 398
397 399 @LoginRequired()
398 400 @NotAnonymous()
399 401 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
400 402 'repository.admin')
401 403 @auth.CSRFRequired()
402 404 def preview_comment(self):
403 405 # Technically a CSRF token is not needed as no state changes with this
404 406 # call. However, as this is a POST is better to have it, so automated
405 407 # tools don't flag it as potential CSRF.
406 408 # Post is required because the payload could be bigger than the maximum
407 409 # allowed by GET.
408 410 if not request.environ.get('HTTP_X_PARTIAL_XHR'):
409 411 raise HTTPBadRequest()
410 412 text = request.POST.get('text')
411 413 renderer = request.POST.get('renderer') or 'rst'
412 414 if text:
413 415 return h.render(text, renderer=renderer, mentions=True)
414 416 return ''
415 417
416 418 @LoginRequired()
417 419 @NotAnonymous()
418 420 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
419 421 'repository.admin')
420 422 @auth.CSRFRequired()
421 423 @jsonify
422 424 def delete_comment(self, repo_name, comment_id):
423 425 comment = ChangesetComment.get(comment_id)
424 426 owner = (comment.author.user_id == c.rhodecode_user.user_id)
425 427 is_repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)
426 428 if h.HasPermissionAny('hg.admin')() or is_repo_admin or owner:
427 429 ChangesetCommentsModel().delete(comment=comment)
428 430 Session().commit()
429 431 return True
430 432 else:
431 433 raise HTTPForbidden()
432 434
433 435 @LoginRequired()
434 436 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
435 437 'repository.admin')
436 438 @jsonify
437 439 def changeset_info(self, repo_name, revision):
438 440 if request.is_xhr:
439 441 try:
440 442 return c.rhodecode_repo.get_commit(commit_id=revision)
441 443 except CommitDoesNotExistError as e:
442 444 return EmptyCommit(message=str(e))
443 445 else:
444 446 raise HTTPBadRequest()
445 447
446 448 @LoginRequired()
447 449 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
448 450 'repository.admin')
449 451 @jsonify
450 452 def changeset_children(self, repo_name, revision):
451 453 if request.is_xhr:
452 454 commit = c.rhodecode_repo.get_commit(commit_id=revision)
453 455 result = {"results": commit.children}
454 456 return result
455 457 else:
456 458 raise HTTPBadRequest()
457 459
458 460 @LoginRequired()
459 461 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
460 462 'repository.admin')
461 463 @jsonify
462 464 def changeset_parents(self, repo_name, revision):
463 465 if request.is_xhr:
464 466 commit = c.rhodecode_repo.get_commit(commit_id=revision)
465 467 result = {"results": commit.parents}
466 468 return result
467 469 else:
468 470 raise HTTPBadRequest()
@@ -1,1020 +1,1024 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2012-2017 RhodeCode GmbH
4 4 #
5 5 # This program is free software: you can redistribute it and/or modify
6 6 # it under the terms of the GNU Affero General Public License, version 3
7 7 # (only), as published by the Free Software Foundation.
8 8 #
9 9 # This program is distributed in the hope that it will be useful,
10 10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 # GNU General Public License for more details.
13 13 #
14 14 # You should have received a copy of the GNU Affero General Public License
15 15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
16 16 #
17 17 # This program is dual-licensed. If you wish to learn more about the
18 18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20 20
21 21 """
22 22 pull requests controller for rhodecode for initializing pull requests
23 23 """
24 24 import types
25 25
26 26 import peppercorn
27 27 import formencode
28 28 import logging
29 29 import collections
30 30
31 31 from webob.exc import HTTPNotFound, HTTPForbidden, HTTPBadRequest
32 32 from pylons import request, tmpl_context as c, url
33 33 from pylons.controllers.util import redirect
34 34 from pylons.i18n.translation import _
35 35 from pyramid.threadlocal import get_current_registry
36 36 from sqlalchemy.sql import func
37 37 from sqlalchemy.sql.expression import or_
38 38
39 39 from rhodecode import events
40 40 from rhodecode.lib import auth, diffs, helpers as h, codeblocks
41 41 from rhodecode.lib.ext_json import json
42 42 from rhodecode.lib.base import (
43 43 BaseRepoController, render, vcs_operation_context)
44 44 from rhodecode.lib.auth import (
45 45 LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
46 46 HasAcceptedRepoType, XHRRequired)
47 47 from rhodecode.lib.channelstream import channelstream_request
48 48 from rhodecode.lib.utils import jsonify
49 49 from rhodecode.lib.utils2 import (
50 50 safe_int, safe_str, str2bool, safe_unicode)
51 51 from rhodecode.lib.vcs.backends.base import (
52 52 EmptyCommit, UpdateFailureReason, EmptyRepository)
53 53 from rhodecode.lib.vcs.exceptions import (
54 54 EmptyRepositoryError, CommitDoesNotExistError, RepositoryRequirementError,
55 55 NodeDoesNotExistError)
56 56
57 57 from rhodecode.model.changeset_status import ChangesetStatusModel
58 58 from rhodecode.model.comment import ChangesetCommentsModel
59 59 from rhodecode.model.db import (PullRequest, ChangesetStatus, ChangesetComment,
60 60 Repository, PullRequestVersion)
61 61 from rhodecode.model.forms import PullRequestForm
62 62 from rhodecode.model.meta import Session
63 63 from rhodecode.model.pull_request import PullRequestModel
64 64
65 65 log = logging.getLogger(__name__)
66 66
67 67
68 68 class PullrequestsController(BaseRepoController):
69 69 def __before__(self):
70 70 super(PullrequestsController, self).__before__()
71 71
72 72 def _load_compare_data(self, pull_request, inline_comments):
73 73 """
74 74 Load context data needed for generating compare diff
75 75
76 76 :param pull_request: object related to the request
77 77 :param enable_comments: flag to determine if comments are included
78 78 """
79 79 source_repo = pull_request.source_repo
80 80 source_ref_id = pull_request.source_ref_parts.commit_id
81 81
82 82 target_repo = pull_request.target_repo
83 83 target_ref_id = pull_request.target_ref_parts.commit_id
84 84
85 85 # despite opening commits for bookmarks/branches/tags, we always
86 86 # convert this to rev to prevent changes after bookmark or branch change
87 87 c.source_ref_type = 'rev'
88 88 c.source_ref = source_ref_id
89 89
90 90 c.target_ref_type = 'rev'
91 91 c.target_ref = target_ref_id
92 92
93 93 c.source_repo = source_repo
94 94 c.target_repo = target_repo
95 95
96 96 c.fulldiff = bool(request.GET.get('fulldiff'))
97 97
98 98 # diff_limit is the old behavior, will cut off the whole diff
99 99 # if the limit is applied otherwise will just hide the
100 100 # big files from the front-end
101 101 diff_limit = self.cut_off_limit_diff
102 102 file_limit = self.cut_off_limit_file
103 103
104 104 pre_load = ["author", "branch", "date", "message"]
105 105
106 106 c.commit_ranges = []
107 107 source_commit = EmptyCommit()
108 108 target_commit = EmptyCommit()
109 109 c.missing_requirements = False
110 110 try:
111 111 c.commit_ranges = [
112 112 source_repo.get_commit(commit_id=rev, pre_load=pre_load)
113 113 for rev in pull_request.revisions]
114 114
115 115 c.statuses = source_repo.statuses(
116 116 [x.raw_id for x in c.commit_ranges])
117 117
118 118 target_commit = source_repo.get_commit(
119 119 commit_id=safe_str(target_ref_id))
120 120 source_commit = source_repo.get_commit(
121 121 commit_id=safe_str(source_ref_id))
122 122 except RepositoryRequirementError:
123 123 c.missing_requirements = True
124 124
125 125 # auto collapse if we have more than limit
126 126 collapse_limit = diffs.DiffProcessor._collapse_commits_over
127 127 c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
128 128
129 129 c.changes = {}
130 130 c.missing_commits = False
131 131 if (c.missing_requirements or
132 132 isinstance(source_commit, EmptyCommit) or
133 133 source_commit == target_commit):
134 134 _parsed = []
135 135 c.missing_commits = True
136 136 else:
137 137 vcs_diff = PullRequestModel().get_diff(pull_request)
138 138 diff_processor = diffs.DiffProcessor(
139 139 vcs_diff, format='newdiff', diff_limit=diff_limit,
140 140 file_limit=file_limit, show_full_diff=c.fulldiff)
141 141
142 142 _parsed = diff_processor.prepare()
143 143 c.limited_diff = isinstance(_parsed, diffs.LimitedDiffContainer)
144 144
145 145 included_files = {}
146 146 for f in _parsed:
147 147 included_files[f['filename']] = f['stats']
148 148
149 149 c.deleted_files = [fname for fname in inline_comments if
150 150 fname not in included_files]
151 151
152 152 c.deleted_files_comments = collections.defaultdict(dict)
153 153 for fname, per_line_comments in inline_comments.items():
154 154 if fname in c.deleted_files:
155 155 c.deleted_files_comments[fname]['stats'] = 0
156 156 c.deleted_files_comments[fname]['comments'] = list()
157 157 for lno, comments in per_line_comments.items():
158 158 c.deleted_files_comments[fname]['comments'].extend(comments)
159 159
160 160 def _node_getter(commit):
161 161 def get_node(fname):
162 162 try:
163 163 return commit.get_node(fname)
164 164 except NodeDoesNotExistError:
165 165 return None
166 166 return get_node
167 167
168 168 c.diffset = codeblocks.DiffSet(
169 169 repo_name=c.repo_name,
170 170 source_repo_name=c.source_repo.repo_name,
171 171 source_node_getter=_node_getter(target_commit),
172 172 target_node_getter=_node_getter(source_commit),
173 173 comments=inline_comments
174 174 ).render_patchset(_parsed, target_commit.raw_id, source_commit.raw_id)
175 175
176 176 def _extract_ordering(self, request):
177 177 column_index = safe_int(request.GET.get('order[0][column]'))
178 178 order_dir = request.GET.get('order[0][dir]', 'desc')
179 179 order_by = request.GET.get(
180 180 'columns[%s][data][sort]' % column_index, 'name_raw')
181 181 return order_by, order_dir
182 182
183 183 @LoginRequired()
184 184 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
185 185 'repository.admin')
186 186 @HasAcceptedRepoType('git', 'hg')
187 187 def show_all(self, repo_name):
188 188 # filter types
189 189 c.active = 'open'
190 190 c.source = str2bool(request.GET.get('source'))
191 191 c.closed = str2bool(request.GET.get('closed'))
192 192 c.my = str2bool(request.GET.get('my'))
193 193 c.awaiting_review = str2bool(request.GET.get('awaiting_review'))
194 194 c.awaiting_my_review = str2bool(request.GET.get('awaiting_my_review'))
195 195 c.repo_name = repo_name
196 196
197 197 opened_by = None
198 198 if c.my:
199 199 c.active = 'my'
200 200 opened_by = [c.rhodecode_user.user_id]
201 201
202 202 statuses = [PullRequest.STATUS_NEW, PullRequest.STATUS_OPEN]
203 203 if c.closed:
204 204 c.active = 'closed'
205 205 statuses = [PullRequest.STATUS_CLOSED]
206 206
207 207 if c.awaiting_review and not c.source:
208 208 c.active = 'awaiting'
209 209 if c.source and not c.awaiting_review:
210 210 c.active = 'source'
211 211 if c.awaiting_my_review:
212 212 c.active = 'awaiting_my'
213 213
214 214 data = self._get_pull_requests_list(
215 215 repo_name=repo_name, opened_by=opened_by, statuses=statuses)
216 216 if not request.is_xhr:
217 217 c.data = json.dumps(data['data'])
218 218 c.records_total = data['recordsTotal']
219 219 return render('/pullrequests/pullrequests.mako')
220 220 else:
221 221 return json.dumps(data)
222 222
223 223 def _get_pull_requests_list(self, repo_name, opened_by, statuses):
224 224 # pagination
225 225 start = safe_int(request.GET.get('start'), 0)
226 226 length = safe_int(request.GET.get('length'), c.visual.dashboard_items)
227 227 order_by, order_dir = self._extract_ordering(request)
228 228
229 229 if c.awaiting_review:
230 230 pull_requests = PullRequestModel().get_awaiting_review(
231 231 repo_name, source=c.source, opened_by=opened_by,
232 232 statuses=statuses, offset=start, length=length,
233 233 order_by=order_by, order_dir=order_dir)
234 234 pull_requests_total_count = PullRequestModel(
235 235 ).count_awaiting_review(
236 236 repo_name, source=c.source, statuses=statuses,
237 237 opened_by=opened_by)
238 238 elif c.awaiting_my_review:
239 239 pull_requests = PullRequestModel().get_awaiting_my_review(
240 240 repo_name, source=c.source, opened_by=opened_by,
241 241 user_id=c.rhodecode_user.user_id, statuses=statuses,
242 242 offset=start, length=length, order_by=order_by,
243 243 order_dir=order_dir)
244 244 pull_requests_total_count = PullRequestModel(
245 245 ).count_awaiting_my_review(
246 246 repo_name, source=c.source, user_id=c.rhodecode_user.user_id,
247 247 statuses=statuses, opened_by=opened_by)
248 248 else:
249 249 pull_requests = PullRequestModel().get_all(
250 250 repo_name, source=c.source, opened_by=opened_by,
251 251 statuses=statuses, offset=start, length=length,
252 252 order_by=order_by, order_dir=order_dir)
253 253 pull_requests_total_count = PullRequestModel().count_all(
254 254 repo_name, source=c.source, statuses=statuses,
255 255 opened_by=opened_by)
256 256
257 257 from rhodecode.lib.utils import PartialRenderer
258 258 _render = PartialRenderer('data_table/_dt_elements.mako')
259 259 data = []
260 260 for pr in pull_requests:
261 261 comments = ChangesetCommentsModel().get_all_comments(
262 262 c.rhodecode_db_repo.repo_id, pull_request=pr)
263 263
264 264 data.append({
265 265 'name': _render('pullrequest_name',
266 266 pr.pull_request_id, pr.target_repo.repo_name),
267 267 'name_raw': pr.pull_request_id,
268 268 'status': _render('pullrequest_status',
269 269 pr.calculated_review_status()),
270 270 'title': _render(
271 271 'pullrequest_title', pr.title, pr.description),
272 272 'description': h.escape(pr.description),
273 273 'updated_on': _render('pullrequest_updated_on',
274 274 h.datetime_to_time(pr.updated_on)),
275 275 'updated_on_raw': h.datetime_to_time(pr.updated_on),
276 276 'created_on': _render('pullrequest_updated_on',
277 277 h.datetime_to_time(pr.created_on)),
278 278 'created_on_raw': h.datetime_to_time(pr.created_on),
279 279 'author': _render('pullrequest_author',
280 280 pr.author.full_contact, ),
281 281 'author_raw': pr.author.full_name,
282 282 'comments': _render('pullrequest_comments', len(comments)),
283 283 'comments_raw': len(comments),
284 284 'closed': pr.is_closed(),
285 285 })
286 286 # json used to render the grid
287 287 data = ({
288 288 'data': data,
289 289 'recordsTotal': pull_requests_total_count,
290 290 'recordsFiltered': pull_requests_total_count,
291 291 })
292 292 return data
293 293
294 294 @LoginRequired()
295 295 @NotAnonymous()
296 296 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
297 297 'repository.admin')
298 298 @HasAcceptedRepoType('git', 'hg')
299 299 def index(self):
300 300 source_repo = c.rhodecode_db_repo
301 301
302 302 try:
303 303 source_repo.scm_instance().get_commit()
304 304 except EmptyRepositoryError:
305 305 h.flash(h.literal(_('There are no commits yet')),
306 306 category='warning')
307 307 redirect(url('summary_home', repo_name=source_repo.repo_name))
308 308
309 309 commit_id = request.GET.get('commit')
310 310 branch_ref = request.GET.get('branch')
311 311 bookmark_ref = request.GET.get('bookmark')
312 312
313 313 try:
314 314 source_repo_data = PullRequestModel().generate_repo_data(
315 315 source_repo, commit_id=commit_id,
316 316 branch=branch_ref, bookmark=bookmark_ref)
317 317 except CommitDoesNotExistError as e:
318 318 log.exception(e)
319 319 h.flash(_('Commit does not exist'), 'error')
320 320 redirect(url('pullrequest_home', repo_name=source_repo.repo_name))
321 321
322 322 default_target_repo = source_repo
323 323
324 324 if source_repo.parent:
325 325 parent_vcs_obj = source_repo.parent.scm_instance()
326 326 if parent_vcs_obj and not parent_vcs_obj.is_empty():
327 327 # change default if we have a parent repo
328 328 default_target_repo = source_repo.parent
329 329
330 330 target_repo_data = PullRequestModel().generate_repo_data(
331 331 default_target_repo)
332 332
333 333 selected_source_ref = source_repo_data['refs']['selected_ref']
334 334
335 335 title_source_ref = selected_source_ref.split(':', 2)[1]
336 336 c.default_title = PullRequestModel().generate_pullrequest_title(
337 337 source=source_repo.repo_name,
338 338 source_ref=title_source_ref,
339 339 target=default_target_repo.repo_name
340 340 )
341 341
342 342 c.default_repo_data = {
343 343 'source_repo_name': source_repo.repo_name,
344 344 'source_refs_json': json.dumps(source_repo_data),
345 345 'target_repo_name': default_target_repo.repo_name,
346 346 'target_refs_json': json.dumps(target_repo_data),
347 347 }
348 348 c.default_source_ref = selected_source_ref
349 349
350 350 return render('/pullrequests/pullrequest.mako')
351 351
352 352 @LoginRequired()
353 353 @NotAnonymous()
354 354 @XHRRequired()
355 355 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
356 356 'repository.admin')
357 357 @jsonify
358 358 def get_repo_refs(self, repo_name, target_repo_name):
359 359 repo = Repository.get_by_repo_name(target_repo_name)
360 360 if not repo:
361 361 raise HTTPNotFound
362 362 return PullRequestModel().generate_repo_data(repo)
363 363
364 364 @LoginRequired()
365 365 @NotAnonymous()
366 366 @XHRRequired()
367 367 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
368 368 'repository.admin')
369 369 @jsonify
370 370 def get_repo_destinations(self, repo_name):
371 371 repo = Repository.get_by_repo_name(repo_name)
372 372 if not repo:
373 373 raise HTTPNotFound
374 374 filter_query = request.GET.get('query')
375 375
376 376 query = Repository.query() \
377 377 .order_by(func.length(Repository.repo_name)) \
378 378 .filter(or_(
379 379 Repository.repo_name == repo.repo_name,
380 380 Repository.fork_id == repo.repo_id))
381 381
382 382 if filter_query:
383 383 ilike_expression = u'%{}%'.format(safe_unicode(filter_query))
384 384 query = query.filter(
385 385 Repository.repo_name.ilike(ilike_expression))
386 386
387 387 add_parent = False
388 388 if repo.parent:
389 389 if filter_query in repo.parent.repo_name:
390 390 parent_vcs_obj = repo.parent.scm_instance()
391 391 if parent_vcs_obj and not parent_vcs_obj.is_empty():
392 392 add_parent = True
393 393
394 394 limit = 20 - 1 if add_parent else 20
395 395 all_repos = query.limit(limit).all()
396 396 if add_parent:
397 397 all_repos += [repo.parent]
398 398
399 399 repos = []
400 400 for obj in self.scm_model.get_repos(all_repos):
401 401 repos.append({
402 402 'id': obj['name'],
403 403 'text': obj['name'],
404 404 'type': 'repo',
405 405 'obj': obj['dbrepo']
406 406 })
407 407
408 408 data = {
409 409 'more': False,
410 410 'results': [{
411 411 'text': _('Repositories'),
412 412 'children': repos
413 413 }] if repos else []
414 414 }
415 415 return data
416 416
417 417 @LoginRequired()
418 418 @NotAnonymous()
419 419 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
420 420 'repository.admin')
421 421 @HasAcceptedRepoType('git', 'hg')
422 422 @auth.CSRFRequired()
423 423 def create(self, repo_name):
424 424 repo = Repository.get_by_repo_name(repo_name)
425 425 if not repo:
426 426 raise HTTPNotFound
427 427
428 428 controls = peppercorn.parse(request.POST.items())
429 429
430 430 try:
431 431 _form = PullRequestForm(repo.repo_id)().to_python(controls)
432 432 except formencode.Invalid as errors:
433 433 if errors.error_dict.get('revisions'):
434 434 msg = 'Revisions: %s' % errors.error_dict['revisions']
435 435 elif errors.error_dict.get('pullrequest_title'):
436 436 msg = _('Pull request requires a title with min. 3 chars')
437 437 else:
438 438 msg = _('Error creating pull request: {}').format(errors)
439 439 log.exception(msg)
440 440 h.flash(msg, 'error')
441 441
442 442 # would rather just go back to form ...
443 443 return redirect(url('pullrequest_home', repo_name=repo_name))
444 444
445 445 source_repo = _form['source_repo']
446 446 source_ref = _form['source_ref']
447 447 target_repo = _form['target_repo']
448 448 target_ref = _form['target_ref']
449 449 commit_ids = _form['revisions'][::-1]
450 450 reviewers = [
451 451 (r['user_id'], r['reasons']) for r in _form['review_members']]
452 452
453 453 # find the ancestor for this pr
454 454 source_db_repo = Repository.get_by_repo_name(_form['source_repo'])
455 455 target_db_repo = Repository.get_by_repo_name(_form['target_repo'])
456 456
457 457 source_scm = source_db_repo.scm_instance()
458 458 target_scm = target_db_repo.scm_instance()
459 459
460 460 source_commit = source_scm.get_commit(source_ref.split(':')[-1])
461 461 target_commit = target_scm.get_commit(target_ref.split(':')[-1])
462 462
463 463 ancestor = source_scm.get_common_ancestor(
464 464 source_commit.raw_id, target_commit.raw_id, target_scm)
465 465
466 466 target_ref_type, target_ref_name, __ = _form['target_ref'].split(':')
467 467 target_ref = ':'.join((target_ref_type, target_ref_name, ancestor))
468 468
469 469 pullrequest_title = _form['pullrequest_title']
470 470 title_source_ref = source_ref.split(':', 2)[1]
471 471 if not pullrequest_title:
472 472 pullrequest_title = PullRequestModel().generate_pullrequest_title(
473 473 source=source_repo,
474 474 source_ref=title_source_ref,
475 475 target=target_repo
476 476 )
477 477
478 478 description = _form['pullrequest_desc']
479 479 try:
480 480 pull_request = PullRequestModel().create(
481 481 c.rhodecode_user.user_id, source_repo, source_ref, target_repo,
482 482 target_ref, commit_ids, reviewers, pullrequest_title,
483 483 description
484 484 )
485 485 Session().commit()
486 486 h.flash(_('Successfully opened new pull request'),
487 487 category='success')
488 488 except Exception as e:
489 489 msg = _('Error occurred during sending pull request')
490 490 log.exception(msg)
491 491 h.flash(msg, category='error')
492 492 return redirect(url('pullrequest_home', repo_name=repo_name))
493 493
494 494 return redirect(url('pullrequest_show', repo_name=target_repo,
495 495 pull_request_id=pull_request.pull_request_id))
496 496
497 497 @LoginRequired()
498 498 @NotAnonymous()
499 499 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
500 500 'repository.admin')
501 501 @auth.CSRFRequired()
502 502 @jsonify
503 503 def update(self, repo_name, pull_request_id):
504 504 pull_request_id = safe_int(pull_request_id)
505 505 pull_request = PullRequest.get_or_404(pull_request_id)
506 506 # only owner or admin can update it
507 507 allowed_to_update = PullRequestModel().check_user_update(
508 508 pull_request, c.rhodecode_user)
509 509 if allowed_to_update:
510 510 controls = peppercorn.parse(request.POST.items())
511 511
512 512 if 'review_members' in controls:
513 513 self._update_reviewers(
514 514 pull_request_id, controls['review_members'])
515 515 elif str2bool(request.POST.get('update_commits', 'false')):
516 516 self._update_commits(pull_request)
517 517 elif str2bool(request.POST.get('close_pull_request', 'false')):
518 518 self._reject_close(pull_request)
519 519 elif str2bool(request.POST.get('edit_pull_request', 'false')):
520 520 self._edit_pull_request(pull_request)
521 521 else:
522 522 raise HTTPBadRequest()
523 523 return True
524 524 raise HTTPForbidden()
525 525
526 526 def _edit_pull_request(self, pull_request):
527 527 try:
528 528 PullRequestModel().edit(
529 529 pull_request, request.POST.get('title'),
530 530 request.POST.get('description'))
531 531 except ValueError:
532 532 msg = _(u'Cannot update closed pull requests.')
533 533 h.flash(msg, category='error')
534 534 return
535 535 else:
536 536 Session().commit()
537 537
538 538 msg = _(u'Pull request title & description updated.')
539 539 h.flash(msg, category='success')
540 540 return
541 541
542 542 def _update_commits(self, pull_request):
543 543 resp = PullRequestModel().update_commits(pull_request)
544 544
545 545 if resp.executed:
546 546 msg = _(
547 547 u'Pull request updated to "{source_commit_id}" with '
548 548 u'{count_added} added, {count_removed} removed commits.')
549 549 msg = msg.format(
550 550 source_commit_id=pull_request.source_ref_parts.commit_id,
551 551 count_added=len(resp.changes.added),
552 552 count_removed=len(resp.changes.removed))
553 553 h.flash(msg, category='success')
554 554
555 555 registry = get_current_registry()
556 556 rhodecode_plugins = getattr(registry, 'rhodecode_plugins', {})
557 557 channelstream_config = rhodecode_plugins.get('channelstream', {})
558 558 if channelstream_config.get('enabled'):
559 559 message = msg + (
560 560 ' - <a onclick="window.location.reload()">'
561 561 '<strong>{}</strong></a>'.format(_('Reload page')))
562 562 channel = '/repo${}$/pr/{}'.format(
563 563 pull_request.target_repo.repo_name,
564 564 pull_request.pull_request_id
565 565 )
566 566 payload = {
567 567 'type': 'message',
568 568 'user': 'system',
569 569 'exclude_users': [request.user.username],
570 570 'channel': channel,
571 571 'message': {
572 572 'message': message,
573 573 'level': 'success',
574 574 'topic': '/notifications'
575 575 }
576 576 }
577 577 channelstream_request(
578 578 channelstream_config, [payload], '/message',
579 579 raise_exc=False)
580 580 else:
581 581 msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason]
582 582 warning_reasons = [
583 583 UpdateFailureReason.NO_CHANGE,
584 584 UpdateFailureReason.WRONG_REF_TPYE,
585 585 ]
586 586 category = 'warning' if resp.reason in warning_reasons else 'error'
587 587 h.flash(msg, category=category)
588 588
589 589 @auth.CSRFRequired()
590 590 @LoginRequired()
591 591 @NotAnonymous()
592 592 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
593 593 'repository.admin')
594 594 def merge(self, repo_name, pull_request_id):
595 595 """
596 596 POST /{repo_name}/pull-request/{pull_request_id}
597 597
598 598 Merge will perform a server-side merge of the specified
599 599 pull request, if the pull request is approved and mergeable.
600 600 After succesfull merging, the pull request is automatically
601 601 closed, with a relevant comment.
602 602 """
603 603 pull_request_id = safe_int(pull_request_id)
604 604 pull_request = PullRequest.get_or_404(pull_request_id)
605 605 user = c.rhodecode_user
606 606
607 607 if self._meets_merge_pre_conditions(pull_request, user):
608 608 log.debug("Pre-conditions checked, trying to merge.")
609 609 extras = vcs_operation_context(
610 610 request.environ, repo_name=pull_request.target_repo.repo_name,
611 611 username=user.username, action='push',
612 612 scm=pull_request.target_repo.repo_type)
613 613 self._merge_pull_request(pull_request, user, extras)
614 614
615 615 return redirect(url(
616 616 'pullrequest_show',
617 617 repo_name=pull_request.target_repo.repo_name,
618 618 pull_request_id=pull_request.pull_request_id))
619 619
620 620 def _meets_merge_pre_conditions(self, pull_request, user):
621 621 if not PullRequestModel().check_user_merge(pull_request, user):
622 622 raise HTTPForbidden()
623 623
624 624 merge_status, msg = PullRequestModel().merge_status(pull_request)
625 625 if not merge_status:
626 626 log.debug("Cannot merge, not mergeable.")
627 627 h.flash(msg, category='error')
628 628 return False
629 629
630 630 if (pull_request.calculated_review_status()
631 631 is not ChangesetStatus.STATUS_APPROVED):
632 632 log.debug("Cannot merge, approval is pending.")
633 633 msg = _('Pull request reviewer approval is pending.')
634 634 h.flash(msg, category='error')
635 635 return False
636 636 return True
637 637
638 638 def _merge_pull_request(self, pull_request, user, extras):
639 639 merge_resp = PullRequestModel().merge(
640 640 pull_request, user, extras=extras)
641 641
642 642 if merge_resp.executed:
643 643 log.debug("The merge was successful, closing the pull request.")
644 644 PullRequestModel().close_pull_request(
645 645 pull_request.pull_request_id, user)
646 646 Session().commit()
647 647 msg = _('Pull request was successfully merged and closed.')
648 648 h.flash(msg, category='success')
649 649 else:
650 650 log.debug(
651 651 "The merge was not successful. Merge response: %s",
652 652 merge_resp)
653 653 msg = PullRequestModel().merge_status_message(
654 654 merge_resp.failure_reason)
655 655 h.flash(msg, category='error')
656 656
657 657 def _update_reviewers(self, pull_request_id, review_members):
658 658 reviewers = [
659 659 (int(r['user_id']), r['reasons']) for r in review_members]
660 660 PullRequestModel().update_reviewers(pull_request_id, reviewers)
661 661 Session().commit()
662 662
663 663 def _reject_close(self, pull_request):
664 664 if pull_request.is_closed():
665 665 raise HTTPForbidden()
666 666
667 667 PullRequestModel().close_pull_request_with_comment(
668 668 pull_request, c.rhodecode_user, c.rhodecode_db_repo)
669 669 Session().commit()
670 670
671 671 @LoginRequired()
672 672 @NotAnonymous()
673 673 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
674 674 'repository.admin')
675 675 @auth.CSRFRequired()
676 676 @jsonify
677 677 def delete(self, repo_name, pull_request_id):
678 678 pull_request_id = safe_int(pull_request_id)
679 679 pull_request = PullRequest.get_or_404(pull_request_id)
680 680 # only owner can delete it !
681 681 if pull_request.author.user_id == c.rhodecode_user.user_id:
682 682 PullRequestModel().delete(pull_request)
683 683 Session().commit()
684 684 h.flash(_('Successfully deleted pull request'),
685 685 category='success')
686 686 return redirect(url('my_account_pullrequests'))
687 687 raise HTTPForbidden()
688 688
689 689 def _get_pr_version(self, pull_request_id, version=None):
690 690 pull_request_id = safe_int(pull_request_id)
691 691 at_version = None
692 692
693 693 if version and version == 'latest':
694 694 pull_request_ver = PullRequest.get(pull_request_id)
695 695 pull_request_obj = pull_request_ver
696 696 _org_pull_request_obj = pull_request_obj
697 697 at_version = 'latest'
698 698 elif version:
699 699 pull_request_ver = PullRequestVersion.get_or_404(version)
700 700 pull_request_obj = pull_request_ver
701 701 _org_pull_request_obj = pull_request_ver.pull_request
702 702 at_version = pull_request_ver.pull_request_version_id
703 703 else:
704 704 _org_pull_request_obj = pull_request_obj = PullRequest.get_or_404(pull_request_id)
705 705
706 706 pull_request_display_obj = PullRequest.get_pr_display_object(
707 707 pull_request_obj, _org_pull_request_obj)
708 708 return _org_pull_request_obj, pull_request_obj, \
709 709 pull_request_display_obj, at_version
710 710
711 711 def _get_pr_version_changes(self, version, pull_request_latest):
712 712 """
713 713 Generate changes commits, and diff data based on the current pr version
714 714 """
715 715
716 716 #TODO(marcink): save those changes as JSON metadata for chaching later.
717 717
718 718 # fake the version to add the "initial" state object
719 719 pull_request_initial = PullRequest.get_pr_display_object(
720 720 pull_request_latest, pull_request_latest,
721 721 internal_methods=['get_commit', 'versions'])
722 722 pull_request_initial.revisions = []
723 723 pull_request_initial.source_repo.get_commit = types.MethodType(
724 724 lambda *a, **k: EmptyCommit(), pull_request_initial)
725 725 pull_request_initial.source_repo.scm_instance = types.MethodType(
726 726 lambda *a, **k: EmptyRepository(), pull_request_initial)
727 727
728 728 _changes_versions = [pull_request_latest] + \
729 729 list(reversed(c.versions)) + \
730 730 [pull_request_initial]
731 731
732 732 if version == 'latest':
733 733 index = 0
734 734 else:
735 735 for pos, prver in enumerate(_changes_versions):
736 736 ver = getattr(prver, 'pull_request_version_id', -1)
737 737 if ver == safe_int(version):
738 738 index = pos
739 739 break
740 740 else:
741 741 index = 0
742 742
743 743 cur_obj = _changes_versions[index]
744 744 prev_obj = _changes_versions[index + 1]
745 745
746 746 old_commit_ids = set(prev_obj.revisions)
747 747 new_commit_ids = set(cur_obj.revisions)
748 748
749 749 changes = PullRequestModel()._calculate_commit_id_changes(
750 750 old_commit_ids, new_commit_ids)
751 751
752 752 old_diff_data, new_diff_data = PullRequestModel()._generate_update_diffs(
753 753 cur_obj, prev_obj)
754 754 file_changes = PullRequestModel()._calculate_file_changes(
755 755 old_diff_data, new_diff_data)
756 756 return changes, file_changes
757 757
758 758 @LoginRequired()
759 759 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
760 760 'repository.admin')
761 761 def show(self, repo_name, pull_request_id):
762 762 pull_request_id = safe_int(pull_request_id)
763 763 version = request.GET.get('version')
764 764
765 765 (pull_request_latest,
766 766 pull_request_at_ver,
767 767 pull_request_display_obj,
768 768 at_version) = self._get_pr_version(pull_request_id, version=version)
769 769
770 770 c.template_context['pull_request_data']['pull_request_id'] = \
771 771 pull_request_id
772 772
773 773 # pull_requests repo_name we opened it against
774 774 # ie. target_repo must match
775 775 if repo_name != pull_request_at_ver.target_repo.repo_name:
776 776 raise HTTPNotFound
777 777
778 778 c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(
779 779 pull_request_at_ver)
780 780
781 781 pr_closed = pull_request_latest.is_closed()
782 782 if at_version and not at_version == 'latest':
783 783 c.allowed_to_change_status = False
784 784 c.allowed_to_update = False
785 785 c.allowed_to_merge = False
786 786 c.allowed_to_delete = False
787 787 c.allowed_to_comment = False
788 788 else:
789 789 c.allowed_to_change_status = PullRequestModel(). \
790 790 check_user_change_status(pull_request_at_ver, c.rhodecode_user)
791 791 c.allowed_to_update = PullRequestModel().check_user_update(
792 792 pull_request_latest, c.rhodecode_user) and not pr_closed
793 793 c.allowed_to_merge = PullRequestModel().check_user_merge(
794 794 pull_request_latest, c.rhodecode_user) and not pr_closed
795 795 c.allowed_to_delete = PullRequestModel().check_user_delete(
796 796 pull_request_latest, c.rhodecode_user) and not pr_closed
797 797 c.allowed_to_comment = not pr_closed
798 798
799 799 cc_model = ChangesetCommentsModel()
800 800
801 801 c.pull_request_reviewers = pull_request_at_ver.reviewers_statuses()
802 802 c.pull_request_review_status = pull_request_at_ver.calculated_review_status()
803 803 c.pr_merge_status, c.pr_merge_msg = PullRequestModel().merge_status(
804 804 pull_request_at_ver)
805 805 c.approval_msg = None
806 806 if c.pull_request_review_status != ChangesetStatus.STATUS_APPROVED:
807 807 c.approval_msg = _('Reviewer approval is pending.')
808 808 c.pr_merge_status = False
809 809
810 810 # inline comments
811 811 inline_comments = cc_model.get_inline_comments(
812 812 c.rhodecode_db_repo.repo_id, pull_request=pull_request_id)
813 813
814 814 _inline_cnt, c.inline_versions = cc_model.get_inline_comments_count(
815 815 inline_comments, version=at_version, include_aggregates=True)
816 816
817 c.versions = pull_request_display_obj.versions()
817 818 c.at_version_num = at_version if at_version and at_version != 'latest' else None
819 c.at_version_pos = ChangesetComment.get_index_from_version(
820 c.at_version_num, c.versions)
821
818 822 is_outdated = lambda co: \
819 823 not c.at_version_num \
820 824 or co.pull_request_version_id <= c.at_version_num
821 825
822 826 # inline_comments_until_version
823 827 if c.at_version_num:
824 828 # if we use version, then do not show later comments
825 829 # than current version
826 830 paths = collections.defaultdict(lambda: collections.defaultdict(list))
827 831 for fname, per_line_comments in inline_comments.iteritems():
828 832 for lno, comments in per_line_comments.iteritems():
829 833 for co in comments:
830 834 if co.pull_request_version_id and is_outdated(co):
831 835 paths[co.f_path][co.line_no].append(co)
832 836 inline_comments = paths
833 837
834 838 # outdated comments
835 839 c.outdated_cnt = 0
836 840 if ChangesetCommentsModel.use_outdated_comments(pull_request_latest):
837 841 outdated_comments = cc_model.get_outdated_comments(
838 842 c.rhodecode_db_repo.repo_id,
839 843 pull_request=pull_request_at_ver)
840 844
841 845 # Count outdated comments and check for deleted files
842 846 is_outdated = lambda co: \
843 847 not c.at_version_num \
844 848 or co.pull_request_version_id < c.at_version_num
845 849 for file_name, lines in outdated_comments.iteritems():
846 850 for comments in lines.values():
847 851 comments = [comm for comm in comments if is_outdated(comm)]
848 852 c.outdated_cnt += len(comments)
849 853
850 854 # load compare data into template context
851 855 self._load_compare_data(pull_request_at_ver, inline_comments)
852 856
853 857 # this is a hack to properly display links, when creating PR, the
854 858 # compare view and others uses different notation, and
855 859 # compare_commits.mako renders links based on the target_repo.
856 860 # We need to swap that here to generate it properly on the html side
857 861 c.target_repo = c.source_repo
858 862
859 863 # general comments
860 864 c.comments = cc_model.get_comments(
861 865 c.rhodecode_db_repo.repo_id, pull_request=pull_request_id)
862 866
863 867 if c.allowed_to_update:
864 868 force_close = ('forced_closed', _('Close Pull Request'))
865 869 statuses = ChangesetStatus.STATUSES + [force_close]
866 870 else:
867 871 statuses = ChangesetStatus.STATUSES
868 872 c.commit_statuses = statuses
869 873
870 874 c.ancestor = None # TODO: add ancestor here
871 875 c.pull_request = pull_request_display_obj
872 876 c.pull_request_latest = pull_request_latest
873 877 c.at_version = at_version
874 878
875 c.versions = pull_request_display_obj.versions()
876 879 c.changes = None
877 880 c.file_changes = None
878 881
879 882 c.show_version_changes = 1 # control flag, not used yet
880 883
881 884 if at_version and c.show_version_changes:
882 885 c.changes, c.file_changes = self._get_pr_version_changes(
883 886 version, pull_request_latest)
884 887
885 888 return render('/pullrequests/pullrequest_show.mako')
886 889
887 890 @LoginRequired()
888 891 @NotAnonymous()
889 892 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
890 893 'repository.admin')
891 894 @auth.CSRFRequired()
892 895 @jsonify
893 896 def comment(self, repo_name, pull_request_id):
894 897 pull_request_id = safe_int(pull_request_id)
895 898 pull_request = PullRequest.get_or_404(pull_request_id)
896 899 if pull_request.is_closed():
897 900 raise HTTPForbidden()
898 901
899 902 # TODO: johbo: Re-think this bit, "approved_closed" does not exist
900 903 # as a changeset status, still we want to send it in one value.
901 904 status = request.POST.get('changeset_status', None)
902 905 text = request.POST.get('text')
903 906 if status and '_closed' in status:
904 907 close_pr = True
905 908 status = status.replace('_closed', '')
906 909 else:
907 910 close_pr = False
908 911
909 912 forced = (status == 'forced')
910 913 if forced:
911 914 status = 'rejected'
912 915
913 916 allowed_to_change_status = PullRequestModel().check_user_change_status(
914 917 pull_request, c.rhodecode_user)
915 918
916 919 if status and allowed_to_change_status:
917 920 message = (_('Status change %(transition_icon)s %(status)s')
918 921 % {'transition_icon': '>',
919 922 'status': ChangesetStatus.get_status_lbl(status)})
920 923 if close_pr:
921 924 message = _('Closing with') + ' ' + message
922 925 text = text or message
923 926 comm = ChangesetCommentsModel().create(
924 927 text=text,
925 928 repo=c.rhodecode_db_repo.repo_id,
926 929 user=c.rhodecode_user.user_id,
927 930 pull_request=pull_request_id,
928 931 f_path=request.POST.get('f_path'),
929 932 line_no=request.POST.get('line'),
930 933 status_change=(ChangesetStatus.get_status_lbl(status)
931 934 if status and allowed_to_change_status else None),
932 935 status_change_type=(status
933 936 if status and allowed_to_change_status else None),
934 937 closing_pr=close_pr
935 938 )
936 939
937 940 if allowed_to_change_status:
938 941 old_calculated_status = pull_request.calculated_review_status()
939 942 # get status if set !
940 943 if status:
941 944 ChangesetStatusModel().set_status(
942 945 c.rhodecode_db_repo.repo_id,
943 946 status,
944 947 c.rhodecode_user.user_id,
945 948 comm,
946 949 pull_request=pull_request_id
947 950 )
948 951
949 952 Session().flush()
950 953 events.trigger(events.PullRequestCommentEvent(pull_request, comm))
951 954 # we now calculate the status of pull request, and based on that
952 955 # calculation we set the commits status
953 956 calculated_status = pull_request.calculated_review_status()
954 957 if old_calculated_status != calculated_status:
955 958 PullRequestModel()._trigger_pull_request_hook(
956 959 pull_request, c.rhodecode_user, 'review_status_change')
957 960
958 961 calculated_status_lbl = ChangesetStatus.get_status_lbl(
959 962 calculated_status)
960 963
961 964 if close_pr:
962 965 status_completed = (
963 966 calculated_status in [ChangesetStatus.STATUS_APPROVED,
964 967 ChangesetStatus.STATUS_REJECTED])
965 968 if forced or status_completed:
966 969 PullRequestModel().close_pull_request(
967 970 pull_request_id, c.rhodecode_user)
968 971 else:
969 972 h.flash(_('Closing pull request on other statuses than '
970 973 'rejected or approved is forbidden. '
971 974 'Calculated status from all reviewers '
972 975 'is currently: %s') % calculated_status_lbl,
973 976 category='warning')
974 977
975 978 Session().commit()
976 979
977 980 if not request.is_xhr:
978 981 return redirect(h.url('pullrequest_show', repo_name=repo_name,
979 982 pull_request_id=pull_request_id))
980 983
981 984 data = {
982 985 'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),
983 986 }
984 987 if comm:
985 988 c.co = comm
989 c.inline_comment = True if comm.line_no else False
986 990 data.update(comm.get_dict())
987 991 data.update({'rendered_text':
988 992 render('changeset/changeset_comment_block.mako')})
989 993
990 994 return data
991 995
992 996 @LoginRequired()
993 997 @NotAnonymous()
994 998 @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
995 999 'repository.admin')
996 1000 @auth.CSRFRequired()
997 1001 @jsonify
998 1002 def delete_comment(self, repo_name, comment_id):
999 1003 return self._delete_comment(comment_id)
1000 1004
1001 1005 def _delete_comment(self, comment_id):
1002 1006 comment_id = safe_int(comment_id)
1003 1007 co = ChangesetComment.get_or_404(comment_id)
1004 1008 if co.pull_request.is_closed():
1005 1009 # don't allow deleting comments on closed pull request
1006 1010 raise HTTPForbidden()
1007 1011
1008 1012 is_owner = co.author.user_id == c.rhodecode_user.user_id
1009 1013 is_repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)
1010 1014 if h.HasPermissionAny('hg.admin')() or is_repo_admin or is_owner:
1011 1015 old_calculated_status = co.pull_request.calculated_review_status()
1012 1016 ChangesetCommentsModel().delete(comment=co)
1013 1017 Session().commit()
1014 1018 calculated_status = co.pull_request.calculated_review_status()
1015 1019 if old_calculated_status != calculated_status:
1016 1020 PullRequestModel()._trigger_pull_request_hook(
1017 1021 co.pull_request, c.rhodecode_user, 'review_status_change')
1018 1022 return True
1019 1023 else:
1020 1024 raise HTTPForbidden()
@@ -1,3794 +1,3806 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2010-2017 RhodeCode GmbH
4 4 #
5 5 # This program is free software: you can redistribute it and/or modify
6 6 # it under the terms of the GNU Affero General Public License, version 3
7 7 # (only), as published by the Free Software Foundation.
8 8 #
9 9 # This program is distributed in the hope that it will be useful,
10 10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 # GNU General Public License for more details.
13 13 #
14 14 # You should have received a copy of the GNU Affero General Public License
15 15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
16 16 #
17 17 # This program is dual-licensed. If you wish to learn more about the
18 18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20 20
21 21 """
22 22 Database Models for RhodeCode Enterprise
23 23 """
24 24
25 25 import re
26 26 import os
27 27 import time
28 28 import hashlib
29 29 import logging
30 30 import datetime
31 31 import warnings
32 32 import ipaddress
33 33 import functools
34 34 import traceback
35 35 import collections
36 36
37 37
38 38 from sqlalchemy import *
39 39 from sqlalchemy.ext.declarative import declared_attr
40 40 from sqlalchemy.ext.hybrid import hybrid_property
41 41 from sqlalchemy.orm import (
42 42 relationship, joinedload, class_mapper, validates, aliased)
43 43 from sqlalchemy.sql.expression import true
44 44 from beaker.cache import cache_region
45 45 from webob.exc import HTTPNotFound
46 46 from zope.cachedescriptors.property import Lazy as LazyProperty
47 47
48 48 from pylons import url
49 49 from pylons.i18n.translation import lazy_ugettext as _
50 50
51 51 from rhodecode.lib.vcs import get_vcs_instance
52 52 from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
53 53 from rhodecode.lib.utils2 import (
54 54 str2bool, safe_str, get_commit_safe, safe_unicode, md5_safe,
55 55 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
56 56 glob2re, StrictAttributeDict)
57 57 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType
58 58 from rhodecode.lib.ext_json import json
59 59 from rhodecode.lib.caching_query import FromCache
60 60 from rhodecode.lib.encrypt import AESCipher
61 61
62 62 from rhodecode.model.meta import Base, Session
63 63
64 64 URL_SEP = '/'
65 65 log = logging.getLogger(__name__)
66 66
67 67 # =============================================================================
68 68 # BASE CLASSES
69 69 # =============================================================================
70 70
71 71 # this is propagated from .ini file rhodecode.encrypted_values.secret or
72 72 # beaker.session.secret if first is not set.
73 73 # and initialized at environment.py
74 74 ENCRYPTION_KEY = None
75 75
76 76 # used to sort permissions by types, '#' used here is not allowed to be in
77 77 # usernames, and it's very early in sorted string.printable table.
78 78 PERMISSION_TYPE_SORT = {
79 79 'admin': '####',
80 80 'write': '###',
81 81 'read': '##',
82 82 'none': '#',
83 83 }
84 84
85 85
86 86 def display_sort(obj):
87 87 """
88 88 Sort function used to sort permissions in .permissions() function of
89 89 Repository, RepoGroup, UserGroup. Also it put the default user in front
90 90 of all other resources
91 91 """
92 92
93 93 if obj.username == User.DEFAULT_USER:
94 94 return '#####'
95 95 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
96 96 return prefix + obj.username
97 97
98 98
99 99 def _hash_key(k):
100 100 return md5_safe(k)
101 101
102 102
103 103 class EncryptedTextValue(TypeDecorator):
104 104 """
105 105 Special column for encrypted long text data, use like::
106 106
107 107 value = Column("encrypted_value", EncryptedValue(), nullable=False)
108 108
109 109 This column is intelligent so if value is in unencrypted form it return
110 110 unencrypted form, but on save it always encrypts
111 111 """
112 112 impl = Text
113 113
114 114 def process_bind_param(self, value, dialect):
115 115 if not value:
116 116 return value
117 117 if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):
118 118 # protect against double encrypting if someone manually starts
119 119 # doing
120 120 raise ValueError('value needs to be in unencrypted format, ie. '
121 121 'not starting with enc$aes')
122 122 return 'enc$aes_hmac$%s' % AESCipher(
123 123 ENCRYPTION_KEY, hmac=True).encrypt(value)
124 124
125 125 def process_result_value(self, value, dialect):
126 126 import rhodecode
127 127
128 128 if not value:
129 129 return value
130 130
131 131 parts = value.split('$', 3)
132 132 if not len(parts) == 3:
133 133 # probably not encrypted values
134 134 return value
135 135 else:
136 136 if parts[0] != 'enc':
137 137 # parts ok but without our header ?
138 138 return value
139 139 enc_strict_mode = str2bool(rhodecode.CONFIG.get(
140 140 'rhodecode.encrypted_values.strict') or True)
141 141 # at that stage we know it's our encryption
142 142 if parts[1] == 'aes':
143 143 decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])
144 144 elif parts[1] == 'aes_hmac':
145 145 decrypted_data = AESCipher(
146 146 ENCRYPTION_KEY, hmac=True,
147 147 strict_verification=enc_strict_mode).decrypt(parts[2])
148 148 else:
149 149 raise ValueError(
150 150 'Encryption type part is wrong, must be `aes` '
151 151 'or `aes_hmac`, got `%s` instead' % (parts[1]))
152 152 return decrypted_data
153 153
154 154
155 155 class BaseModel(object):
156 156 """
157 157 Base Model for all classes
158 158 """
159 159
160 160 @classmethod
161 161 def _get_keys(cls):
162 162 """return column names for this model """
163 163 return class_mapper(cls).c.keys()
164 164
165 165 def get_dict(self):
166 166 """
167 167 return dict with keys and values corresponding
168 168 to this model data """
169 169
170 170 d = {}
171 171 for k in self._get_keys():
172 172 d[k] = getattr(self, k)
173 173
174 174 # also use __json__() if present to get additional fields
175 175 _json_attr = getattr(self, '__json__', None)
176 176 if _json_attr:
177 177 # update with attributes from __json__
178 178 if callable(_json_attr):
179 179 _json_attr = _json_attr()
180 180 for k, val in _json_attr.iteritems():
181 181 d[k] = val
182 182 return d
183 183
184 184 def get_appstruct(self):
185 185 """return list with keys and values tuples corresponding
186 186 to this model data """
187 187
188 188 l = []
189 189 for k in self._get_keys():
190 190 l.append((k, getattr(self, k),))
191 191 return l
192 192
193 193 def populate_obj(self, populate_dict):
194 194 """populate model with data from given populate_dict"""
195 195
196 196 for k in self._get_keys():
197 197 if k in populate_dict:
198 198 setattr(self, k, populate_dict[k])
199 199
200 200 @classmethod
201 201 def query(cls):
202 202 return Session().query(cls)
203 203
204 204 @classmethod
205 205 def get(cls, id_):
206 206 if id_:
207 207 return cls.query().get(id_)
208 208
209 209 @classmethod
210 210 def get_or_404(cls, id_):
211 211 try:
212 212 id_ = int(id_)
213 213 except (TypeError, ValueError):
214 214 raise HTTPNotFound
215 215
216 216 res = cls.query().get(id_)
217 217 if not res:
218 218 raise HTTPNotFound
219 219 return res
220 220
221 221 @classmethod
222 222 def getAll(cls):
223 223 # deprecated and left for backward compatibility
224 224 return cls.get_all()
225 225
226 226 @classmethod
227 227 def get_all(cls):
228 228 return cls.query().all()
229 229
230 230 @classmethod
231 231 def delete(cls, id_):
232 232 obj = cls.query().get(id_)
233 233 Session().delete(obj)
234 234
235 235 @classmethod
236 236 def identity_cache(cls, session, attr_name, value):
237 237 exist_in_session = []
238 238 for (item_cls, pkey), instance in session.identity_map.items():
239 239 if cls == item_cls and getattr(instance, attr_name) == value:
240 240 exist_in_session.append(instance)
241 241 if exist_in_session:
242 242 if len(exist_in_session) == 1:
243 243 return exist_in_session[0]
244 244 log.exception(
245 245 'multiple objects with attr %s and '
246 246 'value %s found with same name: %r',
247 247 attr_name, value, exist_in_session)
248 248
249 249 def __repr__(self):
250 250 if hasattr(self, '__unicode__'):
251 251 # python repr needs to return str
252 252 try:
253 253 return safe_str(self.__unicode__())
254 254 except UnicodeDecodeError:
255 255 pass
256 256 return '<DB:%s>' % (self.__class__.__name__)
257 257
258 258
259 259 class RhodeCodeSetting(Base, BaseModel):
260 260 __tablename__ = 'rhodecode_settings'
261 261 __table_args__ = (
262 262 UniqueConstraint('app_settings_name'),
263 263 {'extend_existing': True, 'mysql_engine': 'InnoDB',
264 264 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
265 265 )
266 266
267 267 SETTINGS_TYPES = {
268 268 'str': safe_str,
269 269 'int': safe_int,
270 270 'unicode': safe_unicode,
271 271 'bool': str2bool,
272 272 'list': functools.partial(aslist, sep=',')
273 273 }
274 274 DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
275 275 GLOBAL_CONF_KEY = 'app_settings'
276 276
277 277 app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
278 278 app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
279 279 _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
280 280 _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
281 281
282 282 def __init__(self, key='', val='', type='unicode'):
283 283 self.app_settings_name = key
284 284 self.app_settings_type = type
285 285 self.app_settings_value = val
286 286
287 287 @validates('_app_settings_value')
288 288 def validate_settings_value(self, key, val):
289 289 assert type(val) == unicode
290 290 return val
291 291
292 292 @hybrid_property
293 293 def app_settings_value(self):
294 294 v = self._app_settings_value
295 295 _type = self.app_settings_type
296 296 if _type:
297 297 _type = self.app_settings_type.split('.')[0]
298 298 # decode the encrypted value
299 299 if 'encrypted' in self.app_settings_type:
300 300 cipher = EncryptedTextValue()
301 301 v = safe_unicode(cipher.process_result_value(v, None))
302 302
303 303 converter = self.SETTINGS_TYPES.get(_type) or \
304 304 self.SETTINGS_TYPES['unicode']
305 305 return converter(v)
306 306
307 307 @app_settings_value.setter
308 308 def app_settings_value(self, val):
309 309 """
310 310 Setter that will always make sure we use unicode in app_settings_value
311 311
312 312 :param val:
313 313 """
314 314 val = safe_unicode(val)
315 315 # encode the encrypted value
316 316 if 'encrypted' in self.app_settings_type:
317 317 cipher = EncryptedTextValue()
318 318 val = safe_unicode(cipher.process_bind_param(val, None))
319 319 self._app_settings_value = val
320 320
321 321 @hybrid_property
322 322 def app_settings_type(self):
323 323 return self._app_settings_type
324 324
325 325 @app_settings_type.setter
326 326 def app_settings_type(self, val):
327 327 if val.split('.')[0] not in self.SETTINGS_TYPES:
328 328 raise Exception('type must be one of %s got %s'
329 329 % (self.SETTINGS_TYPES.keys(), val))
330 330 self._app_settings_type = val
331 331
332 332 def __unicode__(self):
333 333 return u"<%s('%s:%s[%s]')>" % (
334 334 self.__class__.__name__,
335 335 self.app_settings_name, self.app_settings_value,
336 336 self.app_settings_type
337 337 )
338 338
339 339
340 340 class RhodeCodeUi(Base, BaseModel):
341 341 __tablename__ = 'rhodecode_ui'
342 342 __table_args__ = (
343 343 UniqueConstraint('ui_key'),
344 344 {'extend_existing': True, 'mysql_engine': 'InnoDB',
345 345 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
346 346 )
347 347
348 348 HOOK_REPO_SIZE = 'changegroup.repo_size'
349 349 # HG
350 350 HOOK_PRE_PULL = 'preoutgoing.pre_pull'
351 351 HOOK_PULL = 'outgoing.pull_logger'
352 352 HOOK_PRE_PUSH = 'prechangegroup.pre_push'
353 353 HOOK_PUSH = 'changegroup.push_logger'
354 354
355 355 # TODO: johbo: Unify way how hooks are configured for git and hg,
356 356 # git part is currently hardcoded.
357 357
358 358 # SVN PATTERNS
359 359 SVN_BRANCH_ID = 'vcs_svn_branch'
360 360 SVN_TAG_ID = 'vcs_svn_tag'
361 361
362 362 ui_id = Column(
363 363 "ui_id", Integer(), nullable=False, unique=True, default=None,
364 364 primary_key=True)
365 365 ui_section = Column(
366 366 "ui_section", String(255), nullable=True, unique=None, default=None)
367 367 ui_key = Column(
368 368 "ui_key", String(255), nullable=True, unique=None, default=None)
369 369 ui_value = Column(
370 370 "ui_value", String(255), nullable=True, unique=None, default=None)
371 371 ui_active = Column(
372 372 "ui_active", Boolean(), nullable=True, unique=None, default=True)
373 373
374 374 def __repr__(self):
375 375 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
376 376 self.ui_key, self.ui_value)
377 377
378 378
379 379 class RepoRhodeCodeSetting(Base, BaseModel):
380 380 __tablename__ = 'repo_rhodecode_settings'
381 381 __table_args__ = (
382 382 UniqueConstraint(
383 383 'app_settings_name', 'repository_id',
384 384 name='uq_repo_rhodecode_setting_name_repo_id'),
385 385 {'extend_existing': True, 'mysql_engine': 'InnoDB',
386 386 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
387 387 )
388 388
389 389 repository_id = Column(
390 390 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
391 391 nullable=False)
392 392 app_settings_id = Column(
393 393 "app_settings_id", Integer(), nullable=False, unique=True,
394 394 default=None, primary_key=True)
395 395 app_settings_name = Column(
396 396 "app_settings_name", String(255), nullable=True, unique=None,
397 397 default=None)
398 398 _app_settings_value = Column(
399 399 "app_settings_value", String(4096), nullable=True, unique=None,
400 400 default=None)
401 401 _app_settings_type = Column(
402 402 "app_settings_type", String(255), nullable=True, unique=None,
403 403 default=None)
404 404
405 405 repository = relationship('Repository')
406 406
407 407 def __init__(self, repository_id, key='', val='', type='unicode'):
408 408 self.repository_id = repository_id
409 409 self.app_settings_name = key
410 410 self.app_settings_type = type
411 411 self.app_settings_value = val
412 412
413 413 @validates('_app_settings_value')
414 414 def validate_settings_value(self, key, val):
415 415 assert type(val) == unicode
416 416 return val
417 417
418 418 @hybrid_property
419 419 def app_settings_value(self):
420 420 v = self._app_settings_value
421 421 type_ = self.app_settings_type
422 422 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
423 423 converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
424 424 return converter(v)
425 425
426 426 @app_settings_value.setter
427 427 def app_settings_value(self, val):
428 428 """
429 429 Setter that will always make sure we use unicode in app_settings_value
430 430
431 431 :param val:
432 432 """
433 433 self._app_settings_value = safe_unicode(val)
434 434
435 435 @hybrid_property
436 436 def app_settings_type(self):
437 437 return self._app_settings_type
438 438
439 439 @app_settings_type.setter
440 440 def app_settings_type(self, val):
441 441 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
442 442 if val not in SETTINGS_TYPES:
443 443 raise Exception('type must be one of %s got %s'
444 444 % (SETTINGS_TYPES.keys(), val))
445 445 self._app_settings_type = val
446 446
447 447 def __unicode__(self):
448 448 return u"<%s('%s:%s:%s[%s]')>" % (
449 449 self.__class__.__name__, self.repository.repo_name,
450 450 self.app_settings_name, self.app_settings_value,
451 451 self.app_settings_type
452 452 )
453 453
454 454
455 455 class RepoRhodeCodeUi(Base, BaseModel):
456 456 __tablename__ = 'repo_rhodecode_ui'
457 457 __table_args__ = (
458 458 UniqueConstraint(
459 459 'repository_id', 'ui_section', 'ui_key',
460 460 name='uq_repo_rhodecode_ui_repository_id_section_key'),
461 461 {'extend_existing': True, 'mysql_engine': 'InnoDB',
462 462 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
463 463 )
464 464
465 465 repository_id = Column(
466 466 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
467 467 nullable=False)
468 468 ui_id = Column(
469 469 "ui_id", Integer(), nullable=False, unique=True, default=None,
470 470 primary_key=True)
471 471 ui_section = Column(
472 472 "ui_section", String(255), nullable=True, unique=None, default=None)
473 473 ui_key = Column(
474 474 "ui_key", String(255), nullable=True, unique=None, default=None)
475 475 ui_value = Column(
476 476 "ui_value", String(255), nullable=True, unique=None, default=None)
477 477 ui_active = Column(
478 478 "ui_active", Boolean(), nullable=True, unique=None, default=True)
479 479
480 480 repository = relationship('Repository')
481 481
482 482 def __repr__(self):
483 483 return '<%s[%s:%s]%s=>%s]>' % (
484 484 self.__class__.__name__, self.repository.repo_name,
485 485 self.ui_section, self.ui_key, self.ui_value)
486 486
487 487
488 488 class User(Base, BaseModel):
489 489 __tablename__ = 'users'
490 490 __table_args__ = (
491 491 UniqueConstraint('username'), UniqueConstraint('email'),
492 492 Index('u_username_idx', 'username'),
493 493 Index('u_email_idx', 'email'),
494 494 {'extend_existing': True, 'mysql_engine': 'InnoDB',
495 495 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
496 496 )
497 497 DEFAULT_USER = 'default'
498 498 DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'
499 499 DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
500 500
501 501 user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
502 502 username = Column("username", String(255), nullable=True, unique=None, default=None)
503 503 password = Column("password", String(255), nullable=True, unique=None, default=None)
504 504 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
505 505 admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
506 506 name = Column("firstname", String(255), nullable=True, unique=None, default=None)
507 507 lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
508 508 _email = Column("email", String(255), nullable=True, unique=None, default=None)
509 509 last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
510 510 extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
511 511 extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
512 512 api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
513 513 inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
514 514 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
515 515 _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data
516 516
517 517 user_log = relationship('UserLog')
518 518 user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
519 519
520 520 repositories = relationship('Repository')
521 521 repository_groups = relationship('RepoGroup')
522 522 user_groups = relationship('UserGroup')
523 523
524 524 user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
525 525 followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
526 526
527 527 repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
528 528 repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
529 529 user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
530 530
531 531 group_member = relationship('UserGroupMember', cascade='all')
532 532
533 533 notifications = relationship('UserNotification', cascade='all')
534 534 # notifications assigned to this user
535 535 user_created_notifications = relationship('Notification', cascade='all')
536 536 # comments created by this user
537 537 user_comments = relationship('ChangesetComment', cascade='all')
538 538 # user profile extra info
539 539 user_emails = relationship('UserEmailMap', cascade='all')
540 540 user_ip_map = relationship('UserIpMap', cascade='all')
541 541 user_auth_tokens = relationship('UserApiKeys', cascade='all')
542 542 # gists
543 543 user_gists = relationship('Gist', cascade='all')
544 544 # user pull requests
545 545 user_pull_requests = relationship('PullRequest', cascade='all')
546 546 # external identities
547 547 extenal_identities = relationship(
548 548 'ExternalIdentity',
549 549 primaryjoin="User.user_id==ExternalIdentity.local_user_id",
550 550 cascade='all')
551 551
552 552 def __unicode__(self):
553 553 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
554 554 self.user_id, self.username)
555 555
556 556 @hybrid_property
557 557 def email(self):
558 558 return self._email
559 559
560 560 @email.setter
561 561 def email(self, val):
562 562 self._email = val.lower() if val else None
563 563
564 564 @property
565 565 def firstname(self):
566 566 # alias for future
567 567 return self.name
568 568
569 569 @property
570 570 def emails(self):
571 571 other = UserEmailMap.query().filter(UserEmailMap.user==self).all()
572 572 return [self.email] + [x.email for x in other]
573 573
574 574 @property
575 575 def auth_tokens(self):
576 576 return [self.api_key] + [x.api_key for x in self.extra_auth_tokens]
577 577
578 578 @property
579 579 def extra_auth_tokens(self):
580 580 return UserApiKeys.query().filter(UserApiKeys.user == self).all()
581 581
582 582 @property
583 583 def feed_token(self):
584 584 feed_tokens = UserApiKeys.query()\
585 585 .filter(UserApiKeys.user == self)\
586 586 .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)\
587 587 .all()
588 588 if feed_tokens:
589 589 return feed_tokens[0].api_key
590 590 else:
591 591 # use the main token so we don't end up with nothing...
592 592 return self.api_key
593 593
594 594 @classmethod
595 595 def extra_valid_auth_tokens(cls, user, role=None):
596 596 tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
597 597 .filter(or_(UserApiKeys.expires == -1,
598 598 UserApiKeys.expires >= time.time()))
599 599 if role:
600 600 tokens = tokens.filter(or_(UserApiKeys.role == role,
601 601 UserApiKeys.role == UserApiKeys.ROLE_ALL))
602 602 return tokens.all()
603 603
604 604 @property
605 605 def builtin_token_roles(self):
606 606 return map(UserApiKeys._get_role_name, [
607 607 UserApiKeys.ROLE_API, UserApiKeys.ROLE_FEED, UserApiKeys.ROLE_HTTP
608 608 ])
609 609
610 610 @property
611 611 def ip_addresses(self):
612 612 ret = UserIpMap.query().filter(UserIpMap.user == self).all()
613 613 return [x.ip_addr for x in ret]
614 614
615 615 @property
616 616 def username_and_name(self):
617 617 return '%s (%s %s)' % (self.username, self.firstname, self.lastname)
618 618
619 619 @property
620 620 def username_or_name_or_email(self):
621 621 full_name = self.full_name if self.full_name is not ' ' else None
622 622 return self.username or full_name or self.email
623 623
624 624 @property
625 625 def full_name(self):
626 626 return '%s %s' % (self.firstname, self.lastname)
627 627
628 628 @property
629 629 def full_name_or_username(self):
630 630 return ('%s %s' % (self.firstname, self.lastname)
631 631 if (self.firstname and self.lastname) else self.username)
632 632
633 633 @property
634 634 def full_contact(self):
635 635 return '%s %s <%s>' % (self.firstname, self.lastname, self.email)
636 636
637 637 @property
638 638 def short_contact(self):
639 639 return '%s %s' % (self.firstname, self.lastname)
640 640
641 641 @property
642 642 def is_admin(self):
643 643 return self.admin
644 644
645 645 @property
646 646 def AuthUser(self):
647 647 """
648 648 Returns instance of AuthUser for this user
649 649 """
650 650 from rhodecode.lib.auth import AuthUser
651 651 return AuthUser(user_id=self.user_id, api_key=self.api_key,
652 652 username=self.username)
653 653
654 654 @hybrid_property
655 655 def user_data(self):
656 656 if not self._user_data:
657 657 return {}
658 658
659 659 try:
660 660 return json.loads(self._user_data)
661 661 except TypeError:
662 662 return {}
663 663
664 664 @user_data.setter
665 665 def user_data(self, val):
666 666 if not isinstance(val, dict):
667 667 raise Exception('user_data must be dict, got %s' % type(val))
668 668 try:
669 669 self._user_data = json.dumps(val)
670 670 except Exception:
671 671 log.error(traceback.format_exc())
672 672
673 673 @classmethod
674 674 def get_by_username(cls, username, case_insensitive=False,
675 675 cache=False, identity_cache=False):
676 676 session = Session()
677 677
678 678 if case_insensitive:
679 679 q = cls.query().filter(
680 680 func.lower(cls.username) == func.lower(username))
681 681 else:
682 682 q = cls.query().filter(cls.username == username)
683 683
684 684 if cache:
685 685 if identity_cache:
686 686 val = cls.identity_cache(session, 'username', username)
687 687 if val:
688 688 return val
689 689 else:
690 690 q = q.options(
691 691 FromCache("sql_cache_short",
692 692 "get_user_by_name_%s" % _hash_key(username)))
693 693
694 694 return q.scalar()
695 695
696 696 @classmethod
697 697 def get_by_auth_token(cls, auth_token, cache=False, fallback=True):
698 698 q = cls.query().filter(cls.api_key == auth_token)
699 699
700 700 if cache:
701 701 q = q.options(FromCache("sql_cache_short",
702 702 "get_auth_token_%s" % auth_token))
703 703 res = q.scalar()
704 704
705 705 if fallback and not res:
706 706 #fallback to additional keys
707 707 _res = UserApiKeys.query()\
708 708 .filter(UserApiKeys.api_key == auth_token)\
709 709 .filter(or_(UserApiKeys.expires == -1,
710 710 UserApiKeys.expires >= time.time()))\
711 711 .first()
712 712 if _res:
713 713 res = _res.user
714 714 return res
715 715
716 716 @classmethod
717 717 def get_by_email(cls, email, case_insensitive=False, cache=False):
718 718
719 719 if case_insensitive:
720 720 q = cls.query().filter(func.lower(cls.email) == func.lower(email))
721 721
722 722 else:
723 723 q = cls.query().filter(cls.email == email)
724 724
725 725 if cache:
726 726 q = q.options(FromCache("sql_cache_short",
727 727 "get_email_key_%s" % _hash_key(email)))
728 728
729 729 ret = q.scalar()
730 730 if ret is None:
731 731 q = UserEmailMap.query()
732 732 # try fetching in alternate email map
733 733 if case_insensitive:
734 734 q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
735 735 else:
736 736 q = q.filter(UserEmailMap.email == email)
737 737 q = q.options(joinedload(UserEmailMap.user))
738 738 if cache:
739 739 q = q.options(FromCache("sql_cache_short",
740 740 "get_email_map_key_%s" % email))
741 741 ret = getattr(q.scalar(), 'user', None)
742 742
743 743 return ret
744 744
745 745 @classmethod
746 746 def get_from_cs_author(cls, author):
747 747 """
748 748 Tries to get User objects out of commit author string
749 749
750 750 :param author:
751 751 """
752 752 from rhodecode.lib.helpers import email, author_name
753 753 # Valid email in the attribute passed, see if they're in the system
754 754 _email = email(author)
755 755 if _email:
756 756 user = cls.get_by_email(_email, case_insensitive=True)
757 757 if user:
758 758 return user
759 759 # Maybe we can match by username?
760 760 _author = author_name(author)
761 761 user = cls.get_by_username(_author, case_insensitive=True)
762 762 if user:
763 763 return user
764 764
765 765 def update_userdata(self, **kwargs):
766 766 usr = self
767 767 old = usr.user_data
768 768 old.update(**kwargs)
769 769 usr.user_data = old
770 770 Session().add(usr)
771 771 log.debug('updated userdata with ', kwargs)
772 772
773 773 def update_lastlogin(self):
774 774 """Update user lastlogin"""
775 775 self.last_login = datetime.datetime.now()
776 776 Session().add(self)
777 777 log.debug('updated user %s lastlogin', self.username)
778 778
779 779 def update_lastactivity(self):
780 780 """Update user lastactivity"""
781 781 usr = self
782 782 old = usr.user_data
783 783 old.update({'last_activity': time.time()})
784 784 usr.user_data = old
785 785 Session().add(usr)
786 786 log.debug('updated user %s lastactivity', usr.username)
787 787
788 788 def update_password(self, new_password, change_api_key=False):
789 789 from rhodecode.lib.auth import get_crypt_password,generate_auth_token
790 790
791 791 self.password = get_crypt_password(new_password)
792 792 if change_api_key:
793 793 self.api_key = generate_auth_token(self.username)
794 794 Session().add(self)
795 795
796 796 @classmethod
797 797 def get_first_super_admin(cls):
798 798 user = User.query().filter(User.admin == true()).first()
799 799 if user is None:
800 800 raise Exception('FATAL: Missing administrative account!')
801 801 return user
802 802
803 803 @classmethod
804 804 def get_all_super_admins(cls):
805 805 """
806 806 Returns all admin accounts sorted by username
807 807 """
808 808 return User.query().filter(User.admin == true())\
809 809 .order_by(User.username.asc()).all()
810 810
811 811 @classmethod
812 812 def get_default_user(cls, cache=False):
813 813 user = User.get_by_username(User.DEFAULT_USER, cache=cache)
814 814 if user is None:
815 815 raise Exception('FATAL: Missing default account!')
816 816 return user
817 817
818 818 def _get_default_perms(self, user, suffix=''):
819 819 from rhodecode.model.permission import PermissionModel
820 820 return PermissionModel().get_default_perms(user.user_perms, suffix)
821 821
822 822 def get_default_perms(self, suffix=''):
823 823 return self._get_default_perms(self, suffix)
824 824
825 825 def get_api_data(self, include_secrets=False, details='full'):
826 826 """
827 827 Common function for generating user related data for API
828 828
829 829 :param include_secrets: By default secrets in the API data will be replaced
830 830 by a placeholder value to prevent exposing this data by accident. In case
831 831 this data shall be exposed, set this flag to ``True``.
832 832
833 833 :param details: details can be 'basic|full' basic gives only a subset of
834 834 the available user information that includes user_id, name and emails.
835 835 """
836 836 user = self
837 837 user_data = self.user_data
838 838 data = {
839 839 'user_id': user.user_id,
840 840 'username': user.username,
841 841 'firstname': user.name,
842 842 'lastname': user.lastname,
843 843 'email': user.email,
844 844 'emails': user.emails,
845 845 }
846 846 if details == 'basic':
847 847 return data
848 848
849 849 api_key_length = 40
850 850 api_key_replacement = '*' * api_key_length
851 851
852 852 extras = {
853 853 'api_key': api_key_replacement,
854 854 'api_keys': [api_key_replacement],
855 855 'active': user.active,
856 856 'admin': user.admin,
857 857 'extern_type': user.extern_type,
858 858 'extern_name': user.extern_name,
859 859 'last_login': user.last_login,
860 860 'ip_addresses': user.ip_addresses,
861 861 'language': user_data.get('language')
862 862 }
863 863 data.update(extras)
864 864
865 865 if include_secrets:
866 866 data['api_key'] = user.api_key
867 867 data['api_keys'] = user.auth_tokens
868 868 return data
869 869
870 870 def __json__(self):
871 871 data = {
872 872 'full_name': self.full_name,
873 873 'full_name_or_username': self.full_name_or_username,
874 874 'short_contact': self.short_contact,
875 875 'full_contact': self.full_contact,
876 876 }
877 877 data.update(self.get_api_data())
878 878 return data
879 879
880 880
881 881 class UserApiKeys(Base, BaseModel):
882 882 __tablename__ = 'user_api_keys'
883 883 __table_args__ = (
884 884 Index('uak_api_key_idx', 'api_key'),
885 885 Index('uak_api_key_expires_idx', 'api_key', 'expires'),
886 886 UniqueConstraint('api_key'),
887 887 {'extend_existing': True, 'mysql_engine': 'InnoDB',
888 888 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
889 889 )
890 890 __mapper_args__ = {}
891 891
892 892 # ApiKey role
893 893 ROLE_ALL = 'token_role_all'
894 894 ROLE_HTTP = 'token_role_http'
895 895 ROLE_VCS = 'token_role_vcs'
896 896 ROLE_API = 'token_role_api'
897 897 ROLE_FEED = 'token_role_feed'
898 898 ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]
899 899
900 900 user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
901 901 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
902 902 api_key = Column("api_key", String(255), nullable=False, unique=True)
903 903 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
904 904 expires = Column('expires', Float(53), nullable=False)
905 905 role = Column('role', String(255), nullable=True)
906 906 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
907 907
908 908 user = relationship('User', lazy='joined')
909 909
910 910 @classmethod
911 911 def _get_role_name(cls, role):
912 912 return {
913 913 cls.ROLE_ALL: _('all'),
914 914 cls.ROLE_HTTP: _('http/web interface'),
915 915 cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
916 916 cls.ROLE_API: _('api calls'),
917 917 cls.ROLE_FEED: _('feed access'),
918 918 }.get(role, role)
919 919
920 920 @property
921 921 def expired(self):
922 922 if self.expires == -1:
923 923 return False
924 924 return time.time() > self.expires
925 925
926 926 @property
927 927 def role_humanized(self):
928 928 return self._get_role_name(self.role)
929 929
930 930
931 931 class UserEmailMap(Base, BaseModel):
932 932 __tablename__ = 'user_email_map'
933 933 __table_args__ = (
934 934 Index('uem_email_idx', 'email'),
935 935 UniqueConstraint('email'),
936 936 {'extend_existing': True, 'mysql_engine': 'InnoDB',
937 937 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
938 938 )
939 939 __mapper_args__ = {}
940 940
941 941 email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
942 942 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
943 943 _email = Column("email", String(255), nullable=True, unique=False, default=None)
944 944 user = relationship('User', lazy='joined')
945 945
946 946 @validates('_email')
947 947 def validate_email(self, key, email):
948 948 # check if this email is not main one
949 949 main_email = Session().query(User).filter(User.email == email).scalar()
950 950 if main_email is not None:
951 951 raise AttributeError('email %s is present is user table' % email)
952 952 return email
953 953
954 954 @hybrid_property
955 955 def email(self):
956 956 return self._email
957 957
958 958 @email.setter
959 959 def email(self, val):
960 960 self._email = val.lower() if val else None
961 961
962 962
963 963 class UserIpMap(Base, BaseModel):
964 964 __tablename__ = 'user_ip_map'
965 965 __table_args__ = (
966 966 UniqueConstraint('user_id', 'ip_addr'),
967 967 {'extend_existing': True, 'mysql_engine': 'InnoDB',
968 968 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
969 969 )
970 970 __mapper_args__ = {}
971 971
972 972 ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
973 973 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
974 974 ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
975 975 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
976 976 description = Column("description", String(10000), nullable=True, unique=None, default=None)
977 977 user = relationship('User', lazy='joined')
978 978
979 979 @classmethod
980 980 def _get_ip_range(cls, ip_addr):
981 981 net = ipaddress.ip_network(ip_addr, strict=False)
982 982 return [str(net.network_address), str(net.broadcast_address)]
983 983
984 984 def __json__(self):
985 985 return {
986 986 'ip_addr': self.ip_addr,
987 987 'ip_range': self._get_ip_range(self.ip_addr),
988 988 }
989 989
990 990 def __unicode__(self):
991 991 return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
992 992 self.user_id, self.ip_addr)
993 993
994 994 class UserLog(Base, BaseModel):
995 995 __tablename__ = 'user_logs'
996 996 __table_args__ = (
997 997 {'extend_existing': True, 'mysql_engine': 'InnoDB',
998 998 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
999 999 )
1000 1000 user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1001 1001 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1002 1002 username = Column("username", String(255), nullable=True, unique=None, default=None)
1003 1003 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)
1004 1004 repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
1005 1005 user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
1006 1006 action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
1007 1007 action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
1008 1008
1009 1009 def __unicode__(self):
1010 1010 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1011 1011 self.repository_name,
1012 1012 self.action)
1013 1013
1014 1014 @property
1015 1015 def action_as_day(self):
1016 1016 return datetime.date(*self.action_date.timetuple()[:3])
1017 1017
1018 1018 user = relationship('User')
1019 1019 repository = relationship('Repository', cascade='')
1020 1020
1021 1021
1022 1022 class UserGroup(Base, BaseModel):
1023 1023 __tablename__ = 'users_groups'
1024 1024 __table_args__ = (
1025 1025 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1026 1026 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1027 1027 )
1028 1028
1029 1029 users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1030 1030 users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
1031 1031 user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
1032 1032 users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
1033 1033 inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
1034 1034 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
1035 1035 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1036 1036 _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data
1037 1037
1038 1038 members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
1039 1039 users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
1040 1040 users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1041 1041 users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
1042 1042 user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
1043 1043 user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
1044 1044
1045 1045 user = relationship('User')
1046 1046
1047 1047 @hybrid_property
1048 1048 def group_data(self):
1049 1049 if not self._group_data:
1050 1050 return {}
1051 1051
1052 1052 try:
1053 1053 return json.loads(self._group_data)
1054 1054 except TypeError:
1055 1055 return {}
1056 1056
1057 1057 @group_data.setter
1058 1058 def group_data(self, val):
1059 1059 try:
1060 1060 self._group_data = json.dumps(val)
1061 1061 except Exception:
1062 1062 log.error(traceback.format_exc())
1063 1063
1064 1064 def __unicode__(self):
1065 1065 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1066 1066 self.users_group_id,
1067 1067 self.users_group_name)
1068 1068
1069 1069 @classmethod
1070 1070 def get_by_group_name(cls, group_name, cache=False,
1071 1071 case_insensitive=False):
1072 1072 if case_insensitive:
1073 1073 q = cls.query().filter(func.lower(cls.users_group_name) ==
1074 1074 func.lower(group_name))
1075 1075
1076 1076 else:
1077 1077 q = cls.query().filter(cls.users_group_name == group_name)
1078 1078 if cache:
1079 1079 q = q.options(FromCache(
1080 1080 "sql_cache_short",
1081 1081 "get_group_%s" % _hash_key(group_name)))
1082 1082 return q.scalar()
1083 1083
1084 1084 @classmethod
1085 1085 def get(cls, user_group_id, cache=False):
1086 1086 user_group = cls.query()
1087 1087 if cache:
1088 1088 user_group = user_group.options(FromCache("sql_cache_short",
1089 1089 "get_users_group_%s" % user_group_id))
1090 1090 return user_group.get(user_group_id)
1091 1091
1092 1092 def permissions(self, with_admins=True, with_owner=True):
1093 1093 q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
1094 1094 q = q.options(joinedload(UserUserGroupToPerm.user_group),
1095 1095 joinedload(UserUserGroupToPerm.user),
1096 1096 joinedload(UserUserGroupToPerm.permission),)
1097 1097
1098 1098 # get owners and admins and permissions. We do a trick of re-writing
1099 1099 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1100 1100 # has a global reference and changing one object propagates to all
1101 1101 # others. This means if admin is also an owner admin_row that change
1102 1102 # would propagate to both objects
1103 1103 perm_rows = []
1104 1104 for _usr in q.all():
1105 1105 usr = AttributeDict(_usr.user.get_dict())
1106 1106 usr.permission = _usr.permission.permission_name
1107 1107 perm_rows.append(usr)
1108 1108
1109 1109 # filter the perm rows by 'default' first and then sort them by
1110 1110 # admin,write,read,none permissions sorted again alphabetically in
1111 1111 # each group
1112 1112 perm_rows = sorted(perm_rows, key=display_sort)
1113 1113
1114 1114 _admin_perm = 'usergroup.admin'
1115 1115 owner_row = []
1116 1116 if with_owner:
1117 1117 usr = AttributeDict(self.user.get_dict())
1118 1118 usr.owner_row = True
1119 1119 usr.permission = _admin_perm
1120 1120 owner_row.append(usr)
1121 1121
1122 1122 super_admin_rows = []
1123 1123 if with_admins:
1124 1124 for usr in User.get_all_super_admins():
1125 1125 # if this admin is also owner, don't double the record
1126 1126 if usr.user_id == owner_row[0].user_id:
1127 1127 owner_row[0].admin_row = True
1128 1128 else:
1129 1129 usr = AttributeDict(usr.get_dict())
1130 1130 usr.admin_row = True
1131 1131 usr.permission = _admin_perm
1132 1132 super_admin_rows.append(usr)
1133 1133
1134 1134 return super_admin_rows + owner_row + perm_rows
1135 1135
1136 1136 def permission_user_groups(self):
1137 1137 q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)
1138 1138 q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
1139 1139 joinedload(UserGroupUserGroupToPerm.target_user_group),
1140 1140 joinedload(UserGroupUserGroupToPerm.permission),)
1141 1141
1142 1142 perm_rows = []
1143 1143 for _user_group in q.all():
1144 1144 usr = AttributeDict(_user_group.user_group.get_dict())
1145 1145 usr.permission = _user_group.permission.permission_name
1146 1146 perm_rows.append(usr)
1147 1147
1148 1148 return perm_rows
1149 1149
1150 1150 def _get_default_perms(self, user_group, suffix=''):
1151 1151 from rhodecode.model.permission import PermissionModel
1152 1152 return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
1153 1153
1154 1154 def get_default_perms(self, suffix=''):
1155 1155 return self._get_default_perms(self, suffix)
1156 1156
1157 1157 def get_api_data(self, with_group_members=True, include_secrets=False):
1158 1158 """
1159 1159 :param include_secrets: See :meth:`User.get_api_data`, this parameter is
1160 1160 basically forwarded.
1161 1161
1162 1162 """
1163 1163 user_group = self
1164 1164
1165 1165 data = {
1166 1166 'users_group_id': user_group.users_group_id,
1167 1167 'group_name': user_group.users_group_name,
1168 1168 'group_description': user_group.user_group_description,
1169 1169 'active': user_group.users_group_active,
1170 1170 'owner': user_group.user.username,
1171 1171 }
1172 1172 if with_group_members:
1173 1173 users = []
1174 1174 for user in user_group.members:
1175 1175 user = user.user
1176 1176 users.append(user.get_api_data(include_secrets=include_secrets))
1177 1177 data['users'] = users
1178 1178
1179 1179 return data
1180 1180
1181 1181
1182 1182 class UserGroupMember(Base, BaseModel):
1183 1183 __tablename__ = 'users_groups_members'
1184 1184 __table_args__ = (
1185 1185 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1186 1186 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1187 1187 )
1188 1188
1189 1189 users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1190 1190 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
1191 1191 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
1192 1192
1193 1193 user = relationship('User', lazy='joined')
1194 1194 users_group = relationship('UserGroup')
1195 1195
1196 1196 def __init__(self, gr_id='', u_id=''):
1197 1197 self.users_group_id = gr_id
1198 1198 self.user_id = u_id
1199 1199
1200 1200
1201 1201 class RepositoryField(Base, BaseModel):
1202 1202 __tablename__ = 'repositories_fields'
1203 1203 __table_args__ = (
1204 1204 UniqueConstraint('repository_id', 'field_key'), # no-multi field
1205 1205 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1206 1206 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1207 1207 )
1208 1208 PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields
1209 1209
1210 1210 repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1211 1211 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
1212 1212 field_key = Column("field_key", String(250))
1213 1213 field_label = Column("field_label", String(1024), nullable=False)
1214 1214 field_value = Column("field_value", String(10000), nullable=False)
1215 1215 field_desc = Column("field_desc", String(1024), nullable=False)
1216 1216 field_type = Column("field_type", String(255), nullable=False, unique=None)
1217 1217 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1218 1218
1219 1219 repository = relationship('Repository')
1220 1220
1221 1221 @property
1222 1222 def field_key_prefixed(self):
1223 1223 return 'ex_%s' % self.field_key
1224 1224
1225 1225 @classmethod
1226 1226 def un_prefix_key(cls, key):
1227 1227 if key.startswith(cls.PREFIX):
1228 1228 return key[len(cls.PREFIX):]
1229 1229 return key
1230 1230
1231 1231 @classmethod
1232 1232 def get_by_key_name(cls, key, repo):
1233 1233 row = cls.query()\
1234 1234 .filter(cls.repository == repo)\
1235 1235 .filter(cls.field_key == key).scalar()
1236 1236 return row
1237 1237
1238 1238
1239 1239 class Repository(Base, BaseModel):
1240 1240 __tablename__ = 'repositories'
1241 1241 __table_args__ = (
1242 1242 Index('r_repo_name_idx', 'repo_name', mysql_length=255),
1243 1243 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1244 1244 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1245 1245 )
1246 1246 DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
1247 1247 DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
1248 1248
1249 1249 STATE_CREATED = 'repo_state_created'
1250 1250 STATE_PENDING = 'repo_state_pending'
1251 1251 STATE_ERROR = 'repo_state_error'
1252 1252
1253 1253 LOCK_AUTOMATIC = 'lock_auto'
1254 1254 LOCK_API = 'lock_api'
1255 1255 LOCK_WEB = 'lock_web'
1256 1256 LOCK_PULL = 'lock_pull'
1257 1257
1258 1258 NAME_SEP = URL_SEP
1259 1259
1260 1260 repo_id = Column(
1261 1261 "repo_id", Integer(), nullable=False, unique=True, default=None,
1262 1262 primary_key=True)
1263 1263 _repo_name = Column(
1264 1264 "repo_name", Text(), nullable=False, default=None)
1265 1265 _repo_name_hash = Column(
1266 1266 "repo_name_hash", String(255), nullable=False, unique=True)
1267 1267 repo_state = Column("repo_state", String(255), nullable=True)
1268 1268
1269 1269 clone_uri = Column(
1270 1270 "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
1271 1271 default=None)
1272 1272 repo_type = Column(
1273 1273 "repo_type", String(255), nullable=False, unique=False, default=None)
1274 1274 user_id = Column(
1275 1275 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
1276 1276 unique=False, default=None)
1277 1277 private = Column(
1278 1278 "private", Boolean(), nullable=True, unique=None, default=None)
1279 1279 enable_statistics = Column(
1280 1280 "statistics", Boolean(), nullable=True, unique=None, default=True)
1281 1281 enable_downloads = Column(
1282 1282 "downloads", Boolean(), nullable=True, unique=None, default=True)
1283 1283 description = Column(
1284 1284 "description", String(10000), nullable=True, unique=None, default=None)
1285 1285 created_on = Column(
1286 1286 'created_on', DateTime(timezone=False), nullable=True, unique=None,
1287 1287 default=datetime.datetime.now)
1288 1288 updated_on = Column(
1289 1289 'updated_on', DateTime(timezone=False), nullable=True, unique=None,
1290 1290 default=datetime.datetime.now)
1291 1291 _landing_revision = Column(
1292 1292 "landing_revision", String(255), nullable=False, unique=False,
1293 1293 default=None)
1294 1294 enable_locking = Column(
1295 1295 "enable_locking", Boolean(), nullable=False, unique=None,
1296 1296 default=False)
1297 1297 _locked = Column(
1298 1298 "locked", String(255), nullable=True, unique=False, default=None)
1299 1299 _changeset_cache = Column(
1300 1300 "changeset_cache", LargeBinary(), nullable=True) # JSON data
1301 1301
1302 1302 fork_id = Column(
1303 1303 "fork_id", Integer(), ForeignKey('repositories.repo_id'),
1304 1304 nullable=True, unique=False, default=None)
1305 1305 group_id = Column(
1306 1306 "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
1307 1307 unique=False, default=None)
1308 1308
1309 1309 user = relationship('User', lazy='joined')
1310 1310 fork = relationship('Repository', remote_side=repo_id, lazy='joined')
1311 1311 group = relationship('RepoGroup', lazy='joined')
1312 1312 repo_to_perm = relationship(
1313 1313 'UserRepoToPerm', cascade='all',
1314 1314 order_by='UserRepoToPerm.repo_to_perm_id')
1315 1315 users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1316 1316 stats = relationship('Statistics', cascade='all', uselist=False)
1317 1317
1318 1318 followers = relationship(
1319 1319 'UserFollowing',
1320 1320 primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
1321 1321 cascade='all')
1322 1322 extra_fields = relationship(
1323 1323 'RepositoryField', cascade="all, delete, delete-orphan")
1324 1324 logs = relationship('UserLog')
1325 1325 comments = relationship(
1326 1326 'ChangesetComment', cascade="all, delete, delete-orphan")
1327 1327 pull_requests_source = relationship(
1328 1328 'PullRequest',
1329 1329 primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
1330 1330 cascade="all, delete, delete-orphan")
1331 1331 pull_requests_target = relationship(
1332 1332 'PullRequest',
1333 1333 primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
1334 1334 cascade="all, delete, delete-orphan")
1335 1335 ui = relationship('RepoRhodeCodeUi', cascade="all")
1336 1336 settings = relationship('RepoRhodeCodeSetting', cascade="all")
1337 1337 integrations = relationship('Integration',
1338 1338 cascade="all, delete, delete-orphan")
1339 1339
1340 1340 def __unicode__(self):
1341 1341 return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
1342 1342 safe_unicode(self.repo_name))
1343 1343
1344 1344 @hybrid_property
1345 1345 def landing_rev(self):
1346 1346 # always should return [rev_type, rev]
1347 1347 if self._landing_revision:
1348 1348 _rev_info = self._landing_revision.split(':')
1349 1349 if len(_rev_info) < 2:
1350 1350 _rev_info.insert(0, 'rev')
1351 1351 return [_rev_info[0], _rev_info[1]]
1352 1352 return [None, None]
1353 1353
1354 1354 @landing_rev.setter
1355 1355 def landing_rev(self, val):
1356 1356 if ':' not in val:
1357 1357 raise ValueError('value must be delimited with `:` and consist '
1358 1358 'of <rev_type>:<rev>, got %s instead' % val)
1359 1359 self._landing_revision = val
1360 1360
1361 1361 @hybrid_property
1362 1362 def locked(self):
1363 1363 if self._locked:
1364 1364 user_id, timelocked, reason = self._locked.split(':')
1365 1365 lock_values = int(user_id), timelocked, reason
1366 1366 else:
1367 1367 lock_values = [None, None, None]
1368 1368 return lock_values
1369 1369
1370 1370 @locked.setter
1371 1371 def locked(self, val):
1372 1372 if val and isinstance(val, (list, tuple)):
1373 1373 self._locked = ':'.join(map(str, val))
1374 1374 else:
1375 1375 self._locked = None
1376 1376
1377 1377 @hybrid_property
1378 1378 def changeset_cache(self):
1379 1379 from rhodecode.lib.vcs.backends.base import EmptyCommit
1380 1380 dummy = EmptyCommit().__json__()
1381 1381 if not self._changeset_cache:
1382 1382 return dummy
1383 1383 try:
1384 1384 return json.loads(self._changeset_cache)
1385 1385 except TypeError:
1386 1386 return dummy
1387 1387 except Exception:
1388 1388 log.error(traceback.format_exc())
1389 1389 return dummy
1390 1390
1391 1391 @changeset_cache.setter
1392 1392 def changeset_cache(self, val):
1393 1393 try:
1394 1394 self._changeset_cache = json.dumps(val)
1395 1395 except Exception:
1396 1396 log.error(traceback.format_exc())
1397 1397
1398 1398 @hybrid_property
1399 1399 def repo_name(self):
1400 1400 return self._repo_name
1401 1401
1402 1402 @repo_name.setter
1403 1403 def repo_name(self, value):
1404 1404 self._repo_name = value
1405 1405 self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
1406 1406
1407 1407 @classmethod
1408 1408 def normalize_repo_name(cls, repo_name):
1409 1409 """
1410 1410 Normalizes os specific repo_name to the format internally stored inside
1411 1411 database using URL_SEP
1412 1412
1413 1413 :param cls:
1414 1414 :param repo_name:
1415 1415 """
1416 1416 return cls.NAME_SEP.join(repo_name.split(os.sep))
1417 1417
1418 1418 @classmethod
1419 1419 def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
1420 1420 session = Session()
1421 1421 q = session.query(cls).filter(cls.repo_name == repo_name)
1422 1422
1423 1423 if cache:
1424 1424 if identity_cache:
1425 1425 val = cls.identity_cache(session, 'repo_name', repo_name)
1426 1426 if val:
1427 1427 return val
1428 1428 else:
1429 1429 q = q.options(
1430 1430 FromCache("sql_cache_short",
1431 1431 "get_repo_by_name_%s" % _hash_key(repo_name)))
1432 1432
1433 1433 return q.scalar()
1434 1434
1435 1435 @classmethod
1436 1436 def get_by_full_path(cls, repo_full_path):
1437 1437 repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
1438 1438 repo_name = cls.normalize_repo_name(repo_name)
1439 1439 return cls.get_by_repo_name(repo_name.strip(URL_SEP))
1440 1440
1441 1441 @classmethod
1442 1442 def get_repo_forks(cls, repo_id):
1443 1443 return cls.query().filter(Repository.fork_id == repo_id)
1444 1444
1445 1445 @classmethod
1446 1446 def base_path(cls):
1447 1447 """
1448 1448 Returns base path when all repos are stored
1449 1449
1450 1450 :param cls:
1451 1451 """
1452 1452 q = Session().query(RhodeCodeUi)\
1453 1453 .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
1454 1454 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1455 1455 return q.one().ui_value
1456 1456
1457 1457 @classmethod
1458 1458 def is_valid(cls, repo_name):
1459 1459 """
1460 1460 returns True if given repo name is a valid filesystem repository
1461 1461
1462 1462 :param cls:
1463 1463 :param repo_name:
1464 1464 """
1465 1465 from rhodecode.lib.utils import is_valid_repo
1466 1466
1467 1467 return is_valid_repo(repo_name, cls.base_path())
1468 1468
1469 1469 @classmethod
1470 1470 def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
1471 1471 case_insensitive=True):
1472 1472 q = Repository.query()
1473 1473
1474 1474 if not isinstance(user_id, Optional):
1475 1475 q = q.filter(Repository.user_id == user_id)
1476 1476
1477 1477 if not isinstance(group_id, Optional):
1478 1478 q = q.filter(Repository.group_id == group_id)
1479 1479
1480 1480 if case_insensitive:
1481 1481 q = q.order_by(func.lower(Repository.repo_name))
1482 1482 else:
1483 1483 q = q.order_by(Repository.repo_name)
1484 1484 return q.all()
1485 1485
1486 1486 @property
1487 1487 def forks(self):
1488 1488 """
1489 1489 Return forks of this repo
1490 1490 """
1491 1491 return Repository.get_repo_forks(self.repo_id)
1492 1492
1493 1493 @property
1494 1494 def parent(self):
1495 1495 """
1496 1496 Returns fork parent
1497 1497 """
1498 1498 return self.fork
1499 1499
1500 1500 @property
1501 1501 def just_name(self):
1502 1502 return self.repo_name.split(self.NAME_SEP)[-1]
1503 1503
1504 1504 @property
1505 1505 def groups_with_parents(self):
1506 1506 groups = []
1507 1507 if self.group is None:
1508 1508 return groups
1509 1509
1510 1510 cur_gr = self.group
1511 1511 groups.insert(0, cur_gr)
1512 1512 while 1:
1513 1513 gr = getattr(cur_gr, 'parent_group', None)
1514 1514 cur_gr = cur_gr.parent_group
1515 1515 if gr is None:
1516 1516 break
1517 1517 groups.insert(0, gr)
1518 1518
1519 1519 return groups
1520 1520
1521 1521 @property
1522 1522 def groups_and_repo(self):
1523 1523 return self.groups_with_parents, self
1524 1524
1525 1525 @LazyProperty
1526 1526 def repo_path(self):
1527 1527 """
1528 1528 Returns base full path for that repository means where it actually
1529 1529 exists on a filesystem
1530 1530 """
1531 1531 q = Session().query(RhodeCodeUi).filter(
1532 1532 RhodeCodeUi.ui_key == self.NAME_SEP)
1533 1533 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1534 1534 return q.one().ui_value
1535 1535
1536 1536 @property
1537 1537 def repo_full_path(self):
1538 1538 p = [self.repo_path]
1539 1539 # we need to split the name by / since this is how we store the
1540 1540 # names in the database, but that eventually needs to be converted
1541 1541 # into a valid system path
1542 1542 p += self.repo_name.split(self.NAME_SEP)
1543 1543 return os.path.join(*map(safe_unicode, p))
1544 1544
1545 1545 @property
1546 1546 def cache_keys(self):
1547 1547 """
1548 1548 Returns associated cache keys for that repo
1549 1549 """
1550 1550 return CacheKey.query()\
1551 1551 .filter(CacheKey.cache_args == self.repo_name)\
1552 1552 .order_by(CacheKey.cache_key)\
1553 1553 .all()
1554 1554
1555 1555 def get_new_name(self, repo_name):
1556 1556 """
1557 1557 returns new full repository name based on assigned group and new new
1558 1558
1559 1559 :param group_name:
1560 1560 """
1561 1561 path_prefix = self.group.full_path_splitted if self.group else []
1562 1562 return self.NAME_SEP.join(path_prefix + [repo_name])
1563 1563
1564 1564 @property
1565 1565 def _config(self):
1566 1566 """
1567 1567 Returns db based config object.
1568 1568 """
1569 1569 from rhodecode.lib.utils import make_db_config
1570 1570 return make_db_config(clear_session=False, repo=self)
1571 1571
1572 1572 def permissions(self, with_admins=True, with_owner=True):
1573 1573 q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
1574 1574 q = q.options(joinedload(UserRepoToPerm.repository),
1575 1575 joinedload(UserRepoToPerm.user),
1576 1576 joinedload(UserRepoToPerm.permission),)
1577 1577
1578 1578 # get owners and admins and permissions. We do a trick of re-writing
1579 1579 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1580 1580 # has a global reference and changing one object propagates to all
1581 1581 # others. This means if admin is also an owner admin_row that change
1582 1582 # would propagate to both objects
1583 1583 perm_rows = []
1584 1584 for _usr in q.all():
1585 1585 usr = AttributeDict(_usr.user.get_dict())
1586 1586 usr.permission = _usr.permission.permission_name
1587 1587 perm_rows.append(usr)
1588 1588
1589 1589 # filter the perm rows by 'default' first and then sort them by
1590 1590 # admin,write,read,none permissions sorted again alphabetically in
1591 1591 # each group
1592 1592 perm_rows = sorted(perm_rows, key=display_sort)
1593 1593
1594 1594 _admin_perm = 'repository.admin'
1595 1595 owner_row = []
1596 1596 if with_owner:
1597 1597 usr = AttributeDict(self.user.get_dict())
1598 1598 usr.owner_row = True
1599 1599 usr.permission = _admin_perm
1600 1600 owner_row.append(usr)
1601 1601
1602 1602 super_admin_rows = []
1603 1603 if with_admins:
1604 1604 for usr in User.get_all_super_admins():
1605 1605 # if this admin is also owner, don't double the record
1606 1606 if usr.user_id == owner_row[0].user_id:
1607 1607 owner_row[0].admin_row = True
1608 1608 else:
1609 1609 usr = AttributeDict(usr.get_dict())
1610 1610 usr.admin_row = True
1611 1611 usr.permission = _admin_perm
1612 1612 super_admin_rows.append(usr)
1613 1613
1614 1614 return super_admin_rows + owner_row + perm_rows
1615 1615
1616 1616 def permission_user_groups(self):
1617 1617 q = UserGroupRepoToPerm.query().filter(
1618 1618 UserGroupRepoToPerm.repository == self)
1619 1619 q = q.options(joinedload(UserGroupRepoToPerm.repository),
1620 1620 joinedload(UserGroupRepoToPerm.users_group),
1621 1621 joinedload(UserGroupRepoToPerm.permission),)
1622 1622
1623 1623 perm_rows = []
1624 1624 for _user_group in q.all():
1625 1625 usr = AttributeDict(_user_group.users_group.get_dict())
1626 1626 usr.permission = _user_group.permission.permission_name
1627 1627 perm_rows.append(usr)
1628 1628
1629 1629 return perm_rows
1630 1630
1631 1631 def get_api_data(self, include_secrets=False):
1632 1632 """
1633 1633 Common function for generating repo api data
1634 1634
1635 1635 :param include_secrets: See :meth:`User.get_api_data`.
1636 1636
1637 1637 """
1638 1638 # TODO: mikhail: Here there is an anti-pattern, we probably need to
1639 1639 # move this methods on models level.
1640 1640 from rhodecode.model.settings import SettingsModel
1641 1641
1642 1642 repo = self
1643 1643 _user_id, _time, _reason = self.locked
1644 1644
1645 1645 data = {
1646 1646 'repo_id': repo.repo_id,
1647 1647 'repo_name': repo.repo_name,
1648 1648 'repo_type': repo.repo_type,
1649 1649 'clone_uri': repo.clone_uri or '',
1650 1650 'url': url('summary_home', repo_name=self.repo_name, qualified=True),
1651 1651 'private': repo.private,
1652 1652 'created_on': repo.created_on,
1653 1653 'description': repo.description,
1654 1654 'landing_rev': repo.landing_rev,
1655 1655 'owner': repo.user.username,
1656 1656 'fork_of': repo.fork.repo_name if repo.fork else None,
1657 1657 'enable_statistics': repo.enable_statistics,
1658 1658 'enable_locking': repo.enable_locking,
1659 1659 'enable_downloads': repo.enable_downloads,
1660 1660 'last_changeset': repo.changeset_cache,
1661 1661 'locked_by': User.get(_user_id).get_api_data(
1662 1662 include_secrets=include_secrets) if _user_id else None,
1663 1663 'locked_date': time_to_datetime(_time) if _time else None,
1664 1664 'lock_reason': _reason if _reason else None,
1665 1665 }
1666 1666
1667 1667 # TODO: mikhail: should be per-repo settings here
1668 1668 rc_config = SettingsModel().get_all_settings()
1669 1669 repository_fields = str2bool(
1670 1670 rc_config.get('rhodecode_repository_fields'))
1671 1671 if repository_fields:
1672 1672 for f in self.extra_fields:
1673 1673 data[f.field_key_prefixed] = f.field_value
1674 1674
1675 1675 return data
1676 1676
1677 1677 @classmethod
1678 1678 def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
1679 1679 if not lock_time:
1680 1680 lock_time = time.time()
1681 1681 if not lock_reason:
1682 1682 lock_reason = cls.LOCK_AUTOMATIC
1683 1683 repo.locked = [user_id, lock_time, lock_reason]
1684 1684 Session().add(repo)
1685 1685 Session().commit()
1686 1686
1687 1687 @classmethod
1688 1688 def unlock(cls, repo):
1689 1689 repo.locked = None
1690 1690 Session().add(repo)
1691 1691 Session().commit()
1692 1692
1693 1693 @classmethod
1694 1694 def getlock(cls, repo):
1695 1695 return repo.locked
1696 1696
1697 1697 def is_user_lock(self, user_id):
1698 1698 if self.lock[0]:
1699 1699 lock_user_id = safe_int(self.lock[0])
1700 1700 user_id = safe_int(user_id)
1701 1701 # both are ints, and they are equal
1702 1702 return all([lock_user_id, user_id]) and lock_user_id == user_id
1703 1703
1704 1704 return False
1705 1705
1706 1706 def get_locking_state(self, action, user_id, only_when_enabled=True):
1707 1707 """
1708 1708 Checks locking on this repository, if locking is enabled and lock is
1709 1709 present returns a tuple of make_lock, locked, locked_by.
1710 1710 make_lock can have 3 states None (do nothing) True, make lock
1711 1711 False release lock, This value is later propagated to hooks, which
1712 1712 do the locking. Think about this as signals passed to hooks what to do.
1713 1713
1714 1714 """
1715 1715 # TODO: johbo: This is part of the business logic and should be moved
1716 1716 # into the RepositoryModel.
1717 1717
1718 1718 if action not in ('push', 'pull'):
1719 1719 raise ValueError("Invalid action value: %s" % repr(action))
1720 1720
1721 1721 # defines if locked error should be thrown to user
1722 1722 currently_locked = False
1723 1723 # defines if new lock should be made, tri-state
1724 1724 make_lock = None
1725 1725 repo = self
1726 1726 user = User.get(user_id)
1727 1727
1728 1728 lock_info = repo.locked
1729 1729
1730 1730 if repo and (repo.enable_locking or not only_when_enabled):
1731 1731 if action == 'push':
1732 1732 # check if it's already locked !, if it is compare users
1733 1733 locked_by_user_id = lock_info[0]
1734 1734 if user.user_id == locked_by_user_id:
1735 1735 log.debug(
1736 1736 'Got `push` action from user %s, now unlocking', user)
1737 1737 # unlock if we have push from user who locked
1738 1738 make_lock = False
1739 1739 else:
1740 1740 # we're not the same user who locked, ban with
1741 1741 # code defined in settings (default is 423 HTTP Locked) !
1742 1742 log.debug('Repo %s is currently locked by %s', repo, user)
1743 1743 currently_locked = True
1744 1744 elif action == 'pull':
1745 1745 # [0] user [1] date
1746 1746 if lock_info[0] and lock_info[1]:
1747 1747 log.debug('Repo %s is currently locked by %s', repo, user)
1748 1748 currently_locked = True
1749 1749 else:
1750 1750 log.debug('Setting lock on repo %s by %s', repo, user)
1751 1751 make_lock = True
1752 1752
1753 1753 else:
1754 1754 log.debug('Repository %s do not have locking enabled', repo)
1755 1755
1756 1756 log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
1757 1757 make_lock, currently_locked, lock_info)
1758 1758
1759 1759 from rhodecode.lib.auth import HasRepoPermissionAny
1760 1760 perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
1761 1761 if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
1762 1762 # if we don't have at least write permission we cannot make a lock
1763 1763 log.debug('lock state reset back to FALSE due to lack '
1764 1764 'of at least read permission')
1765 1765 make_lock = False
1766 1766
1767 1767 return make_lock, currently_locked, lock_info
1768 1768
1769 1769 @property
1770 1770 def last_db_change(self):
1771 1771 return self.updated_on
1772 1772
1773 1773 @property
1774 1774 def clone_uri_hidden(self):
1775 1775 clone_uri = self.clone_uri
1776 1776 if clone_uri:
1777 1777 import urlobject
1778 1778 url_obj = urlobject.URLObject(clone_uri)
1779 1779 if url_obj.password:
1780 1780 clone_uri = url_obj.with_password('*****')
1781 1781 return clone_uri
1782 1782
1783 1783 def clone_url(self, **override):
1784 1784 qualified_home_url = url('home', qualified=True)
1785 1785
1786 1786 uri_tmpl = None
1787 1787 if 'with_id' in override:
1788 1788 uri_tmpl = self.DEFAULT_CLONE_URI_ID
1789 1789 del override['with_id']
1790 1790
1791 1791 if 'uri_tmpl' in override:
1792 1792 uri_tmpl = override['uri_tmpl']
1793 1793 del override['uri_tmpl']
1794 1794
1795 1795 # we didn't override our tmpl from **overrides
1796 1796 if not uri_tmpl:
1797 1797 uri_tmpl = self.DEFAULT_CLONE_URI
1798 1798 try:
1799 1799 from pylons import tmpl_context as c
1800 1800 uri_tmpl = c.clone_uri_tmpl
1801 1801 except Exception:
1802 1802 # in any case if we call this outside of request context,
1803 1803 # ie, not having tmpl_context set up
1804 1804 pass
1805 1805
1806 1806 return get_clone_url(uri_tmpl=uri_tmpl,
1807 1807 qualifed_home_url=qualified_home_url,
1808 1808 repo_name=self.repo_name,
1809 1809 repo_id=self.repo_id, **override)
1810 1810
1811 1811 def set_state(self, state):
1812 1812 self.repo_state = state
1813 1813 Session().add(self)
1814 1814 #==========================================================================
1815 1815 # SCM PROPERTIES
1816 1816 #==========================================================================
1817 1817
1818 1818 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
1819 1819 return get_commit_safe(
1820 1820 self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)
1821 1821
1822 1822 def get_changeset(self, rev=None, pre_load=None):
1823 1823 warnings.warn("Use get_commit", DeprecationWarning)
1824 1824 commit_id = None
1825 1825 commit_idx = None
1826 1826 if isinstance(rev, basestring):
1827 1827 commit_id = rev
1828 1828 else:
1829 1829 commit_idx = rev
1830 1830 return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
1831 1831 pre_load=pre_load)
1832 1832
1833 1833 def get_landing_commit(self):
1834 1834 """
1835 1835 Returns landing commit, or if that doesn't exist returns the tip
1836 1836 """
1837 1837 _rev_type, _rev = self.landing_rev
1838 1838 commit = self.get_commit(_rev)
1839 1839 if isinstance(commit, EmptyCommit):
1840 1840 return self.get_commit()
1841 1841 return commit
1842 1842
1843 1843 def update_commit_cache(self, cs_cache=None, config=None):
1844 1844 """
1845 1845 Update cache of last changeset for repository, keys should be::
1846 1846
1847 1847 short_id
1848 1848 raw_id
1849 1849 revision
1850 1850 parents
1851 1851 message
1852 1852 date
1853 1853 author
1854 1854
1855 1855 :param cs_cache:
1856 1856 """
1857 1857 from rhodecode.lib.vcs.backends.base import BaseChangeset
1858 1858 if cs_cache is None:
1859 1859 # use no-cache version here
1860 1860 scm_repo = self.scm_instance(cache=False, config=config)
1861 1861 if scm_repo:
1862 1862 cs_cache = scm_repo.get_commit(
1863 1863 pre_load=["author", "date", "message", "parents"])
1864 1864 else:
1865 1865 cs_cache = EmptyCommit()
1866 1866
1867 1867 if isinstance(cs_cache, BaseChangeset):
1868 1868 cs_cache = cs_cache.__json__()
1869 1869
1870 1870 def is_outdated(new_cs_cache):
1871 1871 if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
1872 1872 new_cs_cache['revision'] != self.changeset_cache['revision']):
1873 1873 return True
1874 1874 return False
1875 1875
1876 1876 # check if we have maybe already latest cached revision
1877 1877 if is_outdated(cs_cache) or not self.changeset_cache:
1878 1878 _default = datetime.datetime.fromtimestamp(0)
1879 1879 last_change = cs_cache.get('date') or _default
1880 1880 log.debug('updated repo %s with new cs cache %s',
1881 1881 self.repo_name, cs_cache)
1882 1882 self.updated_on = last_change
1883 1883 self.changeset_cache = cs_cache
1884 1884 Session().add(self)
1885 1885 Session().commit()
1886 1886 else:
1887 1887 log.debug('Skipping update_commit_cache for repo:`%s` '
1888 1888 'commit already with latest changes', self.repo_name)
1889 1889
1890 1890 @property
1891 1891 def tip(self):
1892 1892 return self.get_commit('tip')
1893 1893
1894 1894 @property
1895 1895 def author(self):
1896 1896 return self.tip.author
1897 1897
1898 1898 @property
1899 1899 def last_change(self):
1900 1900 return self.scm_instance().last_change
1901 1901
1902 1902 def get_comments(self, revisions=None):
1903 1903 """
1904 1904 Returns comments for this repository grouped by revisions
1905 1905
1906 1906 :param revisions: filter query by revisions only
1907 1907 """
1908 1908 cmts = ChangesetComment.query()\
1909 1909 .filter(ChangesetComment.repo == self)
1910 1910 if revisions:
1911 1911 cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
1912 1912 grouped = collections.defaultdict(list)
1913 1913 for cmt in cmts.all():
1914 1914 grouped[cmt.revision].append(cmt)
1915 1915 return grouped
1916 1916
1917 1917 def statuses(self, revisions=None):
1918 1918 """
1919 1919 Returns statuses for this repository
1920 1920
1921 1921 :param revisions: list of revisions to get statuses for
1922 1922 """
1923 1923 statuses = ChangesetStatus.query()\
1924 1924 .filter(ChangesetStatus.repo == self)\
1925 1925 .filter(ChangesetStatus.version == 0)
1926 1926
1927 1927 if revisions:
1928 1928 # Try doing the filtering in chunks to avoid hitting limits
1929 1929 size = 500
1930 1930 status_results = []
1931 1931 for chunk in xrange(0, len(revisions), size):
1932 1932 status_results += statuses.filter(
1933 1933 ChangesetStatus.revision.in_(
1934 1934 revisions[chunk: chunk+size])
1935 1935 ).all()
1936 1936 else:
1937 1937 status_results = statuses.all()
1938 1938
1939 1939 grouped = {}
1940 1940
1941 1941 # maybe we have open new pullrequest without a status?
1942 1942 stat = ChangesetStatus.STATUS_UNDER_REVIEW
1943 1943 status_lbl = ChangesetStatus.get_status_lbl(stat)
1944 1944 for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
1945 1945 for rev in pr.revisions:
1946 1946 pr_id = pr.pull_request_id
1947 1947 pr_repo = pr.target_repo.repo_name
1948 1948 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
1949 1949
1950 1950 for stat in status_results:
1951 1951 pr_id = pr_repo = None
1952 1952 if stat.pull_request:
1953 1953 pr_id = stat.pull_request.pull_request_id
1954 1954 pr_repo = stat.pull_request.target_repo.repo_name
1955 1955 grouped[stat.revision] = [str(stat.status), stat.status_lbl,
1956 1956 pr_id, pr_repo]
1957 1957 return grouped
1958 1958
1959 1959 # ==========================================================================
1960 1960 # SCM CACHE INSTANCE
1961 1961 # ==========================================================================
1962 1962
1963 1963 def scm_instance(self, **kwargs):
1964 1964 import rhodecode
1965 1965
1966 1966 # Passing a config will not hit the cache currently only used
1967 1967 # for repo2dbmapper
1968 1968 config = kwargs.pop('config', None)
1969 1969 cache = kwargs.pop('cache', None)
1970 1970 full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
1971 1971 # if cache is NOT defined use default global, else we have a full
1972 1972 # control over cache behaviour
1973 1973 if cache is None and full_cache and not config:
1974 1974 return self._get_instance_cached()
1975 1975 return self._get_instance(cache=bool(cache), config=config)
1976 1976
1977 1977 def _get_instance_cached(self):
1978 1978 @cache_region('long_term')
1979 1979 def _get_repo(cache_key):
1980 1980 return self._get_instance()
1981 1981
1982 1982 invalidator_context = CacheKey.repo_context_cache(
1983 1983 _get_repo, self.repo_name, None, thread_scoped=True)
1984 1984
1985 1985 with invalidator_context as context:
1986 1986 context.invalidate()
1987 1987 repo = context.compute()
1988 1988
1989 1989 return repo
1990 1990
1991 1991 def _get_instance(self, cache=True, config=None):
1992 1992 config = config or self._config
1993 1993 custom_wire = {
1994 1994 'cache': cache # controls the vcs.remote cache
1995 1995 }
1996 1996 repo = get_vcs_instance(
1997 1997 repo_path=safe_str(self.repo_full_path),
1998 1998 config=config,
1999 1999 with_wire=custom_wire,
2000 2000 create=False,
2001 2001 _vcs_alias=self.repo_type)
2002 2002
2003 2003 return repo
2004 2004
2005 2005 def __json__(self):
2006 2006 return {'landing_rev': self.landing_rev}
2007 2007
2008 2008 def get_dict(self):
2009 2009
2010 2010 # Since we transformed `repo_name` to a hybrid property, we need to
2011 2011 # keep compatibility with the code which uses `repo_name` field.
2012 2012
2013 2013 result = super(Repository, self).get_dict()
2014 2014 result['repo_name'] = result.pop('_repo_name', None)
2015 2015 return result
2016 2016
2017 2017
2018 2018 class RepoGroup(Base, BaseModel):
2019 2019 __tablename__ = 'groups'
2020 2020 __table_args__ = (
2021 2021 UniqueConstraint('group_name', 'group_parent_id'),
2022 2022 CheckConstraint('group_id != group_parent_id'),
2023 2023 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2024 2024 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2025 2025 )
2026 2026 __mapper_args__ = {'order_by': 'group_name'}
2027 2027
2028 2028 CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups
2029 2029
2030 2030 group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2031 2031 group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
2032 2032 group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
2033 2033 group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
2034 2034 enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
2035 2035 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
2036 2036 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2037 2037 personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
2038 2038
2039 2039 repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
2040 2040 users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
2041 2041 parent_group = relationship('RepoGroup', remote_side=group_id)
2042 2042 user = relationship('User')
2043 2043 integrations = relationship('Integration',
2044 2044 cascade="all, delete, delete-orphan")
2045 2045
2046 2046 def __init__(self, group_name='', parent_group=None):
2047 2047 self.group_name = group_name
2048 2048 self.parent_group = parent_group
2049 2049
2050 2050 def __unicode__(self):
2051 2051 return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,
2052 2052 self.group_name)
2053 2053
2054 2054 @classmethod
2055 2055 def _generate_choice(cls, repo_group):
2056 2056 from webhelpers.html import literal as _literal
2057 2057 _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
2058 2058 return repo_group.group_id, _name(repo_group.full_path_splitted)
2059 2059
2060 2060 @classmethod
2061 2061 def groups_choices(cls, groups=None, show_empty_group=True):
2062 2062 if not groups:
2063 2063 groups = cls.query().all()
2064 2064
2065 2065 repo_groups = []
2066 2066 if show_empty_group:
2067 2067 repo_groups = [('-1', u'-- %s --' % _('No parent'))]
2068 2068
2069 2069 repo_groups.extend([cls._generate_choice(x) for x in groups])
2070 2070
2071 2071 repo_groups = sorted(
2072 2072 repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
2073 2073 return repo_groups
2074 2074
2075 2075 @classmethod
2076 2076 def url_sep(cls):
2077 2077 return URL_SEP
2078 2078
2079 2079 @classmethod
2080 2080 def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
2081 2081 if case_insensitive:
2082 2082 gr = cls.query().filter(func.lower(cls.group_name)
2083 2083 == func.lower(group_name))
2084 2084 else:
2085 2085 gr = cls.query().filter(cls.group_name == group_name)
2086 2086 if cache:
2087 2087 gr = gr.options(FromCache(
2088 2088 "sql_cache_short",
2089 2089 "get_group_%s" % _hash_key(group_name)))
2090 2090 return gr.scalar()
2091 2091
2092 2092 @classmethod
2093 2093 def get_user_personal_repo_group(cls, user_id):
2094 2094 user = User.get(user_id)
2095 2095 return cls.query()\
2096 2096 .filter(cls.personal == true())\
2097 2097 .filter(cls.user == user).scalar()
2098 2098
2099 2099 @classmethod
2100 2100 def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
2101 2101 case_insensitive=True):
2102 2102 q = RepoGroup.query()
2103 2103
2104 2104 if not isinstance(user_id, Optional):
2105 2105 q = q.filter(RepoGroup.user_id == user_id)
2106 2106
2107 2107 if not isinstance(group_id, Optional):
2108 2108 q = q.filter(RepoGroup.group_parent_id == group_id)
2109 2109
2110 2110 if case_insensitive:
2111 2111 q = q.order_by(func.lower(RepoGroup.group_name))
2112 2112 else:
2113 2113 q = q.order_by(RepoGroup.group_name)
2114 2114 return q.all()
2115 2115
2116 2116 @property
2117 2117 def parents(self):
2118 2118 parents_recursion_limit = 10
2119 2119 groups = []
2120 2120 if self.parent_group is None:
2121 2121 return groups
2122 2122 cur_gr = self.parent_group
2123 2123 groups.insert(0, cur_gr)
2124 2124 cnt = 0
2125 2125 while 1:
2126 2126 cnt += 1
2127 2127 gr = getattr(cur_gr, 'parent_group', None)
2128 2128 cur_gr = cur_gr.parent_group
2129 2129 if gr is None:
2130 2130 break
2131 2131 if cnt == parents_recursion_limit:
2132 2132 # this will prevent accidental infinit loops
2133 2133 log.error(('more than %s parents found for group %s, stopping '
2134 2134 'recursive parent fetching' % (parents_recursion_limit, self)))
2135 2135 break
2136 2136
2137 2137 groups.insert(0, gr)
2138 2138 return groups
2139 2139
2140 2140 @property
2141 2141 def children(self):
2142 2142 return RepoGroup.query().filter(RepoGroup.parent_group == self)
2143 2143
2144 2144 @property
2145 2145 def name(self):
2146 2146 return self.group_name.split(RepoGroup.url_sep())[-1]
2147 2147
2148 2148 @property
2149 2149 def full_path(self):
2150 2150 return self.group_name
2151 2151
2152 2152 @property
2153 2153 def full_path_splitted(self):
2154 2154 return self.group_name.split(RepoGroup.url_sep())
2155 2155
2156 2156 @property
2157 2157 def repositories(self):
2158 2158 return Repository.query()\
2159 2159 .filter(Repository.group == self)\
2160 2160 .order_by(Repository.repo_name)
2161 2161
2162 2162 @property
2163 2163 def repositories_recursive_count(self):
2164 2164 cnt = self.repositories.count()
2165 2165
2166 2166 def children_count(group):
2167 2167 cnt = 0
2168 2168 for child in group.children:
2169 2169 cnt += child.repositories.count()
2170 2170 cnt += children_count(child)
2171 2171 return cnt
2172 2172
2173 2173 return cnt + children_count(self)
2174 2174
2175 2175 def _recursive_objects(self, include_repos=True):
2176 2176 all_ = []
2177 2177
2178 2178 def _get_members(root_gr):
2179 2179 if include_repos:
2180 2180 for r in root_gr.repositories:
2181 2181 all_.append(r)
2182 2182 childs = root_gr.children.all()
2183 2183 if childs:
2184 2184 for gr in childs:
2185 2185 all_.append(gr)
2186 2186 _get_members(gr)
2187 2187
2188 2188 _get_members(self)
2189 2189 return [self] + all_
2190 2190
2191 2191 def recursive_groups_and_repos(self):
2192 2192 """
2193 2193 Recursive return all groups, with repositories in those groups
2194 2194 """
2195 2195 return self._recursive_objects()
2196 2196
2197 2197 def recursive_groups(self):
2198 2198 """
2199 2199 Returns all children groups for this group including children of children
2200 2200 """
2201 2201 return self._recursive_objects(include_repos=False)
2202 2202
2203 2203 def get_new_name(self, group_name):
2204 2204 """
2205 2205 returns new full group name based on parent and new name
2206 2206
2207 2207 :param group_name:
2208 2208 """
2209 2209 path_prefix = (self.parent_group.full_path_splitted if
2210 2210 self.parent_group else [])
2211 2211 return RepoGroup.url_sep().join(path_prefix + [group_name])
2212 2212
2213 2213 def permissions(self, with_admins=True, with_owner=True):
2214 2214 q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
2215 2215 q = q.options(joinedload(UserRepoGroupToPerm.group),
2216 2216 joinedload(UserRepoGroupToPerm.user),
2217 2217 joinedload(UserRepoGroupToPerm.permission),)
2218 2218
2219 2219 # get owners and admins and permissions. We do a trick of re-writing
2220 2220 # objects from sqlalchemy to named-tuples due to sqlalchemy session
2221 2221 # has a global reference and changing one object propagates to all
2222 2222 # others. This means if admin is also an owner admin_row that change
2223 2223 # would propagate to both objects
2224 2224 perm_rows = []
2225 2225 for _usr in q.all():
2226 2226 usr = AttributeDict(_usr.user.get_dict())
2227 2227 usr.permission = _usr.permission.permission_name
2228 2228 perm_rows.append(usr)
2229 2229
2230 2230 # filter the perm rows by 'default' first and then sort them by
2231 2231 # admin,write,read,none permissions sorted again alphabetically in
2232 2232 # each group
2233 2233 perm_rows = sorted(perm_rows, key=display_sort)
2234 2234
2235 2235 _admin_perm = 'group.admin'
2236 2236 owner_row = []
2237 2237 if with_owner:
2238 2238 usr = AttributeDict(self.user.get_dict())
2239 2239 usr.owner_row = True
2240 2240 usr.permission = _admin_perm
2241 2241 owner_row.append(usr)
2242 2242
2243 2243 super_admin_rows = []
2244 2244 if with_admins:
2245 2245 for usr in User.get_all_super_admins():
2246 2246 # if this admin is also owner, don't double the record
2247 2247 if usr.user_id == owner_row[0].user_id:
2248 2248 owner_row[0].admin_row = True
2249 2249 else:
2250 2250 usr = AttributeDict(usr.get_dict())
2251 2251 usr.admin_row = True
2252 2252 usr.permission = _admin_perm
2253 2253 super_admin_rows.append(usr)
2254 2254
2255 2255 return super_admin_rows + owner_row + perm_rows
2256 2256
2257 2257 def permission_user_groups(self):
2258 2258 q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)
2259 2259 q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
2260 2260 joinedload(UserGroupRepoGroupToPerm.users_group),
2261 2261 joinedload(UserGroupRepoGroupToPerm.permission),)
2262 2262
2263 2263 perm_rows = []
2264 2264 for _user_group in q.all():
2265 2265 usr = AttributeDict(_user_group.users_group.get_dict())
2266 2266 usr.permission = _user_group.permission.permission_name
2267 2267 perm_rows.append(usr)
2268 2268
2269 2269 return perm_rows
2270 2270
2271 2271 def get_api_data(self):
2272 2272 """
2273 2273 Common function for generating api data
2274 2274
2275 2275 """
2276 2276 group = self
2277 2277 data = {
2278 2278 'group_id': group.group_id,
2279 2279 'group_name': group.group_name,
2280 2280 'group_description': group.group_description,
2281 2281 'parent_group': group.parent_group.group_name if group.parent_group else None,
2282 2282 'repositories': [x.repo_name for x in group.repositories],
2283 2283 'owner': group.user.username,
2284 2284 }
2285 2285 return data
2286 2286
2287 2287
2288 2288 class Permission(Base, BaseModel):
2289 2289 __tablename__ = 'permissions'
2290 2290 __table_args__ = (
2291 2291 Index('p_perm_name_idx', 'permission_name'),
2292 2292 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2293 2293 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2294 2294 )
2295 2295 PERMS = [
2296 2296 ('hg.admin', _('RhodeCode Super Administrator')),
2297 2297
2298 2298 ('repository.none', _('Repository no access')),
2299 2299 ('repository.read', _('Repository read access')),
2300 2300 ('repository.write', _('Repository write access')),
2301 2301 ('repository.admin', _('Repository admin access')),
2302 2302
2303 2303 ('group.none', _('Repository group no access')),
2304 2304 ('group.read', _('Repository group read access')),
2305 2305 ('group.write', _('Repository group write access')),
2306 2306 ('group.admin', _('Repository group admin access')),
2307 2307
2308 2308 ('usergroup.none', _('User group no access')),
2309 2309 ('usergroup.read', _('User group read access')),
2310 2310 ('usergroup.write', _('User group write access')),
2311 2311 ('usergroup.admin', _('User group admin access')),
2312 2312
2313 2313 ('hg.repogroup.create.false', _('Repository Group creation disabled')),
2314 2314 ('hg.repogroup.create.true', _('Repository Group creation enabled')),
2315 2315
2316 2316 ('hg.usergroup.create.false', _('User Group creation disabled')),
2317 2317 ('hg.usergroup.create.true', _('User Group creation enabled')),
2318 2318
2319 2319 ('hg.create.none', _('Repository creation disabled')),
2320 2320 ('hg.create.repository', _('Repository creation enabled')),
2321 2321 ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
2322 2322 ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
2323 2323
2324 2324 ('hg.fork.none', _('Repository forking disabled')),
2325 2325 ('hg.fork.repository', _('Repository forking enabled')),
2326 2326
2327 2327 ('hg.register.none', _('Registration disabled')),
2328 2328 ('hg.register.manual_activate', _('User Registration with manual account activation')),
2329 2329 ('hg.register.auto_activate', _('User Registration with automatic account activation')),
2330 2330
2331 2331 ('hg.password_reset.enabled', _('Password reset enabled')),
2332 2332 ('hg.password_reset.hidden', _('Password reset hidden')),
2333 2333 ('hg.password_reset.disabled', _('Password reset disabled')),
2334 2334
2335 2335 ('hg.extern_activate.manual', _('Manual activation of external account')),
2336 2336 ('hg.extern_activate.auto', _('Automatic activation of external account')),
2337 2337
2338 2338 ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
2339 2339 ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
2340 2340 ]
2341 2341
2342 2342 # definition of system default permissions for DEFAULT user
2343 2343 DEFAULT_USER_PERMISSIONS = [
2344 2344 'repository.read',
2345 2345 'group.read',
2346 2346 'usergroup.read',
2347 2347 'hg.create.repository',
2348 2348 'hg.repogroup.create.false',
2349 2349 'hg.usergroup.create.false',
2350 2350 'hg.create.write_on_repogroup.true',
2351 2351 'hg.fork.repository',
2352 2352 'hg.register.manual_activate',
2353 2353 'hg.password_reset.enabled',
2354 2354 'hg.extern_activate.auto',
2355 2355 'hg.inherit_default_perms.true',
2356 2356 ]
2357 2357
2358 2358 # defines which permissions are more important higher the more important
2359 2359 # Weight defines which permissions are more important.
2360 2360 # The higher number the more important.
2361 2361 PERM_WEIGHTS = {
2362 2362 'repository.none': 0,
2363 2363 'repository.read': 1,
2364 2364 'repository.write': 3,
2365 2365 'repository.admin': 4,
2366 2366
2367 2367 'group.none': 0,
2368 2368 'group.read': 1,
2369 2369 'group.write': 3,
2370 2370 'group.admin': 4,
2371 2371
2372 2372 'usergroup.none': 0,
2373 2373 'usergroup.read': 1,
2374 2374 'usergroup.write': 3,
2375 2375 'usergroup.admin': 4,
2376 2376
2377 2377 'hg.repogroup.create.false': 0,
2378 2378 'hg.repogroup.create.true': 1,
2379 2379
2380 2380 'hg.usergroup.create.false': 0,
2381 2381 'hg.usergroup.create.true': 1,
2382 2382
2383 2383 'hg.fork.none': 0,
2384 2384 'hg.fork.repository': 1,
2385 2385 'hg.create.none': 0,
2386 2386 'hg.create.repository': 1
2387 2387 }
2388 2388
2389 2389 permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2390 2390 permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
2391 2391 permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
2392 2392
2393 2393 def __unicode__(self):
2394 2394 return u"<%s('%s:%s')>" % (
2395 2395 self.__class__.__name__, self.permission_id, self.permission_name
2396 2396 )
2397 2397
2398 2398 @classmethod
2399 2399 def get_by_key(cls, key):
2400 2400 return cls.query().filter(cls.permission_name == key).scalar()
2401 2401
2402 2402 @classmethod
2403 2403 def get_default_repo_perms(cls, user_id, repo_id=None):
2404 2404 q = Session().query(UserRepoToPerm, Repository, Permission)\
2405 2405 .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
2406 2406 .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
2407 2407 .filter(UserRepoToPerm.user_id == user_id)
2408 2408 if repo_id:
2409 2409 q = q.filter(UserRepoToPerm.repository_id == repo_id)
2410 2410 return q.all()
2411 2411
2412 2412 @classmethod
2413 2413 def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
2414 2414 q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
2415 2415 .join(
2416 2416 Permission,
2417 2417 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
2418 2418 .join(
2419 2419 Repository,
2420 2420 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
2421 2421 .join(
2422 2422 UserGroup,
2423 2423 UserGroupRepoToPerm.users_group_id ==
2424 2424 UserGroup.users_group_id)\
2425 2425 .join(
2426 2426 UserGroupMember,
2427 2427 UserGroupRepoToPerm.users_group_id ==
2428 2428 UserGroupMember.users_group_id)\
2429 2429 .filter(
2430 2430 UserGroupMember.user_id == user_id,
2431 2431 UserGroup.users_group_active == true())
2432 2432 if repo_id:
2433 2433 q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
2434 2434 return q.all()
2435 2435
2436 2436 @classmethod
2437 2437 def get_default_group_perms(cls, user_id, repo_group_id=None):
2438 2438 q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
2439 2439 .join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\
2440 2440 .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\
2441 2441 .filter(UserRepoGroupToPerm.user_id == user_id)
2442 2442 if repo_group_id:
2443 2443 q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
2444 2444 return q.all()
2445 2445
2446 2446 @classmethod
2447 2447 def get_default_group_perms_from_user_group(
2448 2448 cls, user_id, repo_group_id=None):
2449 2449 q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
2450 2450 .join(
2451 2451 Permission,
2452 2452 UserGroupRepoGroupToPerm.permission_id ==
2453 2453 Permission.permission_id)\
2454 2454 .join(
2455 2455 RepoGroup,
2456 2456 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
2457 2457 .join(
2458 2458 UserGroup,
2459 2459 UserGroupRepoGroupToPerm.users_group_id ==
2460 2460 UserGroup.users_group_id)\
2461 2461 .join(
2462 2462 UserGroupMember,
2463 2463 UserGroupRepoGroupToPerm.users_group_id ==
2464 2464 UserGroupMember.users_group_id)\
2465 2465 .filter(
2466 2466 UserGroupMember.user_id == user_id,
2467 2467 UserGroup.users_group_active == true())
2468 2468 if repo_group_id:
2469 2469 q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
2470 2470 return q.all()
2471 2471
2472 2472 @classmethod
2473 2473 def get_default_user_group_perms(cls, user_id, user_group_id=None):
2474 2474 q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
2475 2475 .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
2476 2476 .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
2477 2477 .filter(UserUserGroupToPerm.user_id == user_id)
2478 2478 if user_group_id:
2479 2479 q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
2480 2480 return q.all()
2481 2481
2482 2482 @classmethod
2483 2483 def get_default_user_group_perms_from_user_group(
2484 2484 cls, user_id, user_group_id=None):
2485 2485 TargetUserGroup = aliased(UserGroup, name='target_user_group')
2486 2486 q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
2487 2487 .join(
2488 2488 Permission,
2489 2489 UserGroupUserGroupToPerm.permission_id ==
2490 2490 Permission.permission_id)\
2491 2491 .join(
2492 2492 TargetUserGroup,
2493 2493 UserGroupUserGroupToPerm.target_user_group_id ==
2494 2494 TargetUserGroup.users_group_id)\
2495 2495 .join(
2496 2496 UserGroup,
2497 2497 UserGroupUserGroupToPerm.user_group_id ==
2498 2498 UserGroup.users_group_id)\
2499 2499 .join(
2500 2500 UserGroupMember,
2501 2501 UserGroupUserGroupToPerm.user_group_id ==
2502 2502 UserGroupMember.users_group_id)\
2503 2503 .filter(
2504 2504 UserGroupMember.user_id == user_id,
2505 2505 UserGroup.users_group_active == true())
2506 2506 if user_group_id:
2507 2507 q = q.filter(
2508 2508 UserGroupUserGroupToPerm.user_group_id == user_group_id)
2509 2509
2510 2510 return q.all()
2511 2511
2512 2512
2513 2513 class UserRepoToPerm(Base, BaseModel):
2514 2514 __tablename__ = 'repo_to_perm'
2515 2515 __table_args__ = (
2516 2516 UniqueConstraint('user_id', 'repository_id', 'permission_id'),
2517 2517 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2518 2518 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2519 2519 )
2520 2520 repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2521 2521 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2522 2522 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2523 2523 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2524 2524
2525 2525 user = relationship('User')
2526 2526 repository = relationship('Repository')
2527 2527 permission = relationship('Permission')
2528 2528
2529 2529 @classmethod
2530 2530 def create(cls, user, repository, permission):
2531 2531 n = cls()
2532 2532 n.user = user
2533 2533 n.repository = repository
2534 2534 n.permission = permission
2535 2535 Session().add(n)
2536 2536 return n
2537 2537
2538 2538 def __unicode__(self):
2539 2539 return u'<%s => %s >' % (self.user, self.repository)
2540 2540
2541 2541
2542 2542 class UserUserGroupToPerm(Base, BaseModel):
2543 2543 __tablename__ = 'user_user_group_to_perm'
2544 2544 __table_args__ = (
2545 2545 UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
2546 2546 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2547 2547 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2548 2548 )
2549 2549 user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2550 2550 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2551 2551 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2552 2552 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2553 2553
2554 2554 user = relationship('User')
2555 2555 user_group = relationship('UserGroup')
2556 2556 permission = relationship('Permission')
2557 2557
2558 2558 @classmethod
2559 2559 def create(cls, user, user_group, permission):
2560 2560 n = cls()
2561 2561 n.user = user
2562 2562 n.user_group = user_group
2563 2563 n.permission = permission
2564 2564 Session().add(n)
2565 2565 return n
2566 2566
2567 2567 def __unicode__(self):
2568 2568 return u'<%s => %s >' % (self.user, self.user_group)
2569 2569
2570 2570
2571 2571 class UserToPerm(Base, BaseModel):
2572 2572 __tablename__ = 'user_to_perm'
2573 2573 __table_args__ = (
2574 2574 UniqueConstraint('user_id', 'permission_id'),
2575 2575 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2576 2576 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2577 2577 )
2578 2578 user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2579 2579 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2580 2580 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2581 2581
2582 2582 user = relationship('User')
2583 2583 permission = relationship('Permission', lazy='joined')
2584 2584
2585 2585 def __unicode__(self):
2586 2586 return u'<%s => %s >' % (self.user, self.permission)
2587 2587
2588 2588
2589 2589 class UserGroupRepoToPerm(Base, BaseModel):
2590 2590 __tablename__ = 'users_group_repo_to_perm'
2591 2591 __table_args__ = (
2592 2592 UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
2593 2593 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2594 2594 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2595 2595 )
2596 2596 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2597 2597 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2598 2598 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2599 2599 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2600 2600
2601 2601 users_group = relationship('UserGroup')
2602 2602 permission = relationship('Permission')
2603 2603 repository = relationship('Repository')
2604 2604
2605 2605 @classmethod
2606 2606 def create(cls, users_group, repository, permission):
2607 2607 n = cls()
2608 2608 n.users_group = users_group
2609 2609 n.repository = repository
2610 2610 n.permission = permission
2611 2611 Session().add(n)
2612 2612 return n
2613 2613
2614 2614 def __unicode__(self):
2615 2615 return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
2616 2616
2617 2617
2618 2618 class UserGroupUserGroupToPerm(Base, BaseModel):
2619 2619 __tablename__ = 'user_group_user_group_to_perm'
2620 2620 __table_args__ = (
2621 2621 UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
2622 2622 CheckConstraint('target_user_group_id != user_group_id'),
2623 2623 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2624 2624 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2625 2625 )
2626 2626 user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2627 2627 target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2628 2628 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2629 2629 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2630 2630
2631 2631 target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
2632 2632 user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
2633 2633 permission = relationship('Permission')
2634 2634
2635 2635 @classmethod
2636 2636 def create(cls, target_user_group, user_group, permission):
2637 2637 n = cls()
2638 2638 n.target_user_group = target_user_group
2639 2639 n.user_group = user_group
2640 2640 n.permission = permission
2641 2641 Session().add(n)
2642 2642 return n
2643 2643
2644 2644 def __unicode__(self):
2645 2645 return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
2646 2646
2647 2647
2648 2648 class UserGroupToPerm(Base, BaseModel):
2649 2649 __tablename__ = 'users_group_to_perm'
2650 2650 __table_args__ = (
2651 2651 UniqueConstraint('users_group_id', 'permission_id',),
2652 2652 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2653 2653 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2654 2654 )
2655 2655 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2656 2656 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2657 2657 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2658 2658
2659 2659 users_group = relationship('UserGroup')
2660 2660 permission = relationship('Permission')
2661 2661
2662 2662
2663 2663 class UserRepoGroupToPerm(Base, BaseModel):
2664 2664 __tablename__ = 'user_repo_group_to_perm'
2665 2665 __table_args__ = (
2666 2666 UniqueConstraint('user_id', 'group_id', 'permission_id'),
2667 2667 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2668 2668 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2669 2669 )
2670 2670
2671 2671 group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2672 2672 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2673 2673 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
2674 2674 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2675 2675
2676 2676 user = relationship('User')
2677 2677 group = relationship('RepoGroup')
2678 2678 permission = relationship('Permission')
2679 2679
2680 2680 @classmethod
2681 2681 def create(cls, user, repository_group, permission):
2682 2682 n = cls()
2683 2683 n.user = user
2684 2684 n.group = repository_group
2685 2685 n.permission = permission
2686 2686 Session().add(n)
2687 2687 return n
2688 2688
2689 2689
2690 2690 class UserGroupRepoGroupToPerm(Base, BaseModel):
2691 2691 __tablename__ = 'users_group_repo_group_to_perm'
2692 2692 __table_args__ = (
2693 2693 UniqueConstraint('users_group_id', 'group_id'),
2694 2694 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2695 2695 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2696 2696 )
2697 2697
2698 2698 users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2699 2699 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2700 2700 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
2701 2701 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2702 2702
2703 2703 users_group = relationship('UserGroup')
2704 2704 permission = relationship('Permission')
2705 2705 group = relationship('RepoGroup')
2706 2706
2707 2707 @classmethod
2708 2708 def create(cls, user_group, repository_group, permission):
2709 2709 n = cls()
2710 2710 n.users_group = user_group
2711 2711 n.group = repository_group
2712 2712 n.permission = permission
2713 2713 Session().add(n)
2714 2714 return n
2715 2715
2716 2716 def __unicode__(self):
2717 2717 return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
2718 2718
2719 2719
2720 2720 class Statistics(Base, BaseModel):
2721 2721 __tablename__ = 'statistics'
2722 2722 __table_args__ = (
2723 2723 UniqueConstraint('repository_id'),
2724 2724 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2725 2725 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2726 2726 )
2727 2727 stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2728 2728 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
2729 2729 stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
2730 2730 commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
2731 2731 commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
2732 2732 languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
2733 2733
2734 2734 repository = relationship('Repository', single_parent=True)
2735 2735
2736 2736
2737 2737 class UserFollowing(Base, BaseModel):
2738 2738 __tablename__ = 'user_followings'
2739 2739 __table_args__ = (
2740 2740 UniqueConstraint('user_id', 'follows_repository_id'),
2741 2741 UniqueConstraint('user_id', 'follows_user_id'),
2742 2742 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2743 2743 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2744 2744 )
2745 2745
2746 2746 user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2747 2747 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2748 2748 follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
2749 2749 follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
2750 2750 follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
2751 2751
2752 2752 user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
2753 2753
2754 2754 follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
2755 2755 follows_repository = relationship('Repository', order_by='Repository.repo_name')
2756 2756
2757 2757 @classmethod
2758 2758 def get_repo_followers(cls, repo_id):
2759 2759 return cls.query().filter(cls.follows_repo_id == repo_id)
2760 2760
2761 2761
2762 2762 class CacheKey(Base, BaseModel):
2763 2763 __tablename__ = 'cache_invalidation'
2764 2764 __table_args__ = (
2765 2765 UniqueConstraint('cache_key'),
2766 2766 Index('key_idx', 'cache_key'),
2767 2767 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2768 2768 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2769 2769 )
2770 2770 CACHE_TYPE_ATOM = 'ATOM'
2771 2771 CACHE_TYPE_RSS = 'RSS'
2772 2772 CACHE_TYPE_README = 'README'
2773 2773
2774 2774 cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2775 2775 cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
2776 2776 cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
2777 2777 cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
2778 2778
2779 2779 def __init__(self, cache_key, cache_args=''):
2780 2780 self.cache_key = cache_key
2781 2781 self.cache_args = cache_args
2782 2782 self.cache_active = False
2783 2783
2784 2784 def __unicode__(self):
2785 2785 return u"<%s('%s:%s[%s]')>" % (
2786 2786 self.__class__.__name__,
2787 2787 self.cache_id, self.cache_key, self.cache_active)
2788 2788
2789 2789 def _cache_key_partition(self):
2790 2790 prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
2791 2791 return prefix, repo_name, suffix
2792 2792
2793 2793 def get_prefix(self):
2794 2794 """
2795 2795 Try to extract prefix from existing cache key. The key could consist
2796 2796 of prefix, repo_name, suffix
2797 2797 """
2798 2798 # this returns prefix, repo_name, suffix
2799 2799 return self._cache_key_partition()[0]
2800 2800
2801 2801 def get_suffix(self):
2802 2802 """
2803 2803 get suffix that might have been used in _get_cache_key to
2804 2804 generate self.cache_key. Only used for informational purposes
2805 2805 in repo_edit.mako.
2806 2806 """
2807 2807 # prefix, repo_name, suffix
2808 2808 return self._cache_key_partition()[2]
2809 2809
2810 2810 @classmethod
2811 2811 def delete_all_cache(cls):
2812 2812 """
2813 2813 Delete all cache keys from database.
2814 2814 Should only be run when all instances are down and all entries
2815 2815 thus stale.
2816 2816 """
2817 2817 cls.query().delete()
2818 2818 Session().commit()
2819 2819
2820 2820 @classmethod
2821 2821 def get_cache_key(cls, repo_name, cache_type):
2822 2822 """
2823 2823
2824 2824 Generate a cache key for this process of RhodeCode instance.
2825 2825 Prefix most likely will be process id or maybe explicitly set
2826 2826 instance_id from .ini file.
2827 2827 """
2828 2828 import rhodecode
2829 2829 prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')
2830 2830
2831 2831 repo_as_unicode = safe_unicode(repo_name)
2832 2832 key = u'{}_{}'.format(repo_as_unicode, cache_type) \
2833 2833 if cache_type else repo_as_unicode
2834 2834
2835 2835 return u'{}{}'.format(prefix, key)
2836 2836
2837 2837 @classmethod
2838 2838 def set_invalidate(cls, repo_name, delete=False):
2839 2839 """
2840 2840 Mark all caches of a repo as invalid in the database.
2841 2841 """
2842 2842
2843 2843 try:
2844 2844 qry = Session().query(cls).filter(cls.cache_args == repo_name)
2845 2845 if delete:
2846 2846 log.debug('cache objects deleted for repo %s',
2847 2847 safe_str(repo_name))
2848 2848 qry.delete()
2849 2849 else:
2850 2850 log.debug('cache objects marked as invalid for repo %s',
2851 2851 safe_str(repo_name))
2852 2852 qry.update({"cache_active": False})
2853 2853
2854 2854 Session().commit()
2855 2855 except Exception:
2856 2856 log.exception(
2857 2857 'Cache key invalidation failed for repository %s',
2858 2858 safe_str(repo_name))
2859 2859 Session().rollback()
2860 2860
2861 2861 @classmethod
2862 2862 def get_active_cache(cls, cache_key):
2863 2863 inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
2864 2864 if inv_obj:
2865 2865 return inv_obj
2866 2866 return None
2867 2867
2868 2868 @classmethod
2869 2869 def repo_context_cache(cls, compute_func, repo_name, cache_type,
2870 2870 thread_scoped=False):
2871 2871 """
2872 2872 @cache_region('long_term')
2873 2873 def _heavy_calculation(cache_key):
2874 2874 return 'result'
2875 2875
2876 2876 cache_context = CacheKey.repo_context_cache(
2877 2877 _heavy_calculation, repo_name, cache_type)
2878 2878
2879 2879 with cache_context as context:
2880 2880 context.invalidate()
2881 2881 computed = context.compute()
2882 2882
2883 2883 assert computed == 'result'
2884 2884 """
2885 2885 from rhodecode.lib import caches
2886 2886 return caches.InvalidationContext(
2887 2887 compute_func, repo_name, cache_type, thread_scoped=thread_scoped)
2888 2888
2889 2889
2890 2890 class ChangesetComment(Base, BaseModel):
2891 2891 __tablename__ = 'changeset_comments'
2892 2892 __table_args__ = (
2893 2893 Index('cc_revision_idx', 'revision'),
2894 2894 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2895 2895 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2896 2896 )
2897 2897
2898 2898 COMMENT_OUTDATED = u'comment_outdated'
2899 2899
2900 2900 comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
2901 2901 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
2902 2902 revision = Column('revision', String(40), nullable=True)
2903 2903 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
2904 2904 pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
2905 2905 line_no = Column('line_no', Unicode(10), nullable=True)
2906 2906 hl_lines = Column('hl_lines', Unicode(512), nullable=True)
2907 2907 f_path = Column('f_path', Unicode(1000), nullable=True)
2908 2908 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
2909 2909 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
2910 2910 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2911 2911 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2912 2912 renderer = Column('renderer', Unicode(64), nullable=True)
2913 2913 display_state = Column('display_state', Unicode(128), nullable=True)
2914 2914
2915 2915 author = relationship('User', lazy='joined')
2916 2916 repo = relationship('Repository')
2917 2917 status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan")
2918 2918 pull_request = relationship('PullRequest', lazy='joined')
2919 2919 pull_request_version = relationship('PullRequestVersion')
2920 2920
2921 2921 @classmethod
2922 2922 def get_users(cls, revision=None, pull_request_id=None):
2923 2923 """
2924 2924 Returns user associated with this ChangesetComment. ie those
2925 2925 who actually commented
2926 2926
2927 2927 :param cls:
2928 2928 :param revision:
2929 2929 """
2930 2930 q = Session().query(User)\
2931 2931 .join(ChangesetComment.author)
2932 2932 if revision:
2933 2933 q = q.filter(cls.revision == revision)
2934 2934 elif pull_request_id:
2935 2935 q = q.filter(cls.pull_request_id == pull_request_id)
2936 2936 return q.all()
2937 2937
2938 @classmethod
2939 def get_index_from_version(cls, pr_version, versions):
2940 num_versions = [x.pull_request_version_id for x in versions]
2941 try:
2942 return num_versions.index(pr_version) +1
2943 except (IndexError, ValueError):
2944 return
2945
2938 2946 @property
2939 2947 def outdated(self):
2940 2948 return self.display_state == self.COMMENT_OUTDATED
2941 2949
2942 2950 def outdated_at_version(self, version):
2943 2951 """
2944 2952 Checks if comment is outdated for given pull request version
2945 2953 """
2946 2954 return self.outdated and self.pull_request_version_id != version
2947 2955
2956 def get_index_version(self, versions):
2957 return self.get_index_from_version(
2958 self.pull_request_version_id, versions)
2959
2948 2960 def render(self, mentions=False):
2949 2961 from rhodecode.lib import helpers as h
2950 2962 return h.render(self.text, renderer=self.renderer, mentions=mentions)
2951 2963
2952 2964 def __repr__(self):
2953 2965 if self.comment_id:
2954 2966 return '<DB:ChangesetComment #%s>' % self.comment_id
2955 2967 else:
2956 2968 return '<DB:ChangesetComment at %#x>' % id(self)
2957 2969
2958 2970
2959 2971 class ChangesetStatus(Base, BaseModel):
2960 2972 __tablename__ = 'changeset_statuses'
2961 2973 __table_args__ = (
2962 2974 Index('cs_revision_idx', 'revision'),
2963 2975 Index('cs_version_idx', 'version'),
2964 2976 UniqueConstraint('repo_id', 'revision', 'version'),
2965 2977 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2966 2978 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2967 2979 )
2968 2980 STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
2969 2981 STATUS_APPROVED = 'approved'
2970 2982 STATUS_REJECTED = 'rejected'
2971 2983 STATUS_UNDER_REVIEW = 'under_review'
2972 2984
2973 2985 STATUSES = [
2974 2986 (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default
2975 2987 (STATUS_APPROVED, _("Approved")),
2976 2988 (STATUS_REJECTED, _("Rejected")),
2977 2989 (STATUS_UNDER_REVIEW, _("Under Review")),
2978 2990 ]
2979 2991
2980 2992 changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
2981 2993 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
2982 2994 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
2983 2995 revision = Column('revision', String(40), nullable=False)
2984 2996 status = Column('status', String(128), nullable=False, default=DEFAULT)
2985 2997 changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
2986 2998 modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
2987 2999 version = Column('version', Integer(), nullable=False, default=0)
2988 3000 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
2989 3001
2990 3002 author = relationship('User', lazy='joined')
2991 3003 repo = relationship('Repository')
2992 3004 comment = relationship('ChangesetComment', lazy='joined')
2993 3005 pull_request = relationship('PullRequest', lazy='joined')
2994 3006
2995 3007 def __unicode__(self):
2996 3008 return u"<%s('%s[%s]:%s')>" % (
2997 3009 self.__class__.__name__,
2998 3010 self.status, self.version, self.author
2999 3011 )
3000 3012
3001 3013 @classmethod
3002 3014 def get_status_lbl(cls, value):
3003 3015 return dict(cls.STATUSES).get(value)
3004 3016
3005 3017 @property
3006 3018 def status_lbl(self):
3007 3019 return ChangesetStatus.get_status_lbl(self.status)
3008 3020
3009 3021
3010 3022 class _PullRequestBase(BaseModel):
3011 3023 """
3012 3024 Common attributes of pull request and version entries.
3013 3025 """
3014 3026
3015 3027 # .status values
3016 3028 STATUS_NEW = u'new'
3017 3029 STATUS_OPEN = u'open'
3018 3030 STATUS_CLOSED = u'closed'
3019 3031
3020 3032 title = Column('title', Unicode(255), nullable=True)
3021 3033 description = Column(
3022 3034 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
3023 3035 nullable=True)
3024 3036 # new/open/closed status of pull request (not approve/reject/etc)
3025 3037 status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
3026 3038 created_on = Column(
3027 3039 'created_on', DateTime(timezone=False), nullable=False,
3028 3040 default=datetime.datetime.now)
3029 3041 updated_on = Column(
3030 3042 'updated_on', DateTime(timezone=False), nullable=False,
3031 3043 default=datetime.datetime.now)
3032 3044
3033 3045 @declared_attr
3034 3046 def user_id(cls):
3035 3047 return Column(
3036 3048 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
3037 3049 unique=None)
3038 3050
3039 3051 # 500 revisions max
3040 3052 _revisions = Column(
3041 3053 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
3042 3054
3043 3055 @declared_attr
3044 3056 def source_repo_id(cls):
3045 3057 # TODO: dan: rename column to source_repo_id
3046 3058 return Column(
3047 3059 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3048 3060 nullable=False)
3049 3061
3050 3062 source_ref = Column('org_ref', Unicode(255), nullable=False)
3051 3063
3052 3064 @declared_attr
3053 3065 def target_repo_id(cls):
3054 3066 # TODO: dan: rename column to target_repo_id
3055 3067 return Column(
3056 3068 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3057 3069 nullable=False)
3058 3070
3059 3071 target_ref = Column('other_ref', Unicode(255), nullable=False)
3060 3072 _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
3061 3073
3062 3074 # TODO: dan: rename column to last_merge_source_rev
3063 3075 _last_merge_source_rev = Column(
3064 3076 'last_merge_org_rev', String(40), nullable=True)
3065 3077 # TODO: dan: rename column to last_merge_target_rev
3066 3078 _last_merge_target_rev = Column(
3067 3079 'last_merge_other_rev', String(40), nullable=True)
3068 3080 _last_merge_status = Column('merge_status', Integer(), nullable=True)
3069 3081 merge_rev = Column('merge_rev', String(40), nullable=True)
3070 3082
3071 3083 @hybrid_property
3072 3084 def revisions(self):
3073 3085 return self._revisions.split(':') if self._revisions else []
3074 3086
3075 3087 @revisions.setter
3076 3088 def revisions(self, val):
3077 3089 self._revisions = ':'.join(val)
3078 3090
3079 3091 @declared_attr
3080 3092 def author(cls):
3081 3093 return relationship('User', lazy='joined')
3082 3094
3083 3095 @declared_attr
3084 3096 def source_repo(cls):
3085 3097 return relationship(
3086 3098 'Repository',
3087 3099 primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
3088 3100
3089 3101 @property
3090 3102 def source_ref_parts(self):
3091 3103 return self.unicode_to_reference(self.source_ref)
3092 3104
3093 3105 @declared_attr
3094 3106 def target_repo(cls):
3095 3107 return relationship(
3096 3108 'Repository',
3097 3109 primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
3098 3110
3099 3111 @property
3100 3112 def target_ref_parts(self):
3101 3113 return self.unicode_to_reference(self.target_ref)
3102 3114
3103 3115 @property
3104 3116 def shadow_merge_ref(self):
3105 3117 return self.unicode_to_reference(self._shadow_merge_ref)
3106 3118
3107 3119 @shadow_merge_ref.setter
3108 3120 def shadow_merge_ref(self, ref):
3109 3121 self._shadow_merge_ref = self.reference_to_unicode(ref)
3110 3122
3111 3123 def unicode_to_reference(self, raw):
3112 3124 """
3113 3125 Convert a unicode (or string) to a reference object.
3114 3126 If unicode evaluates to False it returns None.
3115 3127 """
3116 3128 if raw:
3117 3129 refs = raw.split(':')
3118 3130 return Reference(*refs)
3119 3131 else:
3120 3132 return None
3121 3133
3122 3134 def reference_to_unicode(self, ref):
3123 3135 """
3124 3136 Convert a reference object to unicode.
3125 3137 If reference is None it returns None.
3126 3138 """
3127 3139 if ref:
3128 3140 return u':'.join(ref)
3129 3141 else:
3130 3142 return None
3131 3143
3132 3144 def get_api_data(self):
3133 3145 from rhodecode.model.pull_request import PullRequestModel
3134 3146 pull_request = self
3135 3147 merge_status = PullRequestModel().merge_status(pull_request)
3136 3148
3137 3149 pull_request_url = url(
3138 3150 'pullrequest_show', repo_name=self.target_repo.repo_name,
3139 3151 pull_request_id=self.pull_request_id, qualified=True)
3140 3152
3141 3153 merge_data = {
3142 3154 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
3143 3155 'reference': (
3144 3156 pull_request.shadow_merge_ref._asdict()
3145 3157 if pull_request.shadow_merge_ref else None),
3146 3158 }
3147 3159
3148 3160 data = {
3149 3161 'pull_request_id': pull_request.pull_request_id,
3150 3162 'url': pull_request_url,
3151 3163 'title': pull_request.title,
3152 3164 'description': pull_request.description,
3153 3165 'status': pull_request.status,
3154 3166 'created_on': pull_request.created_on,
3155 3167 'updated_on': pull_request.updated_on,
3156 3168 'commit_ids': pull_request.revisions,
3157 3169 'review_status': pull_request.calculated_review_status(),
3158 3170 'mergeable': {
3159 3171 'status': merge_status[0],
3160 3172 'message': unicode(merge_status[1]),
3161 3173 },
3162 3174 'source': {
3163 3175 'clone_url': pull_request.source_repo.clone_url(),
3164 3176 'repository': pull_request.source_repo.repo_name,
3165 3177 'reference': {
3166 3178 'name': pull_request.source_ref_parts.name,
3167 3179 'type': pull_request.source_ref_parts.type,
3168 3180 'commit_id': pull_request.source_ref_parts.commit_id,
3169 3181 },
3170 3182 },
3171 3183 'target': {
3172 3184 'clone_url': pull_request.target_repo.clone_url(),
3173 3185 'repository': pull_request.target_repo.repo_name,
3174 3186 'reference': {
3175 3187 'name': pull_request.target_ref_parts.name,
3176 3188 'type': pull_request.target_ref_parts.type,
3177 3189 'commit_id': pull_request.target_ref_parts.commit_id,
3178 3190 },
3179 3191 },
3180 3192 'merge': merge_data,
3181 3193 'author': pull_request.author.get_api_data(include_secrets=False,
3182 3194 details='basic'),
3183 3195 'reviewers': [
3184 3196 {
3185 3197 'user': reviewer.get_api_data(include_secrets=False,
3186 3198 details='basic'),
3187 3199 'reasons': reasons,
3188 3200 'review_status': st[0][1].status if st else 'not_reviewed',
3189 3201 }
3190 3202 for reviewer, reasons, st in pull_request.reviewers_statuses()
3191 3203 ]
3192 3204 }
3193 3205
3194 3206 return data
3195 3207
3196 3208
3197 3209 class PullRequest(Base, _PullRequestBase):
3198 3210 __tablename__ = 'pull_requests'
3199 3211 __table_args__ = (
3200 3212 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3201 3213 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3202 3214 )
3203 3215
3204 3216 pull_request_id = Column(
3205 3217 'pull_request_id', Integer(), nullable=False, primary_key=True)
3206 3218
3207 3219 def __repr__(self):
3208 3220 if self.pull_request_id:
3209 3221 return '<DB:PullRequest #%s>' % self.pull_request_id
3210 3222 else:
3211 3223 return '<DB:PullRequest at %#x>' % id(self)
3212 3224
3213 3225 reviewers = relationship('PullRequestReviewers',
3214 3226 cascade="all, delete, delete-orphan")
3215 3227 statuses = relationship('ChangesetStatus')
3216 3228 comments = relationship('ChangesetComment',
3217 3229 cascade="all, delete, delete-orphan")
3218 3230 versions = relationship('PullRequestVersion',
3219 3231 cascade="all, delete, delete-orphan",
3220 3232 lazy='dynamic')
3221 3233
3222 3234
3223 3235 @classmethod
3224 3236 def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,
3225 3237 internal_methods=None):
3226 3238
3227 3239 class PullRequestDisplay(object):
3228 3240 """
3229 3241 Special object wrapper for showing PullRequest data via Versions
3230 3242 It mimics PR object as close as possible. This is read only object
3231 3243 just for display
3232 3244 """
3233 3245
3234 3246 def __init__(self, attrs, internal=None):
3235 3247 self.attrs = attrs
3236 3248 # internal have priority over the given ones via attrs
3237 3249 self.internal = internal or ['versions']
3238 3250
3239 3251 def __getattr__(self, item):
3240 3252 if item in self.internal:
3241 3253 return getattr(self, item)
3242 3254 try:
3243 3255 return self.attrs[item]
3244 3256 except KeyError:
3245 3257 raise AttributeError(
3246 3258 '%s object has no attribute %s' % (self, item))
3247 3259
3248 3260 def __repr__(self):
3249 3261 return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')
3250 3262
3251 3263 def versions(self):
3252 3264 return pull_request_obj.versions.order_by(
3253 3265 PullRequestVersion.pull_request_version_id).all()
3254 3266
3255 3267 def is_closed(self):
3256 3268 return pull_request_obj.is_closed()
3257 3269
3258 3270 attrs = StrictAttributeDict(pull_request_obj.get_api_data())
3259 3271
3260 3272 attrs.author = StrictAttributeDict(
3261 3273 pull_request_obj.author.get_api_data())
3262 3274 if pull_request_obj.target_repo:
3263 3275 attrs.target_repo = StrictAttributeDict(
3264 3276 pull_request_obj.target_repo.get_api_data())
3265 3277 attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url
3266 3278
3267 3279 if pull_request_obj.source_repo:
3268 3280 attrs.source_repo = StrictAttributeDict(
3269 3281 pull_request_obj.source_repo.get_api_data())
3270 3282 attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url
3271 3283
3272 3284 attrs.source_ref_parts = pull_request_obj.source_ref_parts
3273 3285 attrs.target_ref_parts = pull_request_obj.target_ref_parts
3274 3286 attrs.revisions = pull_request_obj.revisions
3275 3287
3276 3288 attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref
3277 3289
3278 3290 return PullRequestDisplay(attrs, internal=internal_methods)
3279 3291
3280 3292 def is_closed(self):
3281 3293 return self.status == self.STATUS_CLOSED
3282 3294
3283 3295 def __json__(self):
3284 3296 return {
3285 3297 'revisions': self.revisions,
3286 3298 }
3287 3299
3288 3300 def calculated_review_status(self):
3289 3301 from rhodecode.model.changeset_status import ChangesetStatusModel
3290 3302 return ChangesetStatusModel().calculated_review_status(self)
3291 3303
3292 3304 def reviewers_statuses(self):
3293 3305 from rhodecode.model.changeset_status import ChangesetStatusModel
3294 3306 return ChangesetStatusModel().reviewers_statuses(self)
3295 3307
3296 3308
3297 3309 class PullRequestVersion(Base, _PullRequestBase):
3298 3310 __tablename__ = 'pull_request_versions'
3299 3311 __table_args__ = (
3300 3312 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3301 3313 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3302 3314 )
3303 3315
3304 3316 pull_request_version_id = Column(
3305 3317 'pull_request_version_id', Integer(), nullable=False, primary_key=True)
3306 3318 pull_request_id = Column(
3307 3319 'pull_request_id', Integer(),
3308 3320 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3309 3321 pull_request = relationship('PullRequest')
3310 3322
3311 3323 def __repr__(self):
3312 3324 if self.pull_request_version_id:
3313 3325 return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
3314 3326 else:
3315 3327 return '<DB:PullRequestVersion at %#x>' % id(self)
3316 3328
3317 3329 @property
3318 3330 def reviewers(self):
3319 3331 return self.pull_request.reviewers
3320 3332
3321 3333 @property
3322 3334 def versions(self):
3323 3335 return self.pull_request.versions
3324 3336
3325 3337 def is_closed(self):
3326 3338 # calculate from original
3327 3339 return self.pull_request.status == self.STATUS_CLOSED
3328 3340
3329 3341 def calculated_review_status(self):
3330 3342 return self.pull_request.calculated_review_status()
3331 3343
3332 3344 def reviewers_statuses(self):
3333 3345 return self.pull_request.reviewers_statuses()
3334 3346
3335 3347
3336 3348 class PullRequestReviewers(Base, BaseModel):
3337 3349 __tablename__ = 'pull_request_reviewers'
3338 3350 __table_args__ = (
3339 3351 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3340 3352 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3341 3353 )
3342 3354
3343 3355 def __init__(self, user=None, pull_request=None, reasons=None):
3344 3356 self.user = user
3345 3357 self.pull_request = pull_request
3346 3358 self.reasons = reasons or []
3347 3359
3348 3360 @hybrid_property
3349 3361 def reasons(self):
3350 3362 if not self._reasons:
3351 3363 return []
3352 3364 return self._reasons
3353 3365
3354 3366 @reasons.setter
3355 3367 def reasons(self, val):
3356 3368 val = val or []
3357 3369 if any(not isinstance(x, basestring) for x in val):
3358 3370 raise Exception('invalid reasons type, must be list of strings')
3359 3371 self._reasons = val
3360 3372
3361 3373 pull_requests_reviewers_id = Column(
3362 3374 'pull_requests_reviewers_id', Integer(), nullable=False,
3363 3375 primary_key=True)
3364 3376 pull_request_id = Column(
3365 3377 "pull_request_id", Integer(),
3366 3378 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3367 3379 user_id = Column(
3368 3380 "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
3369 3381 _reasons = Column(
3370 3382 'reason', MutationList.as_mutable(
3371 3383 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
3372 3384
3373 3385 user = relationship('User')
3374 3386 pull_request = relationship('PullRequest')
3375 3387
3376 3388
3377 3389 class Notification(Base, BaseModel):
3378 3390 __tablename__ = 'notifications'
3379 3391 __table_args__ = (
3380 3392 Index('notification_type_idx', 'type'),
3381 3393 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3382 3394 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3383 3395 )
3384 3396
3385 3397 TYPE_CHANGESET_COMMENT = u'cs_comment'
3386 3398 TYPE_MESSAGE = u'message'
3387 3399 TYPE_MENTION = u'mention'
3388 3400 TYPE_REGISTRATION = u'registration'
3389 3401 TYPE_PULL_REQUEST = u'pull_request'
3390 3402 TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
3391 3403
3392 3404 notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
3393 3405 subject = Column('subject', Unicode(512), nullable=True)
3394 3406 body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
3395 3407 created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
3396 3408 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3397 3409 type_ = Column('type', Unicode(255))
3398 3410
3399 3411 created_by_user = relationship('User')
3400 3412 notifications_to_users = relationship('UserNotification', lazy='joined',
3401 3413 cascade="all, delete, delete-orphan")
3402 3414
3403 3415 @property
3404 3416 def recipients(self):
3405 3417 return [x.user for x in UserNotification.query()\
3406 3418 .filter(UserNotification.notification == self)\
3407 3419 .order_by(UserNotification.user_id.asc()).all()]
3408 3420
3409 3421 @classmethod
3410 3422 def create(cls, created_by, subject, body, recipients, type_=None):
3411 3423 if type_ is None:
3412 3424 type_ = Notification.TYPE_MESSAGE
3413 3425
3414 3426 notification = cls()
3415 3427 notification.created_by_user = created_by
3416 3428 notification.subject = subject
3417 3429 notification.body = body
3418 3430 notification.type_ = type_
3419 3431 notification.created_on = datetime.datetime.now()
3420 3432
3421 3433 for u in recipients:
3422 3434 assoc = UserNotification()
3423 3435 assoc.notification = notification
3424 3436
3425 3437 # if created_by is inside recipients mark his notification
3426 3438 # as read
3427 3439 if u.user_id == created_by.user_id:
3428 3440 assoc.read = True
3429 3441
3430 3442 u.notifications.append(assoc)
3431 3443 Session().add(notification)
3432 3444
3433 3445 return notification
3434 3446
3435 3447 @property
3436 3448 def description(self):
3437 3449 from rhodecode.model.notification import NotificationModel
3438 3450 return NotificationModel().make_description(self)
3439 3451
3440 3452
3441 3453 class UserNotification(Base, BaseModel):
3442 3454 __tablename__ = 'user_to_notification'
3443 3455 __table_args__ = (
3444 3456 UniqueConstraint('user_id', 'notification_id'),
3445 3457 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3446 3458 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3447 3459 )
3448 3460 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
3449 3461 notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
3450 3462 read = Column('read', Boolean, default=False)
3451 3463 sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
3452 3464
3453 3465 user = relationship('User', lazy="joined")
3454 3466 notification = relationship('Notification', lazy="joined",
3455 3467 order_by=lambda: Notification.created_on.desc(),)
3456 3468
3457 3469 def mark_as_read(self):
3458 3470 self.read = True
3459 3471 Session().add(self)
3460 3472
3461 3473
3462 3474 class Gist(Base, BaseModel):
3463 3475 __tablename__ = 'gists'
3464 3476 __table_args__ = (
3465 3477 Index('g_gist_access_id_idx', 'gist_access_id'),
3466 3478 Index('g_created_on_idx', 'created_on'),
3467 3479 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3468 3480 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3469 3481 )
3470 3482 GIST_PUBLIC = u'public'
3471 3483 GIST_PRIVATE = u'private'
3472 3484 DEFAULT_FILENAME = u'gistfile1.txt'
3473 3485
3474 3486 ACL_LEVEL_PUBLIC = u'acl_public'
3475 3487 ACL_LEVEL_PRIVATE = u'acl_private'
3476 3488
3477 3489 gist_id = Column('gist_id', Integer(), primary_key=True)
3478 3490 gist_access_id = Column('gist_access_id', Unicode(250))
3479 3491 gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
3480 3492 gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
3481 3493 gist_expires = Column('gist_expires', Float(53), nullable=False)
3482 3494 gist_type = Column('gist_type', Unicode(128), nullable=False)
3483 3495 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3484 3496 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3485 3497 acl_level = Column('acl_level', Unicode(128), nullable=True)
3486 3498
3487 3499 owner = relationship('User')
3488 3500
3489 3501 def __repr__(self):
3490 3502 return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
3491 3503
3492 3504 @classmethod
3493 3505 def get_or_404(cls, id_):
3494 3506 res = cls.query().filter(cls.gist_access_id == id_).scalar()
3495 3507 if not res:
3496 3508 raise HTTPNotFound
3497 3509 return res
3498 3510
3499 3511 @classmethod
3500 3512 def get_by_access_id(cls, gist_access_id):
3501 3513 return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
3502 3514
3503 3515 def gist_url(self):
3504 3516 import rhodecode
3505 3517 alias_url = rhodecode.CONFIG.get('gist_alias_url')
3506 3518 if alias_url:
3507 3519 return alias_url.replace('{gistid}', self.gist_access_id)
3508 3520
3509 3521 return url('gist', gist_id=self.gist_access_id, qualified=True)
3510 3522
3511 3523 @classmethod
3512 3524 def base_path(cls):
3513 3525 """
3514 3526 Returns base path when all gists are stored
3515 3527
3516 3528 :param cls:
3517 3529 """
3518 3530 from rhodecode.model.gist import GIST_STORE_LOC
3519 3531 q = Session().query(RhodeCodeUi)\
3520 3532 .filter(RhodeCodeUi.ui_key == URL_SEP)
3521 3533 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
3522 3534 return os.path.join(q.one().ui_value, GIST_STORE_LOC)
3523 3535
3524 3536 def get_api_data(self):
3525 3537 """
3526 3538 Common function for generating gist related data for API
3527 3539 """
3528 3540 gist = self
3529 3541 data = {
3530 3542 'gist_id': gist.gist_id,
3531 3543 'type': gist.gist_type,
3532 3544 'access_id': gist.gist_access_id,
3533 3545 'description': gist.gist_description,
3534 3546 'url': gist.gist_url(),
3535 3547 'expires': gist.gist_expires,
3536 3548 'created_on': gist.created_on,
3537 3549 'modified_at': gist.modified_at,
3538 3550 'content': None,
3539 3551 'acl_level': gist.acl_level,
3540 3552 }
3541 3553 return data
3542 3554
3543 3555 def __json__(self):
3544 3556 data = dict(
3545 3557 )
3546 3558 data.update(self.get_api_data())
3547 3559 return data
3548 3560 # SCM functions
3549 3561
3550 3562 def scm_instance(self, **kwargs):
3551 3563 full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
3552 3564 return get_vcs_instance(
3553 3565 repo_path=safe_str(full_repo_path), create=False)
3554 3566
3555 3567
3556 3568 class DbMigrateVersion(Base, BaseModel):
3557 3569 __tablename__ = 'db_migrate_version'
3558 3570 __table_args__ = (
3559 3571 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3560 3572 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3561 3573 )
3562 3574 repository_id = Column('repository_id', String(250), primary_key=True)
3563 3575 repository_path = Column('repository_path', Text)
3564 3576 version = Column('version', Integer)
3565 3577
3566 3578
3567 3579 class ExternalIdentity(Base, BaseModel):
3568 3580 __tablename__ = 'external_identities'
3569 3581 __table_args__ = (
3570 3582 Index('local_user_id_idx', 'local_user_id'),
3571 3583 Index('external_id_idx', 'external_id'),
3572 3584 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3573 3585 'mysql_charset': 'utf8'})
3574 3586
3575 3587 external_id = Column('external_id', Unicode(255), default=u'',
3576 3588 primary_key=True)
3577 3589 external_username = Column('external_username', Unicode(1024), default=u'')
3578 3590 local_user_id = Column('local_user_id', Integer(),
3579 3591 ForeignKey('users.user_id'), primary_key=True)
3580 3592 provider_name = Column('provider_name', Unicode(255), default=u'',
3581 3593 primary_key=True)
3582 3594 access_token = Column('access_token', String(1024), default=u'')
3583 3595 alt_token = Column('alt_token', String(1024), default=u'')
3584 3596 token_secret = Column('token_secret', String(1024), default=u'')
3585 3597
3586 3598 @classmethod
3587 3599 def by_external_id_and_provider(cls, external_id, provider_name,
3588 3600 local_user_id=None):
3589 3601 """
3590 3602 Returns ExternalIdentity instance based on search params
3591 3603
3592 3604 :param external_id:
3593 3605 :param provider_name:
3594 3606 :return: ExternalIdentity
3595 3607 """
3596 3608 query = cls.query()
3597 3609 query = query.filter(cls.external_id == external_id)
3598 3610 query = query.filter(cls.provider_name == provider_name)
3599 3611 if local_user_id:
3600 3612 query = query.filter(cls.local_user_id == local_user_id)
3601 3613 return query.first()
3602 3614
3603 3615 @classmethod
3604 3616 def user_by_external_id_and_provider(cls, external_id, provider_name):
3605 3617 """
3606 3618 Returns User instance based on search params
3607 3619
3608 3620 :param external_id:
3609 3621 :param provider_name:
3610 3622 :return: User
3611 3623 """
3612 3624 query = User.query()
3613 3625 query = query.filter(cls.external_id == external_id)
3614 3626 query = query.filter(cls.provider_name == provider_name)
3615 3627 query = query.filter(User.user_id == cls.local_user_id)
3616 3628 return query.first()
3617 3629
3618 3630 @classmethod
3619 3631 def by_local_user_id(cls, local_user_id):
3620 3632 """
3621 3633 Returns all tokens for user
3622 3634
3623 3635 :param local_user_id:
3624 3636 :return: ExternalIdentity
3625 3637 """
3626 3638 query = cls.query()
3627 3639 query = query.filter(cls.local_user_id == local_user_id)
3628 3640 return query
3629 3641
3630 3642
3631 3643 class Integration(Base, BaseModel):
3632 3644 __tablename__ = 'integrations'
3633 3645 __table_args__ = (
3634 3646 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3635 3647 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3636 3648 )
3637 3649
3638 3650 integration_id = Column('integration_id', Integer(), primary_key=True)
3639 3651 integration_type = Column('integration_type', String(255))
3640 3652 enabled = Column('enabled', Boolean(), nullable=False)
3641 3653 name = Column('name', String(255), nullable=False)
3642 3654 child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
3643 3655 default=False)
3644 3656
3645 3657 settings = Column(
3646 3658 'settings_json', MutationObj.as_mutable(
3647 3659 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
3648 3660 repo_id = Column(
3649 3661 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
3650 3662 nullable=True, unique=None, default=None)
3651 3663 repo = relationship('Repository', lazy='joined')
3652 3664
3653 3665 repo_group_id = Column(
3654 3666 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
3655 3667 nullable=True, unique=None, default=None)
3656 3668 repo_group = relationship('RepoGroup', lazy='joined')
3657 3669
3658 3670 @property
3659 3671 def scope(self):
3660 3672 if self.repo:
3661 3673 return repr(self.repo)
3662 3674 if self.repo_group:
3663 3675 if self.child_repos_only:
3664 3676 return repr(self.repo_group) + ' (child repos only)'
3665 3677 else:
3666 3678 return repr(self.repo_group) + ' (recursive)'
3667 3679 if self.child_repos_only:
3668 3680 return 'root_repos'
3669 3681 return 'global'
3670 3682
3671 3683 def __repr__(self):
3672 3684 return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
3673 3685
3674 3686
3675 3687 class RepoReviewRuleUser(Base, BaseModel):
3676 3688 __tablename__ = 'repo_review_rules_users'
3677 3689 __table_args__ = (
3678 3690 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3679 3691 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3680 3692 )
3681 3693 repo_review_rule_user_id = Column(
3682 3694 'repo_review_rule_user_id', Integer(), primary_key=True)
3683 3695 repo_review_rule_id = Column("repo_review_rule_id",
3684 3696 Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
3685 3697 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'),
3686 3698 nullable=False)
3687 3699 user = relationship('User')
3688 3700
3689 3701
3690 3702 class RepoReviewRuleUserGroup(Base, BaseModel):
3691 3703 __tablename__ = 'repo_review_rules_users_groups'
3692 3704 __table_args__ = (
3693 3705 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3694 3706 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3695 3707 )
3696 3708 repo_review_rule_users_group_id = Column(
3697 3709 'repo_review_rule_users_group_id', Integer(), primary_key=True)
3698 3710 repo_review_rule_id = Column("repo_review_rule_id",
3699 3711 Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
3700 3712 users_group_id = Column("users_group_id", Integer(),
3701 3713 ForeignKey('users_groups.users_group_id'), nullable=False)
3702 3714 users_group = relationship('UserGroup')
3703 3715
3704 3716
3705 3717 class RepoReviewRule(Base, BaseModel):
3706 3718 __tablename__ = 'repo_review_rules'
3707 3719 __table_args__ = (
3708 3720 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3709 3721 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3710 3722 )
3711 3723
3712 3724 repo_review_rule_id = Column(
3713 3725 'repo_review_rule_id', Integer(), primary_key=True)
3714 3726 repo_id = Column(
3715 3727 "repo_id", Integer(), ForeignKey('repositories.repo_id'))
3716 3728 repo = relationship('Repository', backref='review_rules')
3717 3729
3718 3730 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
3719 3731 default=u'*') # glob
3720 3732 _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
3721 3733 default=u'*') # glob
3722 3734
3723 3735 use_authors_for_review = Column("use_authors_for_review", Boolean(),
3724 3736 nullable=False, default=False)
3725 3737 rule_users = relationship('RepoReviewRuleUser')
3726 3738 rule_user_groups = relationship('RepoReviewRuleUserGroup')
3727 3739
3728 3740 @hybrid_property
3729 3741 def branch_pattern(self):
3730 3742 return self._branch_pattern or '*'
3731 3743
3732 3744 def _validate_glob(self, value):
3733 3745 re.compile('^' + glob2re(value) + '$')
3734 3746
3735 3747 @branch_pattern.setter
3736 3748 def branch_pattern(self, value):
3737 3749 self._validate_glob(value)
3738 3750 self._branch_pattern = value or '*'
3739 3751
3740 3752 @hybrid_property
3741 3753 def file_pattern(self):
3742 3754 return self._file_pattern or '*'
3743 3755
3744 3756 @file_pattern.setter
3745 3757 def file_pattern(self, value):
3746 3758 self._validate_glob(value)
3747 3759 self._file_pattern = value or '*'
3748 3760
3749 3761 def matches(self, branch, files_changed):
3750 3762 """
3751 3763 Check if this review rule matches a branch/files in a pull request
3752 3764
3753 3765 :param branch: branch name for the commit
3754 3766 :param files_changed: list of file paths changed in the pull request
3755 3767 """
3756 3768
3757 3769 branch = branch or ''
3758 3770 files_changed = files_changed or []
3759 3771
3760 3772 branch_matches = True
3761 3773 if branch:
3762 3774 branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
3763 3775 branch_matches = bool(branch_regex.search(branch))
3764 3776
3765 3777 files_matches = True
3766 3778 if self.file_pattern != '*':
3767 3779 files_matches = False
3768 3780 file_regex = re.compile(glob2re(self.file_pattern))
3769 3781 for filename in files_changed:
3770 3782 if file_regex.search(filename):
3771 3783 files_matches = True
3772 3784 break
3773 3785
3774 3786 return branch_matches and files_matches
3775 3787
3776 3788 @property
3777 3789 def review_users(self):
3778 3790 """ Returns the users which this rule applies to """
3779 3791
3780 3792 users = set()
3781 3793 users |= set([
3782 3794 rule_user.user for rule_user in self.rule_users
3783 3795 if rule_user.user.active])
3784 3796 users |= set(
3785 3797 member.user
3786 3798 for rule_user_group in self.rule_user_groups
3787 3799 for member in rule_user_group.users_group.members
3788 3800 if member.user.active
3789 3801 )
3790 3802 return users
3791 3803
3792 3804 def __repr__(self):
3793 3805 return '<RepoReviewerRule(id=%r, repo=%r)>' % (
3794 3806 self.repo_review_rule_id, self.repo)
@@ -1,407 +1,432 b''
1 1 // comments.less
2 2 // For use in RhodeCode applications;
3 3 // see style guide documentation for guidelines.
4 4
5 5
6 6 // Comments
7 7 .comments {
8 8 width: 100%;
9 9 }
10 10
11 11 tr.inline-comments div {
12 12 max-width: 100%;
13 13
14 14 p {
15 15 white-space: normal;
16 16 }
17 17
18 18 code, pre, .code, dd {
19 19 overflow-x: auto;
20 20 width: 1062px;
21 21 }
22 22
23 23 dd {
24 24 width: auto;
25 25 }
26 26 }
27 27
28 28 #injected_page_comments {
29 29 .comment-previous-link,
30 30 .comment-next-link,
31 31 .comment-links-divider {
32 32 display: none;
33 33 }
34 34 }
35 35
36 36 .add-comment {
37 37 margin-bottom: 10px;
38 38 }
39 39 .hide-comment-button .add-comment {
40 40 display: none;
41 41 }
42 42
43 43 .comment-bubble {
44 44 color: @grey4;
45 45 margin-top: 4px;
46 46 margin-right: 30px;
47 47 visibility: hidden;
48 48 }
49 49
50 50 .comment {
51
52 &.comment-general {
53 border: 1px solid @grey5;
54 padding: 5px 5px 5px 5px;
55 }
56
51 57 margin: @padding 0;
52 58 padding: 4px 0 0 0;
53 59 line-height: 1em;
54 60
55 61 .rc-user {
56 62 min-width: 0;
57 63 margin: -2px .5em 0 0;
58 64 }
59 65
60 66 .meta {
61 67 position: relative;
62 68 width: 100%;
63 69 margin: 0 0 .5em 0;
70 border-bottom: 1px solid @grey5;
71 padding: 8px 0px;
64 72
65 73 &:hover .permalink {
66 74 visibility: visible;
67 75 color: @rcblue;
68 76 }
69 77 }
70 78
71 79 .author,
72 80 .date {
73 81 display: inline;
74 margin: 0 .5 0 0;
75 padding: 0 .5 0 0;
76 82
77 83 &:after {
78 84 content: ' | ';
79 85 color: @grey5;
80 86 }
81 87 }
82 88
89 .author-general img {
90 top: -3px;
91 }
92 .author-inline img {
93 top: -3px;
94 }
95
83 96 .status-change,
84 97 .permalink,
85 98 .changeset-status-lbl {
86 99 display: inline;
87 100 }
88 101
89 102 .permalink {
90 103 visibility: hidden;
91 104 }
92 105
93 106 .comment-links-divider {
94 107 display: inline;
95 108 }
96 109
97 110 .comment-links-block {
98 111 float:right;
99 112 text-align: right;
100 113 min-width: 85px;
101 114
102 115 [class^="icon-"]:before,
103 116 [class*=" icon-"]:before {
104 117 margin-left: 0;
105 118 margin-right: 0;
106 119 }
107 120 }
108 121
109 122 .comment-previous-link {
110 123 display: inline-block;
111 124
112 125 .arrow_comment_link{
113 126 cursor: pointer;
114 127 i {
115 128 font-size:10px;
116 129 }
117 130 }
118 131 .arrow_comment_link.disabled {
119 132 cursor: default;
120 133 color: @grey5;
121 134 }
122 135 }
123 136
124 137 .comment-next-link {
125 138 display: inline-block;
126 139
127 140 .arrow_comment_link{
128 141 cursor: pointer;
129 142 i {
130 143 font-size:10px;
131 144 }
132 145 }
133 146 .arrow_comment_link.disabled {
134 147 cursor: default;
135 148 color: @grey5;
136 149 }
137 150 }
138 151
139 152 .flag_status {
140 153 display: inline-block;
141 154 margin: -2px .5em 0 .25em
142 155 }
143 156
144 157 .delete-comment {
145 158 display: inline-block;
146 159 color: @rcblue;
147 160
148 161 &:hover {
149 162 cursor: pointer;
150 163 }
151 164 }
152 165
153 166
154 167 .text {
155 168 clear: both;
156 border: @border-thickness solid @grey5;
157 169 .border-radius(@border-radius);
158 170 .box-sizing(border-box);
159 171
160 172 .markdown-block p,
161 173 .rst-block p {
162 174 margin: .5em 0 !important;
163 175 // TODO: lisa: This is needed because of other rst !important rules :[
164 176 }
165 177 }
178
179 .pr-version {
180 float: left;
181 margin: 0px 4px;
182 }
183 .pr-version-inline {
184 float: left;
185 margin: 1px 4px;
186 }
187 .pr-version-num {
188 font-size: 10px;
189 }
190
166 191 }
167 192
168 193 .show-outdated-comments {
169 194 display: inline;
170 195 color: @rcblue;
171 196 }
172 197
173 198 // Comment Form
174 199 div.comment-form {
175 200 margin-top: 20px;
176 201 }
177 202
178 203 .comment-form strong {
179 204 display: block;
180 205 margin-bottom: 15px;
181 206 }
182 207
183 208 .comment-form textarea {
184 209 width: 100%;
185 210 height: 100px;
186 211 font-family: 'Monaco', 'Courier', 'Courier New', monospace;
187 212 }
188 213
189 214 form.comment-form {
190 215 margin-top: 10px;
191 216 margin-left: 10px;
192 217 }
193 218
194 219 .comment-inline-form .comment-block-ta,
195 220 .comment-form .comment-block-ta,
196 221 .comment-form .preview-box {
197 222 .border-radius(@border-radius);
198 223 .box-sizing(border-box);
199 224 background-color: white;
200 225 }
201 226
202 227 .comment-form-submit {
203 228 margin-top: 5px;
204 229 margin-left: 525px;
205 230 }
206 231
207 232 .file-comments {
208 233 display: none;
209 234 }
210 235
211 236 .comment-form .preview-box.unloaded,
212 237 .comment-inline-form .preview-box.unloaded {
213 238 height: 50px;
214 239 text-align: center;
215 240 padding: 20px;
216 241 background-color: white;
217 242 }
218 243
219 244 .comment-footer {
220 245 position: relative;
221 246 width: 100%;
222 247 min-height: 42px;
223 248
224 249 .status_box,
225 250 .cancel-button {
226 251 float: left;
227 252 display: inline-block;
228 253 }
229 254
230 255 .action-buttons {
231 256 float: right;
232 257 display: inline-block;
233 258 }
234 259 }
235 260
236 261 .comment-form {
237 262
238 263 .comment {
239 264 margin-left: 10px;
240 265 }
241 266
242 267 .comment-help {
243 268 color: @grey4;
244 269 padding: 5px 0 5px 0;
245 270 }
246 271
247 272 .comment-title {
248 273 padding: 5px 0 5px 0;
249 274 }
250 275
251 276 .comment-button {
252 277 display: inline-block;
253 278 }
254 279
255 280 .comment-button .comment-button-input {
256 281 margin-right: 0;
257 282 }
258 283
259 284 .comment-footer {
260 285 margin-bottom: 110px;
261 286 margin-top: 10px;
262 287 }
263 288 }
264 289
265 290
266 291 .comment-form-login {
267 292 .comment-help {
268 293 padding: 0.9em; //same as the button
269 294 }
270 295
271 296 div.clearfix {
272 297 clear: both;
273 298 width: 100%;
274 299 display: block;
275 300 }
276 301 }
277 302
278 303 .preview-box {
279 304 min-height: 105px;
280 305 margin-bottom: 15px;
281 306 background-color: white;
282 307 .border-radius(@border-radius);
283 308 .box-sizing(border-box);
284 309 }
285 310
286 311 .add-another-button {
287 312 margin-left: 10px;
288 313 margin-top: 10px;
289 314 margin-bottom: 10px;
290 315 }
291 316
292 317 .comment .buttons {
293 318 float: right;
294 319 margin: -1px 0px 0px 0px;
295 320 }
296 321
297 322 // Inline Comment Form
298 323 .injected_diff .comment-inline-form,
299 324 .comment-inline-form {
300 325 background-color: white;
301 326 margin-top: 10px;
302 327 margin-bottom: 20px;
303 328 }
304 329
305 330 .inline-form {
306 331 padding: 10px 7px;
307 332 }
308 333
309 334 .inline-form div {
310 335 max-width: 100%;
311 336 }
312 337
313 338 .overlay {
314 339 display: none;
315 340 position: absolute;
316 341 width: 100%;
317 342 text-align: center;
318 343 vertical-align: middle;
319 344 font-size: 16px;
320 345 background: none repeat scroll 0 0 white;
321 346
322 347 &.submitting {
323 348 display: block;
324 349 opacity: 0.5;
325 350 z-index: 100;
326 351 }
327 352 }
328 353 .comment-inline-form .overlay.submitting .overlay-text {
329 354 margin-top: 5%;
330 355 }
331 356
332 357 .comment-inline-form .clearfix,
333 358 .comment-form .clearfix {
334 359 .border-radius(@border-radius);
335 360 margin: 0px;
336 361 }
337 362
338 363 .comment-inline-form .comment-footer {
339 364 margin: 10px 0px 0px 0px;
340 365 }
341 366
342 367 .hide-inline-form-button {
343 368 margin-left: 5px;
344 369 }
345 370 .comment-button .hide-inline-form {
346 371 background: white;
347 372 }
348 373
349 374 .comment-area {
350 375 padding: 8px 12px;
351 376 border: 1px solid @grey5;
352 377 .border-radius(@border-radius);
353 378 }
354 379
355 380 .comment-area-header .nav-links {
356 381 display: flex;
357 382 flex-flow: row wrap;
358 383 -webkit-flex-flow: row wrap;
359 384 width: 100%;
360 385 }
361 386
362 387 .comment-area-footer {
363 388 display: flex;
364 389 }
365 390
366 391 .comment-footer .toolbar {
367 392
368 393 }
369 394
370 395 .nav-links {
371 396 padding: 0;
372 397 margin: 0;
373 398 list-style: none;
374 399 height: auto;
375 400 border-bottom: 1px solid @grey5;
376 401 }
377 402 .nav-links li {
378 403 display: inline-block;
379 404 }
380 405 .nav-links li:before {
381 406 content: "";
382 407 }
383 408 .nav-links li a.disabled {
384 409 cursor: not-allowed;
385 410 }
386 411
387 412 .nav-links li.active a {
388 413 border-bottom: 2px solid @rcblue;
389 414 color: #000;
390 415 font-weight: 600;
391 416 }
392 417 .nav-links li a {
393 418 display: inline-block;
394 419 padding: 0px 10px 5px 10px;
395 420 margin-bottom: -1px;
396 421 font-size: 14px;
397 422 line-height: 28px;
398 423 color: #8f8f8f;
399 424 border-bottom: 2px solid transparent;
400 425 }
401 426
402 427 .toolbar-text {
403 428 float: left;
404 429 margin: -5px 0px 0px 0px;
405 430 font-size: 12px;
406 431 }
407 432
@@ -1,4 +1,4 b''
1 1 ## this is a dummy html file for partial rendering on server and sending
2 2 ## generated output via ajax after comment submit
3 3 <%namespace name="comment" file="/changeset/changeset_file_comment.mako"/>
4 ${comment.comment_block(c.co, inline=True)}
4 ${comment.comment_block(c.co, inline=c.inline_comment)}
@@ -1,263 +1,297 b''
1 1 ## -*- coding: utf-8 -*-
2 2 ## usage:
3 3 ## <%namespace name="comment" file="/changeset/changeset_file_comment.mako"/>
4 4 ## ${comment.comment_block(comment)}
5 5 ##
6 6 <%namespace name="base" file="/base/base.mako"/>
7 7
8 8 <%def name="comment_block(comment, inline=False)">
9 9 <% outdated_at_ver = comment.outdated_at_version(getattr(c, 'at_version', None)) %>
10 <% pr_index_ver = comment.get_index_version(getattr(c, 'versions', [])) %>
10 11
11 12 <div class="comment
12 ${'comment-inline' if inline else ''}
13 ${'comment-inline' if inline else 'comment-general'}
13 14 ${'comment-outdated' if outdated_at_ver else 'comment-current'}"
14 15 id="comment-${comment.comment_id}"
15 16 line="${comment.line_no}"
16 17 data-comment-id="${comment.comment_id}"
17 18 style="${'display: none;' if outdated_at_ver else ''}">
18 19
19 20 <div class="meta">
20 <div class="author">
21 ${base.gravatar_with_user(comment.author.email, 16)}
21 <div class="author ${'author-inline' if inline else 'author-general'}">
22 ${base.gravatar_with_user(comment.author.email, 20)}
22 23 </div>
23 24 <div class="date">
24 25 ${h.age_component(comment.modified_at, time_is_local=True)}
25 26 </div>
27 % if inline:
28 <span></span>
29 % else:
26 30 <div class="status-change">
27 31 % if comment.pull_request:
28 % if comment.outdated:
29 <a href="?version=${comment.pull_request_version_id}#comment-${comment.comment_id}">
30 ${_('Outdated comment from pull request version {}').format(comment.pull_request_version_id)}
31 </a>
32 % else:
33 <a href="${h.url('pullrequest_show',repo_name=comment.pull_request.target_repo.repo_name,pull_request_id=comment.pull_request.pull_request_id)}">
34 %if comment.status_change:
35 ${_('Vote on pull request #%s') % comment.pull_request.pull_request_id}:
36 %else:
37 ${_('Comment on pull request #%s') % comment.pull_request.pull_request_id}
38 %endif
39 </a>
40 % endif
32 <a href="${h.url('pullrequest_show',repo_name=comment.pull_request.target_repo.repo_name,pull_request_id=comment.pull_request.pull_request_id)}">
33 % if comment.status_change:
34 ${_('Vote on pull request #%s') % comment.pull_request.pull_request_id}:
35 % else:
36 ${_('Comment on pull request #%s') % comment.pull_request.pull_request_id}
37 % endif
38 </a>
41 39 % else:
42 40 % if comment.status_change:
43 41 ${_('Status change on commit')}:
44 42 % else:
45 43 ${_('Comment on commit')}
46 44 % endif
47 45 % endif
48 46 </div>
49 %if comment.status_change:
47 % endif
48
49 % if comment.status_change:
50 50 <div class="${'flag_status %s' % comment.status_change[0].status}"></div>
51 51 <div title="${_('Commit status')}" class="changeset-status-lbl">
52 52 ${comment.status_change[0].status_lbl}
53 53 </div>
54 %endif
54 % endif
55
55 56 <a class="permalink" href="#comment-${comment.comment_id}"> &para;</a>
56 57
57 58 <div class="comment-links-block">
59
60 % if inline:
61 % if outdated_at_ver:
62 <div class="pr-version-inline">
63 <a href="${h.url.current(version=comment.pull_request_version_id, anchor='comment-{}'.format(comment.comment_id))}">
64 <code class="pr-version-num">
65 outdated ${'v{}'.format(pr_index_ver)}
66 </code>
67 </a>
68 </div>
69 |
70 % endif
71 % else:
72 % if comment.pull_request_version_id and pr_index_ver:
73 |
74 <div class="pr-version">
75 % if comment.outdated:
76 <a href="?version=${comment.pull_request_version_id}#comment-${comment.comment_id}">
77 ${_('Outdated comment from pull request version {}').format(pr_index_ver)}
78 </a>
79 % else:
80 <div class="tooltip" title="${_('Comment from pull request version {0}').format(pr_index_ver)}">
81 <a href="${h.url('pullrequest_show',repo_name=comment.pull_request.target_repo.repo_name,pull_request_id=comment.pull_request.pull_request_id, version=comment.pull_request_version_id)}">
82 <code class="pr-version-num">
83 ${'v{}'.format(pr_index_ver)}
84 </code>
85 </a>
86 </div>
87 % endif
88 </div>
89 % endif
90 % endif
91
58 92 ## show delete comment if it's not a PR (regular comments) or it's PR that is not closed
59 93 ## only super-admin, repo admin OR comment owner can delete, also hide delete if currently viewed comment is outdated
60 94 %if not outdated_at_ver and (not comment.pull_request or (comment.pull_request and not comment.pull_request.is_closed())):
61 95 ## permissions to delete
62 96 %if h.HasPermissionAny('hg.admin')() or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or comment.author.user_id == c.rhodecode_user.user_id:
63 97 ## TODO: dan: add edit comment here
64 98 <a onclick="return Rhodecode.comments.deleteComment(this);" class="delete-comment"> ${_('Delete')}</a>
65 99 %else:
66 100 <button class="btn-link" disabled="disabled"> ${_('Delete')}</button>
67 101 %endif
68 102 %else:
69 103 <button class="btn-link" disabled="disabled"> ${_('Delete')}</button>
70 104 %endif
71 105
72 106 %if not outdated_at_ver:
73 107 | <a onclick="return Rhodecode.comments.prevComment(this);" class="prev-comment"> ${_('Prev')}</a>
74 108 | <a onclick="return Rhodecode.comments.nextComment(this);" class="next-comment"> ${_('Next')}</a>
75 109 %endif
76 110
77 111 </div>
78 112 </div>
79 113 <div class="text">
80 114 ${comment.render(mentions=True)|n}
81 115 </div>
82 116
83 117 </div>
84 118 </%def>
85 119 ## generate main comments
86 120 <%def name="generate_comments(include_pull_request=False, is_pull_request=False)">
87 121 <div id="comments">
88 122 %for comment in c.comments:
89 123 <div id="comment-tr-${comment.comment_id}">
90 124 ## only render comments that are not from pull request, or from
91 125 ## pull request and a status change
92 126 %if not comment.pull_request or (comment.pull_request and comment.status_change) or include_pull_request:
93 127 ${comment_block(comment)}
94 128 %endif
95 129 </div>
96 130 %endfor
97 131 ## to anchor ajax comments
98 132 <div id="injected_page_comments"></div>
99 133 </div>
100 134 </%def>
101 135
102 136 ## MAIN COMMENT FORM
103 137 <%def name="comments(post_url, cur_status, is_pull_request=False, is_compare=False, change_status=True, form_extras=None)">
104 138
105 139 %if is_compare:
106 140 <% form_id = "comments_form_compare" %>
107 141 %else:
108 142 <% form_id = "comments_form" %>
109 143 %endif
110 144
111 145
112 146 %if is_pull_request:
113 147 <div class="pull-request-merge">
114 148 %if c.allowed_to_merge:
115 149 <div class="pull-request-wrap">
116 150 <div class="pull-right">
117 151 ${h.secure_form(url('pullrequest_merge', repo_name=c.repo_name, pull_request_id=c.pull_request.pull_request_id), id='merge_pull_request_form')}
118 152 <span data-role="merge-message">${c.pr_merge_msg} ${c.approval_msg if c.approval_msg else ''}</span>
119 153 <% merge_disabled = ' disabled' if c.pr_merge_status is False else '' %>
120 154 <input type="submit" id="merge_pull_request" value="${_('Merge Pull Request')}" class="btn${merge_disabled}"${merge_disabled}>
121 155 ${h.end_form()}
122 156 </div>
123 157 </div>
124 158 %else:
125 159 <div class="pull-request-wrap">
126 160 <div class="pull-right">
127 161 <span>${c.pr_merge_msg} ${c.approval_msg if c.approval_msg else ''}</span>
128 162 </div>
129 163 </div>
130 164 %endif
131 165 </div>
132 166 %endif
133 167 <div class="comments">
134 168 <%
135 169 if is_pull_request:
136 170 placeholder = _('Leave a comment on this Pull Request.')
137 171 elif is_compare:
138 172 placeholder = _('Leave a comment on all commits in this range.')
139 173 else:
140 174 placeholder = _('Leave a comment on this Commit.')
141 175 %>
142 176 % if c.rhodecode_user.username != h.DEFAULT_USER:
143 177 <div class="comment-form ac">
144 178 ${h.secure_form(post_url, id_=form_id)}
145 179 <div class="comment-area">
146 180 <div class="comment-area-header">
147 181 <ul class="nav-links clearfix">
148 182 <li class="active">
149 183 <a href="#edit-btn" tabindex="-1" id="edit-btn">${_('Write')}</a>
150 184 </li>
151 185 <li class="">
152 186 <a href="#preview-btn" tabindex="-1" id="preview-btn">${_('Preview')}</a>
153 187 </li>
154 188 </ul>
155 189 </div>
156 190
157 191 <div class="comment-area-write" style="display: block;">
158 192 <div id="edit-container">
159 193 <textarea id="text" name="text" class="comment-block-ta ac-input"></textarea>
160 194 </div>
161 195 <div id="preview-container" class="clearfix" style="display: none;">
162 196 <div id="preview-box" class="preview-box"></div>
163 197 </div>
164 198 </div>
165 199
166 200 <div class="comment-area-footer">
167 201 <div class="toolbar">
168 202 <div class="toolbar-text">
169 203 ${(_('Comments parsed using %s syntax with %s support.') % (
170 204 ('<a href="%s">%s</a>' % (h.url('%s_help' % c.visual.default_renderer), c.visual.default_renderer.upper())),
171 205 ('<span class="tooltip" title="%s">@mention</span>' % _('Use @username inside this text to send notification to this RhodeCode user'))
172 206 )
173 207 )|n}
174 208 </div>
175 209 </div>
176 210 </div>
177 211 </div>
178 212
179 213 <div id="comment_form_extras">
180 214 %if form_extras and isinstance(form_extras, (list, tuple)):
181 215 % for form_ex_el in form_extras:
182 216 ${form_ex_el|n}
183 217 % endfor
184 218 %endif
185 219 </div>
186 220 <div class="comment-footer">
187 221 %if change_status:
188 222 <div class="status_box">
189 223 <select id="change_status" name="changeset_status">
190 224 <option></option> # Placeholder
191 225 %for status,lbl in c.commit_statuses:
192 226 <option value="${status}" data-status="${status}">${lbl}</option>
193 227 %if is_pull_request and change_status and status in ('approved', 'rejected'):
194 228 <option value="${status}_closed" data-status="${status}">${lbl} & ${_('Closed')}</option>
195 229 %endif
196 230 %endfor
197 231 </select>
198 232 </div>
199 233 %endif
200 234 <div class="action-buttons">
201 235 <div class="comment-button">${h.submit('save', _('Comment'), class_="btn btn-success comment-button-input")}</div>
202 236 </div>
203 237 </div>
204 238 ${h.end_form()}
205 239 </div>
206 240 % else:
207 241 <div class="comment-form ac">
208 242
209 243 <div class="comment-area">
210 244 <div class="comment-area-header">
211 245 <ul class="nav-links clearfix">
212 246 <li class="active">
213 247 <a class="disabled" href="#edit-btn" disabled="disabled" onclick="return false">${_('Write')}</a>
214 248 </li>
215 249 <li class="">
216 250 <a class="disabled" href="#preview-btn" disabled="disabled" onclick="return false">${_('Preview')}</a>
217 251 </li>
218 252 </ul>
219 253 </div>
220 254
221 255 <div class="comment-area-write" style="display: block;">
222 256 <div id="edit-container">
223 257 <div style="padding: 40px 0">
224 258 ${_('You need to be logged in to leave comments.')}
225 259 <a href="${h.route_path('login', _query={'came_from': h.url.current()})}">${_('Login now')}</a>
226 260 </div>
227 261 </div>
228 262 <div id="preview-container" class="clearfix" style="display: none;">
229 263 <div id="preview-box" class="preview-box"></div>
230 264 </div>
231 265 </div>
232 266
233 267 <div class="comment-area-footer">
234 268 <div class="toolbar">
235 269 <div class="toolbar-text">
236 270 </div>
237 271 </div>
238 272 </div>
239 273 </div>
240 274
241 275 <div class="comment-footer">
242 276 </div>
243 277
244 278 </div>
245 279 % endif
246 280
247 281 </div>
248 282
249 283 <script>
250 284 // init active elements of commentForm
251 285 var commitId = templateContext.commit_data.commit_id;
252 286 var pullRequestId = templateContext.pull_request_data.pull_request_id;
253 287 var lineNo;
254 288
255 289 var mainCommentForm = new CommentForm(
256 290 "#${form_id}", commitId, pullRequestId, lineNo, true);
257 291
258 292 mainCommentForm.cm.setOption('placeholder', "${placeholder}");
259 293
260 294 mainCommentForm.initStatusChangeSelector();
261 295 bindToggleButtons();
262 296 </script>
263 297 </%def>
@@ -1,711 +1,711 b''
1 1 <%def name="diff_line_anchor(filename, line, type)"><%
2 2 return '%s_%s_%i' % (h.safeid(filename), type, line)
3 3 %></%def>
4 4
5 5 <%def name="action_class(action)">
6 6 <%
7 7 return {
8 8 '-': 'cb-deletion',
9 9 '+': 'cb-addition',
10 10 ' ': 'cb-context',
11 11 }.get(action, 'cb-empty')
12 12 %>
13 13 </%def>
14 14
15 15 <%def name="op_class(op_id)">
16 16 <%
17 17 return {
18 18 DEL_FILENODE: 'deletion', # file deleted
19 19 BIN_FILENODE: 'warning' # binary diff hidden
20 20 }.get(op_id, 'addition')
21 21 %>
22 22 </%def>
23 23
24 24 <%def name="link_for(**kw)">
25 25 <%
26 26 new_args = request.GET.mixed()
27 27 new_args.update(kw)
28 28 return h.url('', **new_args)
29 29 %>
30 30 </%def>
31 31
32 32 <%def name="render_diffset(diffset, commit=None,
33 33
34 34 # collapse all file diff entries when there are more than this amount of files in the diff
35 35 collapse_when_files_over=20,
36 36
37 37 # collapse lines in the diff when more than this amount of lines changed in the file diff
38 38 lines_changed_limit=500,
39 39
40 40 # add a ruler at to the output
41 41 ruler_at_chars=0,
42 42
43 43 # show inline comments
44 44 use_comments=False,
45 45
46 46 # disable new comments
47 47 disable_new_comments=False,
48 48
49 49 # special file-comments that were deleted in previous versions
50 50 # it's used for showing outdated comments for deleted files in a PR
51 51 deleted_files_comments=None
52 52
53 53 )">
54 54
55 55 %if use_comments:
56 56 <div id="cb-comments-inline-container-template" class="js-template">
57 57 ${inline_comments_container([])}
58 58 </div>
59 59 <div class="js-template" id="cb-comment-inline-form-template">
60 60 <div class="comment-inline-form ac">
61 61
62 62 %if c.rhodecode_user.username != h.DEFAULT_USER:
63 63 ${h.form('#', method='get')}
64 64 <div class="comment-area">
65 65 <div class="comment-area-header">
66 66 <ul class="nav-links clearfix">
67 67 <li class="active">
68 68 <a href="#edit-btn" tabindex="-1" id="edit-btn_{1}">${_('Write')}</a>
69 69 </li>
70 70 <li class="">
71 71 <a href="#preview-btn" tabindex="-1" id="preview-btn_{1}">${_('Preview')}</a>
72 72 </li>
73 73 </ul>
74 74 </div>
75 75
76 76 <div class="comment-area-write" style="display: block;">
77 77 <div id="edit-container_{1}">
78 78 <textarea id="text_{1}" name="text" class="comment-block-ta ac-input"></textarea>
79 79 </div>
80 80 <div id="preview-container_{1}" class="clearfix" style="display: none;">
81 81 <div id="preview-box_{1}" class="preview-box"></div>
82 82 </div>
83 83 </div>
84 84
85 85 <div class="comment-area-footer">
86 86 <div class="toolbar">
87 87 <div class="toolbar-text">
88 88 ${(_('Comments parsed using %s syntax with %s support.') % (
89 89 ('<a href="%s">%s</a>' % (h.url('%s_help' % c.visual.default_renderer), c.visual.default_renderer.upper())),
90 90 ('<span class="tooltip" title="%s">@mention</span>' % _('Use @username inside this text to send notification to this RhodeCode user'))
91 91 )
92 92 )|n}
93 93 </div>
94 94 </div>
95 95 </div>
96 96 </div>
97 97
98 98 <div class="comment-footer">
99 99 <div class="action-buttons">
100 100 <input type="hidden" name="f_path" value="{0}">
101 101 <input type="hidden" name="line" value="{1}">
102 102 <button type="button" class="cb-comment-cancel" onclick="return Rhodecode.comments.cancelComment(this);">
103 103 ${_('Cancel')}
104 104 </button>
105 105 ${h.submit('save', _('Comment'), class_='btn btn-success save-inline-form')}
106 106 </div>
107 107 ${h.end_form()}
108 108 </div>
109 109 %else:
110 110 ${h.form('', class_='inline-form comment-form-login', method='get')}
111 111 <div class="pull-left">
112 112 <div class="comment-help pull-right">
113 113 ${_('You need to be logged in to leave comments.')} <a href="${h.route_path('login', _query={'came_from': h.url.current()})}">${_('Login now')}</a>
114 114 </div>
115 115 </div>
116 116 <div class="comment-button pull-right">
117 117 <button type="button" class="cb-comment-cancel" onclick="return Rhodecode.comments.cancelComment(this);">
118 118 ${_('Cancel')}
119 119 </button>
120 120 </div>
121 121 <div class="clearfix"></div>
122 122 ${h.end_form()}
123 123 %endif
124 124 </div>
125 125 </div>
126 126
127 127 %endif
128 128 <%
129 129 collapse_all = len(diffset.files) > collapse_when_files_over
130 130 %>
131 131
132 132 %if c.diffmode == 'sideside':
133 133 <style>
134 134 .wrapper {
135 135 max-width: 1600px !important;
136 136 }
137 137 </style>
138 138 %endif
139 139
140 140 %if ruler_at_chars:
141 141 <style>
142 142 .diff table.cb .cb-content:after {
143 143 content: "";
144 144 border-left: 1px solid blue;
145 145 position: absolute;
146 146 top: 0;
147 147 height: 18px;
148 148 opacity: .2;
149 149 z-index: 10;
150 150 //## +5 to account for diff action (+/-)
151 151 left: ${ruler_at_chars + 5}ch;
152 152 </style>
153 153 %endif
154 154
155 155 <div class="diffset ${disable_new_comments and 'diffset-comments-disabled'}">
156 156 <div class="diffset-heading ${diffset.limited_diff and 'diffset-heading-warning' or ''}">
157 157 %if commit:
158 158 <div class="pull-right">
159 159 <a class="btn tooltip" title="${_('Browse Files at revision {}').format(commit.raw_id)}" href="${h.url('files_home',repo_name=diffset.repo_name, revision=commit.raw_id, f_path='')}">
160 160 ${_('Browse Files')}
161 161 </a>
162 162 </div>
163 163 %endif
164 164 <h2 class="clearinner">
165 165 %if commit:
166 166 <a class="tooltip revision" title="${h.tooltip(commit.message)}" href="${h.url('changeset_home',repo_name=c.repo_name,revision=commit.raw_id)}">${'r%s:%s' % (commit.revision,h.short_id(commit.raw_id))}</a> -
167 167 ${h.age_component(commit.date)} -
168 168 %endif
169 169 %if diffset.limited_diff:
170 170 ${_('The requested commit is too big and content was truncated.')}
171 171
172 172 ${ungettext('%(num)s file changed.', '%(num)s files changed.', diffset.changed_files) % {'num': diffset.changed_files}}
173 173 <a href="${link_for(fulldiff=1)}" onclick="return confirm('${_("Showing a big diff might take some time and resources, continue?")}')">${_('Show full diff')}</a>
174 174 %else:
175 175 ${ungettext('%(num)s file changed: %(linesadd)s inserted, ''%(linesdel)s deleted',
176 176 '%(num)s files changed: %(linesadd)s inserted, %(linesdel)s deleted', diffset.changed_files) % {'num': diffset.changed_files, 'linesadd': diffset.lines_added, 'linesdel': diffset.lines_deleted}}
177 177 %endif
178 178
179 <% at_ver = getattr(c, 'at_version_num', None) %>
179 <% at_ver = getattr(c, 'at_version_pos', None) %>
180 180 % if at_ver:
181 181 <div class="pull-right">
182 ${_('Changes at version %d') % at_ver}
182 ${_('Showing changes at version %d') % at_ver}
183 183 </div>
184 184 % endif
185 185
186 186 </h2>
187 187 </div>
188 188
189 189 %if not diffset.files:
190 190 <p class="empty_data">${_('No files')}</p>
191 191 %endif
192 192
193 193 <div class="filediffs">
194 194 %for i, filediff in enumerate(diffset.files):
195 195
196 196 <%
197 197 lines_changed = filediff['patch']['stats']['added'] + filediff['patch']['stats']['deleted']
198 198 over_lines_changed_limit = lines_changed > lines_changed_limit
199 199 %>
200 200 <input ${collapse_all and 'checked' or ''} class="filediff-collapse-state" id="filediff-collapse-${id(filediff)}" type="checkbox">
201 201 <div
202 202 class="filediff"
203 203 data-f-path="${filediff['patch']['filename']}"
204 204 id="a_${h.FID('', filediff['patch']['filename'])}">
205 205 <label for="filediff-collapse-${id(filediff)}" class="filediff-heading">
206 206 <div class="filediff-collapse-indicator"></div>
207 207 ${diff_ops(filediff)}
208 208 </label>
209 209 ${diff_menu(filediff, use_comments=use_comments)}
210 210 <table class="cb cb-diff-${c.diffmode} code-highlight ${over_lines_changed_limit and 'cb-collapsed' or ''}">
211 211 %if not filediff.hunks:
212 212 %for op_id, op_text in filediff['patch']['stats']['ops'].items():
213 213 <tr>
214 214 <td class="cb-text cb-${op_class(op_id)}" ${c.diffmode == 'unified' and 'colspan=4' or 'colspan=6'}>
215 215 %if op_id == DEL_FILENODE:
216 216 ${_('File was deleted')}
217 217 %elif op_id == BIN_FILENODE:
218 218 ${_('Binary file hidden')}
219 219 %else:
220 220 ${op_text}
221 221 %endif
222 222 </td>
223 223 </tr>
224 224 %endfor
225 225 %endif
226 226 %if filediff.patch['is_limited_diff']:
227 227 <tr class="cb-warning cb-collapser">
228 228 <td class="cb-text" ${c.diffmode == 'unified' and 'colspan=4' or 'colspan=6'}>
229 229 ${_('The requested commit is too big and content was truncated.')} <a href="${link_for(fulldiff=1)}" onclick="return confirm('${_("Showing a big diff might take some time and resources, continue?")}')">${_('Show full diff')}</a>
230 230 </td>
231 231 </tr>
232 232 %else:
233 233 %if over_lines_changed_limit:
234 234 <tr class="cb-warning cb-collapser">
235 235 <td class="cb-text" ${c.diffmode == 'unified' and 'colspan=4' or 'colspan=6'}>
236 236 ${_('This diff has been collapsed as it changes many lines, (%i lines changed)' % lines_changed)}
237 237 <a href="#" class="cb-expand"
238 238 onclick="$(this).closest('table').removeClass('cb-collapsed'); return false;">${_('Show them')}
239 239 </a>
240 240 <a href="#" class="cb-collapse"
241 241 onclick="$(this).closest('table').addClass('cb-collapsed'); return false;">${_('Hide them')}
242 242 </a>
243 243 </td>
244 244 </tr>
245 245 %endif
246 246 %endif
247 247
248 248 %for hunk in filediff.hunks:
249 249 <tr class="cb-hunk">
250 250 <td ${c.diffmode == 'unified' and 'colspan=3' or ''}>
251 251 ## TODO: dan: add ajax loading of more context here
252 252 ## <a href="#">
253 253 <i class="icon-more"></i>
254 254 ## </a>
255 255 </td>
256 256 <td ${c.diffmode == 'sideside' and 'colspan=5' or ''}>
257 257 @@
258 258 -${hunk.source_start},${hunk.source_length}
259 259 +${hunk.target_start},${hunk.target_length}
260 260 ${hunk.section_header}
261 261 </td>
262 262 </tr>
263 263 %if c.diffmode == 'unified':
264 264 ${render_hunk_lines_unified(hunk, use_comments=use_comments)}
265 265 %elif c.diffmode == 'sideside':
266 266 ${render_hunk_lines_sideside(hunk, use_comments=use_comments)}
267 267 %else:
268 268 <tr class="cb-line">
269 269 <td>unknown diff mode</td>
270 270 </tr>
271 271 %endif
272 272 %endfor
273 273
274 274 ## outdated comments that do not fit into currently displayed lines
275 275 % for lineno, comments in filediff.left_comments.items():
276 276
277 277 %if c.diffmode == 'unified':
278 278 <tr class="cb-line">
279 279 <td class="cb-data cb-context"></td>
280 280 <td class="cb-lineno cb-context"></td>
281 281 <td class="cb-lineno cb-context"></td>
282 282 <td class="cb-content cb-context">
283 283 ${inline_comments_container(comments)}
284 284 </td>
285 285 </tr>
286 286 %elif c.diffmode == 'sideside':
287 287 <tr class="cb-line">
288 288 <td class="cb-data cb-context"></td>
289 289 <td class="cb-lineno cb-context"></td>
290 290 <td class="cb-content cb-context"></td>
291 291
292 292 <td class="cb-data cb-context"></td>
293 293 <td class="cb-lineno cb-context"></td>
294 294 <td class="cb-content cb-context">
295 295 ${inline_comments_container(comments)}
296 296 </td>
297 297 </tr>
298 298 %endif
299 299
300 300 % endfor
301 301
302 302 </table>
303 303 </div>
304 304 %endfor
305 305
306 306 ## outdated comments that are made for a file that has been deleted
307 307 % for filename, comments_dict in (deleted_files_comments or {}).items():
308 308
309 309 <div class="filediffs filediff-outdated" style="display: none">
310 310 <input ${collapse_all and 'checked' or ''} class="filediff-collapse-state" id="filediff-collapse-${id(filename)}" type="checkbox">
311 311 <div class="filediff" data-f-path="${filename}" id="a_${h.FID('', filename)}">
312 312 <label for="filediff-collapse-${id(filename)}" class="filediff-heading">
313 313 <div class="filediff-collapse-indicator"></div>
314 314 <span class="pill">
315 315 ## file was deleted
316 316 <strong>${filename}</strong>
317 317 </span>
318 318 <span class="pill-group" style="float: left">
319 319 ## file op, doesn't need translation
320 320 <span class="pill" op="removed">removed in this version</span>
321 321 </span>
322 322 <a class="pill filediff-anchor" href="#a_${h.FID('', filename)}">ΒΆ</a>
323 323 <span class="pill-group" style="float: right">
324 324 <span class="pill" op="deleted">-${comments_dict['stats']}</span>
325 325 </span>
326 326 </label>
327 327
328 328 <table class="cb cb-diff-${c.diffmode} code-highlight ${over_lines_changed_limit and 'cb-collapsed' or ''}">
329 329 <tr>
330 330 % if c.diffmode == 'unified':
331 331 <td></td>
332 332 %endif
333 333
334 334 <td></td>
335 335 <td class="cb-text cb-${op_class(BIN_FILENODE)}" ${c.diffmode == 'unified' and 'colspan=4' or 'colspan=5'}>
336 336 ${_('File was deleted in this version, and outdated comments were made on it')}
337 337 </td>
338 338 </tr>
339 339 %if c.diffmode == 'unified':
340 340 <tr class="cb-line">
341 341 <td class="cb-data cb-context"></td>
342 342 <td class="cb-lineno cb-context"></td>
343 343 <td class="cb-lineno cb-context"></td>
344 344 <td class="cb-content cb-context">
345 345 ${inline_comments_container(comments_dict['comments'])}
346 346 </td>
347 347 </tr>
348 348 %elif c.diffmode == 'sideside':
349 349 <tr class="cb-line">
350 350 <td class="cb-data cb-context"></td>
351 351 <td class="cb-lineno cb-context"></td>
352 352 <td class="cb-content cb-context"></td>
353 353
354 354 <td class="cb-data cb-context"></td>
355 355 <td class="cb-lineno cb-context"></td>
356 356 <td class="cb-content cb-context">
357 357 ${inline_comments_container(comments_dict['comments'])}
358 358 </td>
359 359 </tr>
360 360 %endif
361 361 </table>
362 362 </div>
363 363 </div>
364 364 % endfor
365 365
366 366 </div>
367 367 </div>
368 368 </%def>
369 369
370 370 <%def name="diff_ops(filediff)">
371 371 <%
372 372 stats = filediff['patch']['stats']
373 373 from rhodecode.lib.diffs import NEW_FILENODE, DEL_FILENODE, \
374 374 MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE
375 375 %>
376 376 <span class="pill">
377 377 %if filediff.source_file_path and filediff.target_file_path:
378 378 %if filediff.source_file_path != filediff.target_file_path:
379 379 ## file was renamed
380 380 <strong>${filediff.target_file_path}</strong> β¬… <del>${filediff.source_file_path}</del>
381 381 %else:
382 382 ## file was modified
383 383 <strong>${filediff.source_file_path}</strong>
384 384 %endif
385 385 %else:
386 386 %if filediff.source_file_path:
387 387 ## file was deleted
388 388 <strong>${filediff.source_file_path}</strong>
389 389 %else:
390 390 ## file was added
391 391 <strong>${filediff.target_file_path}</strong>
392 392 %endif
393 393 %endif
394 394 </span>
395 395 <span class="pill-group" style="float: left">
396 396 %if filediff.patch['is_limited_diff']:
397 397 <span class="pill tooltip" op="limited" title="The stats for this diff are not complete">limited diff</span>
398 398 %endif
399 399 %if RENAMED_FILENODE in stats['ops']:
400 400 <span class="pill" op="renamed">renamed</span>
401 401 %endif
402 402
403 403 %if NEW_FILENODE in stats['ops']:
404 404 <span class="pill" op="created">created</span>
405 405 %if filediff['target_mode'].startswith('120'):
406 406 <span class="pill" op="symlink">symlink</span>
407 407 %else:
408 408 <span class="pill" op="mode">${nice_mode(filediff['target_mode'])}</span>
409 409 %endif
410 410 %endif
411 411
412 412 %if DEL_FILENODE in stats['ops']:
413 413 <span class="pill" op="removed">removed</span>
414 414 %endif
415 415
416 416 %if CHMOD_FILENODE in stats['ops']:
417 417 <span class="pill" op="mode">
418 418 ${nice_mode(filediff['source_mode'])} ➑ ${nice_mode(filediff['target_mode'])}
419 419 </span>
420 420 %endif
421 421 </span>
422 422
423 423 <a class="pill filediff-anchor" href="#a_${h.FID('', filediff.patch['filename'])}">ΒΆ</a>
424 424
425 425 <span class="pill-group" style="float: right">
426 426 %if BIN_FILENODE in stats['ops']:
427 427 <span class="pill" op="binary">binary</span>
428 428 %if MOD_FILENODE in stats['ops']:
429 429 <span class="pill" op="modified">modified</span>
430 430 %endif
431 431 %endif
432 432 %if stats['added']:
433 433 <span class="pill" op="added">+${stats['added']}</span>
434 434 %endif
435 435 %if stats['deleted']:
436 436 <span class="pill" op="deleted">-${stats['deleted']}</span>
437 437 %endif
438 438 </span>
439 439
440 440 </%def>
441 441
442 442 <%def name="nice_mode(filemode)">
443 443 ${filemode.startswith('100') and filemode[3:] or filemode}
444 444 </%def>
445 445
446 446 <%def name="diff_menu(filediff, use_comments=False)">
447 447 <div class="filediff-menu">
448 448 %if filediff.diffset.source_ref:
449 449 %if filediff.patch['operation'] in ['D', 'M']:
450 450 <a
451 451 class="tooltip"
452 452 href="${h.url('files_home',repo_name=filediff.diffset.repo_name,f_path=filediff.source_file_path,revision=filediff.diffset.source_ref)}"
453 453 title="${h.tooltip(_('Show file at commit: %(commit_id)s') % {'commit_id': filediff.diffset.source_ref[:12]})}"
454 454 >
455 455 ${_('Show file before')}
456 456 </a> |
457 457 %else:
458 458 <span
459 459 class="tooltip"
460 460 title="${h.tooltip(_('File no longer present at commit: %(commit_id)s') % {'commit_id': filediff.diffset.source_ref[:12]})}"
461 461 >
462 462 ${_('Show file before')}
463 463 </span> |
464 464 %endif
465 465 %if filediff.patch['operation'] in ['A', 'M']:
466 466 <a
467 467 class="tooltip"
468 468 href="${h.url('files_home',repo_name=filediff.diffset.source_repo_name,f_path=filediff.target_file_path,revision=filediff.diffset.target_ref)}"
469 469 title="${h.tooltip(_('Show file at commit: %(commit_id)s') % {'commit_id': filediff.diffset.target_ref[:12]})}"
470 470 >
471 471 ${_('Show file after')}
472 472 </a> |
473 473 %else:
474 474 <span
475 475 class="tooltip"
476 476 title="${h.tooltip(_('File no longer present at commit: %(commit_id)s') % {'commit_id': filediff.diffset.target_ref[:12]})}"
477 477 >
478 478 ${_('Show file after')}
479 479 </span> |
480 480 %endif
481 481 <a
482 482 class="tooltip"
483 483 title="${h.tooltip(_('Raw diff'))}"
484 484 href="${h.url('files_diff_home',repo_name=filediff.diffset.repo_name,f_path=filediff.target_file_path,diff2=filediff.diffset.target_ref,diff1=filediff.diffset.source_ref,diff='raw')}"
485 485 >
486 486 ${_('Raw diff')}
487 487 </a> |
488 488 <a
489 489 class="tooltip"
490 490 title="${h.tooltip(_('Download diff'))}"
491 491 href="${h.url('files_diff_home',repo_name=filediff.diffset.repo_name,f_path=filediff.target_file_path,diff2=filediff.diffset.target_ref,diff1=filediff.diffset.source_ref,diff='download')}"
492 492 >
493 493 ${_('Download diff')}
494 494 </a>
495 495 % if use_comments:
496 496 |
497 497 % endif
498 498
499 499 ## TODO: dan: refactor ignorews_url and context_url into the diff renderer same as diffmode=unified/sideside. Also use ajax to load more context (by clicking hunks)
500 500 %if hasattr(c, 'ignorews_url'):
501 501 ${c.ignorews_url(request.GET, h.FID('', filediff['patch']['filename']))}
502 502 %endif
503 503 %if hasattr(c, 'context_url'):
504 504 ${c.context_url(request.GET, h.FID('', filediff['patch']['filename']))}
505 505 %endif
506 506
507 507 %if use_comments:
508 508 <a href="#" onclick="return Rhodecode.comments.toggleComments(this);">
509 509 <span class="show-comment-button">${_('Show comments')}</span><span class="hide-comment-button">${_('Hide comments')}</span>
510 510 </a>
511 511 %endif
512 512 %endif
513 513 </div>
514 514 </%def>
515 515
516 516
517 517 <%namespace name="commentblock" file="/changeset/changeset_file_comment.mako"/>
518 518 <%def name="inline_comments_container(comments)">
519 519 <div class="inline-comments">
520 520 %for comment in comments:
521 521 ${commentblock.comment_block(comment, inline=True)}
522 522 %endfor
523 523
524 524 % if comments and comments[-1].outdated:
525 525 <span class="btn btn-secondary cb-comment-add-button comment-outdated}"
526 526 style="display: none;}">
527 527 ${_('Add another comment')}
528 528 </span>
529 529 % else:
530 530 <span onclick="return Rhodecode.comments.createComment(this)"
531 531 class="btn btn-secondary cb-comment-add-button">
532 532 ${_('Add another comment')}
533 533 </span>
534 534 % endif
535 535
536 536 </div>
537 537 </%def>
538 538
539 539
540 540 <%def name="render_hunk_lines_sideside(hunk, use_comments=False)">
541 541 %for i, line in enumerate(hunk.sideside):
542 542 <%
543 543 old_line_anchor, new_line_anchor = None, None
544 544 if line.original.lineno:
545 545 old_line_anchor = diff_line_anchor(hunk.filediff.source_file_path, line.original.lineno, 'o')
546 546 if line.modified.lineno:
547 547 new_line_anchor = diff_line_anchor(hunk.filediff.target_file_path, line.modified.lineno, 'n')
548 548 %>
549 549
550 550 <tr class="cb-line">
551 551 <td class="cb-data ${action_class(line.original.action)}"
552 552 data-line-number="${line.original.lineno}"
553 553 >
554 554 <div>
555 555 %if line.original.comments:
556 556 <i class="icon-comment" onclick="return Rhodecode.comments.toggleLineComments(this)"></i>
557 557 %endif
558 558 </div>
559 559 </td>
560 560 <td class="cb-lineno ${action_class(line.original.action)}"
561 561 data-line-number="${line.original.lineno}"
562 562 %if old_line_anchor:
563 563 id="${old_line_anchor}"
564 564 %endif
565 565 >
566 566 %if line.original.lineno:
567 567 <a name="${old_line_anchor}" href="#${old_line_anchor}">${line.original.lineno}</a>
568 568 %endif
569 569 </td>
570 570 <td class="cb-content ${action_class(line.original.action)}"
571 571 data-line-number="o${line.original.lineno}"
572 572 >
573 573 %if use_comments and line.original.lineno:
574 574 ${render_add_comment_button()}
575 575 %endif
576 576 <span class="cb-code">${line.original.action} ${line.original.content or '' | n}</span>
577 577 %if use_comments and line.original.lineno and line.original.comments:
578 578 ${inline_comments_container(line.original.comments)}
579 579 %endif
580 580 </td>
581 581 <td class="cb-data ${action_class(line.modified.action)}"
582 582 data-line-number="${line.modified.lineno}"
583 583 >
584 584 <div>
585 585 %if line.modified.comments:
586 586 <i class="icon-comment" onclick="return Rhodecode.comments.toggleLineComments(this)"></i>
587 587 %endif
588 588 </div>
589 589 </td>
590 590 <td class="cb-lineno ${action_class(line.modified.action)}"
591 591 data-line-number="${line.modified.lineno}"
592 592 %if new_line_anchor:
593 593 id="${new_line_anchor}"
594 594 %endif
595 595 >
596 596 %if line.modified.lineno:
597 597 <a name="${new_line_anchor}" href="#${new_line_anchor}">${line.modified.lineno}</a>
598 598 %endif
599 599 </td>
600 600 <td class="cb-content ${action_class(line.modified.action)}"
601 601 data-line-number="n${line.modified.lineno}"
602 602 >
603 603 %if use_comments and line.modified.lineno:
604 604 ${render_add_comment_button()}
605 605 %endif
606 606 <span class="cb-code">${line.modified.action} ${line.modified.content or '' | n}</span>
607 607 %if use_comments and line.modified.lineno and line.modified.comments:
608 608 ${inline_comments_container(line.modified.comments)}
609 609 %endif
610 610 </td>
611 611 </tr>
612 612 %endfor
613 613 </%def>
614 614
615 615
616 616 <%def name="render_hunk_lines_unified(hunk, use_comments=False)">
617 617 %for old_line_no, new_line_no, action, content, comments in hunk.unified:
618 618 <%
619 619 old_line_anchor, new_line_anchor = None, None
620 620 if old_line_no:
621 621 old_line_anchor = diff_line_anchor(hunk.filediff.source_file_path, old_line_no, 'o')
622 622 if new_line_no:
623 623 new_line_anchor = diff_line_anchor(hunk.filediff.target_file_path, new_line_no, 'n')
624 624 %>
625 625 <tr class="cb-line">
626 626 <td class="cb-data ${action_class(action)}">
627 627 <div>
628 628 %if comments:
629 629 <i class="icon-comment" onclick="return Rhodecode.comments.toggleLineComments(this)"></i>
630 630 %endif
631 631 </div>
632 632 </td>
633 633 <td class="cb-lineno ${action_class(action)}"
634 634 data-line-number="${old_line_no}"
635 635 %if old_line_anchor:
636 636 id="${old_line_anchor}"
637 637 %endif
638 638 >
639 639 %if old_line_anchor:
640 640 <a name="${old_line_anchor}" href="#${old_line_anchor}">${old_line_no}</a>
641 641 %endif
642 642 </td>
643 643 <td class="cb-lineno ${action_class(action)}"
644 644 data-line-number="${new_line_no}"
645 645 %if new_line_anchor:
646 646 id="${new_line_anchor}"
647 647 %endif
648 648 >
649 649 %if new_line_anchor:
650 650 <a name="${new_line_anchor}" href="#${new_line_anchor}">${new_line_no}</a>
651 651 %endif
652 652 </td>
653 653 <td class="cb-content ${action_class(action)}"
654 654 data-line-number="${new_line_no and 'n' or 'o'}${new_line_no or old_line_no}"
655 655 >
656 656 %if use_comments:
657 657 ${render_add_comment_button()}
658 658 %endif
659 659 <span class="cb-code">${action} ${content or '' | n}</span>
660 660 %if use_comments and comments:
661 661 ${inline_comments_container(comments)}
662 662 %endif
663 663 </td>
664 664 </tr>
665 665 %endfor
666 666 </%def>
667 667
668 668 <%def name="render_add_comment_button()">
669 669 <button class="btn btn-small btn-primary cb-comment-box-opener" onclick="return Rhodecode.comments.createComment(this)">
670 670 <span><i class="icon-comment"></i></span>
671 671 </button>
672 672 </%def>
673 673
674 674 <%def name="render_diffset_menu()">
675 675
676 676 <div class="diffset-menu clearinner">
677 677 <div class="pull-right">
678 678 <div class="btn-group">
679 679
680 680 <a
681 681 class="btn ${c.diffmode == 'sideside' and 'btn-primary'} tooltip"
682 682 title="${_('View side by side')}"
683 683 href="${h.url_replace(diffmode='sideside')}">
684 684 <span>${_('Side by Side')}</span>
685 685 </a>
686 686 <a
687 687 class="btn ${c.diffmode == 'unified' and 'btn-primary'} tooltip"
688 688 title="${_('View unified')}" href="${h.url_replace(diffmode='unified')}">
689 689 <span>${_('Unified')}</span>
690 690 </a>
691 691 </div>
692 692 </div>
693 693
694 694 <div class="pull-left">
695 695 <div class="btn-group">
696 696 <a
697 697 class="btn"
698 698 href="#"
699 699 onclick="$('input[class=filediff-collapse-state]').prop('checked', false); return false">${_('Expand All Files')}</a>
700 700 <a
701 701 class="btn"
702 702 href="#"
703 703 onclick="$('input[class=filediff-collapse-state]').prop('checked', true); return false">${_('Collapse All Files')}</a>
704 704 <a
705 705 class="btn"
706 706 href="#"
707 707 onclick="return Rhodecode.comments.toggleWideMode(this)">${_('Wide Mode Diff')}</a>
708 708 </div>
709 709 </div>
710 710 </div>
711 711 </%def>
@@ -1,638 +1,643 b''
1 1 <%inherit file="/base/base.mako"/>
2 2
3 3 <%def name="title()">
4 4 ${_('%s Pull Request #%s') % (c.repo_name, c.pull_request.pull_request_id)}
5 5 %if c.rhodecode_name:
6 6 &middot; ${h.branding(c.rhodecode_name)}
7 7 %endif
8 8 </%def>
9 9
10 10 <%def name="breadcrumbs_links()">
11 11 <span id="pr-title">
12 12 ${c.pull_request.title}
13 13 %if c.pull_request.is_closed():
14 14 (${_('Closed')})
15 15 %endif
16 16 </span>
17 17 <div id="pr-title-edit" class="input" style="display: none;">
18 18 ${h.text('pullrequest_title', id_="pr-title-input", class_="large", value=c.pull_request.title)}
19 19 </div>
20 20 </%def>
21 21
22 22 <%def name="menu_bar_nav()">
23 23 ${self.menu_items(active='repositories')}
24 24 </%def>
25 25
26 26 <%def name="menu_bar_subnav()">
27 27 ${self.repo_menu(active='showpullrequest')}
28 28 </%def>
29 29
30 30 <%def name="main()">
31 31
32 32 <script type="text/javascript">
33 33 // TODO: marcink switch this to pyroutes
34 34 AJAX_COMMENT_DELETE_URL = "${url('pullrequest_comment_delete',repo_name=c.repo_name,comment_id='__COMMENT_ID__')}";
35 35 templateContext.pull_request_data.pull_request_id = ${c.pull_request.pull_request_id};
36 36 </script>
37 37 <div class="box">
38 38 <div class="title">
39 39 ${self.repo_page_title(c.rhodecode_db_repo)}
40 40 </div>
41 41
42 42 ${self.breadcrumbs()}
43 43
44 44 <div class="box pr-summary">
45 45 <div class="summary-details block-left">
46 46 <% summary = lambda n:{False:'summary-short'}.get(n) %>
47 47 <div class="pr-details-title">
48 48 <a href="${h.url('pull_requests_global', pull_request_id=c.pull_request.pull_request_id)}">${_('Pull request #%s') % c.pull_request.pull_request_id}</a> ${_('From')} ${h.format_date(c.pull_request.created_on)}
49 49 %if c.allowed_to_update:
50 50 <div id="delete_pullrequest" class="pull-right action_button ${'' if c.allowed_to_delete else 'disabled' }" style="clear:inherit;padding: 0">
51 51 % if c.allowed_to_delete:
52 52 ${h.secure_form(url('pullrequest_delete', repo_name=c.pull_request.target_repo.repo_name, pull_request_id=c.pull_request.pull_request_id),method='delete')}
53 53 ${h.submit('remove_%s' % c.pull_request.pull_request_id, _('Delete'),
54 54 class_="btn btn-link btn-danger",onclick="return confirm('"+_('Confirm to delete this pull request')+"');")}
55 55 ${h.end_form()}
56 56 % else:
57 57 ${_('Delete')}
58 58 % endif
59 59 </div>
60 60 <div id="open_edit_pullrequest" class="pull-right action_button">${_('Edit')}</div>
61 61 <div id="close_edit_pullrequest" class="pull-right action_button" style="display: none;padding: 0">${_('Cancel')}</div>
62 62 %endif
63 63 </div>
64 64
65 65 <div id="summary" class="fields pr-details-content">
66 66 <div class="field">
67 67 <div class="label-summary">
68 68 <label>${_('Origin')}:</label>
69 69 </div>
70 70 <div class="input">
71 71 <div class="pr-origininfo">
72 72 ## branch link is only valid if it is a branch
73 73 <span class="tag">
74 74 %if c.pull_request.source_ref_parts.type == 'branch':
75 75 <a href="${h.url('changelog_home', repo_name=c.pull_request.source_repo.repo_name, branch=c.pull_request.source_ref_parts.name)}">${c.pull_request.source_ref_parts.type}: ${c.pull_request.source_ref_parts.name}</a>
76 76 %else:
77 77 ${c.pull_request.source_ref_parts.type}: ${c.pull_request.source_ref_parts.name}
78 78 %endif
79 79 </span>
80 80 <span class="clone-url">
81 81 <a href="${h.url('summary_home', repo_name=c.pull_request.source_repo.repo_name)}">${c.pull_request.source_repo.clone_url()}</a>
82 82 </span>
83 83 </div>
84 84 <div class="pr-pullinfo">
85 85 %if h.is_hg(c.pull_request.source_repo):
86 86 <input type="text" value="hg pull -r ${h.short_id(c.source_ref)} ${c.pull_request.source_repo.clone_url()}" readonly="readonly">
87 87 %elif h.is_git(c.pull_request.source_repo):
88 88 <input type="text" value="git pull ${c.pull_request.source_repo.clone_url()} ${c.pull_request.source_ref_parts.name}" readonly="readonly">
89 89 %endif
90 90 </div>
91 91 </div>
92 92 </div>
93 93 <div class="field">
94 94 <div class="label-summary">
95 95 <label>${_('Target')}:</label>
96 96 </div>
97 97 <div class="input">
98 98 <div class="pr-targetinfo">
99 99 ## branch link is only valid if it is a branch
100 100 <span class="tag">
101 101 %if c.pull_request.target_ref_parts.type == 'branch':
102 102 <a href="${h.url('changelog_home', repo_name=c.pull_request.target_repo.repo_name, branch=c.pull_request.target_ref_parts.name)}">${c.pull_request.target_ref_parts.type}: ${c.pull_request.target_ref_parts.name}</a>
103 103 %else:
104 104 ${c.pull_request.target_ref_parts.type}: ${c.pull_request.target_ref_parts.name}
105 105 %endif
106 106 </span>
107 107 <span class="clone-url">
108 108 <a href="${h.url('summary_home', repo_name=c.pull_request.target_repo.repo_name)}">${c.pull_request.target_repo.clone_url()}</a>
109 109 </span>
110 110 </div>
111 111 </div>
112 112 </div>
113 113
114 114 ## Link to the shadow repository.
115 115 <div class="field">
116 116 <div class="label-summary">
117 117 <label>${_('Merge')}:</label>
118 118 </div>
119 119 <div class="input">
120 120 % if not c.pull_request.is_closed() and c.pull_request.shadow_merge_ref:
121 121 <div class="pr-mergeinfo">
122 122 %if h.is_hg(c.pull_request.target_repo):
123 123 <input type="text" value="hg clone -u ${c.pull_request.shadow_merge_ref.name} ${c.shadow_clone_url} pull-request-${c.pull_request.pull_request_id}" readonly="readonly">
124 124 %elif h.is_git(c.pull_request.target_repo):
125 125 <input type="text" value="git clone --branch ${c.pull_request.shadow_merge_ref.name} ${c.shadow_clone_url} pull-request-${c.pull_request.pull_request_id}" readonly="readonly">
126 126 %endif
127 127 </div>
128 128 % else:
129 129 <div class="">
130 130 ${_('Shadow repository data not available')}.
131 131 </div>
132 132 % endif
133 133 </div>
134 134 </div>
135 135
136 136 <div class="field">
137 137 <div class="label-summary">
138 138 <label>${_('Review')}:</label>
139 139 </div>
140 140 <div class="input">
141 141 %if c.pull_request_review_status:
142 142 <div class="${'flag_status %s' % c.pull_request_review_status} tooltip pull-left"></div>
143 143 <span class="changeset-status-lbl tooltip">
144 144 %if c.pull_request.is_closed():
145 145 ${_('Closed')},
146 146 %endif
147 147 ${h.commit_status_lbl(c.pull_request_review_status)}
148 148 </span>
149 149 - ${ungettext('calculated based on %s reviewer vote', 'calculated based on %s reviewers votes', len(c.pull_request_reviewers)) % len(c.pull_request_reviewers)}
150 150 %endif
151 151 </div>
152 152 </div>
153 153 <div class="field">
154 154 <div class="pr-description-label label-summary">
155 155 <label>${_('Description')}:</label>
156 156 </div>
157 157 <div id="pr-desc" class="input">
158 158 <div class="pr-description">${h.urlify_commit_message(c.pull_request.description, c.repo_name)}</div>
159 159 </div>
160 160 <div id="pr-desc-edit" class="input textarea editor" style="display: none;">
161 161 <textarea id="pr-description-input" size="30">${c.pull_request.description}</textarea>
162 162 </div>
163 163 </div>
164 164
165 165 <div class="field">
166 166 <div class="label-summary">
167 167 <label>${_('Versions')} (${len(c.versions)+1}):</label>
168 168 </div>
169 169
170 170 <div class="pr-versions">
171 171 % if c.show_version_changes:
172 172 <table>
173 173 ## CURRENTLY SELECT PR VERSION
174 174 <tr class="version-pr" style="display: ${'' if c.at_version_num is None else 'none'}">
175 175 <td>
176 176 % if c.at_version in [None, 'latest']:
177 177 <i class="icon-ok link"></i>
178 178 % else:
179 179 <i class="icon-comment"></i> <code>${len(c.inline_versions[None])}</code>
180 180 % endif
181 181 </td>
182 182 <td>
183 183 <code>
184 184 % if c.versions:
185 185 <a href="${h.url.current(version='latest')}">${_('latest')}</a>
186 186 % else:
187 187 ${_('initial')}
188 188 % endif
189 189 </code>
190 190 </td>
191 191 <td>
192 192 <code>${c.pull_request_latest.source_ref_parts.commit_id[:6]}</code>
193 193 </td>
194 194 <td>
195 195 ${_('created')} ${h.age_component(c.pull_request_latest.updated_on)}
196 196 </td>
197 197 <td align="right">
198 198 % if c.versions and c.at_version_num in [None, 'latest']:
199 199 <span id="show-pr-versions" class="btn btn-link" onclick="$('.version-pr').show(); $(this).hide(); return false">${_('Show all versions')}</span>
200 200 % endif
201 201 </td>
202 202 </tr>
203 203
204 204 ## SHOW ALL VERSIONS OF PR
205 205 <% ver_pr = None %>
206 % for ver in reversed(c.pull_request.versions()):
206 % for data in reversed(list(enumerate(c.versions, 1))):
207 <% ver_pos = data[0] %>
208 <% ver = data[1] %>
207 209 <% ver_pr = ver.pull_request_version_id %>
210
208 211 <tr class="version-pr" style="display: ${'' if c.at_version == ver_pr else 'none'}">
209 212 <td>
210 213 % if c.at_version == ver_pr:
211 214 <i class="icon-ok link"></i>
212 215 % else:
213 216 <i class="icon-comment"></i> <code>${len(c.inline_versions[ver_pr])}</code>
214 217 % endif
215 218 </td>
216 219 <td>
217 <code><a href="${h.url.current(version=ver_pr)}">version ${ver_pr}</a></code>
220 <code class="tooltip" title="${_('Comment from pull request version {0}').format(ver_pos)}">
221 <a href="${h.url.current(version=ver_pr)}">v${ver_pos}</a>
222 </code>
218 223 </td>
219 224 <td>
220 225 <code>${ver.source_ref_parts.commit_id[:6]}</code>
221 226 </td>
222 227 <td>
223 228 ${_('created')} ${h.age_component(ver.updated_on)}
224 229 </td>
225 230 <td align="right">
226 231 % if c.at_version == ver_pr:
227 232 <span id="show-pr-versions" class="btn btn-link" onclick="$('.version-pr').show(); $(this).hide(); return false">${_('Show all versions')}</span>
228 233 % endif
229 234 </td>
230 235 </tr>
231 236 % endfor
232 237
233 238 ## show comment/inline comments summary
234 239 <tr>
235 240 <td>
236 241 </td>
237 242
238 243 <% inline_comm_count_ver = len(c.inline_versions[ver_pr])%>
239 244 <td colspan="4" style="border-top: 1px dashed #dbd9da">
240 245 ${_('Comments for this version')}:
241 246 %if c.comments:
242 247 <a href="#comments">${_("%d General ") % len(c.comments)}</a>
243 248 %else:
244 249 ${_("%d General ") % len(c.comments)}
245 250 %endif
246 251
247 252 <% inline_comm_count_ver = len(c.inline_versions[c.at_version_num])%>
248 253 %if inline_comm_count_ver:
249 254 , <a href="#" onclick="return Rhodecode.comments.nextComment();" id="inline-comments-counter">${_("%d Inline") % inline_comm_count_ver}</a>
250 255 %else:
251 256 , ${_("%d Inline") % inline_comm_count_ver}
252 257 %endif
253 258
254 259 %if c.outdated_cnt:
255 260 , <a href="#" onclick="showOutdated(); Rhodecode.comments.nextOutdatedComment(); return false;">${_("%d Outdated") % c.outdated_cnt}</a>
256 261 <a href="#" class="showOutdatedComments" onclick="showOutdated(this); return false;"> | ${_('show outdated comments')}</a>
257 262 <a href="#" class="hideOutdatedComments" style="display: none" onclick="hideOutdated(this); return false;"> | ${_('hide outdated comments')}</a>
258 263 %else:
259 264 , ${_("%d Outdated") % c.outdated_cnt}
260 265 %endif
261 266 </td>
262 267 </tr>
263 268
264 269 <tr>
265 270 <td></td>
266 271 <td colspan="4">
267 272 % if c.at_version:
268 273 <pre>
269 274 Changed commits:
270 275 * added: ${len(c.changes.added)}
271 276 * removed: ${len(c.changes.removed)}
272 277
273 278 % if not (c.file_changes.added+c.file_changes.modified+c.file_changes.removed):
274 279 No file changes found
275 280 % else:
276 281 Changed files:
277 282 %for file_name in c.file_changes.added:
278 283 * A <a href="#${'a_' + h.FID('', file_name)}">${file_name}</a>
279 284 %endfor
280 285 %for file_name in c.file_changes.modified:
281 286 * M <a href="#${'a_' + h.FID('', file_name)}">${file_name}</a>
282 287 %endfor
283 288 %for file_name in c.file_changes.removed:
284 289 * R ${file_name}
285 290 %endfor
286 291 % endif
287 292 </pre>
288 293 % endif
289 294 </td>
290 295 </tr>
291 296 </table>
292 297 % else:
293 298 ${_('Pull request versions not available')}.
294 299 % endif
295 300 </div>
296 301 </div>
297 302
298 303 <div id="pr-save" class="field" style="display: none;">
299 304 <div class="label-summary"></div>
300 305 <div class="input">
301 306 <span id="edit_pull_request" class="btn btn-small">${_('Save Changes')}</span>
302 307 </div>
303 308 </div>
304 309 </div>
305 310 </div>
306 311 <div>
307 312 ## AUTHOR
308 313 <div class="reviewers-title block-right">
309 314 <div class="pr-details-title">
310 315 ${_('Author')}
311 316 </div>
312 317 </div>
313 318 <div class="block-right pr-details-content reviewers">
314 319 <ul class="group_members">
315 320 <li>
316 321 ${self.gravatar_with_user(c.pull_request.author.email, 16)}
317 322 </li>
318 323 </ul>
319 324 </div>
320 325 ## REVIEWERS
321 326 <div class="reviewers-title block-right">
322 327 <div class="pr-details-title">
323 328 ${_('Pull request reviewers')}
324 329 %if c.allowed_to_update:
325 330 <span id="open_edit_reviewers" class="block-right action_button">${_('Edit')}</span>
326 331 <span id="close_edit_reviewers" class="block-right action_button" style="display: none;">${_('Close')}</span>
327 332 %endif
328 333 </div>
329 334 </div>
330 335 <div id="reviewers" class="block-right pr-details-content reviewers">
331 336 ## members goes here !
332 337 <input type="hidden" name="__start__" value="review_members:sequence">
333 338 <ul id="review_members" class="group_members">
334 339 %for member,reasons,status in c.pull_request_reviewers:
335 340 <li id="reviewer_${member.user_id}">
336 341 <div class="reviewers_member">
337 342 <div class="reviewer_status tooltip" title="${h.tooltip(h.commit_status_lbl(status[0][1].status if status else 'not_reviewed'))}">
338 343 <div class="${'flag_status %s' % (status[0][1].status if status else 'not_reviewed')} pull-left reviewer_member_status"></div>
339 344 </div>
340 345 <div id="reviewer_${member.user_id}_name" class="reviewer_name">
341 346 ${self.gravatar_with_user(member.email, 16)}
342 347 </div>
343 348 <input type="hidden" name="__start__" value="reviewer:mapping">
344 349 <input type="hidden" name="__start__" value="reasons:sequence">
345 350 %for reason in reasons:
346 351 <div class="reviewer_reason">- ${reason}</div>
347 352 <input type="hidden" name="reason" value="${reason}">
348 353
349 354 %endfor
350 355 <input type="hidden" name="__end__" value="reasons:sequence">
351 356 <input id="reviewer_${member.user_id}_input" type="hidden" value="${member.user_id}" name="user_id" />
352 357 <input type="hidden" name="__end__" value="reviewer:mapping">
353 358 %if c.allowed_to_update:
354 359 <div class="reviewer_member_remove action_button" onclick="removeReviewMember(${member.user_id}, true)" style="visibility: hidden;">
355 360 <i class="icon-remove-sign" ></i>
356 361 </div>
357 362 %endif
358 363 </div>
359 364 </li>
360 365 %endfor
361 366 </ul>
362 367 <input type="hidden" name="__end__" value="review_members:sequence">
363 368 %if not c.pull_request.is_closed():
364 369 <div id="add_reviewer_input" class='ac' style="display: none;">
365 370 %if c.allowed_to_update:
366 371 <div class="reviewer_ac">
367 372 ${h.text('user', class_='ac-input', placeholder=_('Add reviewer'))}
368 373 <div id="reviewers_container"></div>
369 374 </div>
370 375 <div>
371 376 <span id="update_pull_request" class="btn btn-small">${_('Save Changes')}</span>
372 377 </div>
373 378 %endif
374 379 </div>
375 380 %endif
376 381 </div>
377 382 </div>
378 383 </div>
379 384 <div class="box">
380 385 ##DIFF
381 386 <div class="table" >
382 387 <div id="changeset_compare_view_content">
383 388 ##CS
384 389 % if c.missing_requirements:
385 390 <div class="box">
386 391 <div class="alert alert-warning">
387 392 <div>
388 393 <strong>${_('Missing requirements:')}</strong>
389 394 ${_('These commits cannot be displayed, because this repository uses the Mercurial largefiles extension, which was not enabled.')}
390 395 </div>
391 396 </div>
392 397 </div>
393 398 % elif c.missing_commits:
394 399 <div class="box">
395 400 <div class="alert alert-warning">
396 401 <div>
397 402 <strong>${_('Missing commits')}:</strong>
398 403 ${_('This pull request cannot be displayed, because one or more commits no longer exist in the source repository.')}
399 404 ${_('Please update this pull request, push the commits back into the source repository, or consider closing this pull request.')}
400 405 </div>
401 406 </div>
402 407 </div>
403 408 % endif
404 409 <div class="compare_view_commits_title">
405 410
406 411 <div class="pull-left">
407 412 <div class="btn-group">
408 413 <a
409 414 class="btn"
410 415 href="#"
411 416 onclick="$('.compare_select').show();$('.compare_select_hidden').hide(); return false">
412 417 ${ungettext('Expand %s commit','Expand %s commits', len(c.commit_ranges)) % len(c.commit_ranges)}
413 418 </a>
414 419 <a
415 420 class="btn"
416 421 href="#"
417 422 onclick="$('.compare_select').hide();$('.compare_select_hidden').show(); return false">
418 423 ${ungettext('Collapse %s commit','Collapse %s commits', len(c.commit_ranges)) % len(c.commit_ranges)}
419 424 </a>
420 425 </div>
421 426 </div>
422 427
423 428 <div class="pull-right">
424 429 % if c.allowed_to_update and not c.pull_request.is_closed():
425 430 <a id="update_commits" class="btn btn-primary pull-right">${_('Update commits')}</a>
426 431 % else:
427 432 <a class="tooltip btn disabled pull-right" disabled="disabled" title="${_('Update is disabled for current view')}">${_('Update commits')}</a>
428 433 % endif
429 434
430 435 </div>
431 436
432 437 </div>
433 438 % if not c.missing_commits:
434 439 <%include file="/compare/compare_commits.mako" />
435 440 <div class="cs_files">
436 441 <%namespace name="cbdiffs" file="/codeblocks/diffs.mako"/>
437 442 ${cbdiffs.render_diffset_menu()}
438 443 ${cbdiffs.render_diffset(
439 444 c.diffset, use_comments=True,
440 445 collapse_when_files_over=30,
441 446 disable_new_comments=not c.allowed_to_comment,
442 447 deleted_files_comments=c.deleted_files_comments)}
443 448
444 449 </div>
445 450 % endif
446 451 </div>
447 452 </div>
448 453
449 454 ## template for inline comment form
450 455 <%namespace name="comment" file="/changeset/changeset_file_comment.mako"/>
451 456
452 457 ## render general comments
453 458 ${comment.generate_comments(include_pull_request=True, is_pull_request=True)}
454 459
455 460 % if not c.pull_request.is_closed():
456 461 ## main comment form and it status
457 462 ${comment.comments(h.url('pullrequest_comment', repo_name=c.repo_name,
458 463 pull_request_id=c.pull_request.pull_request_id),
459 464 c.pull_request_review_status,
460 465 is_pull_request=True, change_status=c.allowed_to_change_status)}
461 466 %endif
462 467
463 468 <script type="text/javascript">
464 469 if (location.hash) {
465 470 var result = splitDelimitedHash(location.hash);
466 471 var line = $('html').find(result.loc);
467 472 if (line.length > 0){
468 473 offsetScroll(line, 70);
469 474 }
470 475 }
471 476 $(function(){
472 477 ReviewerAutoComplete('user');
473 478 // custom code mirror
474 479 var codeMirrorInstance = initPullRequestsCodeMirror('#pr-description-input');
475 480
476 481 var PRDetails = {
477 482 editButton: $('#open_edit_pullrequest'),
478 483 closeButton: $('#close_edit_pullrequest'),
479 484 deleteButton: $('#delete_pullrequest'),
480 485 viewFields: $('#pr-desc, #pr-title'),
481 486 editFields: $('#pr-desc-edit, #pr-title-edit, #pr-save'),
482 487
483 488 init: function() {
484 489 var that = this;
485 490 this.editButton.on('click', function(e) { that.edit(); });
486 491 this.closeButton.on('click', function(e) { that.view(); });
487 492 },
488 493
489 494 edit: function(event) {
490 495 this.viewFields.hide();
491 496 this.editButton.hide();
492 497 this.deleteButton.hide();
493 498 this.closeButton.show();
494 499 this.editFields.show();
495 500 codeMirrorInstance.refresh();
496 501 },
497 502
498 503 view: function(event) {
499 504 this.editButton.show();
500 505 this.deleteButton.show();
501 506 this.editFields.hide();
502 507 this.closeButton.hide();
503 508 this.viewFields.show();
504 509 }
505 510 };
506 511
507 512 var ReviewersPanel = {
508 513 editButton: $('#open_edit_reviewers'),
509 514 closeButton: $('#close_edit_reviewers'),
510 515 addButton: $('#add_reviewer_input'),
511 516 removeButtons: $('.reviewer_member_remove'),
512 517
513 518 init: function() {
514 519 var that = this;
515 520 this.editButton.on('click', function(e) { that.edit(); });
516 521 this.closeButton.on('click', function(e) { that.close(); });
517 522 },
518 523
519 524 edit: function(event) {
520 525 this.editButton.hide();
521 526 this.closeButton.show();
522 527 this.addButton.show();
523 528 this.removeButtons.css('visibility', 'visible');
524 529 },
525 530
526 531 close: function(event) {
527 532 this.editButton.show();
528 533 this.closeButton.hide();
529 534 this.addButton.hide();
530 535 this.removeButtons.css('visibility', 'hidden');
531 536 }
532 537 };
533 538
534 539 PRDetails.init();
535 540 ReviewersPanel.init();
536 541
537 542 showOutdated = function(self){
538 543 $('.comment-outdated').show();
539 544 $('.filediff-outdated').show();
540 545 $('.showOutdatedComments').hide();
541 546 $('.hideOutdatedComments').show();
542 547
543 548 };
544 549
545 550 hideOutdated = function(self){
546 551 $('.comment-outdated').hide();
547 552 $('.filediff-outdated').hide();
548 553 $('.hideOutdatedComments').hide();
549 554 $('.showOutdatedComments').show();
550 555 };
551 556
552 557 $('#show-outdated-comments').on('click', function(e){
553 558 var button = $(this);
554 559 var outdated = $('.comment-outdated');
555 560
556 561 if (button.html() === "(Show)") {
557 562 button.html("(Hide)");
558 563 outdated.show();
559 564 } else {
560 565 button.html("(Show)");
561 566 outdated.hide();
562 567 }
563 568 });
564 569
565 570 $('.show-inline-comments').on('change', function(e){
566 571 var show = 'none';
567 572 var target = e.currentTarget;
568 573 if(target.checked){
569 574 show = ''
570 575 }
571 576 var boxid = $(target).attr('id_for');
572 577 var comments = $('#{0} .inline-comments'.format(boxid));
573 578 var fn_display = function(idx){
574 579 $(this).css('display', show);
575 580 };
576 581 $(comments).each(fn_display);
577 582 var btns = $('#{0} .inline-comments-button'.format(boxid));
578 583 $(btns).each(fn_display);
579 584 });
580 585
581 586 $('#merge_pull_request_form').submit(function() {
582 587 if (!$('#merge_pull_request').attr('disabled')) {
583 588 $('#merge_pull_request').attr('disabled', 'disabled');
584 589 }
585 590 return true;
586 591 });
587 592
588 593 $('#edit_pull_request').on('click', function(e){
589 594 var title = $('#pr-title-input').val();
590 595 var description = codeMirrorInstance.getValue();
591 596 editPullRequest(
592 597 "${c.repo_name}", "${c.pull_request.pull_request_id}",
593 598 title, description);
594 599 });
595 600
596 601 $('#update_pull_request').on('click', function(e){
597 602 updateReviewers(undefined, "${c.repo_name}", "${c.pull_request.pull_request_id}");
598 603 });
599 604
600 605 $('#update_commits').on('click', function(e){
601 606 var isDisabled = !$(e.currentTarget).attr('disabled');
602 607 $(e.currentTarget).text(_gettext('Updating...'));
603 608 $(e.currentTarget).attr('disabled', 'disabled');
604 609 if(isDisabled){
605 610 updateCommits("${c.repo_name}", "${c.pull_request.pull_request_id}");
606 611 }
607 612
608 613 });
609 614 // fixing issue with caches on firefox
610 615 $('#update_commits').removeAttr("disabled");
611 616
612 617 $('#close_pull_request').on('click', function(e){
613 618 closePullRequest("${c.repo_name}", "${c.pull_request.pull_request_id}");
614 619 });
615 620
616 621 $('.show-inline-comments').on('click', function(e){
617 622 var boxid = $(this).attr('data-comment-id');
618 623 var button = $(this);
619 624
620 625 if(button.hasClass("comments-visible")) {
621 626 $('#{0} .inline-comments'.format(boxid)).each(function(index){
622 627 $(this).hide();
623 628 });
624 629 button.removeClass("comments-visible");
625 630 } else {
626 631 $('#{0} .inline-comments'.format(boxid)).each(function(index){
627 632 $(this).show();
628 633 });
629 634 button.addClass("comments-visible");
630 635 }
631 636 });
632 637 })
633 638 </script>
634 639
635 640 </div>
636 641 </div>
637 642
638 643 </%def>
General Comments 0
You need to be logged in to leave comments. Login now