##// END OF EJS Templates
api/pull-requests: trigger events for comments/review status changes.
marcink -
r3416:ab643e3c stable
parent child Browse files
Show More
@@ -1,937 +1,960 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2011-2018 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 import logging
23 23
24 24 from rhodecode import events
25 25 from rhodecode.api import jsonrpc_method, JSONRPCError, JSONRPCValidationError
26 26 from rhodecode.api.utils import (
27 27 has_superadmin_permission, Optional, OAttr, get_repo_or_error,
28 28 get_pull_request_or_error, get_commit_or_error, get_user_or_error,
29 29 validate_repo_permissions, resolve_ref_or_error)
30 30 from rhodecode.lib.auth import (HasRepoPermissionAnyApi)
31 31 from rhodecode.lib.base import vcs_operation_context
32 32 from rhodecode.lib.utils2 import str2bool
33 33 from rhodecode.model.changeset_status import ChangesetStatusModel
34 34 from rhodecode.model.comment import CommentsModel
35 35 from rhodecode.model.db import Session, ChangesetStatus, ChangesetComment
36 36 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
37 37 from rhodecode.model.settings import SettingsModel
38 38 from rhodecode.model.validation_schema import Invalid
39 39 from rhodecode.model.validation_schema.schemas.reviewer_schema import(
40 40 ReviewerListSchema)
41 41
42 42 log = logging.getLogger(__name__)
43 43
44 44
45 45 @jsonrpc_method()
46 46 def get_pull_request(request, apiuser, pullrequestid, repoid=Optional(None)):
47 47 """
48 48 Get a pull request based on the given ID.
49 49
50 50 :param apiuser: This is filled automatically from the |authtoken|.
51 51 :type apiuser: AuthUser
52 52 :param repoid: Optional, repository name or repository ID from where
53 53 the pull request was opened.
54 54 :type repoid: str or int
55 55 :param pullrequestid: ID of the requested pull request.
56 56 :type pullrequestid: int
57 57
58 58 Example output:
59 59
60 60 .. code-block:: bash
61 61
62 62 "id": <id_given_in_input>,
63 63 "result":
64 64 {
65 65 "pull_request_id": "<pull_request_id>",
66 66 "url": "<url>",
67 67 "title": "<title>",
68 68 "description": "<description>",
69 69 "status" : "<status>",
70 70 "created_on": "<date_time_created>",
71 71 "updated_on": "<date_time_updated>",
72 72 "commit_ids": [
73 73 ...
74 74 "<commit_id>",
75 75 "<commit_id>",
76 76 ...
77 77 ],
78 78 "review_status": "<review_status>",
79 79 "mergeable": {
80 80 "status": "<bool>",
81 81 "message": "<message>",
82 82 },
83 83 "source": {
84 84 "clone_url": "<clone_url>",
85 85 "repository": "<repository_name>",
86 86 "reference":
87 87 {
88 88 "name": "<name>",
89 89 "type": "<type>",
90 90 "commit_id": "<commit_id>",
91 91 }
92 92 },
93 93 "target": {
94 94 "clone_url": "<clone_url>",
95 95 "repository": "<repository_name>",
96 96 "reference":
97 97 {
98 98 "name": "<name>",
99 99 "type": "<type>",
100 100 "commit_id": "<commit_id>",
101 101 }
102 102 },
103 103 "merge": {
104 104 "clone_url": "<clone_url>",
105 105 "reference":
106 106 {
107 107 "name": "<name>",
108 108 "type": "<type>",
109 109 "commit_id": "<commit_id>",
110 110 }
111 111 },
112 112 "author": <user_obj>,
113 113 "reviewers": [
114 114 ...
115 115 {
116 116 "user": "<user_obj>",
117 117 "review_status": "<review_status>",
118 118 }
119 119 ...
120 120 ]
121 121 },
122 122 "error": null
123 123 """
124 124
125 125 pull_request = get_pull_request_or_error(pullrequestid)
126 126 if Optional.extract(repoid):
127 127 repo = get_repo_or_error(repoid)
128 128 else:
129 129 repo = pull_request.target_repo
130 130
131 131 if not PullRequestModel().check_user_read(
132 132 pull_request, apiuser, api=True):
133 133 raise JSONRPCError('repository `%s` or pull request `%s` '
134 134 'does not exist' % (repoid, pullrequestid))
135 135 data = pull_request.get_api_data()
136 136 return data
137 137
138 138
139 139 @jsonrpc_method()
140 140 def get_pull_requests(request, apiuser, repoid, status=Optional('new')):
141 141 """
142 142 Get all pull requests from the repository specified in `repoid`.
143 143
144 144 :param apiuser: This is filled automatically from the |authtoken|.
145 145 :type apiuser: AuthUser
146 146 :param repoid: Optional repository name or repository ID.
147 147 :type repoid: str or int
148 148 :param status: Only return pull requests with the specified status.
149 149 Valid options are.
150 150 * ``new`` (default)
151 151 * ``open``
152 152 * ``closed``
153 153 :type status: str
154 154
155 155 Example output:
156 156
157 157 .. code-block:: bash
158 158
159 159 "id": <id_given_in_input>,
160 160 "result":
161 161 [
162 162 ...
163 163 {
164 164 "pull_request_id": "<pull_request_id>",
165 165 "url": "<url>",
166 166 "title" : "<title>",
167 167 "description": "<description>",
168 168 "status": "<status>",
169 169 "created_on": "<date_time_created>",
170 170 "updated_on": "<date_time_updated>",
171 171 "commit_ids": [
172 172 ...
173 173 "<commit_id>",
174 174 "<commit_id>",
175 175 ...
176 176 ],
177 177 "review_status": "<review_status>",
178 178 "mergeable": {
179 179 "status": "<bool>",
180 180 "message: "<message>",
181 181 },
182 182 "source": {
183 183 "clone_url": "<clone_url>",
184 184 "reference":
185 185 {
186 186 "name": "<name>",
187 187 "type": "<type>",
188 188 "commit_id": "<commit_id>",
189 189 }
190 190 },
191 191 "target": {
192 192 "clone_url": "<clone_url>",
193 193 "reference":
194 194 {
195 195 "name": "<name>",
196 196 "type": "<type>",
197 197 "commit_id": "<commit_id>",
198 198 }
199 199 },
200 200 "merge": {
201 201 "clone_url": "<clone_url>",
202 202 "reference":
203 203 {
204 204 "name": "<name>",
205 205 "type": "<type>",
206 206 "commit_id": "<commit_id>",
207 207 }
208 208 },
209 209 "author": <user_obj>,
210 210 "reviewers": [
211 211 ...
212 212 {
213 213 "user": "<user_obj>",
214 214 "review_status": "<review_status>",
215 215 }
216 216 ...
217 217 ]
218 218 }
219 219 ...
220 220 ],
221 221 "error": null
222 222
223 223 """
224 224 repo = get_repo_or_error(repoid)
225 225 if not has_superadmin_permission(apiuser):
226 226 _perms = (
227 227 'repository.admin', 'repository.write', 'repository.read',)
228 228 validate_repo_permissions(apiuser, repoid, repo, _perms)
229 229
230 230 status = Optional.extract(status)
231 231 pull_requests = PullRequestModel().get_all(repo, statuses=[status])
232 232 data = [pr.get_api_data() for pr in pull_requests]
233 233 return data
234 234
235 235
236 236 @jsonrpc_method()
237 237 def merge_pull_request(
238 238 request, apiuser, pullrequestid, repoid=Optional(None),
239 239 userid=Optional(OAttr('apiuser'))):
240 240 """
241 241 Merge the pull request specified by `pullrequestid` into its target
242 242 repository.
243 243
244 244 :param apiuser: This is filled automatically from the |authtoken|.
245 245 :type apiuser: AuthUser
246 246 :param repoid: Optional, repository name or repository ID of the
247 247 target repository to which the |pr| is to be merged.
248 248 :type repoid: str or int
249 249 :param pullrequestid: ID of the pull request which shall be merged.
250 250 :type pullrequestid: int
251 251 :param userid: Merge the pull request as this user.
252 252 :type userid: Optional(str or int)
253 253
254 254 Example output:
255 255
256 256 .. code-block:: bash
257 257
258 258 "id": <id_given_in_input>,
259 259 "result": {
260 260 "executed": "<bool>",
261 261 "failure_reason": "<int>",
262 262 "merge_commit_id": "<merge_commit_id>",
263 263 "possible": "<bool>",
264 264 "merge_ref": {
265 265 "commit_id": "<commit_id>",
266 266 "type": "<type>",
267 267 "name": "<name>"
268 268 }
269 269 },
270 270 "error": null
271 271 """
272 272 pull_request = get_pull_request_or_error(pullrequestid)
273 273 if Optional.extract(repoid):
274 274 repo = get_repo_or_error(repoid)
275 275 else:
276 276 repo = pull_request.target_repo
277 277
278 278 if not isinstance(userid, Optional):
279 279 if (has_superadmin_permission(apiuser) or
280 280 HasRepoPermissionAnyApi('repository.admin')(
281 281 user=apiuser, repo_name=repo.repo_name)):
282 282 apiuser = get_user_or_error(userid)
283 283 else:
284 284 raise JSONRPCError('userid is not the same as your user')
285 285
286 286 check = MergeCheck.validate(
287 287 pull_request, auth_user=apiuser, translator=request.translate)
288 288 merge_possible = not check.failed
289 289
290 290 if not merge_possible:
291 291 error_messages = []
292 292 for err_type, error_msg in check.errors:
293 293 error_msg = request.translate(error_msg)
294 294 error_messages.append(error_msg)
295 295
296 296 reasons = ','.join(error_messages)
297 297 raise JSONRPCError(
298 298 'merge not possible for following reasons: {}'.format(reasons))
299 299
300 300 target_repo = pull_request.target_repo
301 301 extras = vcs_operation_context(
302 302 request.environ, repo_name=target_repo.repo_name,
303 303 username=apiuser.username, action='push',
304 304 scm=target_repo.repo_type)
305 305 merge_response = PullRequestModel().merge_repo(
306 306 pull_request, apiuser, extras=extras)
307 307 if merge_response.executed:
308 308 PullRequestModel().close_pull_request(
309 309 pull_request.pull_request_id, apiuser)
310 310
311 311 Session().commit()
312 312
313 313 # In previous versions the merge response directly contained the merge
314 314 # commit id. It is now contained in the merge reference object. To be
315 315 # backwards compatible we have to extract it again.
316 316 merge_response = merge_response._asdict()
317 317 merge_response['merge_commit_id'] = merge_response['merge_ref'].commit_id
318 318
319 319 return merge_response
320 320
321 321
322 322 @jsonrpc_method()
323 323 def get_pull_request_comments(
324 324 request, apiuser, pullrequestid, repoid=Optional(None)):
325 325 """
326 326 Get all comments of pull request specified with the `pullrequestid`
327 327
328 328 :param apiuser: This is filled automatically from the |authtoken|.
329 329 :type apiuser: AuthUser
330 330 :param repoid: Optional repository name or repository ID.
331 331 :type repoid: str or int
332 332 :param pullrequestid: The pull request ID.
333 333 :type pullrequestid: int
334 334
335 335 Example output:
336 336
337 337 .. code-block:: bash
338 338
339 339 id : <id_given_in_input>
340 340 result : [
341 341 {
342 342 "comment_author": {
343 343 "active": true,
344 344 "full_name_or_username": "Tom Gore",
345 345 "username": "admin"
346 346 },
347 347 "comment_created_on": "2017-01-02T18:43:45.533",
348 348 "comment_f_path": null,
349 349 "comment_id": 25,
350 350 "comment_lineno": null,
351 351 "comment_status": {
352 352 "status": "under_review",
353 353 "status_lbl": "Under Review"
354 354 },
355 355 "comment_text": "Example text",
356 356 "comment_type": null,
357 357 "pull_request_version": null
358 358 }
359 359 ],
360 360 error : null
361 361 """
362 362
363 363 pull_request = get_pull_request_or_error(pullrequestid)
364 364 if Optional.extract(repoid):
365 365 repo = get_repo_or_error(repoid)
366 366 else:
367 367 repo = pull_request.target_repo
368 368
369 369 if not PullRequestModel().check_user_read(
370 370 pull_request, apiuser, api=True):
371 371 raise JSONRPCError('repository `%s` or pull request `%s` '
372 372 'does not exist' % (repoid, pullrequestid))
373 373
374 374 (pull_request_latest,
375 375 pull_request_at_ver,
376 376 pull_request_display_obj,
377 377 at_version) = PullRequestModel().get_pr_version(
378 378 pull_request.pull_request_id, version=None)
379 379
380 380 versions = pull_request_display_obj.versions()
381 381 ver_map = {
382 382 ver.pull_request_version_id: cnt
383 383 for cnt, ver in enumerate(versions, 1)
384 384 }
385 385
386 386 # GENERAL COMMENTS with versions #
387 387 q = CommentsModel()._all_general_comments_of_pull_request(pull_request)
388 388 q = q.order_by(ChangesetComment.comment_id.asc())
389 389 general_comments = q.all()
390 390
391 391 # INLINE COMMENTS with versions #
392 392 q = CommentsModel()._all_inline_comments_of_pull_request(pull_request)
393 393 q = q.order_by(ChangesetComment.comment_id.asc())
394 394 inline_comments = q.all()
395 395
396 396 data = []
397 397 for comment in inline_comments + general_comments:
398 398 full_data = comment.get_api_data()
399 399 pr_version_id = None
400 400 if comment.pull_request_version_id:
401 401 pr_version_id = 'v{}'.format(
402 402 ver_map[comment.pull_request_version_id])
403 403
404 404 # sanitize some entries
405 405
406 406 full_data['pull_request_version'] = pr_version_id
407 407 full_data['comment_author'] = {
408 408 'username': full_data['comment_author'].username,
409 409 'full_name_or_username': full_data['comment_author'].full_name_or_username,
410 410 'active': full_data['comment_author'].active,
411 411 }
412 412
413 413 if full_data['comment_status']:
414 414 full_data['comment_status'] = {
415 415 'status': full_data['comment_status'][0].status,
416 416 'status_lbl': full_data['comment_status'][0].status_lbl,
417 417 }
418 418 else:
419 419 full_data['comment_status'] = {}
420 420
421 421 data.append(full_data)
422 422 return data
423 423
424 424
425 425 @jsonrpc_method()
426 426 def comment_pull_request(
427 427 request, apiuser, pullrequestid, repoid=Optional(None),
428 428 message=Optional(None), commit_id=Optional(None), status=Optional(None),
429 429 comment_type=Optional(ChangesetComment.COMMENT_TYPE_NOTE),
430 430 resolves_comment_id=Optional(None),
431 431 userid=Optional(OAttr('apiuser'))):
432 432 """
433 433 Comment on the pull request specified with the `pullrequestid`,
434 434 in the |repo| specified by the `repoid`, and optionally change the
435 435 review status.
436 436
437 437 :param apiuser: This is filled automatically from the |authtoken|.
438 438 :type apiuser: AuthUser
439 439 :param repoid: Optional repository name or repository ID.
440 440 :type repoid: str or int
441 441 :param pullrequestid: The pull request ID.
442 442 :type pullrequestid: int
443 443 :param commit_id: Specify the commit_id for which to set a comment. If
444 444 given commit_id is different than latest in the PR status
445 445 change won't be performed.
446 446 :type commit_id: str
447 447 :param message: The text content of the comment.
448 448 :type message: str
449 449 :param status: (**Optional**) Set the approval status of the pull
450 450 request. One of: 'not_reviewed', 'approved', 'rejected',
451 451 'under_review'
452 452 :type status: str
453 453 :param comment_type: Comment type, one of: 'note', 'todo'
454 454 :type comment_type: Optional(str), default: 'note'
455 455 :param userid: Comment on the pull request as this user
456 456 :type userid: Optional(str or int)
457 457
458 458 Example output:
459 459
460 460 .. code-block:: bash
461 461
462 462 id : <id_given_in_input>
463 463 result : {
464 464 "pull_request_id": "<Integer>",
465 465 "comment_id": "<Integer>",
466 466 "status": {"given": <given_status>,
467 467 "was_changed": <bool status_was_actually_changed> },
468 468 },
469 469 error : null
470 470 """
471 471 pull_request = get_pull_request_or_error(pullrequestid)
472 472 if Optional.extract(repoid):
473 473 repo = get_repo_or_error(repoid)
474 474 else:
475 475 repo = pull_request.target_repo
476 476
477 477 if not isinstance(userid, Optional):
478 478 if (has_superadmin_permission(apiuser) or
479 479 HasRepoPermissionAnyApi('repository.admin')(
480 480 user=apiuser, repo_name=repo.repo_name)):
481 481 apiuser = get_user_or_error(userid)
482 482 else:
483 483 raise JSONRPCError('userid is not the same as your user')
484 484
485 485 if not PullRequestModel().check_user_read(
486 486 pull_request, apiuser, api=True):
487 487 raise JSONRPCError('repository `%s` does not exist' % (repoid,))
488 488 message = Optional.extract(message)
489 489 status = Optional.extract(status)
490 490 commit_id = Optional.extract(commit_id)
491 491 comment_type = Optional.extract(comment_type)
492 492 resolves_comment_id = Optional.extract(resolves_comment_id)
493 493
494 494 if not message and not status:
495 495 raise JSONRPCError(
496 496 'Both message and status parameters are missing. '
497 497 'At least one is required.')
498 498
499 499 if (status not in (st[0] for st in ChangesetStatus.STATUSES) and
500 500 status is not None):
501 501 raise JSONRPCError('Unknown comment status: `%s`' % status)
502 502
503 503 if commit_id and commit_id not in pull_request.revisions:
504 504 raise JSONRPCError(
505 505 'Invalid commit_id `%s` for this pull request.' % commit_id)
506 506
507 507 allowed_to_change_status = PullRequestModel().check_user_change_status(
508 508 pull_request, apiuser)
509 509
510 510 # if commit_id is passed re-validated if user is allowed to change status
511 511 # based on latest commit_id from the PR
512 512 if commit_id:
513 513 commit_idx = pull_request.revisions.index(commit_id)
514 514 if commit_idx != 0:
515 515 allowed_to_change_status = False
516 516
517 517 if resolves_comment_id:
518 518 comment = ChangesetComment.get(resolves_comment_id)
519 519 if not comment:
520 520 raise JSONRPCError(
521 521 'Invalid resolves_comment_id `%s` for this pull request.'
522 522 % resolves_comment_id)
523 523 if comment.comment_type != ChangesetComment.COMMENT_TYPE_TODO:
524 524 raise JSONRPCError(
525 525 'Comment `%s` is wrong type for setting status to resolved.'
526 526 % resolves_comment_id)
527 527
528 528 text = message
529 529 status_label = ChangesetStatus.get_status_lbl(status)
530 530 if status and allowed_to_change_status:
531 531 st_message = ('Status change %(transition_icon)s %(status)s'
532 532 % {'transition_icon': '>', 'status': status_label})
533 533 text = message or st_message
534 534
535 535 rc_config = SettingsModel().get_all_settings()
536 536 renderer = rc_config.get('rhodecode_markup_renderer', 'rst')
537 537
538 538 status_change = status and allowed_to_change_status
539 539 comment = CommentsModel().create(
540 540 text=text,
541 541 repo=pull_request.target_repo.repo_id,
542 542 user=apiuser.user_id,
543 543 pull_request=pull_request.pull_request_id,
544 544 f_path=None,
545 545 line_no=None,
546 546 status_change=(status_label if status_change else None),
547 547 status_change_type=(status if status_change else None),
548 548 closing_pr=False,
549 549 renderer=renderer,
550 550 comment_type=comment_type,
551 551 resolves_comment_id=resolves_comment_id,
552 552 auth_user=apiuser
553 553 )
554 554
555 555 if allowed_to_change_status and status:
556 old_calculated_status = pull_request.calculated_review_status()
556 557 ChangesetStatusModel().set_status(
557 558 pull_request.target_repo.repo_id,
558 559 status,
559 560 apiuser.user_id,
560 561 comment,
561 562 pull_request=pull_request.pull_request_id
562 563 )
563 564 Session().flush()
564 565
565 566 Session().commit()
567
568 PullRequestModel().trigger_pull_request_hook(
569 pull_request, apiuser, 'comment',
570 data={'comment': comment})
571
572 if allowed_to_change_status and status:
573 # we now calculate the status of pull request, and based on that
574 # calculation we set the commits status
575 calculated_status = pull_request.calculated_review_status()
576 if old_calculated_status != calculated_status:
577 PullRequestModel().trigger_pull_request_hook(
578 pull_request, apiuser, 'review_status_change',
579 data={'status': calculated_status})
580
566 581 data = {
567 582 'pull_request_id': pull_request.pull_request_id,
568 583 'comment_id': comment.comment_id if comment else None,
569 584 'status': {'given': status, 'was_changed': status_change},
570 585 }
571 586 return data
572 587
573 588
574 589 @jsonrpc_method()
575 590 def create_pull_request(
576 591 request, apiuser, source_repo, target_repo, source_ref, target_ref,
577 592 title=Optional(''), description=Optional(''), description_renderer=Optional(''),
578 593 reviewers=Optional(None)):
579 594 """
580 595 Creates a new pull request.
581 596
582 597 Accepts refs in the following formats:
583 598
584 599 * branch:<branch_name>:<sha>
585 600 * branch:<branch_name>
586 601 * bookmark:<bookmark_name>:<sha> (Mercurial only)
587 602 * bookmark:<bookmark_name> (Mercurial only)
588 603
589 604 :param apiuser: This is filled automatically from the |authtoken|.
590 605 :type apiuser: AuthUser
591 606 :param source_repo: Set the source repository name.
592 607 :type source_repo: str
593 608 :param target_repo: Set the target repository name.
594 609 :type target_repo: str
595 610 :param source_ref: Set the source ref name.
596 611 :type source_ref: str
597 612 :param target_ref: Set the target ref name.
598 613 :type target_ref: str
599 614 :param title: Optionally Set the pull request title, it's generated otherwise
600 615 :type title: str
601 616 :param description: Set the pull request description.
602 617 :type description: Optional(str)
603 618 :type description_renderer: Optional(str)
604 619 :param description_renderer: Set pull request renderer for the description.
605 620 It should be 'rst', 'markdown' or 'plain'. If not give default
606 621 system renderer will be used
607 622 :param reviewers: Set the new pull request reviewers list.
608 623 Reviewer defined by review rules will be added automatically to the
609 624 defined list.
610 625 :type reviewers: Optional(list)
611 626 Accepts username strings or objects of the format:
612 627
613 628 [{'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}]
614 629 """
615 630
616 631 source_db_repo = get_repo_or_error(source_repo)
617 632 target_db_repo = get_repo_or_error(target_repo)
618 633 if not has_superadmin_permission(apiuser):
619 634 _perms = ('repository.admin', 'repository.write', 'repository.read',)
620 635 validate_repo_permissions(apiuser, source_repo, source_db_repo, _perms)
621 636
622 637 full_source_ref = resolve_ref_or_error(source_ref, source_db_repo)
623 638 full_target_ref = resolve_ref_or_error(target_ref, target_db_repo)
624 639
625 640 source_scm = source_db_repo.scm_instance()
626 641 target_scm = target_db_repo.scm_instance()
627 642
628 643 source_commit = get_commit_or_error(full_source_ref, source_db_repo)
629 644 target_commit = get_commit_or_error(full_target_ref, target_db_repo)
630 645
631 646 ancestor = source_scm.get_common_ancestor(
632 647 source_commit.raw_id, target_commit.raw_id, target_scm)
633 648 if not ancestor:
634 649 raise JSONRPCError('no common ancestor found')
635 650
636 651 # recalculate target ref based on ancestor
637 652 target_ref_type, target_ref_name, __ = full_target_ref.split(':')
638 653 full_target_ref = ':'.join((target_ref_type, target_ref_name, ancestor))
639 654
640 655 commit_ranges = target_scm.compare(
641 656 target_commit.raw_id, source_commit.raw_id, source_scm,
642 657 merge=True, pre_load=[])
643 658
644 659 if not commit_ranges:
645 660 raise JSONRPCError('no commits found')
646 661
647 662 reviewer_objects = Optional.extract(reviewers) or []
648 663
649 664 # serialize and validate passed in given reviewers
650 665 if reviewer_objects:
651 666 schema = ReviewerListSchema()
652 667 try:
653 668 reviewer_objects = schema.deserialize(reviewer_objects)
654 669 except Invalid as err:
655 670 raise JSONRPCValidationError(colander_exc=err)
656 671
657 672 # validate users
658 673 for reviewer_object in reviewer_objects:
659 674 user = get_user_or_error(reviewer_object['username'])
660 675 reviewer_object['user_id'] = user.user_id
661 676
662 677 get_default_reviewers_data, validate_default_reviewers = \
663 678 PullRequestModel().get_reviewer_functions()
664 679
665 680 # recalculate reviewers logic, to make sure we can validate this
666 681 reviewer_rules = get_default_reviewers_data(
667 682 apiuser.get_instance(), source_db_repo,
668 683 source_commit, target_db_repo, target_commit)
669 684
670 685 # now MERGE our given with the calculated
671 686 reviewer_objects = reviewer_rules['reviewers'] + reviewer_objects
672 687
673 688 try:
674 689 reviewers = validate_default_reviewers(
675 690 reviewer_objects, reviewer_rules)
676 691 except ValueError as e:
677 692 raise JSONRPCError('Reviewers Validation: {}'.format(e))
678 693
679 694 title = Optional.extract(title)
680 695 if not title:
681 696 title_source_ref = source_ref.split(':', 2)[1]
682 697 title = PullRequestModel().generate_pullrequest_title(
683 698 source=source_repo,
684 699 source_ref=title_source_ref,
685 700 target=target_repo
686 701 )
687 702 # fetch renderer, if set fallback to plain in case of PR
688 703 rc_config = SettingsModel().get_all_settings()
689 704 default_system_renderer = rc_config.get('rhodecode_markup_renderer', 'plain')
690 705 description = Optional.extract(description)
691 706 description_renderer = Optional.extract(description_renderer) or default_system_renderer
692 707
693 708 pull_request = PullRequestModel().create(
694 709 created_by=apiuser.user_id,
695 710 source_repo=source_repo,
696 711 source_ref=full_source_ref,
697 712 target_repo=target_repo,
698 713 target_ref=full_target_ref,
699 714 revisions=[commit.raw_id for commit in reversed(commit_ranges)],
700 715 reviewers=reviewers,
701 716 title=title,
702 717 description=description,
703 718 description_renderer=description_renderer,
704 719 reviewer_data=reviewer_rules,
705 720 auth_user=apiuser
706 721 )
707 722
708 723 Session().commit()
709 724 data = {
710 725 'msg': 'Created new pull request `{}`'.format(title),
711 726 'pull_request_id': pull_request.pull_request_id,
712 727 }
713 728 return data
714 729
715 730
716 731 @jsonrpc_method()
717 732 def update_pull_request(
718 733 request, apiuser, pullrequestid, repoid=Optional(None),
719 734 title=Optional(''), description=Optional(''), description_renderer=Optional(''),
720 735 reviewers=Optional(None), update_commits=Optional(None)):
721 736 """
722 737 Updates a pull request.
723 738
724 739 :param apiuser: This is filled automatically from the |authtoken|.
725 740 :type apiuser: AuthUser
726 741 :param repoid: Optional repository name or repository ID.
727 742 :type repoid: str or int
728 743 :param pullrequestid: The pull request ID.
729 744 :type pullrequestid: int
730 745 :param title: Set the pull request title.
731 746 :type title: str
732 747 :param description: Update pull request description.
733 748 :type description: Optional(str)
734 749 :type description_renderer: Optional(str)
735 750 :param description_renderer: Update pull request renderer for the description.
736 751 It should be 'rst', 'markdown' or 'plain'
737 752 :param reviewers: Update pull request reviewers list with new value.
738 753 :type reviewers: Optional(list)
739 754 Accepts username strings or objects of the format:
740 755
741 756 [{'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}]
742 757
743 758 :param update_commits: Trigger update of commits for this pull request
744 759 :type: update_commits: Optional(bool)
745 760
746 761 Example output:
747 762
748 763 .. code-block:: bash
749 764
750 765 id : <id_given_in_input>
751 766 result : {
752 767 "msg": "Updated pull request `63`",
753 768 "pull_request": <pull_request_object>,
754 769 "updated_reviewers": {
755 770 "added": [
756 771 "username"
757 772 ],
758 773 "removed": []
759 774 },
760 775 "updated_commits": {
761 776 "added": [
762 777 "<sha1_hash>"
763 778 ],
764 779 "common": [
765 780 "<sha1_hash>",
766 781 "<sha1_hash>",
767 782 ],
768 783 "removed": []
769 784 }
770 785 }
771 786 error : null
772 787 """
773 788
774 789 pull_request = get_pull_request_or_error(pullrequestid)
775 790 if Optional.extract(repoid):
776 791 repo = get_repo_or_error(repoid)
777 792 else:
778 793 repo = pull_request.target_repo
779 794
780 795 if not PullRequestModel().check_user_update(
781 796 pull_request, apiuser, api=True):
782 797 raise JSONRPCError(
783 798 'pull request `%s` update failed, no permission to update.' % (
784 799 pullrequestid,))
785 800 if pull_request.is_closed():
786 801 raise JSONRPCError(
787 802 'pull request `%s` update failed, pull request is closed' % (
788 803 pullrequestid,))
789 804
790 805 reviewer_objects = Optional.extract(reviewers) or []
791 806
792 807 if reviewer_objects:
793 808 schema = ReviewerListSchema()
794 809 try:
795 810 reviewer_objects = schema.deserialize(reviewer_objects)
796 811 except Invalid as err:
797 812 raise JSONRPCValidationError(colander_exc=err)
798 813
799 814 # validate users
800 815 for reviewer_object in reviewer_objects:
801 816 user = get_user_or_error(reviewer_object['username'])
802 817 reviewer_object['user_id'] = user.user_id
803 818
804 819 get_default_reviewers_data, get_validated_reviewers = \
805 820 PullRequestModel().get_reviewer_functions()
806 821
807 822 # re-use stored rules
808 823 reviewer_rules = pull_request.reviewer_data
809 824 try:
810 825 reviewers = get_validated_reviewers(
811 826 reviewer_objects, reviewer_rules)
812 827 except ValueError as e:
813 828 raise JSONRPCError('Reviewers Validation: {}'.format(e))
814 829 else:
815 830 reviewers = []
816 831
817 832 title = Optional.extract(title)
818 833 description = Optional.extract(description)
819 834 description_renderer = Optional.extract(description_renderer)
820 835
821 836 if title or description:
822 837 PullRequestModel().edit(
823 838 pull_request,
824 839 title or pull_request.title,
825 840 description or pull_request.description,
826 841 description_renderer or pull_request.description_renderer,
827 842 apiuser)
828 843 Session().commit()
829 844
830 845 commit_changes = {"added": [], "common": [], "removed": []}
831 846 if str2bool(Optional.extract(update_commits)):
832 847 if PullRequestModel().has_valid_update_type(pull_request):
833 848 update_response = PullRequestModel().update_commits(
834 849 pull_request)
835 850 commit_changes = update_response.changes or commit_changes
836 851 Session().commit()
837 852
838 853 reviewers_changes = {"added": [], "removed": []}
839 854 if reviewers:
855 old_calculated_status = pull_request.calculated_review_status()
840 856 added_reviewers, removed_reviewers = \
841 857 PullRequestModel().update_reviewers(pull_request, reviewers, apiuser)
842 858
843 859 reviewers_changes['added'] = sorted(
844 860 [get_user_or_error(n).username for n in added_reviewers])
845 861 reviewers_changes['removed'] = sorted(
846 862 [get_user_or_error(n).username for n in removed_reviewers])
847 863 Session().commit()
848 864
865 # trigger status changed if change in reviewers changes the status
866 calculated_status = pull_request.calculated_review_status()
867 if old_calculated_status != calculated_status:
868 PullRequestModel().trigger_pull_request_hook(
869 pull_request, apiuser, 'review_status_change',
870 data={'status': calculated_status})
871
849 872 data = {
850 873 'msg': 'Updated pull request `{}`'.format(
851 874 pull_request.pull_request_id),
852 875 'pull_request': pull_request.get_api_data(),
853 876 'updated_commits': commit_changes,
854 877 'updated_reviewers': reviewers_changes
855 878 }
856 879
857 880 return data
858 881
859 882
860 883 @jsonrpc_method()
861 884 def close_pull_request(
862 885 request, apiuser, pullrequestid, repoid=Optional(None),
863 886 userid=Optional(OAttr('apiuser')), message=Optional('')):
864 887 """
865 888 Close the pull request specified by `pullrequestid`.
866 889
867 890 :param apiuser: This is filled automatically from the |authtoken|.
868 891 :type apiuser: AuthUser
869 892 :param repoid: Repository name or repository ID to which the pull
870 893 request belongs.
871 894 :type repoid: str or int
872 895 :param pullrequestid: ID of the pull request to be closed.
873 896 :type pullrequestid: int
874 897 :param userid: Close the pull request as this user.
875 898 :type userid: Optional(str or int)
876 899 :param message: Optional message to close the Pull Request with. If not
877 900 specified it will be generated automatically.
878 901 :type message: Optional(str)
879 902
880 903 Example output:
881 904
882 905 .. code-block:: bash
883 906
884 907 "id": <id_given_in_input>,
885 908 "result": {
886 909 "pull_request_id": "<int>",
887 910 "close_status": "<str:status_lbl>,
888 911 "closed": "<bool>"
889 912 },
890 913 "error": null
891 914
892 915 """
893 916 _ = request.translate
894 917
895 918 pull_request = get_pull_request_or_error(pullrequestid)
896 919 if Optional.extract(repoid):
897 920 repo = get_repo_or_error(repoid)
898 921 else:
899 922 repo = pull_request.target_repo
900 923
901 924 if not isinstance(userid, Optional):
902 925 if (has_superadmin_permission(apiuser) or
903 926 HasRepoPermissionAnyApi('repository.admin')(
904 927 user=apiuser, repo_name=repo.repo_name)):
905 928 apiuser = get_user_or_error(userid)
906 929 else:
907 930 raise JSONRPCError('userid is not the same as your user')
908 931
909 932 if pull_request.is_closed():
910 933 raise JSONRPCError(
911 934 'pull request `%s` is already closed' % (pullrequestid,))
912 935
913 936 # only owner or admin or person with write permissions
914 937 allowed_to_close = PullRequestModel().check_user_update(
915 938 pull_request, apiuser, api=True)
916 939
917 940 if not allowed_to_close:
918 941 raise JSONRPCError(
919 942 'pull request `%s` close failed, no permission to close.' % (
920 943 pullrequestid,))
921 944
922 945 # message we're using to close the PR, else it's automatically generated
923 946 message = Optional.extract(message)
924 947
925 948 # finally close the PR, with proper message comment
926 949 comment, status = PullRequestModel().close_pull_request_with_comment(
927 950 pull_request, apiuser, repo, message=message, auth_user=apiuser)
928 951 status_lbl = ChangesetStatus.get_status_lbl(status)
929 952
930 953 Session().commit()
931 954
932 955 data = {
933 956 'pull_request_id': pull_request.pull_request_id,
934 957 'close_status': status_lbl,
935 958 'closed': True,
936 959 }
937 960 return data
@@ -1,97 +1,100 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2010-2018 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 import pytest
22 22
23 23 from rhodecode.tests.events.conftest import EventCatcher
24 24
25 25 from rhodecode.model.comment import CommentsModel
26 26 from rhodecode.model.pull_request import PullRequestModel
27 27 from rhodecode.events import (
28 28 PullRequestCreateEvent,
29 29 PullRequestUpdateEvent,
30 30 PullRequestCommentEvent,
31 31 PullRequestReviewEvent,
32 32 PullRequestMergeEvent,
33 33 PullRequestCloseEvent,
34 34 )
35 35
36 36 # TODO: dan: make the serialization tests complete json comparisons
37 37 @pytest.mark.backends("git", "hg")
38 38 @pytest.mark.parametrize('EventClass', [
39 39 PullRequestCreateEvent,
40 40 PullRequestUpdateEvent,
41 41 PullRequestReviewEvent,
42 42 PullRequestMergeEvent,
43 43 PullRequestCloseEvent,
44 44 ])
45 45 def test_pullrequest_events_serialized(EventClass, pr_util, config_stub):
46 46 pr = pr_util.create_pull_request()
47 if EventClass == PullRequestReviewEvent:
48 event = EventClass(pr, 'approved')
49 else:
47 50 event = EventClass(pr)
48 51 data = event.as_dict()
49 52 assert data['name'] == EventClass.name
50 53 assert data['repo']['repo_name'] == pr.target_repo.repo_name
51 54 assert data['pullrequest']['pull_request_id'] == pr.pull_request_id
52 55 assert data['pullrequest']['url']
53 56 assert data['pullrequest']['permalink_url']
54 57
55 58
56 59 @pytest.mark.backends("git", "hg")
57 60 def test_create_pull_request_events(pr_util, config_stub):
58 61 with EventCatcher() as event_catcher:
59 62 pr_util.create_pull_request()
60 63
61 64 assert PullRequestCreateEvent in event_catcher.events_types
62 65
63 66
64 67 @pytest.mark.backends("git", "hg")
65 68 def test_pullrequest_comment_events_serialized(pr_util, config_stub):
66 69 pr = pr_util.create_pull_request()
67 70 comment = CommentsModel().get_comments(
68 71 pr.target_repo.repo_id, pull_request=pr)[0]
69 72 event = PullRequestCommentEvent(pr, comment)
70 73 data = event.as_dict()
71 74 assert data['name'] == PullRequestCommentEvent.name
72 75 assert data['repo']['repo_name'] == pr.target_repo.repo_name
73 76 assert data['pullrequest']['pull_request_id'] == pr.pull_request_id
74 77 assert data['pullrequest']['url']
75 78 assert data['pullrequest']['permalink_url']
76 79 assert data['comment']['text'] == comment.text
77 80
78 81
79 82 @pytest.mark.backends("git", "hg")
80 83 def test_close_pull_request_events(pr_util, user_admin, config_stub):
81 84 pr = pr_util.create_pull_request()
82 85
83 86 with EventCatcher() as event_catcher:
84 87 PullRequestModel().close_pull_request(pr, user_admin)
85 88
86 89 assert PullRequestCloseEvent in event_catcher.events_types
87 90
88 91
89 92 @pytest.mark.backends("git", "hg")
90 93 def test_close_pull_request_with_comment_events(pr_util, user_admin, config_stub):
91 94 pr = pr_util.create_pull_request()
92 95
93 96 with EventCatcher() as event_catcher:
94 97 PullRequestModel().close_pull_request_with_comment(
95 98 pr, user_admin, pr.target_repo)
96 99
97 100 assert PullRequestCloseEvent in event_catcher.events_types
General Comments 0
You need to be logged in to leave comments. Login now